update 0722

app.py

@@ -1,3 +1,366 @@
+# import gradio as gr
+# from huggingface_hub import InferenceClient
+# import json
+# import random
+# import re
+# from load_data import load_data
+# from openai import OpenAI
+# from transformers import AutoTokenizer, AutoModel
+# import weaviate
+# import os 
+# import subprocess 
+# import torch
+# from tqdm import tqdm
+# import numpy as np
+
+#    # 设置 Matplotlib 的缓存目录 
+# os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib' 
+# # 设置 Hugging Face Transformers 的缓存目录 
+# os.environ['TRANSFORMERS_CACHE'] = '/tmp/huggingface_cache' 
+# # 确保这些目录存在 
+# os.makedirs(os.environ['MPLCONFIGDIR'], exist_ok=True) 
+# os.makedirs(os.environ['TRANSFORMERS_CACHE'], exist_ok=True) 
+
+# auth_config = weaviate.AuthApiKey(api_key="Y7c8DRmcxZ4nP5IJLwkznIsK84l6EdwfXwcH")
+
+# URL = "https://39nlafviqvard82k6y8btq.c0.asia-southeast1.gcp.weaviate.cloud"
+
+# # Connect to a WCS instance
+# db_client = weaviate.Client(
+#   url=URL,
+#   auth_client_secret=auth_config
+# )
+
+
+# class_name="ad_DB02"
+
+# device = torch.device(device='cuda' if torch.cuda.is_available() else 'cpu')
+# tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")
+# model = AutoModel.from_pretrained("bert-base-chinese")
+
+
+# global_api_key = None
+# client = None
+
+# def initialize_clients(api_key):
+#     global client
+#     client = OpenAI(api_key=api_key)
+
+# def get_keywords(message):
+#     system_message = """
+#     # 角色
+#     你是一个关键词提取机器人
+#     # 指令
+#     你的目标是从用户的输入中提取关键词，这些关键词应该尽可能是购买意图相关的。关键词中应该尽可能注意那些名词和形容词
+#     # 输出格式
+#     你应该直接输出关键词，关键词之间用空格分隔。例如：苹果 电脑 裤子 蓝色 裙
+#     # 注意：如果输入文本过短可以重复输出关键词，例如对输入“你好”可以输出：你好 你好 你好 你好 你好
+#     """
+
+#     messages = [{"role": "system", "content": system_message}]
+#     messages.append({"role": "user", "content": f"从下面的文本中给我提取五个关键词，只输出这五个关键词，以空格分隔{message}"})
+
+#     response = client.chat.completions.create(
+#         model="gpt-3.5-turbo",
+#         messages=messages,
+#         max_tokens=100,
+#         temperature=0.7,
+#         top_p=0.9,
+#     )
+
+#     keywords = response.choices[0].message.content.split(' ')
+#     return ','.join(keywords)
+
+
+# #字符串匹配模块
+# def keyword_match(query_keywords_dict, ad_keywords_lists, triggered_keywords, current_turn, window_size,distance_threshold):
+#     distance = 0
+#     most_matching_list = None
+#     index = 0
+
+#     # query_keywords = query_keywords.split(',')
+#     # query_keywords = [keyword for keyword in query_keywords if keyword]
+    
+#     #匹配模块
+#     query_keywords= list(query_keywords_dict.keys())
+    
+#     for i, lst in enumerate(ad_keywords_lists):
+#         lst = lst.split(',')
+#         matches = sum(
+#             any(
+#                 ad_keyword in keyword and
+#                 (
+#                     keyword not in triggered_keywords or
+#                     triggered_keywords.get(keyword) is None or
+#                     current_turn - triggered_keywords.get(keyword, 0) > window_size
+#                 ) * query_keywords_dict.get(keyword, 1) #计数乘以权重
+#                 for keyword in query_keywords
+#             )
+#             for ad_keyword in lst
+#         )
+#         if matches > distance:
+#             distance = matches
+#             most_matching_list = lst
+#             index = i
+
+#     #更新对distance 有贡献的关键词
+#     if distance >= distance_threshold:
+#         for keyword in query_keywords:
+#             if any(
+#                 ad_keyword in keyword for ad_keyword in most_matching_list
+#             ):
+#                 triggered_keywords[keyword] = current_turn
+    
+#     return distance, index
+
+
+# def encode_list_to_avg(keywords_list_list, model, tokenizer, device):
+#     if torch.cuda.is_available():
+#         print('Using GPU')
+#         print(device)
+#     else:
+#         print('Using CPU')
+#         print(device)
+
+#     avg_embeddings = []
+#     for keywords in tqdm(keywords_list_list):
+#         keywords_lst=[]
+#         # keywords.split(',')
+#         for keyword in keywords:
+#             inputs = tokenizer(keyword, return_tensors='pt', padding=True, truncation=True, max_length=512)
+#             inputs.to(device)
+#             with torch.no_grad():
+#                 outputs = model(**inputs)
+#             embeddings = outputs.last_hidden_state.mean(dim=1)
+#             keywords_lst.append(embeddings)
+#         avg_embedding = sum(keywords_lst) / len(keywords_lst)
+#         avg_embeddings.append(avg_embedding)
+
+#     return avg_embeddings
+
+
+# def encode_to_avg(keywords_dict, model, tokenizer, device):
+#     if torch.cuda.is_available():
+#         print('Using GPU')
+#         print(device)
+#     else:
+#         print('Using CPU')
+#         print(device)
+    
+    
+#     keyword_embeddings=[]
+#     for keyword, weight in keywords_dict.items():
+#         inputs = tokenizer(keyword, return_tensors='pt', padding=True, truncation=True, max_length=512)
+#         inputs.to(device)
+#         with torch.no_grad():
+#             outputs = model(**inputs)
+#         embedding = outputs.last_hidden_state.mean(dim=1)
+
+#         keyword_embedding=embedding * weight
+        
+#         keyword_embeddings.append(keyword_embedding * weight)
+
+#     avg_embedding = sum(keyword_embeddings) / sum(keywords_dict.values())
+
+#     return avg_embedding.tolist()
+
+
+# def fetch_response_from_db(query_keywords_dict,class_name):
+  
+    
+#     avg_vec=np.array(encode_to_avg(query_keywords_dict, model, tokenizer, device))
+#     nearVector = {
+#         'vector': avg_vec
+#     }
+
+#     response = (
+#         db_client.query
+#         .get(class_name, ['keywords', 'summary'])
+#         .with_near_vector(nearVector)
+#         .with_limit(1)
+#         .with_additional(['distance'])
+#         .do()
+#     )
+
+#     print(response)
+#     class_name=class_name[0].upper()+class_name[1:]
+
+#     if class_name in response['data']['Get']:
+#         results = response['data']['Get'][class_name]
+#         return results[0]['_additional']['distance'],results[0]['summary'], results[0]['keywords']
+#     else:
+#         print(f"Class name {class_name} not found in response")
+#         return None
+
+
+
+# def wrapper(message, history, max_tokens, temperature, top_p, window_size, distance_threshold, weight_keywords_users, weight_keywords_triggered, api_key, state):
+#     initialize_clients(api_key) 
+#     return respond(message, history, max_tokens, temperature, top_p, window_size, distance_threshold, weight_keywords_users, weight_keywords_triggered, state)
+
+
+# #触发词及触发回合字典
+
+
+# def respond(
+#     message,
+#     history: list[tuple[str, str]],
+#     max_tokens,
+#     temperature,
+#     top_p,
+#     window_size,
+#     distance_threshold,
+#     weight_keywords_users,
+#     weight_keywords_triggered,
+#     triggered_keywords
+# ):
+
+#     triggered_keywords=triggered_keywords or {}
+#     system_message_with_ad = """
+#     # 角色
+#     你是一个热情的聊天机器人
+#     # 指令
+#     你的目标是以一种微妙的方式将给定的广告内容嵌入对话中。插入广告时应尽量自然，避免突兀。优先正常回答用户问题，然后逐步以推荐方式引入广告内容。
+#     注意要在商品的描述前面加上是来自哪个品牌的广告。
+#     注意在推荐中不要脑补用户的身份，只是进行简单推荐。
+#     注意要热情但是语气只要适度热情
+#     # 输入格式
+#     用户查询后跟随广告品牌，用<sep>分隔，广告品牌后跟随广告描述，再用<sep>分隔。
+#     例如：我想买一条阔腿裤 <sep> 腾讯 <sep> 宽松的阔腿裤这两年真的吸粉不少，明星时尚达人的心头爱。毕竟好穿时尚，谁都能穿出腿长2米的效果宽松的裤腿，当然是遮肉小能手啊。上身随性自然不拘束，面料亲肤舒适贴身体验感棒棒哒。系带部分增加设计看点，还让单品的设计感更强。腿部线条若隐若现的，性感撩人。颜色敲温柔的，与裤子本身所呈现的风格有点反差萌。
+#     注意: 当没有<sep>时，正常回复用户，不插入广告。
+#     # 输出格式
+#     始终使用中文，只输出聊天内容，不输出任何自我分析的信息
+#     """
+
+#     system_message_without_ad = """
+#     你是一个热情的聊天机器人
+#     """
+#     print(f"triggered_keywords{triggered_keywords}")
+#     # 更新当前轮次
+#     current_turn = len(history) + 1
+#     print(f"current_turn: {current_turn}")
+#     # 检查历史记录的长度
+#     if len(history) >= window_size:
+#         combined_message_user = " ".join([h[0] for h in history[-window_size:] if h[0]] + [message])
+#         combined_message_assistant=" ".join(h[1] for h in history[-window_size:] if h[1])
+#     else:
+#         combined_message_user = message
+#         combined_message_assistant = ""
+
+#     key_words_users=get_keywords(combined_message_user).split(',')
+#     key_words_assistant=get_keywords(combined_message_assistant).split(',')
+
+#     print(f"Initial keywords_users: {key_words_users}")
+#     print(f"Initial keywords_assistant: {key_words_assistant}")
+
+#     keywords_dict={}
+#     for keywords in key_words_users:
+#         if keywords in keywords_dict:
+#             keywords_dict[keywords]+=weight_keywords_users
+#         else:
+#             keywords_dict[keywords]=weight_keywords_users
+#     for keywords in key_words_assistant:
+#         if keywords in keywords_dict:
+#             keywords_dict[keywords]+=1
+#         else:
+#             keywords_dict[keywords]=1
+
+#     #窗口内触发过的关键词权重下调为0.5
+#     for keyword in list(keywords_dict.keys()):
+#         if keyword in triggered_keywords:
+#             if current_turn - triggered_keywords[keyword] < window_size:
+#                 keywords_dict[keyword] = weight_keywords_triggered
+    
+#     query_keywords = list(keywords_dict.keys())
+#     print(keywords_dict)
+
+#     distance,top_keywords_list,top_summary = fetch_response_from_db(keywords_dict,class_name)
+
+#     print(f"distance: {distance}")
+
+#     if distance<distance_threshold:
+#         ad =top_summary
+
+#         messages = [{"role": "system", "content": system_message_with_ad}]
+
+#         for val in history:
+#             if val[0]:
+#                 messages.append({"role": "user", "content": val[0]})
+#             if val[1]:  
+#                 messages.append({"role": "assistant", "content": val[1]})
+
+#         brands = ['腾讯', '百度', '京东', '华为', '小米', '苹果', '微软', '谷歌', '亚马逊']
+#         brand = random.choice(brands)
+#         messages.append({"role": "user", "content": f"{message} <sep>{brand}的 <sep> {ad}"})
+
+#         #更新触发词
+#         for keyword in query_keywords:
+#             if any(
+#                 ad_keyword in keyword for ad_keyword in top_keywords_list
+#             ):
+#                 triggered_keywords[keyword] = current_turn
+
+#     else:
+#         messages = [{"role": "system", "content": system_message_without_ad}]
+
+#         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 = client.chat.completions.create(
+#         model="gpt-3.5-turbo",
+#         messages=messages,
+#         max_tokens=max_tokens,
+#         temperature=temperature,
+#         top_p=top_p,
+#     )
+    
+#     return response.choices[0].message.content , triggered_keywords
+
+
+# # def chat_interface(message, history, max_tokens, temperature, top_p, window_size, distance_threshold):
+# #     global triggered_keywords
+# #     response, triggered_keywords = respond(
+# #         message,
+# #         history,
+# #         max_tokens,
+# #         temperature,
+# #         top_p,
+# #         window_size,
+# #         distance_threshold,
+# #         triggered_keywords
+# #     )
+# #     return response, history + [(message, response)]
+
+# demo = gr.ChatInterface(
+#     wrapper,
+#     additional_inputs=[
+#         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 (nucleus sampling)",
+#         ),
+#         gr.Slider(minimum=1, maximum=5, value=2, step=1, label="Window size"),
+#         gr.Slider(minimum=0.01, maximum=0.20, value=0.08, step=0.01, label="Distance threshold"),
+#         gr.Slider(minimum=1, maximum=5, value=2, step=1, label="Weight of keywords from users"),
+#         gr.Slider(minimum=0, maximum=2, value=0.5, step=0.5, label="Weight of triggered keywords"),
+#         gr.Textbox(label="api_key"),
+#         'state'
+#     ],
+# )
+
+# if __name__ == "__main__":
+#     demo.launch(share=True)
+
 import gradio as gr
 from huggingface_hub import InferenceClient
 import json
