Upload 13 files

.gitattributes

@@ -33,3 +33,5 @@ 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
+data/data.db filter=lfs diff=lfs merge=lfs -text
+data/fakedb.db filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,4 @@
+from ui import demo
+
+if __name__ == "__main__":
+    demo.launch()

client.py

@@ -0,0 +1,106 @@
+from huggingface_hub import InferenceClient
+from init import ACCESS_TOKEN, SYSTEM_PROMPT
+from utils import extract_sql, is_sql
+from database import execute
+
+
+client = InferenceClient()
+
+
+def respond(message, history, system_message, max_tokens, temperature, top_p):
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    # Xử lý lịch sử chat
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    # Tạo response đầu tiên
+    response = ""
+    for message in client.chat.completions.create(
+        model="Qwen/Qwen2.5-3B-Instruct",
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+        messages=messages,
+    ):
+        token = message.choices[0].delta.content
+        response += token
+        yield response
+
+    # Xử lý logic SQL và retry
+    if is_sql(response):
+        sql_query = extract_sql(response)
+        max_attempts = 3
+        attempts = 0
+        sql_result = None
+        last_error = None
+
+        while attempts < max_attempts:
+            try:
+                sql_result = execute(sql_query)
+                break
+            except Exception as e:
+                last_error = str(e)
+                attempts += 1
+                if attempts < max_attempts:
+                    # Thêm thông tin lỗi vào context và yêu cầu mô hình hỏi lại người dùng
+                    clarification_prompt = f"""Tôi gặp lỗi khi thực hiện truy vấn SQL: {last_error}
+                    Bạn có thể cung cấp thêm thông tin hoặc chỉnh sửa câu hỏi để tôi có thể sửa truy vấn không?"""
+                    messages += [
+                        {"role": "assistant", "content": response},
+                        {"role": "user", "content": clarification_prompt},
+                    ]
+
+                    # Tạo response yêu cầu thông tin thêm
+                    response = ""
+                    for message in client.chat.completions.create(
+                        model="Qwen/Qwen2.5-3B-Instruct",
+                        max_tokens=max_tokens,
+                        stream=True,
+                        temperature=temperature,
+                        top_p=top_p,
+                        messages=messages,
+                    ):
+                        token = message.choices[0].delta.content
+                        response += token
+                        yield response
+
+                    # Nếu mô hình cung cấp SQL mới, tiếp tục thử
+                    if is_sql(response):
+                        sql_query = extract_sql(response)
+                else:
+                    # Nếu sau 3 lần vẫn lỗi, tiếp tục hỏi lại người dùng thay vì in lỗi
+                    retry_prompt = f"""Tôi đã thử {max_attempts} lần nhưng vẫn gặp lỗi: {last_error}
+                    Bạn có thể cung cấp thêm chi tiết về dữ liệu cần truy vấn không?"""
+                    messages.append({"role": "assistant", "content": retry_prompt})
+                    yield retry_prompt
+                    return
+
+        # Nếu thực hiện truy vấn thành công
+        if sql_result is not None:
+            reformulation_prompt = f"""Kết quả truy vấn SQL:
+            {sql_result}
+            Hãy tóm tắt kết quả thành phản hồi tự nhiên cho người dùng."""
+            messages += [
+                {"role": "assistant", "content": response},
+                {"role": "user", "content": reformulation_prompt},
+            ]
+
+            # Tạo response tóm tắt
+            reformulated_response = ""
+            for message in client.chat.completions.create(
+                model="Qwen/Qwen2.5-3B-Instruct",
+                max_tokens=512,
+                stream=True,
+                temperature=temperature,
+                top_p=top_p,
+                messages=messages,
+            ):
+                token = message.choices[0].delta.content
+                reformulated_response += token
+                yield reformulated_response

client_old.py

