Upload 14 files

DataProcessing.py

@@ -0,0 +1,88 @@
+import string
+
+import underthesea
+
+from dictionary import (emotion2wordform_dict, mispelling_dict, number_dict, translate_dict, wordform2vnese_dict)
+
+
+#10 Remove stopwords 
+def remove_stopwords(input_text, stopwords_file='Datasets/Query/stopword.txt'):
+    # Read the custom stop words from the file
+    with open(stopwords_file, 'r', encoding='utf-8') as file:
+        stopwords = set(line.strip() for line in file)
+
+    cleaned_words = [word for word in input_text.split() if word.lower() not in stopwords]
+    cleaned_text = ' '.join(cleaned_words)
+
+    return cleaned_text
+
+#9 word segmentation
+def word_segment(text):
+    return underthesea.word_tokenize(text, format="text")
+
+#8 Remove numbers
+def remove_numbers(input_string):
+    # Use the isalpha() method to filter out numeric characters
+    cleaned_string = ''.join(char for char in input_string if not char.isdigit())
+    return cleaned_string
+
+#7 
+def remove_extra_whitespace(input_string):
+    words = input_string.split()
+    return ' '.join(words)
+
+#6 Tranform Number to text (8 - tám)
+def number2text(sentence):
+    words = sentence.split()
+    converted_words = [number_dict.get(word, word) for word in words]
+    converted_sentence = ' '.join(converted_words)
+    return converted_sentence
+
+#5 Transform mispelling words, acronyms, .....(include translate english words)
+def translate2word(sentence, dictionary = translate_dict):
+    sentence = " " + sentence.strip() + " "
+    for key, value_list in dictionary.items():
+        for value in value_list:
+            sentence = sentence.replace(value, key)
+    return sentence
+
+def mispell2word(sentence, dictionary = mispelling_dict):
+    sentence = " " + sentence.strip() + " "
+    for key, value_list in dictionary.items():
+        for value in value_list:
+            sentence = sentence.replace(value, key)
+    return sentence
+
+#4 Transform word from into vietnamese (colonsmile - cười)
+def word_form2Vnese(sentence):
+    words = sentence.split()
+    converted_words = [wordform2vnese_dict.get(word, word) for word in words]
+    converted_sentence = ' '.join(converted_words)
+    return converted_sentence
+
+#3 f
+def remove_punctuation(input_string):
+    # Create a translation table to remove all punctuation characters
+    translator = str.maketrans('', '', string.punctuation)
+    
+    # Use the translate method to remove punctuation
+    cleaned_string = input_string.translate(translator)
+    
+    return cleaned_string
+
+#2 emoticon to word form  ( :) - colonsmile )
+def emoticon2word(sentence):
+    words = sentence.split()
+    converted_words = [emotion2wordform_dict.get(word, word) for word in words]
+    converted_sentence = ' '.join(converted_words)
+    return converted_sentence
+
+#1 lower case
+def lower_case(text):
+    return text.lower()
+
+def data_preprocessing(text):
+    return remove_stopwords(word_segment(remove_extra_whitespace(number2text(mispell2word(remove_punctuation(lower_case(text)))))))
+
+def read_input(input): #hàm cuối cùng khi đọc và xử lí input sentence
+    return data_preprocessing(input)

Dockerfile

@@ -0,0 +1,75 @@
+# FROM python:3.11-slim
+
+# # Install git and git-lfs
+# RUN apt-get update && \
+#     apt-get install -y git git-lfs && \
+#     apt-get clean && \
+#     rm -rf /var/lib/apt/lists/*
+
+# # Add a non-root user for better security
+# RUN useradd -m -u 1000 user
+
+# # Switch to non-root user
+# USER user
+
+# # Ensure pip, setuptools, and wheel are up to date
+# RUN python -m pip install --upgrade pip setuptools wheel
+
+# # Set PATH to include user installs
+# ENV PATH="/home/user/.local/bin:$PATH"
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy requirements.txt file and install dependencies
+# COPY --chown=user ./requirements.txt /app/requirements.txt
+
+# # Install only necessary dependencies from the requirements.txt
+# RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# # Create Saved_Model directory and download model from Hugging Face
+# RUN mkdir -p /app/Saved_Model && \
+#     cd /app && \
+#     git lfs install && \
+#     git clone https://huggingface.co/spaces/darkbreakerk/triventure_ai && \
+#     cp -r triventure_ai/Model_API/Saved_Model/* Saved_Model/ && \
+#     rm -rf triventure_ai
+
+# # Copy the rest of the application code to the working directory
+# COPY --chown=user . /app
+
+# # Expose the port that your app will run on
+# EXPOSE 7880
+
+# # Run the Python script when the container starts
+# CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7880"]
+
+# Use the slim variant of Python 3.11 to reduce the size
+FROM python:3.11-slim
+
+# Add a non-root user for better security
+RUN useradd -m -u 1000 user
+
+# Switch to non-root user
+USER user
+
+# Ensure pip, setuptools, and wheel are up to date
+RUN python -m pip install --upgrade pip setuptools wheel
+
+# Set PATH to include user installs
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy requirements.txt file and install dependencies
+COPY --chown=user ./requirements.txt /app/requirements.txt
+
+# Install only necessary dependencies from the requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Copy the rest of the application code to the working directory
+COPY --chown=user . /app
+
+# Start the FastAPI application with uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,16 @@
 ---
-title: TriVenture Personalize
-emoji: 📊
-colorFrom: red
-colorTo: green
+title: Triventure Personalize
+emoji: 📉
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
+license: apache-2.0
+short_description: AI of Triventure project
 ---
 
+# Triventure AI
+
+This project uses MongoDB for data storage. The database is configured in the `docker-compose.yml` file and can be accessed through the MongoDB Express interface at http://localhost:8081.
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,233 @@
+import os
+from typing import Any, Dict, List
+from dotenv import load_dotenv
+load_dotenv()
+import uvicorn
+from fastapi import APIRouter, FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from model_predict_onnx import onnx_predictor
+from user_weights import (get_all_users, get_user_metadata,
+                                       get_user_weights,
+                                       track_question_tags,
+                                       update_user_metadata,
+                                       update_user_weights,
+                                       update_weights_from_feedback,
+                                       update_weights_from_query)
+from get_destinations import (get_destinations_list,get_question_vector)
+from get_default_weight import feature_names, weights_bias_vector
+from database import db
+
+# Define request models
+class WeightUpdateRequest(BaseModel):
+    tag_indices: List[int]
+    new_weights: List[float]
+    metadata: Dict[str, Any] = {}
+
+class FeedbackRequest(BaseModel):
+    destination_id: int
+    tag_id: int
+    rating: int  # 1-5 stars
+
+router = APIRouter(prefix="/model", tags=["Model"])
+
+@router.get("/get_question_tags/{question}")
+async def get_question_tags(question: str):
+    # Get the prediction
+    original_sentence, predicted_tags = onnx_predictor.predict(question)
+
+    # Print the sentence and its predicted tags
+    print("Sentence:", original_sentence)
+    print("Predicted Tags:", predicted_tags)
+    return {"question_tags": predicted_tags}
+
+@router.get("/get_destinations_list/{question_tags}/{top_k}")
+async def get_destinations_list_api(question_tags: str, top_k:str):
+    # Get the prediction
+    question_vector = get_question_vector(question_tags)
+    destinations_list = get_destinations_list(question_vector, int(top_k))
+
+    print("destinations_list:", destinations_list)
+    return {"destinations_list": destinations_list}
+
+@router.get("/get_destinations_list_by_question/{question}/{top_k}")
+async def get_destinations_list_api(question: str, top_k: str):
+    # Get the prediction
+    original_sentence, question_tags = onnx_predictor.predict(question)
+
+    # Print the sentence and its predicted tags
+    print("Sentence:", original_sentence)
+    print("Predicted Tags:", question_tags)
+    # Get the prediction
+    question_tags = " ".join(question_tags)
+    question_vector = get_question_vector(question_tags)
+    destinations_list = get_destinations_list(question_vector, int(top_k))
+
+    print("destinations_list:", destinations_list)
+    return {"destinations_list": destinations_list}
+
+@router.get("/get_destinations_list_by_question/{question}/{top_k}/{user_id}")
+def get_destinations_list_with_user_api(question: str, top_k: str, user_id: str):
+    """
+    Get a list of destinations based on a question and user-specific weights.
+    
+    Parameters:
+    question (str): The question to get destinations for.
+    top_k (str): The number of destinations to return.
+    user_id (str): The ID of the user.
+    
+    Returns:
+    dict: A dictionary containing the list of destinations.
+    """
+    # Get the prediction
+    original_sentence, question_tags = onnx_predictor.predict(question)
+
+    # Print the sentence and its predicted tags
+    print("Sentence:", original_sentence)
+    print("Predicted Tags:", question_tags)
+    
+    # Track the question tags for the user
+    track_question_tags(user_id, question_tags)
+    
+    # Update weights based on query tags
+    update_weights_from_query(user_id, question_tags, feature_names, weights_bias_vector)
+    
+    # Get the prediction
+    question_tags_str = " ".join(question_tags)
+    question_vector = get_question_vector(question_tags_str)
+    destinations_list = get_destinations_list(question_vector, int(top_k), user_id)
+
+    print("destinations_list:", destinations_list)
+    return {"destinations_list": destinations_list}
+
+@router.get("/users")
+def get_users():
+    """
+    Get a list of all users.
+    
+    Returns:
+    dict: A dictionary containing the list of users.
+    """
+    users = get_all_users()
+    return {"users": users}
+
+@router.get("/users/{user_id}")
+def get_user(user_id: str):
+    """
+    Get the metadata for a user.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    
+    Returns:
+    dict: A dictionary containing the user's metadata.
+    """
+    metadata = get_user_metadata(user_id)
+    return {"metadata": metadata}
+
+@router.get("/users/{user_id}/weights")
+def get_user_weights_api(user_id: str):
+    """
+    Get the weights for a user.
+
+    Parameters:
+    user_id (str): The ID of the user.
+
+    Returns:
+    dict: A dictionary containing the user's weights.
+    """
+    weights = get_user_weights(user_id, weights_bias_vector)
+    # Convert numpy array to list for JSON serialization
+    weights_list = weights.tolist() if weights is not None else None
+    return {"user_id": user_id, "weights": weights_list}
+
+@router.post("/users/{user_id}/weights")
+def update_user_weights_api(user_id: str, request: WeightUpdateRequest):
+    """
+    Update the weights for a user.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    request (WeightUpdateRequest): The request containing the tag indices, new weights, and metadata.
+    
+    Returns:
+    dict: A dictionary indicating whether the update was successful.
+    """
+    # Validate the request
+    if len(request.tag_indices) != len(request.new_weights):
+        raise HTTPException(status_code=400, detail="Tag indices and new weights must have the same length")
+    
+    # Update the weights
+    success = update_user_weights(user_id, request.tag_indices, request.new_weights, weights_bias_vector)
+    
+    # Update the metadata
+    if success and request.metadata:
+        update_user_metadata(user_id, request.metadata)
+    
+    return {"success": success}
+
+@router.post("/users/{user_id}/feedback")
+def record_user_feedback(user_id: str, request: FeedbackRequest):
+    """
+    Record user feedback on a specific tag for a specific destination.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    request (FeedbackRequest): The request containing the destination ID, tag ID, and rating.
+    
+    Returns:
+    dict: A dictionary indicating whether the feedback was recorded successfully.
+    """
+    # Validate the request
+    if request.rating < 1 or request.rating > 5:
+        raise HTTPException(status_code=400, detail="Rating must be between 1 and 5")
+    
+    # Update weights based on feedback
+    success = update_weights_from_feedback(
+        user_id, 
+        request.destination_id, 
+        request.tag_id, 
+        request.rating, 
+        weights_bias_vector
+    )
+    
+    return {"success": success}
+
+@router.get("/tags")
+def get_tags():
+    """
+    Get a list of all tags.
+    
+    Returns:
+    dict: A dictionary containing the list of tags.
+    """
+    return {"tags": feature_names.tolist()}
+
+app = FastAPI(docs_url="/")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=['*'],
+    allow_credentials=True,
+    allow_methods=['*'],
+    allow_headers=['*'],
+    expose_headers=['*',]
+)
+
+app.include_router(router)
+
+@app.on_event("startup")
+def startup_event():
+    """
+    Connect to the database when the API starts.
+    """
+    db.connect()
+
+@app.on_event("shutdown")
+def shutdown_event():
+    """
+    Close the database connection when the API shuts down.
+    """
+    db.close()
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7880)))

