add model NER extract name

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+
+*.onnx binary
+tokenizer.json text eol=lf
+vocab.txt text eol=lf

app/dialogflow/api/v1/dialogflow.py

@@ -4,6 +4,7 @@ from fastapi.responses import JSONResponse, RedirectResponse, HTMLResponse # typ
 from datetime import datetime, timedelta
 from fastapi.templating import Jinja2Templates
 from app.dialogflow.services.dialog_service import dialog_service
+from app.ner.services.ner import NER
 from utils.format_data_dialog import extra_time_dialogflow, get_weekday_name, find_surrounding_times
 
 from common.external.external_api import api
@@ -809,6 +810,50 @@ async def is_valid_select_seat(request: Request) -> Response:
     except Exception as e:
         return DialogFlowResponseAPI(text=["Hệ thống xảy ra lỗi. Quý khách vui lòng thử lại sau hoặc liên hệ Trung tâm tổng đài 1900 6067 để được hỗ trợ."])
 
+@router.post('/trip/check-exist-user-info')
+async def check_exist_user_info(request: Request) -> Response:
+    body = await request.json()
+    session_info = body.get("sessionInfo", {})
+    parameters = session_info.get("parameters")
+    
+    is_exist_user_info = dialog_service.check_exist_user_info()
+    
+    user_info = {}
+    
+    if is_exist_user_info:
+        user_info = dialog_service.get_user_info()
+
+    user_name = user_info.get("name")
+    phone_number = user_info.get("phone_number")
+    email = user_info.get("email")
+    
+    parameters = {
+        "is_user_exist": is_exist_user_info,
+        "user_name":  user_name,
+        "phone_number": phone_number,
+        "email": email
+    }
+        
+    return DialogFlowResponseAPI(parameters=parameters)
+
+@router.post('/trip/extract-user-name')
+async def extract_user_name(request: Request) -> Response:
+    body = await request.json()
+    session_info = body.get("sessionInfo", {})
+    parameters = session_info.get("parameters")
+    
+    raw_text_user_name = (body.get("text",""))
+    
+    ner: NER = request.app.state.ner
+    
+    user_name = dialog_service.extract_user_name(text=raw_text_user_name, ner=ner)
+    
+    parameters = {
+        "user_name": user_name
+    }
+        
+    return DialogFlowResponseAPI(parameters=parameters)
+
 @router.post('/trip/stop/pickup')
 async def pickup(request: Request) -> Response:
     body = await request.json()

app/dialogflow/services/dialog_service.py

@@ -3,6 +3,8 @@ from datetime import datetime, timedelta
 
 from fastapi import logger
 
+from app.ner.services.ner import NER
+
 from common.external.external_api import api
 from core.conf import settings
 
@@ -365,5 +367,49 @@ class DialogService:
                                 return group["provinceName"]
         return None
 
+    async def check_exist_user_info(self, user_id: str = None):
+        try:
+            # response = await api.get(f'/user/{user_id}')
+            # if response.get("status") == 200:
+            #     return True
+            return True
+            
+            # return False
+        except Exception as e:
+            logger.error(f"Error checking user info: {e}")
+            return False
+    
+    async def get_user_info(self, user_id: str = None):
+        try:
+            # response = await api.get(f'/user/{user_id}')
+            # if response.get("status") == 200:
+            #     return response.get("data")
+            user_info = {
+                "user_name": "Đại",
+                "phone_number": "0987654321",
+                "email": "[email protected]"
+            }
+            
+            return user_info
+            
+            # return None
+        except Exception as e:
+            logger.error(f"Error fetching user info: {e}")
+            return None
+    
+    def extract_user_name(text: str, ner: NER):
+        if text is None:
+            return None
+        
+        user_name_pred = ner.predict(text=text, entity_tag="PERSON")
+        
+        if user_name_pred:
+            user_name = user_name_pred[0]
+            
+            if user_name:
+                return user_name
+        
+        return None
+
 dialog_service: DialogService = DialogService()
     

app/ner/models/base_model.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+from transformers import AutoTokenizer
+from optimum.onnxruntime import ORTModelForTokenClassification
+from optimum.pipelines import pipeline
+start = datetime.now()
+
+
+
+tokenizer = AutoTokenizer.from_pretrained("model_ner")
+model = ORTModelForTokenClassification.from_pretrained("model_ner", provider="CPUExecutionProvider")
+pipe = pipeline("token-classification", model=model, tokenizer=tokenizer, accelerator="ort", device=-1)
+
+result = pipe("Tôi tên là Trần Văn Đại, địa chỉ 12 Phan đình phùng")
+end = datetime.now()
+print(result)
+print("Time taken: ", (end - start).total_seconds())

app/ner/models/ner/config.json