@@ -0,0 +1,49 @@
+from huggingface_hub import InferenceClient
+from init import ACCESS_TOKEN, SYSTEM_PROMPT
+from utils import extract_sql, is_sql
+from database import execute
+
+client = InferenceClient(api_key=ACCESS_TOKEN)
+messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+
+def respond(message, history, system_message, max_tokens, temperature, top_p):
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+    for message in client.chat.completions.create(
+        model="Qwen/Qwen2.5-3B-Instruct",
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+        messages=messages,
+    ):
+        token = message.choices[0].delta.content
+        response += token
+        yield response
+    if is_sql(response):
+        sql_query = extract_sql(response)
+        sql_result = execute(sql_query)
+
+        reformulation_prompt = f"Kết quả truy vấn SQL:\n{sql_result}\n\nHãy diễn đạt lại kết quả cho người dùng một cách dễ hiểu."
+        messages.append({"role": "user", "content": reformulation_prompt})
+
+        reformulated_response = ""
+        for msg in client.chat.completions.create(
+            model="Qwen/Qwen2.5-3B-Instruct",
+            max_tokens=512,
+            stream=True,
+            temperature=temperature,
+            top_p=top_p,
+            messages=messages,
+        ):
+            token = msg.choices[0].delta.content
+            reformulated_response += token
+            yield reformulated_response

createDB.py

@@ -0,0 +1,69 @@
+### This file use only for created a fakedb for testing purpose
+
+import duckdb
+
+
+conn = duckdb.connect("./data/fakedb.db")
+
+# init all here
+conn.execute(
+    """\
+-- Tạo bảng trong DuckDB
+CREATE TABLE gmes_production_report (
+    Model TEXT,
+    Process TEXT,
+    Total_Yield FLOAT,
+    Total_OK INTEGER,
+    Total_NG INTEGER,
+    Total INTEGER,
+    Yield_2024_02_12 FLOAT,
+    Yield_2024_02_13 FLOAT,
+    Yield_2024_02_14 FLOAT
+);
+
+-- Chèn dữ liệu giả
+INSERT INTO gmes_production_report (Model, Process, Total_Yield, Total_OK, Total_NG, Total, Yield_2024_02_12, Yield_2024_02_13, Yield_2024_02_14) VALUES
+('Model A', 'Process 1', 98.5, 500, 10, 510, 98.2, 98.6, 98.4),
+('Model B', 'Process 2', 97.2, 480, 14, 494, 97.0, 97.3, 97.1),
+('Model C', 'Process 3', 99.0, 600, 6, 606, 99.1, 99.0, 98.9),
+('Model D', 'Process 1', 96.8, 450, 20, 470, 96.5, 96.7, 96.9),
+('Model E', 'Process 2', 95.5, 420, 22, 442, 95.4, 95.6, 95.3),
+('Model F', 'Process 3', 98.0, 510, 10, 520, 97.8, 98.1, 98.2),
+('Model G', 'Process 1', 99.2, 630, 5, 635, 99.0, 99.3, 99.1),
+('Model H', 'Process 2', 97.6, 470, 12, 482, 97.5, 97.7, 97.4),
+('Model I', 'Process 3', 98.9, 590, 7, 597, 98.7, 98.8, 99.0),
+('Model J', 'Process 1', 97.3, 490, 15, 505, 97.1, 97.4, 97.2),
+('Model K', 'Process 2', 96.0, 440, 18, 458, 95.8, 96.1, 95.9),
+('Model L', 'Process 3', 98.3, 520, 9, 529, 98.2, 98.4, 98.1),
+('Model M', 'Process 1', 99.1, 625, 6, 631, 99.0, 99.2, 98.9),
+('Model N', 'Process 2', 97.9, 485, 11, 496, 97.8, 98.0, 97.7),
+('Model O', 'Process 3', 98.6, 580, 8, 588, 98.5, 98.7, 98.4),
+('Model P', 'Process 1', 96.7, 445, 19, 464, 96.6, 96.8, 96.5),
+('Model Q', 'Process 2', 95.8, 430, 23, 453, 95.7, 95.9, 95.6),
+('Model R', 'Process 3', 97.4, 495, 14, 509, 97.3, 97.5, 97.2),
+('Model S', 'Process 1', 98.8, 600, 7, 607, 98.7, 98.9, 98.6),
+('Model T', 'Process 2', 97.1, 475, 13, 488, 97.0, 97.2, 97.3);
+
+-- Tạo bảng Table Worst
+CREATE TABLE table_worst (
+    Model TEXT,
+    Process TEXT,
+    Error_Name TEXT,
+    Error_Count INTEGER,
+    Error_Percentage FLOAT
+);
+
+-- Chèn dữ liệu giả vào Table Worst
+INSERT INTO table_worst (Model, Process, Error_Name, Error_Count, Error_Percentage) VALUES
+('Model A', 'Process 1', 'Defect A', 5, 1.0),
+('Model B', 'Process 2', 'Defect B', 8, 1.6),
+('Model C', 'Process 3', 'Defect C', 3, 0.5),
+('Model D', 'Process 1', 'Defect D', 10, 2.1),
+('Model E', 'Process 2', 'Defect E', 12, 2.7),
+('Model F', 'Process 3', 'Defect F', 7, 1.3),
+('Model G', 'Process 1', 'Defect G', 4, 0.8),
+('Model H', 'Process 2', 'Defect H', 6, 1.2),
+('Model I', 'Process 3', 'Defect I', 5, 1.0),
+('Model J', 'Process 1', 'Defect J', 9, 1.8);
+"""
+)