config.py

@@ -0,0 +1,35 @@
+import json
+import pandas as pd
+from sklearn.feature_extraction.text import CountVectorizer
+from constants import DEFAULT_TEXT_ANNOTATION_FILE, DEFAULT_DESTINATIONS
+# Load the JSON data
+with open(DEFAULT_TEXT_ANNOTATION_FILE, 'r', encoding='utf-8') as file:
+    data = json.load(file)
+
+# Prepare sentences and labels
+sentences = [item[0] for item in data["annotations"]]
+labels = [item[1]['entities'] for item in data["annotations"]]
+# Define tags
+tags = data["classes"]
+# tags = ['<pad>'] + tags
+
+# Convert tags to indices
+tag2idx = {tag: 0 for idx, tag in enumerate(tags)}
+for label in labels:
+    for entity in label:
+        tag2idx[entity[1]] = tag2idx[entity[1]] + 1
+# Sort the dictionary by values
+sorted_tags_dict = dict(sorted(tag2idx.items(), key=lambda item: item[1],reverse=True))
+sorted_tags = {key: value for key, value in sorted_tags_dict.items()}
+sorted_tags = list(sorted_tags)
+
+for i in range(len(sorted_tags)):
+    sorted_tags[i] = sorted_tags[i].replace(" ", "_")
+    
+destinations = pd.read_excel(DEFAULT_DESTINATIONS)
+
+vectorizer = CountVectorizer(max_features=10000, stop_words="english")
+tags_vector = vectorizer.fit_transform(destinations["tags"].values.astype('U')).toarray()
+tags_vector = tags_vector[1:]
+
+feature_names = vectorizer.get_feature_names_out()

constants.py

@@ -0,0 +1,11 @@
+import os
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+DEFAULT_TEXT_ANNOTATION_FILE = os.path.join(BASE_DIR,"triventure_model_api", "Datasets", "Query", "datasets_text.json")
+DEFAULT_TAGS = os.path.join(BASE_DIR, "triventure_model_api", "Datasets", "Query", "tags.json")
+DEFAULT_DESTINATIONS = os.path.join(BASE_DIR, "triventure_model_api", "Datasets", "Places", "des_retags_copilot.xlsx")
+DEFAULT_WEIGHTS_BIAS_VECTOR = os.path.join(BASE_DIR, "triventure_model_api", "Model_API", "Saved_Model", "weights_bias_vector.npy")
+DEFAULT_FEATURE_NAMES = os.path.join(BASE_DIR, "triventure_model_api", "Model_API", "Saved_Model", "feature_names.npy")
+DEFAULT_PRETRAIN_MODEL_NAME_TOKENIZER = "vinai/phobert-base-v2"
+ONNX_MODEL_PATH = os.path.join(BASE_DIR, "triventure_model_api", "Model_API", "Saved_Model", "key_ner.onnx")

database.py

@@ -0,0 +1,293 @@
+import json
+import os
+import datetime
+
+import numpy as np
+import pymongo
+from pymongo import MongoClient
+from bson.binary import Binary
+from dotenv import load_dotenv
+from bson import ObjectId
+from loguru import logger
+
+load_dotenv()
+
+print(os.environ.get("MONGODB_URL"))
+
+
+class Database:
+    def __init__(self):
+        self.client = None
+        self.db = None
+
+    def connect(self):
+        """
+        Connect to the MongoDB database.
+        """
+        try:
+            # Connect to MongoDB
+            self.client = MongoClient(os.environ.get("MONGODB_URL"))
+            self.db = self.client[os.environ.get("DB_NAME", "triventure")]
+
+            # Create users collection if it doesn't exist
+            if "user" not in self.db.list_collection_names():
+                self.db.create_collection("user")
+
+            return True
+        except Exception as e:
+            logger.error(f"Error connecting to database: {e}")
+            return False
+
+    def close(self):
+        """
+        Close the database connection.
+        """
+        if self.client:
+            self.client.close()
+
+    def create_tables(self):
+        """
+        Create the necessary collections if they don't exist.
+
+        Note: This method is kept for backward compatibility but is no longer used
+        for creating user-specific collections. Instead, user data is stored in collections
+        that are created on-demand when saving user data.
+        """
+        try:
+            # Ensure users collection exists
+            if "user" not in self.db.list_collection_names():
+                self.db.create_collection("user")
+
+            return True
+        except Exception as e:
+            logger.error(f"Error creating collections: {e}")
+            return False
+
+    def create_user_table(self, user_id):
+        """
+        Create a collection for a specific user if it doesn't exist.
+
+        Parameters:
+        user_id (str): The ID of the user.
+
+        Returns:
+        bool: True if the collection was created successfully, False otherwise.
+        """
+        try:
+            # # User data is stored in the "user_data" collection
+            # if "user" not in self.db.list_collection_names():
+            #     self.db.create_collection("user")
+
+            # Add user to the users collection if not exists
+            self.db.user.update_one(
+                {"_id": ObjectId(user_id)},
+                {"$setOnInsert": {"created_at": datetime.datetime.now()}},
+                upsert=True,
+            )
+
+            return True
+        except Exception as e:
+            logger.error(f"Error creating user collection: {e}")
+            return False
+
+    def save_user_weights(self, user_id, weights):
+        """
+        Save user weights to the database.
+
+        Parameters:
+        user_id (str): The ID of the user.
+        weights (numpy.ndarray): The weights to save.
+
+        Returns:
+        bool: True if the weights were saved successfully, False otherwise.
+        """
+        try:
+            # Create user entry if it doesn't exist
+            # if not self.create_user_table(user_id):
+            #     return False
+
+            # Convert numpy array to bytes
+            weights_bytes = Binary(weights.tobytes())
+
+            # Update or insert weights
+            self.db.user.update_one(
+                {"_id": ObjectId(user_id)},
+                {
+                    "$set": {
+                        "weights": weights_bytes,
+                        "weights_updated_at": datetime.datetime.now(),
+                    }
+                },
+            )
+
+            return True
+        except Exception as e:
+            logger.error(f"Error saving user weights: {e}")
+            return False
+
+    def get_user_weights(self, user_id, default_weights):
+        """
+        Get user weights from the database.
+
+        Parameters:
+        user_id (str): The ID of the user.
+        default_weights (numpy.ndarray): The default weights to use if the user doesn't have weights.
+
+        Returns:
+        numpy.ndarray: The weights for the user.
+        """
+        try:
+            # Get weights from user_data collection
+            result = self.db.user.find_one({"_id": ObjectId(user_id)})
+
+            if result and "weights" in result:
+                # Convert bytes to numpy array
+                weights_bytes = result["weights"]
+                weights = np.frombuffer(weights_bytes, dtype=default_weights.dtype)
+                return weights.reshape(default_weights.shape)
+
+            return default_weights
+        except Exception as e:
+            logger.error(f"Error getting user weights: {e}")
+            return default_weights
+
+    def user_weights_exist(self, user_id):
+        """
+        Check if weights exist for the given user.
+
+        Parameters:
+        user_id (str): The ID of the user.
+
+        Returns:
+        bool: True if weights exist for the user, False otherwise.
+        """
+        try:
+            # Check if weights exist in user_data collection
+            result = self.db.user.find_one({"_id": ObjectId(user_id)})
+
+            return result is not None
+        except Exception as e:
+            logger.error(f"Error checking if user weights exist: {e}")
+            return False
+
+    def save_user_metadata(self, user_id, metadata):
+        """
+        Save user metadata to the database.
+
+        Parameters:
+        user_id (str): The ID of the user.
+        metadata (dict): The metadata to save.
+
+        Returns:
+        bool: True if the metadata was saved successfully, False otherwise.
+        """
+        try:
+            # Create user entry if it doesn't exist
+            # if not self.create_user_table(user_id):
+            #     return False
+
+            # Update or insert metadata
+            self.db.user.update_one(
+                {"_id": ObjectId(user_id)},
+                {
+                    "$set": {
+                        "metadata": metadata,
+                        "weights_updated_at": datetime.datetime.now(),
+                    }
+                },
+            )
+
+            return True
+        except Exception as e:
+            logger.error(f"Error saving user metadata: {e}")
+            return False
+
+    def get_user_metadata(self, user_id):
+        """
+        Get user metadata from the database.
+
+        Parameters:
+        user_id (str): The ID of the user.
+
+        Returns:
+        dict: The metadata for the user.
+        """
+        try:
+            # Get metadata from user_data collection
+            result = self.db.user.find_one({"_id": ObjectId(user_id)})
+
+            if result and "metadata" in result:
+                return result["metadata"]
+
+            return {}
+        except Exception as e:
+            logger.error(f"Error getting user metadata: {e}")
+            return {}
+
+    def get_all_user_metadata(self):
+        """
+        Get metadata for all users from the database.
+
+        Returns:
+        dict: A dictionary mapping user IDs to their metadata.
+        """
+        try:
+            # Get metadata for all users
+            results = self.db.user.find({})
+
+            # Build a dictionary of user_id -> metadata
+            metadata = {}
+            for result in results:
+                if "_id" in result and "metadata" in result:
+                    metadata[result["_id"]] = result["metadata"]
+
+            return metadata
+        except Exception as e:
+            logger.error(f"Error getting all user metadata: {e}")
+            return {}
+
+    def get_user_metadata(self, user_id):
+        """
+        Get metadata for a specific user from the database.
+
+        Parameters:
+        user_id (str): The ID of the user.
+
+        Returns:
+        dict: The metadata for the user.
+        """
+        try:
+            # Get metadata from user_data collection
+            result = self.db.user.find_one({"_id": ObjectId(user_id)})
+
+            if result and "metadata" in result:
+                return result["metadata"]
+
+            return {}
+        except Exception as e:
+            logger.error(f"Error getting user metadata: {e}")
+            return {}
+
+    def get_all_users(self):
+        """
+        Get a list of all users from the database.
+
+        Returns:
+        list: A list of all user IDs.
+        """
+        try:
+            # Get all users from users collection
+            results = self.db.user.find({})
+
+            # Extract user IDs
+            user_ids = [str(result["_id"]) for result in results]
+            print("user_ids", user_ids)
+
+            return user_ids
+        except Exception as e:
+            logger.error(f"Error getting all users: {e}")
+            return []
+
+
+# Create a singleton instance
+db = Database()