@@ -7,38 +370,32 @@ from load_data import load_data
 from openai import OpenAI
 from transformers import AutoTokenizer, AutoModel
 import weaviate
-import os 
-import subprocess 
+import os
+import subprocess
 import torch
 from tqdm import tqdm
 import numpy as np
 
-   # 设置 Matplotlib 的缓存目录 
-os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib' 
-# 设置 Hugging Face Transformers 的缓存目录 
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/huggingface_cache' 
-# 确保这些目录存在 
-os.makedirs(os.environ['MPLCONFIGDIR'], exist_ok=True) 
-os.makedirs(os.environ['TRANSFORMERS_CACHE'], exist_ok=True) 
+# 设置 Matplotlib 和 Hugging Face Transformers 的缓存目录
+os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib'
+os.environ['TRANSFORMERS_CACHE'] = '/tmp/huggingface_cache'
+os.makedirs(os.environ['MPLCONFIGDIR'], exist_ok=True)
+os.makedirs(os.environ['TRANSFORMERS_CACHE'], exist_ok=True)
 
 auth_config = weaviate.AuthApiKey(api_key="Y7c8DRmcxZ4nP5IJLwkznIsK84l6EdwfXwcH")
-
 URL = "https://39nlafviqvard82k6y8btq.c0.asia-southeast1.gcp.weaviate.cloud"
 
 # Connect to a WCS instance
 db_client = weaviate.Client(
-  url=URL,
-  auth_client_secret=auth_config
+    url=URL,
+    auth_client_secret=auth_config
 )
 