data/data.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dd5494e07d68aec0e4e5a166ae7b1189f03c8c109b06c0934f3fa0271141e40
+size 1847296

data/fakedb.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f29b623ea3e713ae83491b3d69ad20085104f88e874a591f6ebb24d183ed59eb
+size 798720

database.py

@@ -0,0 +1,36 @@
+import duckdb
+
+conn = duckdb.connect("./data/fakedb.db")
+
+
+def execute(sql_query):
+    try:
+        return conn.sql(sql_query).to_df().to_string()
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+
+def formattedDB():
+    try:
+        tables = conn.execute("SHOW TABLES").fetchall()
+        result = ""
+
+        for table in tables:
+            table_name = table[0]
+            result += f"CREATE TABLE {table_name} (\n"
+            columns = conn.execute(f"PRAGMA table_info('{table_name}');").fetchall()
+
+            column_definitions = [
+                f"    {col[1]} {col[2]} {'NOT NULL' if col[3] else ''} {'DEFAULT ' + str(col[4]) if col[4] else ''}".strip()
+                for col in columns
+            ]
+
+            result += ",\n".join(column_definitions)
+            result += "\n);\n"
+
+        return result
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+
+db_schema = formattedDB()

init.py

@@ -0,0 +1,39 @@
+from database import db_schema
+import os
+from router import gmes, worst
+
+ACCESS_TOKEN = os.getenv("HF_TOKEN")
+
+SYSTEM_PROMPT = f"""You are a helpful assistant with the ability to generate valid DuckDB SQL queries based on a given database schema.  
+
+Here is the database schema that the SQL query will run on:  
+{db_schema}
+
+### Table descriptions:
+{gmes}
+
+{worst}
+
+### Guidelines for generating SQL queries:  
+1. Generate an SQL query **only if**:  
+   - The question can be answered directly using the given schema.  
+   - The required tables and columns exist in the schema.  
+   - The query is a valid `SELECT` statement (no `INSERT`, `UPDATE`, or `DELETE`).  
+   - The question has a clear meaning without ambiguity.  
+
+2. Ask the user for clarification **if**:  
+   - The question is vague or open-ended.  
+   - The necessary tables or columns are missing from the schema.  
+   - The question requires additional details.  
+   - There are multiple possible interpretations of the question.  
+
+3. Do **not** generate an SQL query **if**:  
+   - The request is unrelated to the database schema.  
+   - The query requires modifying data instead of reading it.  
+   - The question involves computations too complex for SQL alone.  
+
+If the question is valid and meets the above criteria, return an SQL query in the following format:  
+```sql  
+<SQL query>  
+```
+"""