dictionary.py

@@ -0,0 +1,501 @@
+emotion2wordform_dict = { 
+  	':)'  	:'colonsmile',
+  	':('  	:'colonsad',
+  	'@@'  	:'colonsurprise',
+	'<3'  	:'colonlove',
+	':d'  	:'colonsmilesmile',
+	':3'  	:'coloncontemn',
+	':v'  	:'colonbigsmile',
+	':_'  	:'coloncc',
+	':p'  	:'colonsmallsmile',
+	'>>'  	:'coloncolon',
+	':">' 	:'colonlovelove',
+	'^^'  	:'colonhihi',
+	':'   	:'doubledot',
+	":'(" 	:'colonsadcolon',
+	':’(' 	:'colonsadcolon',
+	':@'  	:'colondoublesurprise',
+	'v.v' 	:'vdotv',
+	'...' 	:'dotdotdot',
+	'/'   	:'fraction',
+	'c#'  	:'cshrap',
+  	'=)'  	:'coloneyesmile',
+  	':3'  	: 'coloncontemn',
+  	'^^'  	: 'colonhihi',
+  	'c++' 	: 'cplusplus',
+  	'&'   	: 'and',
+  	'?'   	:  'dotthinking',
+  	'3dot0'	: 'dotnumbers',
+}
+
+wordform2vnese_dict = {
+        'colonsmile' 		: 'cười nhẹ',
+        'colonsad'   		: 'buồn',
+        'colonsurprise'		: 'ngạc nhiên',
+	'colonlove'     	: 'trái tim',
+	'colonsmilesmile'	: 'cười tươi',
+	'coloncontemn'		: 'dễ thương',
+	'colonbigsmile'		: 'cười nhạt',
+	'coloncc'		: 'thích',
+	'colonsmallsmile'	: 'vui vẻ',
+	'coloncolon'		: 'tuyệt',
+	'colonlovelove'		: 'thẹn thùng',
+	'colonhihi'		: 'hạnh phúc',
+	'doubledot'		: 'như là',
+	'colonsadcolon'		: 'khóc',
+	'colondoublesurprise': 'hơi ngạc nhiên',
+	'vdotv'			: 'vân vân',
+	'dotdotdot'		: 'vân vân',
+	'fraction'		: 'chia',
+	'cshrap'		: 'ngôn ngữ lập trình',
+	'coloneyesmile'		: 'hạnh phúc',
+	'cplusplus'		: 'ngôn ngữ lập trình',
+	'and'			: 'và',
+	'dotthinking'		: 'thắc mắc',
+	'dotnumbers'		: 'chấm',
+}
+
+
+mispelling_dict = {
+        #-----------------------------------------------------------------------------------------------------#
+        # Từ phức:
+
+        'lặp đi lặp lại': ['lập đi lập lại','lập đi lặp lại','lặp đi lập lại','lap di lap lai'],
+        'yêu cầu': ['yêu câu','yêu cau','yeu cầu','yeu câu','yeu cau'],        
+        'kiến thức': ['kiến thực','kiến thưc','kiến thúc','kiến thuc','kiên thức','kiên thưc','kiên thúc','kiên thuc','kien thức','kien thưc','kien thúc','kien thuc'],              
+        'bục giảng': ['bụt giảng', 'bục giãng','bụt giãng','buc giang','but giang','buc giảng','but giảng'],
+        'tận tâm': ['tân tâm','tận tam','tân tam','tan tam'],
+        'tăng cường': ['tăng cương','tăng cuong','tang cuong','tang cường','tang cương'],
+        'trang thiết bị': ['trang thiet bi','trang thết bị','trang thêt bị','trang thiet bị','trang thiêt bị','trang thiêt bị','trang thiêt bi','trang thiêt bi','trang thiết bi','trang thết','trang thiết'],
+        'thiết bị': ['thết bị','thêt bị','thêt bi','thet bị','thet bi','thiêt bị','thiêt bi','thiết bi','thiet bi','thiet bị'],
+        'thống nhất cùng': ['thống nhất cũng'], 
+        'khó khăn': ['khó khắn','khó khắn','khó khẵn','khó khặn','khó khan','kho khăn'],
+        'phòng máy': ['phỏng máy','phong máy','phong may'],
+        'khảo sát': ['khảo sat','khão sát','khão sat','khạo sát','khạo sat','khao sát','khảo sác','khảo sác','khảo sac','khao sat'],
+        ' học sinh ': [' hs ',' học sin ',' hoc sin ','hoc sinh'],       
+        'dễ hiểu': ['dễ hiêu','dê hieu','dê hiêu','de hieu'],
+        'khó hiểu': ['khó hiêu','khó hieu','kho hiểu','kho hiêu','kho hieu'],     
+        ' giảng dạy ': [' giảng dạ ', ' giản dạy ', ' giảng dạyy ',' giảng dậy ',' giang day '],       
+        ' bình thường ': [' bình thưởng ', ' bình thườn ',' binh thuong '],
+        'kéo dài' : ['kéo đài', 'keo dài', 'keo dai'],
+        'bắt đầu' :['bắt đàu', 'bắt đau','bắt đâu','bắt dau','băt đầu','băt đâu','băt đau','băt dau','bat đầu','bat đâu','bat đau','bat dau'],
+        'tìm hiểu' : ['tmf hiểu','tim hieu', 'timf hiểu','tìm hiều'],
+        'áp đặt' : ['áp đặp', 'ap dat'],
+        'lướt qua' : ['lước qua','lươt qua','luot qua'],
+        'bổ sung' : ['bổ xung', 'bo sung', 'bô sung','bỏ sung'],
+        ' giảng viên ' : [' giãng viên ',' giãng vien ',' giảng vien ',' giang viên ',' giản viên ',' giảng viến ',' giang vien ',' gv '],
+        ' giáo viên ' : [' giá viên ',' giao viên ',' giao vien ',' giao viên ',' giáo vien '],
+        'gần gũi': ['gần gủi','gần gui', 'gan gui'],
+        'cộc lốc': ['cọc lốc','cọc lóc','coc loc'],      
+        'vấn đề': ['vẫn đê','vân đê','vấn đê','vân đề','van de','van đề','vấn đe','vấn de'],
+        ' mạnh dạn ': [' mạnh dạng '],     
+        'nhiệt tình': ['nhiêt tình','nhiet tình','nhiệt tinh', 'nhiet tinh'],
+        'bài mẫu': ['bày mẫu','bai mẫu','bai mau'],
+        'truyền đạt': ['truyền đật','truyên dat','truyền đat','truyên đạt','truyên dạt','truyên đat','truyen dat'],      
+        'trắc nghiệm': ['trăc nghiệm','trắc nghiem','trac nghiệm','trac nghiem'],
+        'lập trình': ['lâp trình','lap trình','lap trinh'],
+        'nhắc nhở': ['nhác nhở','nhac nho'],
+        'lên lớp': ['lên lớn','len lop','lên lơp','lên lop'],
+        'hoàn hảo': ['hoan hao'],
+        'nhắn tin': ['nhăn tin','nhan tin'],
+        'hứng thú': ['hướng thú','hung thu'],
+        'cô dạy': ['cố dạy'],
+        'hoàn chỉnh': ['hoàn chính','hoan chinh'],
+        'tận tình': ['tân tình','tận hình','tận tinh','tan tinh'],
+        'cuối cùng': ['cuối cung', 'cuoi cung'],
+        'tiếp xúc': ['tiếp súc','tiếp xuc','tiep xúc','tiep xuc'],
+        ' thực tế ': [' thức tế ',' thức tê ',' thự tế ',' thực tê ',' thực te ',' thưc tế ',' thưc tê ',' thưc te ',' thuc te '],
+        'tâm huyết': ['tâm huyến','tâm huyêt','tam huyêt','tam huyết','tam huyet'],
+        'công nghệ phần mềm': ['cnpm','cong nghe phan mem'],
+        ' công nghệ ': [' côn nghệ ',' côn nghê ',' côn nghẹ ',' côn nghe ',' công nghê ',' công nghẹ ',' công nghe ',' cong nghệ ',' cong nghê ',' cong nghẹ ',' cong nghe '],
+        'nâng cấp': ['năng cấp','nâng câp','nâng cap','nang câp','nang cấp','nang cap'],
+        ' không thể ': [' không thẻ ',' ko thể ',' khum thể ',' k thể ',' không the ',' ko the ',' k the ',' khum the ',' khong the '],      
+        'tham khảo': ['tam khảo','tham khao'],  
+        'giám sát': ['dám sát','giám sat','giam sát','giam sat'],
+        'một số' : ['mốt số','môt số','môt sô','môt so','mot số','mot sô','mot so'],       
+        'hạn chế': ['hạn chê','hạn che','han che'],
+        'cảm ơn' : ['cám ơn', 'cẻm ơn','kẽm ơn','cam on'],
+        'ngắn gọn' : ['ngắn gọc','ngắn gọt','ngắn gõn','ngắn gôn','ngắn gon','ngan gon'],
+        ' đảm bảo chất lượng ' : [' đbcl ',' dbcl '],
+        'đảm bảo' : ['đảm bao','đảm bão','đãm bão','đãm bảo','đãm bao','đam bảo','đam bao','đam bão','dam bảo','dam bao','dam bão'],
+        'hiện nay' : ['hien nay', 'hiên nay','hiện nây'],
+        'quan tâm' : ['quan tấm', 'quan tam'],
+        'nền tảng' : ['nền tẳng', 'nen tang'],
+        'hàng ngày' : ['hằng ngày','hang ngay'],
+        'nâng cao' : ['năng cao','nâng cáo', 'nâng cào', 'nâng cảo','nang cáo', 'nang cào', 'nang cảo','nang cao'],
+        ' phòng đào tạo ' : [' pdt ',' pđt ','phòng đào tao','phòng dao tạo' ,'phong dao tao'],
+        'đào tạo': ['đào tao','đào tảo','đào tão','đao tạo','đao tảo','đao tão','đao tao','dao tảo','dao dão','dao tạo','dao tao'],
+        'khắt khe': ['khắc khe','khăc khe','khăt khe','khat khe'],
+        'lưu loát': ['lưu lát','lưu loat','luu loát','luu loat','lưu lat','luu lat'],
+        ' sinh viên ': [' sv ',' svien ',' sinhvien ',' sinh vien ',' sinh diên ',' sanh diên ',' sanh viên ',' sanh vien '],
+        'dễ thương': ['dẽ thương','dẽ thuong','dễ thuong','dê thương','dê thuong','de thương','de thuong'],
+        'vật lý': ['vậy lý','vậy lí','vật ly','vật li','vât ly','vât li','vat ly','vat li'],
+        ' học kỳ ': [' hk ',' học ky ',' học ki ',' hoc ki ',' hoc ky ',' hoc kì ',' hoc kỳ '],
+        ' học kỳ 1 ': [' hk1 ',' học ky 1 ',' học ki 1 ',' hoc ki 1 ',' hoc ky 1 ',' hoc kì 1 ',' hoc kỳ 1 '],
+        ' học kỳ 2 ': [' hk2 ',' học ky 2 ',' học ki 2 ',' hoc ki 2 ',' hoc ky 2 ',' hoc kì 2 ',' hoc kỳ 2 '],
+        'lười nhát': ['lười nhác','lười nhat','lười nhac','lươi nhát','lươi nhat','luoi nhat'],      
+        ' bài tập ': [' bai tập ',' bài tâp ',' bài tap ',' bai tập ',' bai tâp ',' bai tap ',' btap ',' bt '],
+        ' bài tập về nhà ': [' btvn '],
+        ' ví dụ ': [' vd ',' vdu ',' vidu ',' ví du ',' vi dụ ',' vi du '],       
+        'chất lượng': ['chất lương','chất luong','chât lượng','chât lương','chât luong','chat lượng','chat lương','chat luong'],     
+        ' nội dung ': [' nối dung ',' nối dun ',' nội dun ',' nôi dung ',' nôi dun ',' noi dung '],
+        'thực hành': ['thực hanh','thưc hành','thưc hanh','thuc hành','thuc hanh'],        
+        'hướng dẫn': ['hướng dân','hướng dan','hương dẫn','hương dân','hương dan','huong dẫn','huong dân','huong dan'],
+        'đầy đủ': ['đầy đu','đầy du','đây đủ','đây đu','đây du','đay đủ','đay đu','đay du','day đủ','day đu','day du'],
+        'đúng giờ': ['đúng giơ','đúng gio','đung giờ','đung giơ ','đung gio','dung giờ','dung giơ','dung gio'],
+        'thoải mái': ['thoải mai','thoai mái','thoai mai','thoãi mái','thoãi mai'],       
+        'chi tiết': ['chi tiêt','chi tiet','chy tiết','chy tiêt','chy tiet','chỉ tiết'],
+        'tóm t��t': ['tóm tăt','tóm tat','tom tắt','tom tăt','tom tat'],
+        'hiền lành': ['hiền lanh','hiên lành','hiên lanh','hien lành','hien lanh'],
+        'tận tụy': ['tận tuy','tân tụy','tân tuy','tan tụy','tan tuy'],
+        ' vui vẻ ': [' vui ve ',' vui vee ',' vui vẻe ',' vui vẻee '],
+        'hòa đồng': ['hòa đông','hòa đong','hòa dong','hoa đồng','hoa đông','hoa đong','hoa dong'],
+        'thường xuyên': ['thường xuyen','thương xuyên','thương xuyen','thuong xuyên','thuong xuyen'],
+        'khó chịu': ['khó chiu','kho chịu','khó chiệu','kho chiu'],
+        'cơ sở': ['cơ sỏ','cơ sơ','co sở','co sỏ','co so','cơ sỡ','co sỡ'],
+        'vật chất': ['vật chât','vật chát','vật chat','vât chất','vât chât','vât chát','vât chat','vat chất','vat chât','vat chát','vat chat'],
+        'hấp dẫn': ['hấp dẩn','hấp dân','hấp dan','hâp dẫn','hâp dân','hâp dan','háp dẫn','háp dân','háp dan','hap dẫn','hap dân','hap dan'],
+        ' trẻ trung ': [' tre trung ',' trẽ trung ',' trẻ trun ',' trẽ trun '],
+        'dạy tệ': ['dạy tê','dạy te','day tệ','day tê','day te'],
+        'quá tệ': ['quá tê','quá te','qua tệ','qua tê','qua te'],
+        'tích cực': ['tích cưc','tích cục','tích cuc','tich cực','tich cưc','tich cục','tich cuc'],
+        'tiêu cực': ['tiêu cưc','tiêu cục','tiêu cuc','tieu cực','tieu cưc','tieu cục','tieu cuc'],
+        'hiệu quả': ['hiệu qua','hiêu quả','hiêu qua','hieu quả','hieu qua'],
+        'khô khan': ['khô khán','khô khàn','khô khản','khô khạn'],        
+        'cụ thể': ['cụ thê','cụ thẻ','cụ the','cu thể','cu thê','cu thẻ','cu the'],
+        'lôi cuốn': ['lôi cuôn','lôi cuón','loi cuốn','loi cuôn','loi cuon'],
+        'hỗ trợ': ['hồ trợ','hỗ trơ','hỗ tro','hổ trợ','hô trợ','hô trơ','hô tro','ho trợ','ho trơ','ho tro'],
+        'soạn thảo': ['soản thảo','soạn thao','soan thảo','soan thao'],
+        'theo dõi': ['theo giỏi','theo giõi','theo gioi','theo doi','theo dỏi'],
+        'tự luận': ['tự luân','tự luạn','tự luan','tư luận','tư luân','tư luan','tu luận','tu luân','tu luận'],
+        'đôi lúc': ['đội lúc','đội luc','đôi luc','đoi lúc','đoi luc','doi lúc','doi luc'],
+        'đôi khi': ['đoi khi','doi khi'],
+        'cập nhật': ['cập nhât','cập nhạt','cập nhat','câp nhật','câp nhạt','câp nhat','cap nhật','cap nhât','cap nhạt','cap nhat'],
+        'tài liệu': ['tài liêu','tài liẹu','tài lieu','tai liệu','tai liêu','tai liẹu','tai lieu'],
+        'ý kiến': ['y kiến','y kiên','y kien','ý kiên','ý kien'],
+        'so với': ['so vời','so vơi','so voi','so vói','so vòi'],        
+        'cần dành': ['cần giành','can danh'],
+        'hòa hợp': ['hóa hợp','hòa hơp','hòa hop','hoa hợp','hoa hơp','hoa hop'],
+        'phương pháp':['phương phap','phuong pháp','phuong phap'],
+        'bổ ích': ['bổ ich','bổ ít','bô ích','bô ich','bo ích','bo ich'],
+        ' dạy chán ': [' dạy chan ',' day chán ',' day chan ',' dạy cháng ',' dạy chang ',' day cháng '],
+        'môn học': ['môn hoc','môn hóc','mon học','mon hóc','mon hoc'],
+        ' tuyệt vời ': [' tuyệt vơi ',' tuyệt vòi ',' tuyệt voi ',' tuyêt vời ',' tuyêt vơi ',' tuyêt vòi ',' tuyêt voi ',' tuyet vời ',' tuyet vơi ',' tuyet voi ',' tuỵt vời ',' tuỵt vơi ',' tuỵt vòi ',' tuỵt voi ',' tuyt vời ',' tuyt vơi ',' tuyt vòi ',' tuyệt dời ',' tuyệt dơi ',' tuyet doi '],
+        ' thời gian ': [' thời giang ',' thơi gian ',' thoi gian '],
+        'tuy nhiên': ['tuy nhien','tuy nhiến','tuy nhiền','tuy nhiển','tuy nhiện','tuy nhién','tuy nhièn','tuy nhiẻn','tuy nhiẽn','tuy nhiẹn'],
+        'cung cấp': ['cung câp','cung cap','cung cắp','cung căp','cung cáp'],
+        'phòng học': ['phòng hoc','phòng hóc','phong học','phong hoc','phong hóc'],
+        'xem xét': ['xem xet','xem set','xem sét','sem xét','sem xet','sem set','sem sét'],
+        'vui tính': ['vui tình','vui tỉnh','vui tĩnh','vui tịnh','vui tinh'],
+        'khả năng': ['khả nang','khả nâng','kha nâng','kha năng','kha nang','khã năng','khã nâng','khã nang'],
+        'chu đáo': ['chu đao','chu đạo','chu đảo','chu đào','chu đão','chu dao'],
+        'đề nghị': ['đề nghi','đê nghị','đê nghi','đe nghị','đe nghi','de nghị','de nghi'],
+        'dạy ổn': ['dạy ôn','dạy on','day ổn','day ôn','day on'],
+        ' lan man ': [' lan mang ',' lang man ',' lang mang '],
+        'lớp học': ['lớp hoc','lớp hóc','lơp học','lơp hóc','lơp hoc','lop hóc','lop học','lop hoc'],
+        'bài thi': ['bai thi','bái thi','bải thi','bãi thi','bại thi'],
+        'bài học': ['bài hoc','b��i hóc','bai học','bai hóc','bai hoc'],
+        'làm biếng': ['làm biêng','làm bieng','lam biếng','lam biêng','lam bieng'],
+        'cực kì': ['cực ki','cưc kì','cưc ki','cuc kì','cuc ki','cực ky','cưc kỳ','cưc ky','cuc kỳ','cuc ky'],
+        'thân thiện': ['thân thiên','thân thiẹn','thân thien','than thiện','than thiên','than thiẹn','than thien'],
+        'diễn đạt': ['diễn đat','diễn dạt','diễn dat','diên đạt','diên đat','diên dạt','diên dat','dien đạt','dien đat','dien dạt','dien dat'],
+        'gì đâu': ['gì đau','gì dau','gi đâu','gi đau','gi dau','gí đâu','gí đau','gí dau','j đâu','j đau','j dau'],
+        'thông báo': ['thông bao','thong báo','thong bao','thông bào','thông bảo','thông bão','thong bào','thong bảo','thong bão'],
+        'thích thú': ['thích thu','thích thù','thích thủ','thích thũ','thích thụ','thich thu','thich thù','thich thủ','thich thũ','thich thụ'],
+        'xứng đáng': ['xứng đang','xứng dáng','xứng dang','xưng đáng','xưng đang','xưng dáng','xưng dang','xung đáng','xung đang','xung dáng','xung dang'],
+        'đa dạng': ['đa dang','da dạng','da dang','đa dảng','đa dãng','da dảng','da dãng'],
+        'liên hệ': ['liên hê','liên hẹ','liên he','lien hệ','lien hê','lien hẹ','lien he'],
+        'lý thuyết': ['lý thuyêt','lý thuýet','lý thuyet','ly thuyết','ly thuyêt','ly thuýet','ly thuyet','lí thuyêt','lí thuýet','lí thuyet','li thuyết','li thuyêt','li thuýet','li thuyet'],
+        'vô cùng': ['vô cung','vo cùng','vo cung'],
+        'ý nghĩa': ['ý nghia','ý nghía','ý nghìa','ý nghỉa','ý nghịa','y nghĩa','y nghia','y nghía','y nghìa','y nghỉa','y nghịa'],
+        'cơ hội': ['cơ hôi','cơ hối','cơ hồi','cơ hổi','cơ hỗi','co hội','co hôi','co hối','co hồi','co hổi','co hỗi','cơ hoi','cơ họi','co hoi'],
+        'thú vị': ['thú vi','thu vị','thu vi'],
+        'thuận tiện': ['thuận tiên','thuận tien','thuân tiện','thuân tiên','thuân tien','thuan tiện','thuan tiên','thuan tien'],
+        'trình bày': ['trình bay','trình báy','trình bảy','trình bãy','trình bạy','trinh bày','trinh báy','trinh bảy','trinh bãy','trinh bạy','trinh bay'],
+        ' vận dụng ': [' vận dụn ',' vận dung ',' vân dụng ',' vân dung ',' van dụng ',' van dung '],
+        'hạn hẹp': ['hạn hep','han hẹp','han hep'],
+        'tương tác': ['tương tac','tuong tác','tuong tac'],
+        'buồn ngủ': ['buồn ngu','buồn ngũ','buồn ngụ','buồn ngú','buôn ngủ','buôn ngu','buôn ngũ','buôn ngụ','buôn ngú','buon ngủ','buon ngu','buon ngũ','buon ngụ','buon ngú'],
+        'trao đổi': ['trao đôi','trao đỏi','trao đoi','trao đỗi','trao dỏi','trao dõi','trao doi'],
+        'kĩ năng': ['kĩ nang','ki năng','ki nang','kỉ năng','kỉ nang','kỹ nang','ky năng','ky nang','kỷ năng','kỷ nang'],
+        'trình độ': ['trình đô','trình đọ','trình đo','trình do','trinh độ','trinh đô','trinh đọ','trinh đo','trinh do'],
+        'sư phạm': ['sư pham','su phạm','su pham'],
+        ' hăng say ': [' hăn say ',' hang say '],
+        'câu hỏi': ['câu hõi','câu hoi','câu họi','cau hỏi','cau hõi','cau hoi','cau họi'],
+        ' thời khóa biểu ': [' thời khóa biễu ',' thơi khoa biêu ',' thoi khoa bieu ',' tkb '],
+        ' ứng dụng ': [' ứng dụn ',' ứn dụng ',' ứn dụn ',' ứng dung ',' ưng dụng ',' ưng dung ',' ung dụng '],
+        'tương đối': ['tương đôi','tương đói','tương doi','tuong đối','tuong đôi','tuong đói','tuong doi'],
+        'cải thiện': ['cải thiên','cải thiẹn','cải thien','cãi thiện','cãi thiên','cãi thiẹn','cãi thien','cai thiện','cai thiên','cai thiẹn','cai thien'],
+        'chương trình': ['chương trinh','chuong trình','chuong trinh'],
+
+        #-----------------------------------------------------------------------------------------------------#
+
+        # Từ đơn:
+                      
+        ' về ': [' vê ',' dề ',' dềe ',' vềe ',' vềee ',' vè ',' vèe '],
+        ' ngành ': [' nganh ',' ngánh ',' ngảnh ',' ngãnh ',' ngạnh ',' nghành '],
+        ' được ': [' đươc ',' dc ',' dcc ',' dccc ',' đc ',' đcc ',' đccc ',' duoc ',' đuoc '],
+        ' chỗ ': [' chổ ',' chỗo '],
+        ' nè ': [' nà ',' nèe ',' nèee ',' nèeee '],
+        ' dễ ': [' de2 ',' dễe ',' dể ',' deef '],
+        ' có ' : [' co ',' cóo ',' cóoo ',' cóooo ', ' cóa ',' cóaa ',' cóaaa ', ' cóaaaa ',' coa '],
+        ' giảng ' : [' giảnh ',' giang ',' giãng '],
+        ' giờ ': [' giời ',' gờ ',' h ',' dờ '],
+        ' dạy ': [' giạy ',' dậy học ',' day '],
+        ' thêm ': [' them '],
+        ' bằng ': [' bắng ',' bang '],
+        ' gì ': [' gi ',' gí ',' j ',' jj ',' jjj '],
+        ' không ': [' k ',' ko ',' koo ',' kooo ',' khom ',' khomm ',' khum ',' khumm ',' hong ',' hongg ',' honggg ',' hông ',' hôngg ',' hônggg ',' khong ',' khongg ',' khonggg '],
+        ' rất ': [' rắt ',' rât ',' rat '],
+        ' sao ': [' saoooo ',' xao ',' saoo ',' saooo ',' s '],
+        ' vậy ': [' z ',' zz ',' dãy ',' dãyy ',' dãyyy ',' d ',' vay ',' vayy ',' vayyy ',' zay ',' zayy ',' zayyy ',' v '],
+        ' rõ ': [' rỏ ',' rõo ',' rõoo '],
+        ' dẫn ': [' dẩn ',' dẩnn ',' dẩnnn ',' dẫnn ',' dẫnnn '],
+        ' nhiều ': [' nhìu ',' nhìuu ',' nhìuuu ',' nhiềuu ',' nhiềuuu '],
+        ' cũng ': [' cũn ',' cũm ',' cx ',' cũngg ',' cũnggg '],
+        ' luôn ': [' luon ',' luônn ',' luônnn '],
+        ' buổi ': [' buôi ',' buối ',' buội ',' buỗi ',' buoi ',' bủi ',' bũi '],
+        ' tốt ': [' tôt ',' tôtt ',' tot ',' tott ',' tốtt ',' tốttt '],
+        ' đỉnh ': [' đink ',' đinkk ',' đĩnh ',' đĩnhh ',' dink ',' dinkk ',' đỉnhh ',' đỉnhhh '],
+        ' hay ': [' hayy ',' hayyy ',' hayyyy '],
+        ' nhưng ': [' nhưn ',' nhung '],
+        ' biết ': [' biêt ',' biêtt ',' biêttt ',' bik ',' bikk ',' bikkk ',' bit ',' bít ',' bítt ',' bíttt ',' biếtt ',' biếttt ',' pit ',' pít ',' pítt ',' píttt '],
+        ' rồi ': [' rùi ',' rùii ',' ròi ',' ròii ',' rầu ',' rầuu ',' gòi ',' gòii ',' rồii ',' rồiii ',' r '],
+        ' dở ': [' dởo ',' dỏm ',' dỏmm ',' dõm ',' dõmm ',' do '],
+        ' tệ ': [' cùi bắp ',' cùi mía ',' cùi ',],
+        ' cách ': [' cạch ',' cach '],
+        ' đúng ': [' đung ',' đún ',' đúm ',' đúngg ',' đúnggg '],
+        ' thôi ': [' thoi ',' thoii ',' thoiii ',' thoiiii ',' thoai ',' thoaii ',' thoaiii ',' thoaiiii ',' hoi ',' hoii ',' hoiii ',' hoiiii ',' thui ',' thuii ',' thuiii ',' thuiiii ',' thâu ',' thâuu ',' thâuuu ',' thâuuuu ',' thou ',' thouu ',' thouuu ',' thouuuu '],
+        ' ngủ ': [' ngu ',' ngu3 ',' ngủu ',' ngủuu '],
+        ' tuyệt ': [' tuyệt ',' tuỵt ',' tuyệtt ',' tuyệttt ',' tuyet '],
+        ' với ': [' vs ',' vớii ',' vớiii ',' dới ',' dớii ',' dớiii '],
+        ' hoài ': [' quài ',' quàii ',' quàiii ',' hoàii ',' hoàiii '],
+        ' trời ': [' xời ',' xờii ',' xờiii ',' trờii ',' trờiii ',' troi ',' tr '],
+        ' trường ': [' trương ',' truong '],
+        ' lớp ': [' lop ',' lơp '],
+        ' như ': [' nhu ',' nhưu '],
+        ' giỏi ': [' gioi ',' giói ',' giòi ',' giõi ',' giọi '],
+        ' cao ': [' kao ',' caoo ',' kaoo '],
+        ' hết ': [' het ',' hêt ',' hếtt '],
+        ' nữa ': [' nưa ',' nựa ',' nx ',' nữaa ',' nữaaa '],
+        ' điểm ': [' điêm ',' điem ',' diem '],
+        ' giữa ': [' giưa ', ' giua '],
+        ' giúp ': [' giup ',' giụp '],
+        ' thầy ': [' thày ']
+        }
+
+translate_dict = {
+        ' bài trình chiếu ': [' slide ','slides'],
+        ' đầy đủ ': [' full '],
+        ' hội thảo ': [' seminar '],
+        ' thời hạn ': [' deadline ','deadlines', ' dealine ',' dl ',' dline '],
+        ' kiểm tra ': [' test ','tests',' check ','checks'],
+        ' tổng quan ': [' overview '],
+        ' được ': [' ok ',' oke ',' okela ',' okelaa ','okelaaa',' okay ',' okee ','okeee',' oki ',' okii ','okiii'],
+        ' bộ dụng cụ ': [' kit '],
+        ' thực hành ': [' lab '],
+        ' đăng tải ' : [' post ',' up '],
+        ' tải lên ' : [' upload ','uploads'],
+        ' chủ đề ' :[' topic '],
+        ' bài học ' : [' unit ','units'],
+        ' trò chơi ' :[' game ','games'],
+        ' phần mềm ' : [' wireshark ', ' silverlight ',' proteus '],
+        ' sao chép ' :[' copy ',' copies ','copys'],
+        ' dán ' : [' paste ','pastes'],
+        ' tệp ' : [' file ','files'],
+        ' giao diện ' : [' console ',' win form '],
+        ' mô hình ứng dụng ' : [' pattern serverside ',' lập tình windows ',' lập trình window ',' lập trình windows '],
+        ' lập trình hướng đối tượng ' : [' oop ',' java '], 
+        ' ngôn ngữ lập trình ' : [' prolog '],
+        ' trang mạng ' :[' web ',' webs ',' wed ', ' website ','websites',' progressive web app ',' web app ',' web apps ',' webs app ',' webs apps ',' amp ',' seo '],
+        ' sách điện tử ': [' ebook ','ebooks', ' e-book ','e-books'],
+        ' công ty ' : [' altera '],
+        ' ngôn ngữ truy vấn ' : [' sql '],
+        ' dự án ': [' project ',' proj '],
+        ' chia sẻ ': [' share '],
+        ' cập nhật ': [' update '],
+        ' công nghệ thông tin ': [' it '],
+        ' trả lời ': ['reply',' rep '],
+        ' không ': [' nope ',' no ',' not '],
+        ' tiếng anh ': [' english ',' engrisk ',' englisk ',' eng '],
+        ' là ': [ ' is ',' are ',' was ',' were '],
+        ' rất ': [' very '],
+        ' tốt ': [' good ',' gud ',' gút ',' gut ',' gudd ',' best ',' the best ',' bestt ','besttt'],
+        ' khóa học ': [' courses ',' crs ',' course ',' coursera ','courseras'],
+        ' trình bày thử ': [' demo '],
+        ' hoàn hảo ': [' perfect ',' perf ','perfection'],
+        ' nhắn tin ': [' chat ',' chats ',' ib ',' inbox ',' ibox ',' chitchat ',' chatting '],
+        ' tư duy ': [' logic ','logics'],
+        ' nộp ': [' submit '],
+        ' trẻ trung ': [' teen '],
+        ' ngoài trời ' : [' outdoor ','outdoors'],
+        ' hoạt động ': [' activity ', ' activities '],
+        ' vui ' :[' funny ', ' fun ','funnys','funnies'],
+        ' hệ điều hành ' : [' linux ',' windows ', ' win server '],
+        ' góp ý ' : [' feed back ',' feed backs ',' feedback ',' feedbacks '],
+        ' phương pháp học tập ' : [' projectbase ','projectbases',' project-base ','project-bases'],
+        ' nhóm ' : [' team ',' group '],
+        ' dễ thương ' : [' cute ',' cutee ','cuteee'],
+        ' đào tạo ' : [' train ','trains',' training ','trainings','trained'],
+        ' thích ' : [' like ','likes'],
+        ' thất bại ' : ['failse',' fail ','failed',' fails '],
+        ' ông chủ ' : [' boss ','bosses'],
+        ' phòng trò chuyện ' : [' chat room ','chat rooms'],
+        ' thêm ' : [' add ','addition'],
+        ' tên ' : [' name ','names'],
+        ' kích cỡ ' : [' size ','sizes'],
+        ' thiết kế phần mềm ' : [' design pattern ',' design patterns ',' designs pattern ',' designs patterns '],
+        ' sơ đồ luồng dữ liệu ' : [' dfd '],
+        ' phiên bản ' : [' version ',' versions '],
+        ' vi mạch tích hợp ' : [' nfc ',' NearField Communication ',' NearField Communications ',' Near-Field Communication ', ' Near-Field Communications '],
+        ' dễ ' : [' easy ',' ez ',' easies ',' easys '],
+        'từng bước một' : ['step by step','steps by steps','steps by step','step by steps'],
+        ' quá giờ ': [' over time ',' over times ',' overtime ',' overtimes '],
+        ' buổi thuyết trình ': [' buổi present ',' buổi presents ',' presentation ',' presentations '],
+        ' thuyết trình ': [' present ',' presents '],
+        ' tải ': [' down ',' downs ',' download ',' downloads '],
+        ' phong cách ': [' style ',' styles '],
+        ' cực kì ': [' max ',' maxx ',' maxxx '],
+        ' cấp độ ': [' level ',' levels ',' lv '],
+        ' bình luận ': [' comment ',' comments ',' cmt ',' cmts '],
+        ' sách giáo khoa ': [' textbook ',' textbooks ',' book ',' books '],
+        ' cơ bản ': [' basic ',' basics '],
+        ' phản biện ': [' debate ',' debates '],
+        ' trả lời tin nhắn ': [' rep mail ',' rep mails ',' reply mail ',' reply mails '],
+        ' nhắn tin ': [' mail ',' mails '],
+        ' đỉnh ': [' pro ',' proo ',' prooo ',' vip ',' vipp ',' vippp '],
+        ' bỏ phiếu ': [' vote ',' votes ']
+        }
+
+
+
+number_dict = {
+    '0%': 'không phần trăm',
+    '5%': 'năm phần trăm',
+    '10%': 'mười phần trăm',
+    '15%': 'mười lăm phần trăm',
+    '20%': 'hai mươi phần trăm',
+    '25%': 'hai mươi lăm phần trăm',
+    '30%': 'ba mươi phần trăm',
+    '35%': 'ba mươi lăm phần trăm',
+    '40%': 'bốn mươi phần trăm',
+    '45%': 'bốn mươi lăm phần trăm',
+    '50%': 'năm mươi phần trăm',
+    '55%': 'năm mươi lăm phần trăm',
+    '60%': 'sáu mươi phần trăm',
+    '65%': 'sáu mươi lăm phần trăm',
+    '70%': 'bảy mươi phần trăm',
+    '75%': 'bảy mươi lăm phần trăm',
+    '80%': 'tám mươi phần trăm',
+    '85%': 'tám mươi lăm phần trăm',
+    '90%': 'chín mươi phần trăm',
+    '95%': 'chín mươi lăm phần trăm',
+    '100%': 'trăm phần trăm',
+
+
+
+    '0': 'không',
+    '1': 'một',
+    '2': 'hai',
+    '3': 'ba',
+    '4': 'bốn',
+    '5': 'năm',
+    '6': 'sáu',
+    '7': 'bảy',
+    '8': 'tám',
+    '9': 'chín',
+    '10': 'mười',
+    '11': 'mười một',
+    '12': 'mười hai',
+    '13': 'mười ba',
+    '14': 'mười bốn',
+    '15': 'mười lăm',
+    '16': 'mười sáu',
+    '17': 'mười bảy',
+    '18': 'mười tám',
+    '19': 'mười chín',
+    '20': 'hai mươi',
+    '21': 'hai mươi mốt',
+    '22': 'hai mươi hai',
+    '23': 'hai mươi ba',
+    '24': 'hai mươi bốn',
+    '25': 'hai mươi lăm',
+    '26': 'hai mươi sáu',
+    '27': 'hai mươi bảy',
+    '28': 'hai mươi tám',
+    '29': 'hai mươi chín',
+    '30': 'ba mươi',
+    '31': 'ba mươi mốt',
+    '32': 'ba mươi hai',
+    '33': 'ba mươi ba',
+    '34': 'ba mươi bốn',
+    '35': 'ba mươi lăm',
+    '36': 'ba mươi sáu',
+    '37': 'ba mươi bảy',
+    '38': 'ba mươi tám',
+    '39': 'ba mươi chín',
+    '40': 'bốn mươi',
+    '41': 'bốn mươi mốt',
+    '42': 'bốn mươi hai',
+    '43': 'bốn mươi ba',
+    '44': 'bốn mươi bốn',
+    '45': 'bốn mươi lăm',
+    '46': 'bốn mươi sáu',
+    '47': 'bốn mươi bảy',
+    '48': 'bốn mươi tám',
+    '49': 'bốn mươi chín',
+    '50': 'năm mươi',
+    '51': 'năm mươi mốt',
+    '52': 'năm mươi hai',
+    '53': 'năm mươi ba',
+    '54': 'năm mươi bốn',
+    '55': 'năm mươi lăm',
+    '56': 'năm mươi sáu',
+    '57': 'năm mươi bảy',
+    '58': 'năm mươi tám',
+    '59': 'năm mươi chín',
+    '60': 'sáu mươi',
+    '61': 'sáu mươi mốt',
+    '62': 'sáu mươi hai',
+    '63': 'sáu mươi ba',
+    '64': 'sáu mươi bốn',
+    '65': 'sáu mươi lăm',
+    '66': 'sáu mươi sáu',
+    '67': 'sáu mươi bảy',
+    '68': 'sáu mươi tám',
+    '69': 'sáu mươi chín',
+    '70': 'bảy mươi',
+    '71': 'bảy mươi mốt',
+    '72': 'bảy mươi hai',
+    '73': 'bảy mươi ba',
+    '74': 'bảy mươi bốn',
+    '75': 'bảy mươi lăm',
+    '76': 'bảy mươi sáu',
+    '77': 'bảy mươi bảy',
+    '78': 'bảy mươi tám',
+    '79': 'bảy mươi chín',
+    '80': 'tám mươi',
+    '81': 'tám mươi mốt',
+    '82': 'tám mươi hai',
+    '83': 'tám mươi ba',
+    '84': 'tám mươi bốn',
+    '85': 'tám mươi lăm',
+    '86': 'tám mươi sáu',
+    '87': 'tám mươi bảy',
+    '88': 'tám mươi tám',
+    '89': 'tám mươi chín',
+    '90': 'chín mươi',
+    '91': 'chín mươi mốt',
+    '92': 'chín mươi hai',
+    '93': 'chín mươi ba',
+    '94': 'chín mươi bốn',
+    '95': 'chín mươi lăm',
+    '96': 'chín mươi sáu',
+    '97': 'chín mươi bảy',
+    '98': 'chín mươi tám',
+    '99': 'chín mươi chín',
+    '100': 'một trăm'
+    }
+
+# Từ đơn: 50 từ
+# Từ phức: 163 từ