@@ -0,0 +1,53 @@
+{
+  "_name_or_path": "NlpHUST/ner-vietnamese-electra-base",
+  "architectures": [
+    "ElectraForTokenClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "embedding_size": 768,
+  "finetuning_task": "ner",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "B-LOCATION",
+    "1": "B-MISCELLANEOUS",
+    "2": "B-ORGANIZATION",
+    "3": "B-PERSON",
+    "4": "I-LOCATION",
+    "5": "I-MISCELLANEOUS",
+    "6": "I-ORGANIZATION",
+    "7": "I-PERSON",
+    "8": "O"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "B-LOCATION": 0,
+    "B-MISCELLANEOUS": 1,
+    "B-ORGANIZATION": 2,
+    "B-PERSON": 3,
+    "I-LOCATION": 4,
+    "I-MISCELLANEOUS": 5,
+    "I-ORGANIZATION": 6,
+    "I-PERSON": 7,
+    "O": 8
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "electra",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "summary_activation": "gelu",
+  "summary_last_dropout": 0.1,
+  "summary_type": "first",
+  "summary_use_proj": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.48.3",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 62000
+}

app/ner/models/ner/ort_config.json

@@ -0,0 +1,37 @@
+{
+  "one_external_file": true,
+  "opset": null,
+  "optimization": {
+    "disable_attention": null,
+    "disable_attention_fusion": false,
+    "disable_bias_gelu": null,
+    "disable_bias_gelu_fusion": false,
+    "disable_bias_skip_layer_norm": null,
+    "disable_bias_skip_layer_norm_fusion": false,
+    "disable_embed_layer_norm": true,
+    "disable_embed_layer_norm_fusion": true,
+    "disable_gelu": null,
+    "disable_gelu_fusion": false,
+    "disable_group_norm_fusion": true,
+    "disable_layer_norm": null,
+    "disable_layer_norm_fusion": false,
+    "disable_packed_kv": true,
+    "disable_rotary_embeddings": false,
+    "disable_shape_inference": false,
+    "disable_skip_layer_norm": null,
+    "disable_skip_layer_norm_fusion": false,
+    "enable_gelu_approximation": true,
+    "enable_gemm_fast_gelu_fusion": false,
+    "enable_transformers_specific_optimizations": true,
+    "fp16": false,
+    "no_attention_mask": false,
+    "optimization_level": 2,
+    "optimize_for_gpu": false,
+    "optimize_with_onnxruntime_only": null,
+    "use_mask_index": false,
+    "use_multi_head_attention": false,
+    "use_raw_attention_mask": false
+  },
+  "quantization": {},
+  "use_external_data_format": false
+}

app/ner/models/ner/special_tokens_map.json

@@ -0,0 +1,37 @@
+{
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "[PAD]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

app/ner/models/ner/tokenizer_config.json

@@ -0,0 +1,65 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": false,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "max_length": 256,
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_to_multiple_of": null,
+  "pad_token": "[PAD]",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "[SEP]",
+  "stride": 0,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "ElectraTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "[UNK]"
+}

app/ner/services/ner.py

@@ -0,0 +1,77 @@
+from ....core.conf import settings
+
+class NER:
+    def __init__(self, model_name: str = settings.NER_MODEL_NAME):
+        self.model_name = model_name
+        self.model = None
+        self.tokenizer = None
+        self.pipeline = None
+
+    def load_model(self):
+        from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
+
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForTokenClassification.from_pretrained(self.model_name)
+        self.pipeline = pipeline(settings.TASK_NAME, model=self.model, tokenizer=self.tokenizer)
+        
+    def predict(self, text: str, entity_tag: str = None):
+        if self.pipeline is None:
+            raise ValueError("Model not loaded. Please call load_model() first.")
+        pred = self.pipeline(text)
+        if entity_tag:
+            return self.extract_entities(pred, entity_tag)
+        return pred
+    
+    def extract_entities(self, result_pred: list[dict[str, any]], entity: str) -> list[str]:
+        if self.pipeline is None:
+            raise ValueError("Model not loaded. Please call load_model() first.")
+        B_ENTITY = f"B-{entity}"
+        I_ENTITY = f"I-{entity}"
+        
+        extracted_entities = []
+        current_entity_tokens = []
+        
+        for item in result_pred:
+            word = item["word"]
+            entity_tag = item["entity"]
+            
+            if entity_tag == B_ENTITY:
+                if current_entity_tokens:
+                    extracted_entities.append(self._combine_token(current_entity_tokens))
+                current_entity_tokens = [word]
+            elif entity_tag == I_ENTITY and current_entity_tokens:
+                current_entity_tokens.append(word)
+            else:
+                if current_entity_tokens:
+                    extracted_entities.append(self._combine_token(current_entity_tokens))
+                    current_entity_tokens = []
+                    
+        if current_entity_tokens:
+            extracted_entities.append(self._combine_token(current_entity_tokens))
+        
+        return extracted_entities
+
+    def _combine_token(tokens: list[str]) -> str:
+        """Combines tokens into a single string, removing leading hashtags from the first token if present.
+        Args:
+            tokens (list[str]): List of tokens to combine.
+            
+        Returns:
+            str: Combined string of tokens.
+        """
+        if not tokens:
+            return ""
+        
+        words = []
+        
+        for token in tokens:
+            if token.strip("#") != token:
+                clean_token = token.strip("#")
+                if words:
+                    words[-1] += clean_token
+                else:
+                    words.append(clean_token)
+            else:
+                words.append(token)
+        
+        return " ".join(words)

utils/life_span.py

@@ -0,0 +1,17 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Load the ML model
+    from app.ner.services.ner import NER
+    ner: NER = NER()
+    ner.load_model()
+    app.state.ner = ner
+    print("NER model loaded successfully.")
+    yield
+    # Clean up the ML models and release the resources
+    print("Cleaning up NER model...")
+    del app.state.ner