router.py

@@ -0,0 +1,70 @@
+### Router methods
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+
+model = SentenceTransformer("sentence-transformers/stsb-xlm-r-multilingual")
+
+gmes = """## **1. Bảng gmes_production_report**
+Bảng này lưu trữ **dữ liệu hiệu suất sản xuất** cho các mô hình và quy trình khác nhau. Bảng theo dõi tỷ lệ năng suất, tổng số lượng sản xuất và hiệu suất hàng ngày theo thời gian.
+
+### **Cột:**
+- **Mô hình (`TEXT`)** – Tên hoặc mã định danh của mô hình sản phẩm đang được sản xuất.
+- **Quy trình (`TEXT`)** – Quy trình hoặc giai đoạn sản xuất cụ thể (ví dụ: lắp ráp, thử nghiệm).
+- **Tổng_năng suất (`FLOAT`)** – Tỷ lệ năng suất chung cho mô hình trong quy trình đó, được tính là `(Tổng_đồng ý / Tổng) * 100`.
+- **Total_OK (`INTEGER`)** – Tổng số đơn vị đã vượt qua kiểm soát chất lượng.
+- **Total_NG (`INTEGER`)** – Tổng số đơn vị bị lỗi (không tốt) không vượt qua kiểm soát chất lượng.
+- **Total (`INTEGER`)** – Tổng số đơn vị đã xử lý (tổng của `Total_OK` và `Total_NG`).
+- **Yield_2024_02_12 (`FLOAT`)** – Tỷ lệ phần trăm sản lượng được ghi nhận vào **ngày 12 tháng 2 năm 2024**.
+- **Yield_2024_02_13 (`FLOAT`)** – Tỷ lệ phần trăm sản lượng được ghi nhận vào **ngày 13 tháng 2 năm 2024**.
+- **Yield_2024_02_14 (`FLOAT`)** – Tỷ lệ phần trăm sản lượng được ghi nhận vào **ngày 14 tháng 2 năm 2024**.
+
+### **Cách sử dụng:**
+- Giúp theo dõi **hiệu quả sản xuất** theo thời gian.
+- Cho phép **phân tích xu hướng năng suất** hàng ngày.
+- Hỗ trợ **đánh giá kiểm soát chất lượng** bằng cách so sánh tỷ lệ lỗi giữa các mô hình và quy trình khác nhau.
+"""
+
+
+worst = """## **2. table_worst Bảng**
+Bảng này theo dõi **thông tin liên quan đến lỗi**, làm nổi bật các lỗi phổ biến nhất xảy ra trong quá trình sản xuất.
+
+### **Cột:**
+- **Mô hình (`TEXT`)** – Mô hình sản phẩm liên quan đến lỗi đã ghi lại.
+- **Quy trình (`TEXT`)** – Quy trình sản xuất cụ thể nơi xảy ra lỗi.
+- **Error_Name (`TEXT`)** – Tên hoặc danh mục lỗi (ví dụ: "Lỗi A", "Sai lệch").
+- **Error_Count (`INTEGER`)** – Số lần lỗi này được ghi lại đối với mô hình và quy trình đã cho.
+- **Error_Percentage (`FLOAT`)** – Tỷ lệ phần trăm các đơn vị bị lỗi do lỗi cụ thể này, được tính là `(Error_Count / Total) * 100`.
+
+### **Cách sử dụng:**
+- Giúp xác định **các lỗi có vấn đề** trong dây chuyền sản xuất.
+- Cho phép **phân tích nguyên nhân gốc rễ** bằng cách liên kết các lỗi với các quy trình cụ thể.
+- Hỗ trợ **cải tiến liên tục** trong kiểm soát chất lượng bằng cách giải quyết các lỗi thường gặp nhất.
+
+"""
+
+
+def create_metadata_embedings(metadata: list, model):
+    embeddings = model.encode(metadata)
+    return embeddings
+
+
+def find_best_fit(embeddings, model, user_query):
+    query_embedding = model.encode([user_query])
+    similarities = cosine_similarity(query_embedding, embeddings)
+    best_match_table = similarities.argmax()
+    if best_match_table == 0:
+        table_metadata = gmes
+    elif best_match_table == 1:
+        table_metadata = worst
+
+    return table_metadata
+
+
+user_query = "Tôi muốn biết tổng lỗi lặp của Model A"
+
+metadata = [gmes, worst]
+embeddings = create_metadata_embedings(metadata, model)
+table_metadata = find_best_fit(embeddings, model, user_query)
+
+
+print(table_metadata)