get_default_weight.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+from config import destinations, feature_names, sorted_tags_dict, tags_vector
+
+
+def create_bias_weights():
+    """
+    Create a weights vector for bias based on the given tags and weights.
+    The function initializes a weights vector to zero, then maps the weights from the weights_tags_vector to the appropriate positions in the weights_vector based on the tags present in the destinations.
+    """
+    weights_tags_vector = [
+        [15, 15, 0.9, 15, 15, 10, 1, 5, 0.6, 0.9, 0.9, 0.8, 10, 10, 1, 15],
+        [15, 15, 0.9, 15, 15, 10, 15, 1, 10, 0.6, 0.9, 0.9, 0.8, 10, 10, 15, 0.8, 15],
+        [15, 0.9, 0.8, 15, 15, 1, 10, 10, 0.6, 0.9, 0.9, 0.8, 5, 5, 1, 15],
+        [15, 15, 0.9, 15, 0.7, 15, 15, 15, 1, 10, 10, 1, 0.9, 0.9, 0.9, 5, 5, 15, 0.8, 15],
+        [10, 10, 15, 15, 0.8, 0.9, 15, 15, 15, 1, 10, 10, 0.6, 0.5, 0.9, 0.9, 0.8, 0.7, 15, 15, 15, 15, 15],
+        [0.8, 0.9, 15, 0.8, 15, 0.9, 10, 15, 0.9, 0.9, 0.9, 0.8, 15, 10, 1, 15],
+        [0.9, 0.8, 5, 1, 0.9, 10, 15, 0.9, 0.9, 0.9, 0.9, 0.8, 15, 1, 1, 15],
+        [0.8, 0.9, 5, 1, 15, 15, 0.9, 0.9, 0.9, 0.8, 15, 1, 15],
+        [0.8, 0.7, 15, 15, 1, 10, 0.7, 0.7, 0.6, 5, 5, 15],
+        [0.8, 5, 1, 15, 15, 15, 0.7, 0.7, 15],
+        [0.8, 0.7, 1, 15, 15, 0.7, 0.7, 15],
+        [0.8, 0.7, 1, 15, 15, 15, 0.7, 0.9, 15],
+        [0.8, 0.7, 1, 15, 15, 0.7, 0.7, 15],
+        [0.8, 0.7, 1, 15, 15, 15, 0.7, 0.7, 15],
+        [0.8, 0.7, 1, 15, 15, 15, 1, 10, 15],
+        [10, 0.9, 0.8, 1, 15, 15, 15, 0.8, 10, 15],
+        [0.8, 15, 1, 15, 15, 0.8, 10, 15],
+        [10, 0.8, 1, 15, 1, 0.9, 0.8, 5, 0.8],
+        [0.8, 15, 1, 5, 0.9, 0.8, 0.7, 0.7],
+        [0.9, 0.8, 15, 1, 15, 0.7, 0.8, 0.7, 0.7, 5, 5, 15],
+        [0.8, 0.7, 1, 5, 0.9, 10, 10, 15],
+        [0.8, 1, 15, 15, 1, 0.9, 0.8, 0.8, 15],
+        [0.8, 1, 10, 5, 5, 15],
+        [0.8, 0.7, 1, 15, 15, 0.8, 0.9, 15],
+        [10, 10, 10, 1, 10, 0.8, 1, 5, 10, 10, 10, 10, 1, 0.9, 1, 1, 15],
+        [0.8, 0.7, 1, 15, 15, 0.8, 0.9, 15],
+        [0.8, 0.7, 1, 10, 10, 0.8, 0.9, 15],
+        [10, 0.8, 0.7, 15, 15, 1, 15, 15, 0.7, 0.7, 0.6, 5, 5, 1, 15],
+        [5, 0.8, 0.7, 5, 5, 1, 10, 10, 0.7, 0.7, 0.6, 5, 5, 1, 15],
+        [0.8, 0.7, 15, 5, 1, 10, 10, 10, 0.8, 0.7, 0.7, 5, 5, 5, 10, 15],
+        [5, 5, 10, 15, 15, 15, 15, 0.9, 0.8, 0.7, 0.7, 1, 15],
+        [10, 10, 15, 15, 10, 5, 1, 15, 15, 15, 15, 0.7, 5, 5, 0.8, 1, 15],
+        [10, 15, 15, 15, 10, 10, 1, 1, 1, 15, 15, 5, 5],
+        [0.8, 0.7, 0.6, 0.8, 1, 1, 1, 0.9, 0.8, 0.7, 0.7, 0.6, 5, 5, 1, 15],
+        [1, 0.8, 0.9, 0.7, 0.6, 1, 0.9, 0.8, 1, 1, 0.9, 0.8, 0.8, 0.7, 0.9, 5, 5, 15],
+        [1, 0.8, 0.9, 0.7, 0.6, 1, 0.9, 0.8, 1, 1, 0.9, 0.7, 0.6, 0.8, 0.8, 0.8, 0.7, 5, 5, 1, 0.7, 0.6, 15],
+        [0.9, 0.7, 1, 1, 0.8, 0.7, 0.8, 0.8, 0.7, 1, 1, 1, 1, 15]
+    ]
+    #Create a weights vector initialized to zero
+    weights_vector = np.zeros(tags_vector.shape)
+
+    # Map weights to the appropriate positions in the weights_vector
+    for i, row in enumerate(destinations["tags"][1:].values):
+        tags = row.split()
+        for tag, weight in zip(tags, weights_tags_vector[i]):
+            index = np.where(feature_names == tag.lower())[0][0]
+            weights_vector[i][index] = weight
+    np.save("Datasets/Weights/weights_bias.npy", weights_vector)
+
+def create_freq_weights():
+    """
+    This function creates a weights vector for frequency-based weights based on the given tags and their frequencies.
+    The function initializes a weights vector to zero, then maps the weights from the sorted_tags_dict to the appropriate positions in the weights_vector based on the tags present in the destinations.
+    The weights are calculated as the ratio of the tag's frequency to the maximum frequency among all tags.
+
+    Parameters:
+    tags_vector (numpy.ndarray): A 2D numpy array representing the tags vector. Each row corresponds to a destination, and each column corresponds to a tag. The value at each position is 1 if the tag is present in the destination, and 0 otherwise.
+    sorted_tags_dict (dict): A dictionary where the keys are the tags and the values are their frequencies.
+    feature_names (numpy.ndarray): A 1D numpy array representing the names of the features (tags).
+    destinations (pandas.DataFrame): A pandas DataFrame containing the destinations data, including the tags column.
+
+    Returns:
+    numpy.ndarray: A 2D numpy array representing the weights vector for frequency-based weights. Each row corresponds to a destination, and each column corresponds to a tag. The value at each position represents the weight of the tag for that destination.
+    """
+    #Create a weights vector initialized to zero
+    weights_vector = np.zeros(tags_vector.shape)
+    max_freq = max(sorted_tags_dict.values())
+    
+    # Map weights to the appropriate positions in the weights_vector
+    for i, row in enumerate(destinations['tags'][1:].values):
+        tags = row.split()
+        for tag in tags:
+            index = np.where(feature_names == tag.lower())[0][0]
+            weights_vector[i][index] = f"{(sorted_tags_dict[tag.replace('_', ' ')]/max_freq):.2f}"
+    np.save("Datasets/Weights/weights_freq.npy", weights_vector)
+
+create_bias_weights()
+create_freq_weights()
+
+weights_bias_vector = np.load("Datasets/Weights/weights_bias.npy")
+weights_freq = np.load("Datasets/Weights/weights_freq.npy")
+weighted_tags_vector = weights_bias_vector