-
-class_name="ad_DB02"
-
+class_name = "ad_DB02"
 device = torch.device(device='cuda' if torch.cuda.is_available() else 'cpu')
 tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")
 model = AutoModel.from_pretrained("bert-base-chinese")
 
-
 global_api_key = None
 client = None
 
@@ -56,7 +413,6 @@ def get_keywords(message):
     你应该直接输出关键词，关键词之间用空格分隔。例如：苹果 电脑 裤子 蓝色 裙
     # 注意：如果输入文本过短可以重复输出关键词，例如对输入“你好”可以输出：你好 你好 你好 你好 你好
     """
-
     messages = [{"role": "system", "content": system_message}]
     messages.append({"role": "user", "content": f"从下面的文本中给我提取五个关键词，只输出这五个关键词，以空格分隔{message}"})
 
@@ -71,73 +427,27 @@ def get_keywords(message):
     keywords = response.choices[0].message.content.split(' ')
     return ','.join(keywords)
 
+def fetch_response_from_db(query_keywords_dict, class_name):
+    avg_vec = np.array(encode_to_avg(query_keywords_dict, model, tokenizer, device))
+    nearVector = {'vector': avg_vec}
 
-#字符串匹配模块
-def keyword_match(query_keywords_dict, ad_keywords_lists, triggered_keywords, current_turn, window_size,distance_threshold):
-    distance = 0
-    most_matching_list = None
-    index = 0
-
-    # query_keywords = query_keywords.split(',')
-    # query_keywords = [keyword for keyword in query_keywords if keyword]
-    
-    #匹配模块
-    query_keywords= list(query_keywords_dict.keys())
-    
-    for i, lst in enumerate(ad_keywords_lists):
-        lst = lst.split(',')
-        matches = sum(
-            any(
-                ad_keyword in keyword and
-                (
-                    keyword not in triggered_keywords or
-                    triggered_keywords.get(keyword) is None or
-                    current_turn - triggered_keywords.get(keyword, 0) > window_size
-                ) * query_keywords_dict.get(keyword, 1) #计数乘以权重
-                for keyword in query_keywords
-            )
-            for ad_keyword in lst
-        )
-        if matches > distance:
-            distance = matches
-            most_matching_list = lst
-            index = i
-
-    #更新对distance 有贡献的关键词
-    if distance >= distance_threshold:
-        for keyword in query_keywords:
-            if any(
-                ad_keyword in keyword for ad_keyword in most_matching_list
-            ):
-                triggered_keywords[keyword] = current_turn
-    
-    return distance, index
+    response = (
+        db_client.query
+        .get(class_name, ['keywords', 'summary'])
+        .with_near_vector(nearVector)
+        .with_limit(1)
+        .with_additional(['distance'])
+        .do()
+    )
 
+    class_name = class_name[0].upper() + class_name[1:]
 
-def encode_list_to_avg(keywords_list_list, model, tokenizer, device):
-    if torch.cuda.is_available():
-        print('Using GPU')
-        print(device)
+    if class_name in response['data']['Get']:
+        results = response['data']['Get'][class_name]
+        return results[0]['_additional']['distance'], results[0]['summary'], results[0]['keywords']
     else:
-        print('Using CPU')
-        print(device)
-
-    avg_embeddings = []
-    for keywords in tqdm(keywords_list_list):
-        keywords_lst=[]
-        # keywords.split(',')
-        for keyword in keywords:
-            inputs = tokenizer(keyword, return_tensors='pt', padding=True, truncation=True, max_length=512)
-            inputs.to(device)
-            with torch.no_grad():
-                outputs = model(**inputs)
-            embeddings = outputs.last_hidden_state.mean(dim=1)
-            keywords_lst.append(embeddings)
-        avg_embedding = sum(keywords_lst) / len(keywords_lst)
-        avg_embeddings.append(avg_embedding)
-
-    return avg_embeddings
-
+        print(f"Class name {class_name} not found in response")
+        return None
 
 def encode_to_avg(keywords_dict, model, tokenizer, device):
     if torch.cuda.is_available():
@@ -147,8 +457,7 @@ def encode_to_avg(keywords_dict, model, tokenizer, device):
         print('Using CPU')
         print(device)
     
-    
-    keyword_embeddings=[]
+    keyword_embeddings = []
     for keyword, weight in keywords_dict.items():
         inputs = tokenizer(keyword, return_tensors='pt', padding=True, truncation=True, max_length=512)
         inputs.to(device)
@@ -156,55 +465,19 @@ def encode_to_avg(keywords_dict, model, tokenizer, device):
             outputs = model(**inputs)
         embedding = outputs.last_hidden_state.mean(dim=1)
 
-        keyword_embedding=embedding * weight
-        
-        keyword_embeddings.append(keyword_embedding * weight)
+        keyword_embedding = embedding * weight
+        keyword_embeddings.append(keyword_embedding)
 
     avg_embedding = sum(keyword_embeddings) / sum(keywords_dict.values())
-
     return avg_embedding.tolist()
 
-
-def fetch_response_from_db(query_keywords_dict,class_name):
-  
-    
-    avg_vec=np.array(encode_to_avg(query_keywords_dict, model, tokenizer, device))
-    nearVector = {
-        'vector': avg_vec
-    }
-
-    response = (
-        db_client.query
-        .get(class_name, ['keywords', 'summary'])
-        .with_near_vector(nearVector)
-        .with_limit(1)
-        .with_additional(['distance'])
-        .do()
-    )
-
-    print(response)
-    class_name=class_name[0].upper()+class_name[1:]
-
-    if class_name in response['data']['Get']:
-        results = response['data']['Get'][class_name]
-        return results[0]['_additional']['distance'],results[0]['summary'], results[0]['keywords']
-    else:
-        print(f"Class name {class_name} not found in response")
-        return None
-
-
-
 def wrapper(message, history, max_tokens, temperature, top_p, window_size, distance_threshold, weight_keywords_users, weight_keywords_triggered, api_key, state):
     initialize_clients(api_key) 
     return respond(message, history, max_tokens, temperature, top_p, window_size, distance_threshold, weight_keywords_users, weight_keywords_triggered, state)
 
-
-#触发词及触发回合字典
-
-
 def respond(
     message,
-    history: list[tuple[str, str]],
+    history,
     max_tokens,
     temperature,
     top_p,
@@ -212,106 +485,65 @@ def respond(
     distance_threshold,
     weight_keywords_users,
     weight_keywords_triggered,
-    triggered_keywords
+    state
 ):
-
-    triggered_keywords=triggered_keywords or {}
-    system_message_with_ad = """
-    # 角色
-    你是一个热情的聊天机器人
-    # 指令
-    你的目标是以一种微妙的方式将给定的广告内容嵌入对话中。插入广告时应尽量自然，避免突兀。优先正常回答用户问题，然后逐步以推荐方式引入广告内容。
-    注意要在商品的描述前面加上是来自哪个品牌的广告。
-    注意在推荐中不要脑补用户的身份，只是进行简单推荐。
-    注意要热情但是语气只要适度热情
-    # 输入格式
-    用户查询后跟随广告品牌，用<sep>分隔，广告品牌后跟随广告描述，再用<sep>分隔。
-    例如：我想买一条阔腿裤 <sep> 腾讯 <sep> 宽松的阔腿裤这两年真的吸粉不少，明星时尚达人的心头爱。毕竟好穿时尚，谁都能穿出腿长2米的效果宽松的裤腿，当然是遮肉小能手啊。上身随性自然不拘束，面料亲肤舒适贴身体验感棒棒哒。系带部分增加设计看点，还让单品的设计感更强。腿部线条若隐若现的，性感撩人。颜色敲温柔的，与裤子本身所呈现的风格有点反差萌。
-    注意: 当没有<sep>时，正常回复用户，不插入广告。
-    # 输出格式
-    始终使用中文，只输出聊天内容，不输出任何自我分析的信息
-    """
-
-    system_message_without_ad = """
-    你是一个热情的聊天机器人
-    """
-    print(f"triggered_keywords{triggered_keywords}")
-    # 更新当前轮次
+    triggered_keywords = state.get('triggered_keywords', {})
     current_turn = len(history) + 1
-    print(f"current_turn: {current_turn}")
-    # 检查历史记录的长度
+
     if len(history) >= window_size:
         combined_message_user = " ".join([h[0] for h in history[-window_size:] if h[0]] + [message])
-        combined_message_assistant=" ".join(h[1] for h in history[-window_size:] if h[1])
+        combined_message_assistant = " ".join(h[1] for h in history[-window_size:] if h[1])
     else:
         combined_message_user = message
         combined_message_assistant = ""
 
-    key_words_users=get_keywords(combined_message_user).split(',')
-    key_words_assistant=get_keywords(combined_message_assistant).split(',')
-
-    print(f"Initial keywords_users: {key_words_users}")
-    print(f"Initial keywords_assistant: {key_words_assistant}")
+    key_words_users = get_keywords(combined_message_user).split(',')
+    key_words_assistant = get_keywords(combined_message_assistant).split(',')
 
-    keywords_dict={}
-    for keywords in key_words_users:
-        if keywords in keywords_dict:
-            keywords_dict[keywords]+=weight_keywords_users
+    keywords_dict = {}
+    for keyword in key_words_users:
+        if keyword in keywords_dict:
+            keywords_dict[keyword] += weight_keywords_users
         else:
-            keywords_dict[keywords]=weight_keywords_users
-    for keywords in key_words_assistant:
-        if keywords in keywords_dict:
-            keywords_dict[keywords]+=1
+            keywords_dict[keyword] = weight_keywords_users
+    for keyword in key_words_assistant:
+        if keyword in keywords_dict:
+            keywords_dict[keyword] += 1
         else:
-            keywords_dict[keywords]=1
+            keywords_dict[keyword] = 1
 
-    #窗口内触发过的关键词权重下调为0.5
     for keyword in list(keywords_dict.keys()):
         if keyword in triggered_keywords:
             if current_turn - triggered_keywords[keyword] < window_size:
                 keywords_dict[keyword] = weight_keywords_triggered
-    
-    query_keywords = list(keywords_dict.keys())
-    print(keywords_dict)
-
-    distance,top_keywords_list,top_summary = fetch_response_from_db(keywords_dict,class_name)
 
-    print(f"distance: {distance}")
-
-    if distance<distance_threshold:
-        ad =top_summary
+    query_keywords = list(keywords_dict.keys())
+    distance, top_keywords_list, top_summary = fetch_response_from_db(keywords_dict, class_name)
 
+    if distance < distance_threshold:
+        ad = top_summary
         messages = [{"role": "system", "content": system_message_with_ad}]
-
         for val in history:
             if val[0]:
                 messages.append({"role": "user", "content": val[0]})
-            if val[1]:  
+            if val[1]:
                 messages.append({"role": "assistant", "content": val[1]})
-
         brands = ['腾讯', '百度', '京东', '华为', '小米', '苹果', '微软', '谷歌', '亚马逊']
         brand = random.choice(brands)
         messages.append({"role": "user", "content": f"{message} <sep>{brand}的 <sep> {ad}"})
 
-        #更新触发词
         for keyword in query_keywords:
-            if any(
-                ad_keyword in keyword for ad_keyword in top_keywords_list
-            ):
+            if any(ad_keyword in keyword for ad_keyword in top_keywords_list):
                 triggered_keywords[keyword] = current_turn
-
     else:
         messages = [{"role": "system", "content": system_message_without_ad}]
-
         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 = client.chat.completions.create(
         model="gpt-3.5-turbo",
         messages=messages,
@@ -319,42 +551,22 @@ def respond(
         temperature=temperature,
         top_p=top_p,
     )
-    
-    return response.choices[0].message.content , triggered_keywords
-
-
-# def chat_interface(message, history, max_tokens, temperature, top_p, window_size, distance_threshold):
-#     global triggered_keywords
-#     response, triggered_keywords = respond(
-#         message,
-#         history,
-#         max_tokens,
-#         temperature,
-#         top_p,
-#         window_size,
-#         distance_threshold,
-#         triggered_keywords
-#     )
-#     return response, history + [(message, response)]
+
+    state['triggered_keywords'] = triggered_keywords
+    return response.choices[0].message.content, state
 
 demo = gr.ChatInterface(
     wrapper,
     additional_inputs=[
         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 (nucleus sampling)",
-        ),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)"),
         gr.Slider(minimum=1, maximum=5, value=2, step=1, label="Window size"),
         gr.Slider(minimum=0.01, maximum=0.20, value=0.08, step=0.01, label="Distance threshold"),
         gr.Slider(minimum=1, maximum=5, value=2, step=1, label="Weight of keywords from users"),
         gr.Slider(minimum=0, maximum=2, value=0.5, step=0.5, label="Weight of triggered keywords"),
         gr.Textbox(label="api_key"),
-        'state'
+        gr.State(label="state")
     ],
 )