style.css

@@ -0,0 +1,63 @@
+/* General styles */
+body {
+    font-family: 'Arial', sans-serif;
+    background-color: #f4f4f9;
+    margin: 0;
+    padding: 0;
+}
+
+/* Chatbot container */
+.gradio-container {
+    max-width: 800px;
+    margin: auto;
+    background: #ffffff;
+    padding: 20px;
+    border-radius: 10px;
+    box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
+}
+
+/* Chatbot messages */
+.gradio-chatbot {
+    background-color: #f9f9f9;
+    border-radius: 8px;
+    padding: 15px;
+    height: 600px;
+    overflow-y: auto;
+}
+
+/* User input box */
+input[type="text"],
+textarea {
+    width: 100%;
+    padding: 12px;
+    margin-top: 10px;
+    border: 1px solid #ccc;
+    border-radius: 5px;
+    font-size: 16px;
+}
+
+/* Sliders */
+.gradio-slider {
+    margin-top: 15px;
+}
+
+.gradio-slider label {
+    font-weight: bold;
+    color: #333;
+}
+
+/* Buttons */
+button {
+    background-color: #007bff;
+    color: white;
+    border: none;
+    padding: 12px 20px;
+    margin-top: 10px;
+    cursor: pointer;
+    border-radius: 5px;
+    font-size: 16px;
+}
+
+button:hover {
+    background-color: #0056b3;
+}

testdb.py

@@ -0,0 +1,10 @@
+import duckdb
+
+conn = duckdb.connect("./data/data.db")
+
+
+conn.sql(
+    """\
+SELECT * FROM Users
+"""
+).show()

ui.py

@@ -0,0 +1,54 @@
+import time
+import gradio as gr
+import requests
+from client import respond
+from huggingface_hub.errors import HfHubHTTPError
+
+
+"""
+API Huggingface some time return 503 error, so we need to retry multiple times
+"""
+
+
+def robust_respond(*args, **kwargs):
+    max_retries = 10
+    wait_time = 2
+
+    for attempt in range(max_retries):
+        try:
+            yield from respond(*args, **kwargs)
+            return
+        except HfHubHTTPError as e:
+            if "503" in str(e):
+                print(
+                    f"Attempt {attempt+1}: Hugging Face API is down. Retrying in {wait_time}s..."
+                )
+                time.sleep(wait_time)
+                wait_time *= 2
+            else:
+                yield f"Error: {str(e)}"
+                return
+
+    yield "Server busy right now !"
+
+
+chatbot = gr.Chatbot(height=600)
+
+demo = gr.ChatInterface(
+    robust_respond,
+    additional_inputs=[
+        gr.Textbox(value="", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-P",
+        ),
+    ],
+    fill_height=True,
+    chatbot=chatbot,
+    theme="Nymbo/Nymbo_Theme",
+)

utils.py

@@ -0,0 +1,17 @@
+import re
+
+
+# def extract_sql(response):
+#     match = re.search(r"```sql\s+(.*?)\s+```", response, re.DOTALL | re.IGNORECASE)
+#     return match.group(1) if match else None
+
+
+def extract_sql(response):
+    matches = re.findall(r"```sql\s+(.*?)\s+```", response, re.DOTALL | re.IGNORECASE)
+    if matches:
+        return matches[0].strip()
+    return None
+
+
+def is_sql(response):
+    return bool(re.search(r"```sql\s+.*?```", response, re.DOTALL | re.IGNORECASE))