get_destinations.py

@@ -0,0 +1,66 @@
+import numpy as np
+
+from config import vectorizer
+from get_default_weight import destinations, weights_bias_vector
+from user_weights import get_user_weights
+
+
+def get_des_accumulation(question_vector, weights_bias_vector):
+    accumulation = 0
+    for index in range(len(weights_bias_vector)):
+        if question_vector[index]==1:
+            accumulation += weights_bias_vector[index]
+            
+    return accumulation
+
+def get_destinations_list(question_vector, top_k, user_id=None):
+    des = destinations
+    des = des[1:].reset_index(drop=True)
+    """
+    This function calculates the accumulated scores for each destination based on the given question vector and weights vector.
+    It then selects the top 5 destinations with the highest scores and returns their names.
+    Parameters:
+    question_vector (numpy.ndarray): A 1D numpy array representing the question vector. Each element corresponds to a tag, and its value is 1 if the tag is present in the question, and 0 otherwise.
+    weights_bias_vector (numpy.ndarray): A 2D numpy array representing the weights vector. Each row corresponds to a destination, and each column corresponds to a tag. The value at each position represents the weight of the tag for that destination.
+    Returns:
+    destinations_list: A list of strings representing the names of the top k destinations with the highest scores.
+    """
+    # Use user-specific weights if available, otherwise use default weights
+    weights_vector = weights_bias_vector
+    if user_id is not None:
+        weights_vector = get_user_weights(user_id, weights_bias_vector)
+    
+    accumulation_dict = {}
+    for index in range(len(weights_vector)):
+        accumulation = get_des_accumulation(question_vector[0], weights_vector[index])
+        accumulation_dict[str(index)] = accumulation
+    
+    top_keys = sorted(accumulation_dict, key=accumulation_dict.get, reverse=True)
+    print(f"Top keys: {top_keys}")
+    scores = [accumulation_dict[key] for key in top_keys]
+    q1_score = np.percentile(scores, 25)
+    destinations_list = []
+    for key in top_keys:
+        if accumulation_dict[key] > q1_score:
+            destinations_list.append(des["name"][int(key)])
+            print(f"{des['name'][int(key)]}: {accumulation_dict[key]}")
+    
+    return destinations_list[:top_k]
+
+def get_question_vector(question_tags):
+    """
+    Generate a question vector based on the given list of question tags.
+
+    Parameters:
+    question_tags (list): A list of strings representing the tags associated with the question.
+        Each tag is a word or phrase that describes a characteristic of a destination.
+
+    Returns:
+    numpy.ndarray: A 2D numpy array representing the question vector.
+        The array is transformed from the input list of question tags using a vectorizer.
+        Each row in the array corresponds to a tag, and its value is either 0 or 1.
+        The length of each row is equal to the number of unique tags in the dataset.
+    """
+    question_tags = [question_tags]
+    question_vector = vectorizer.transform(question_tags).toarray()
+    return question_vector

load_data.py

@@ -0,0 +1,38 @@
+import json
+from constants import DEFAULT_TEXT_ANNOTATION_FILE
+
+with open(DEFAULT_TEXT_ANNOTATION_FILE, 'r', encoding='utf-8') as file:
+    data = json.load(file)
+    
+# Prepare sentences and labels
+sentences = [item[0] for item in data["annotations"]]
+"""
+List[str]: A list of sentences extracted from the dataset.
+Each sentence corresponds to an annotation in the dataset.
+"""
+
+labels = [item[1]['entities'] for item in data["annotations"]]
+"""
+List[List[Tuple[str, str]]]: A list of entity labels for each sentence.
+Each label is a tuple containing the entity text and its corresponding tag.
+"""
+
+# Define tags
+tags = data["classes"]
+"""
+List[str]: A list of all possible entity tags (classes) in the dataset.
+These tags will be used to label the tokens in each sentence.
+"""
+
+# Convert tags to indices
+tag2idx = {tag: 0 for idx, tag in enumerate(tags)}
+for label in labels:
+    for entity in label:
+        tag2idx[entity[1]] = tag2idx[entity[1]] + 1
+# Sort the dictionary by values
+sorted_tags = dict(sorted(tag2idx.items(), key=lambda item: item[1],reverse=True))
+sorted_tags = {key: value for key, value in sorted_tags.items() if value != 0}
+
+new_tag = {'<pad>': 0}
+
+sorted_tags = {**new_tag, **sorted_tags}

model_predict_onnx.py

@@ -0,0 +1,59 @@
+import numpy as np
+import onnxruntime as ort
+from DataProcessing import read_input
+from load_data import sorted_tags
+from transformers import AutoTokenizer
+from constants import ONNX_MODEL_PATH,DEFAULT_PRETRAIN_MODEL_NAME_TOKENIZER
+class Key_Ner_ONNX_Predictor:
+    def __init__(self, model_path, tokenizer, tag_map):
+        """
+        Initialize the ONNX predictor.
+        Args:
+            model_path (str): Path to the ONNX model.
+            tokenizer (BertTokenizer): Tokenizer to process input sentences.
+            tag_map (Dict[int, str]): Mapping of indices to tags.
+        """
+        self.session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
+        self.tokenizer = tokenizer
+        self.tag_map = tag_map
+
+    def predict(self, sentence):
+        """
+        Predict tags using the ONNX model.
+        Args:
+            sentence (str): Input sentence.
+        Returns:
+            Tuple[str, List[str]]: Original sentence and predicted tags.
+        """
+        sentence = read_input(sentence)
+        tokens = self.tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
+
+        # Convert to int64 (ONNX requirement)
+        input_ids = tokens["input_ids"].astype(np.int64)
+        attention_mask = tokens["attention_mask"].astype(np.int64)
+
+        # Run inference
+        outputs = self.session.run(None, {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask
+        })
+
+        logits = outputs[0]
+        predicted_tags = np.argmax(logits, axis=2)[0]
+
+        # Convert indices to tags
+        predicted_tags = [self.tag_map[idx] for idx in predicted_tags]
+        print("PREDICTING", predicted_tags)
+        predicted_tags = set(predicted_tags)
+        predicted_tags.discard('<pad>')
+        predicted_tags = [tag.replace(" ", "_") for tag in predicted_tags]
+
+        return self.tokenizer.decode(input_ids[0], skip_special_tokens=True), predicted_tags
+
+# Initialize ONNX-based predictor
+tokenizer = AutoTokenizer.from_pretrained(DEFAULT_PRETRAIN_MODEL_NAME_TOKENIZER)
+onnx_predictor = Key_Ner_ONNX_Predictor(
+    model_path=ONNX_MODEL_PATH,
+    tokenizer=tokenizer,
+    tag_map=dict(enumerate(sorted_tags))
+)

requirements.txt

@@ -0,0 +1,12 @@
+python-dotenv
+onnxruntime
+uvicorn
+pymongo
+fastapi
+pandas
+scikit-learn
+openpyxl
+transformers
+underthesea==6.8.4
+underthesea_core==1.0.4
+loguru

user_weights.py

@@ -0,0 +1,205 @@
+import datetime
+import json
+
+import numpy as np
+from database import db
+
+
+def get_user_weights(user_id, default_weights):
+    """
+    Get the weights for the given user. If the user doesn't have weights,
+    return the default weights.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    default_weights (numpy.ndarray): The default weights to use if the user doesn't have weights.
+    
+    Returns:
+    numpy.ndarray: The weights for the user.
+    """
+    weights = db.get_user_weights(user_id, default_weights)
+    if weights is not None:
+        return weights.copy()
+    else:
+        return default_weights.copy()
+
+def user_weights_exist(user_id):
+    """
+    Check if weights exist for the given user.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    
+    Returns:
+    bool: True if weights exist for the user, False otherwise.
+    """
+    return db.user_weights_exist(user_id)
+
+def save_user_weights(user_id, weights):
+    """
+    Save the weights for the given user.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    weights (numpy.ndarray): The weights to save.
+    
+    Returns:
+    bool: True if the weights were saved successfully, False otherwise.
+    """
+    return db.save_user_weights(user_id, weights)
+
+def update_user_weights(user_id, tag_indices, new_weights, default_weights):
+    """
+    Update the weights for the given user at the specified tag indices.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    tag_indices (list): The indices of the tags to update.
+    new_weights (list): The new weights for the tags.
+    default_weights (numpy.ndarray): The default weights to use if the user doesn't have weights.
+    
+    Returns:
+    bool: True if the weights were updated successfully, False otherwise.
+    """
+    weights = get_user_weights(user_id, default_weights)
+    
+    # Update the weights
+    for i, tag_index in enumerate(tag_indices):
+        for j in range(len(weights)):
+            weights[j][tag_index] = new_weights[i]
+    
+    return save_user_weights(user_id, weights)
+
+def update_weights_from_query(user_id, query_tags, feature_names, default_weights):
+    """
+    Update weights based on user query. For each tag in the query, if a destination
+    has that tag with a weight > 0, increase the weight by 5.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    query_tags (list): The tags from the user's query.
+    feature_names (numpy.ndarray): The names of all features (tags).
+    default_weights (numpy.ndarray): The default weights to use if the user doesn't have weights.
+    
+    Returns:
+    bool: True if the weights were updated successfully, False otherwise.
+    """
+    weights = get_user_weights(user_id, default_weights)
+    print(f"weights: {weights}")
+    # Find indices of query tags
+    tag_indices = []
+    for tag in query_tags:
+        # Find the index of the tag in feature_names
+        matches = np.where(feature_names == tag.lower())[0]
+        if len(matches) > 0:
+            tag_indices.append(matches[0])
+    
+    # Update weights for destinations that have these tags
+    for tag_index in tag_indices:
+        for dest_index in range(len(weights)):
+            # If the destination has this tag with weight > 0, increase by 5
+            if weights[dest_index][tag_index] > 0:
+                weights[dest_index][tag_index] += 5
+    
+    return save_user_weights(user_id, weights)
+
+def update_weights_from_feedback(user_id, destination_id, tag_id, rating, default_weights):
+    """
+    Update weights based on user feedback (star rating).
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    destination_id (int): The ID of the destination.
+    tag_id (int): The ID of the tag.
+    rating (int): The star rating (1-5).
+    default_weights (numpy.ndarray): The default weights to use if the user doesn't have weights.
+    
+    Returns:
+    bool: True if the weights were updated successfully, False otherwise.
+    """
+    weights = get_user_weights(user_id, default_weights)
+    
+    # Adjust weight based on rating
+    if rating == 5:
+        weights[destination_id][tag_id] += 5
+    elif rating == 4:
+        weights[destination_id][tag_id] += 3
+    elif rating == 3:
+        weights[destination_id][tag_id] += 1
+    elif rating == 2:
+        weights[destination_id][tag_id] -= 3
+    elif rating == 1:
+        weights[destination_id][tag_id] -= 5
+    
+    return save_user_weights(user_id, weights)
+
+def get_user_metadata(user_id):
+    """
+    Get the metadata for a specific user.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    
+    Returns:
+    dict: The metadata for the user.
+    """
+    return db.get_user_metadata(user_id)
+
+def update_user_metadata(user_id, metadata):
+    """
+    Update the metadata for the given user.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    metadata (dict): The metadata for the user.
+    
+    Returns:
+    bool: True if the metadata was updated successfully, False otherwise.
+    """
+    # Get existing metadata
+    existing_metadata = db.get_user_metadata(user_id)
+    
+    # Update with new metadata
+    existing_metadata.update(metadata)
+    
+    # Save updated metadata
+    return db.save_user_metadata(user_id, existing_metadata)
+
+def track_question_tags(user_id, question_tags):
+    """
+    Track the tags from a user's question, keeping the last 5 questions.
+    
+    Parameters:
+    user_id (str): The ID of the user.
+    question_tags (list): The tags from the user's question.
+    
+    Returns:
+    bool: True if the tags were tracked successfully, False otherwise.
+    """
+    # Get existing metadata
+    metadata = db.get_user_metadata(user_id)
+    
+    # Initialize recent_tags if it doesn't exist
+    if "recent_tags" not in metadata:
+        metadata["recent_tags"] = []
+    
+    # Add new tags to the beginning of the list
+    metadata["recent_tags"].insert(0, {
+        "timestamp": str(datetime.datetime.now()),
+        "tags": question_tags
+    })
+    
+    # Keep only the last 5 entries
+    metadata["recent_tags"] = metadata["recent_tags"][:5]
+    
+    # Save updated metadata
+    return db.save_user_metadata(user_id, metadata)
+
+def get_all_users():
+    """
+    Get a list of all users.
+    
+    Returns:
+    list: A list of all user IDs.
+    """
+    return db.get_all_users()