| # 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 torch | |
| # from tqdm import tqdm | |
| # import numpy as np | |
| # import time | |
| # # 设置缓存目录 | |
| # 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) | |
| # # Weaviate 连接配置 | |
| # WEAVIATE_API_KEY = "Y7c8DRmcxZ4nP5IJLwkznIsK84l6EdwfXwcH" | |
| # WEAVIATE_URL = "https://39nlafviqvard82k6y8btq.c0.asia-southeast1.gcp.weaviate.cloud" | |
| # weaviate_auth_config = weaviate.AuthApiKey(api_key=WEAVIATE_API_KEY) | |
| # weaviate_client = weaviate.Client(url=WEAVIATE_URL, auth_client_secret=weaviate_auth_config) | |
| # # 预训练模型配置 | |
| # MODEL_NAME = "bert-base-chinese" | |
| # device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') | |
| # tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME) | |
| # model = AutoModel.from_pretrained(MODEL_NAME) | |
| # # OpenAI 客户端 | |
| # openai_client = None | |
| # def initialize_openai_client(api_key): | |
| # global openai_client | |
| # openai_client = OpenAI(api_key=api_key) | |
| # def extract_keywords(text): | |
| # prompt = """ | |
| # 你是一个关键词提取机器人。提取用户输入中的关键词，特别是名词和形容词，关键词之间用空格分隔。例如：苹果 电脑 裤子 蓝色 裙。 | |
| # """ | |
| # messages = [ | |
| # {"role": "system", "content": prompt}, | |
| # {"role": "user", "content": f"从下面的文本中提取五个关键词，以空格分隔：{text}"} | |
| # ] | |
| # response = openai_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 match_keywords(query_keywords, ad_keywords_list, triggered_keywords, current_turn, window_size, threshold): | |
| # best_match_distance = 0 | |
| # best_match_index = -1 | |
| # for i, ad_keywords in enumerate(ad_keywords_list): | |
| # match_count = sum( | |
| # any( | |
| # ad_keyword in keyword and | |
| # (keyword not in triggered_keywords or current_turn - triggered_keywords[keyword] > window_size) | |
| # ) for keyword in query_keywords | |
| # ) | |
| # if match_count > best_match_distance: | |
| # best_match_distance = match_count | |
| # best_match_index = i | |
| # if best_match_distance >= threshold: | |
| # for keyword in query_keywords: | |
| # if any(ad_keyword in keyword for ad_keyword in ad_keywords_list[best_match_index]): | |
| # triggered_keywords[keyword] = current_turn | |
| # return best_match_distance, best_match_index | |
| # def encode_keywords_to_avg(keywords, model, tokenizer, device): | |
| # embeddings = [] | |
| # for keyword in tqdm(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.append(outputs.last_hidden_state.mean(dim=1)) | |
| # avg_embedding = sum(embeddings) / len(embeddings) | |
| # return avg_embedding | |
| # def get_response_from_db(keywords_dict, class_name): | |
| # avg_vec = encode_keywords_to_avg(keywords_dict.keys(), model, tokenizer, device).numpy() | |
| # response = ( | |
| # weaviate_client.query | |
| # .get(class_name, ['keywords', 'summary']) | |
| # .with_near_vector({'vector': avg_vec}) | |
| # .with_limit(1) | |
| # .with_additional(['distance']) | |
| # .do() | |
| # ) | |
| # if class_name.capitalize() in response['data']['Get']: | |
| # result = response['data']['Get'][class_name.capitalize()][0] | |
| # return result['_additional']['distance'], result['summary'], result['keywords'] | |
| # else: | |
| # return None, None, None | |
| # def chatbot_response(message, max_tokens, temperature, top_p, window_size, threshold, user_weight, triggered_weight, api_key, state): | |
| # initialize_openai_client(api_key) | |
| # history = state.get('history', []) | |
| # triggered_keywords = state.get('triggered_keywords', {}) | |
| # current_turn = len(history) + 1 | |
| # combined_user_message = " ".join([h[0] for h in history[-window_size:]] + [message]) | |
| # combined_assistant_message = " ".join([h[1] for h in history[-window_size:]]) | |
| # user_keywords = extract_keywords(combined_user_message).split(',') | |
| # assistant_keywords = extract_keywords(combined_assistant_message).split(',') | |
| # keywords_dict = {keyword: user_weight for keyword in user_keywords} | |
| # for keyword in assistant_keywords: | |
| # keywords_dict[keyword] = keywords_dict.get(keyword, 0) + 1 | |
| # for keyword in list(keywords_dict.keys()): | |
| # if keyword in triggered_keywords and current_turn - triggered_keywords[keyword] < window_size: | |
| # keywords_dict[keyword] = triggered_weight | |
| # distance, ad_summary, ad_keywords = get_response_from_db(keywords_dict, class_name="ad_DB02") | |
| # if distance and distance < threshold: | |
| # ad_message = f"{message} <sep>品牌<sep>{ad_summary}" | |
| # messages = [{"role": "system", "content": "你是一个热情的聊天机器人，应微妙地嵌入广告内容。"}] | |
| # for msg in history: | |
| # messages.extend([{"role": "user", "content": msg[0]}, {"role": "assistant", "content": msg[1]}]) | |
| # messages.append({"role": "user", "content": ad_message}) | |
| # for keyword in keywords_dict.keys(): | |
| # if any(ad_keyword in keyword for ad_keyword in ad_keywords.split(',')): | |
| # triggered_keywords[keyword] = current_turn | |
| # else: | |
| # messages = [{"role": "system", "content": "你是一个热情的聊天机器人。"}] | |
| # for msg in history: | |
| # messages.extend([{"role": "user", "content": msg[0]}, {"role": "assistant", "content": msg[1]}]) | |
| # messages.append({"role": "user", "content": message}) | |
| # response = openai_client.chat.completions.create( | |
| # model="gpt-3.5-turbo", | |
| # messages=messages, | |
| # max_tokens=max_tokens, | |
| # temperature=temperature, | |
| # top_p=top_p, | |
| # ) | |
| # history.append((message, response.choices[0].message.content)) | |
| # state['history'] = history | |
| # state['triggered_keywords'] = triggered_keywords | |
| # return response.choices[0].message.content, state | |
| # # Gradio UI | |
| # demo = gr.Interface( | |
| # fn=chatbot_response, | |
| # inputs=[ | |
| # gr.Textbox(label="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 (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"), | |
| # gr.State(value={'history': [], 'triggered_keywords': {}}) # Combined state | |
| # ], | |
| # outputs=[ | |
| # gr.Textbox(label="Response"), | |
| # gr.State() # Return the updated state | |
| # ] | |
| # ) | |
| # if __name__ == "__main__": | |
| # demo.launch(share=True) | |
| 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 torch | |
| from tqdm import tqdm | |
| import numpy as np | |
| import time | |
| import requests | |
| from requests.adapters import HTTPAdapter | |
| from requests.packages.urllib3.util.retry import Retry | |
| # 设置缓存目录 | |
| 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) | |
| # Weaviate 连接配置 | |
| # 预训练模型配置 | |
| MODEL_NAME = "BAAI/bge-large-zh-v1.5" | |
| device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') | |
| tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME) | |
| model = AutoModel.from_pretrained(MODEL_NAME) | |
| # OpenAI 客户端 | |
| openai_client = None | |
| def initialize_openai_client(api_key): | |
| global openai_client | |
| openai_client = OpenAI(api_key=api_key) | |
| def extract_keywords(text): | |
| prompt = """ | |
| 你的任务是从用户的输入中提取关键词，特别是名词和形容词，输出关键词之间用空格分隔。例如：苹果 电脑 裤子 蓝色 裙。 | |
| 注意: | |
| 1.不要重复输出关键词，如果输入内容较短，你可以输出少于五个关键词，但至少输出两个 | |
| 2.对于停用词不要进行输出，停用词如各类人称代词，连词等 | |
| 3.关键词应该严格是名词和形容词，不要输出动词等其他词性 | |
| 4.输出格式为关键词之间用空格分隔，例如：苹果 电脑 裤子 蓝色 裙 | |
| """ | |
| messages = [ | |
| {"role": "system", "content": prompt}, | |
| {"role": "user", "content": f"从下面的文本中提取五个名词或形容词词性的关键词，以空格分隔：例子：她穿着蓝色的裙子，坐在电脑前，一边吃苹果一边看着裤子的购物网站。 输出：苹果 电脑 裤子 蓝色 裙\n\n 文本：{text}"} | |
| ] | |
| response = openai_client.chat.completions.create( | |
| model="gpt-4o", | |
| messages=messages, | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.9, | |
| ) | |
| keywords = response.choices[0].message.content.split(' ') | |
| return ','.join(keywords) | |
| # def match_keywords(query_keywords, ad_keywords_list, triggered_keywords, current_turn, window_size, threshold): | |
| # best_match_distance = 0 | |
| # best_match_index = -1 | |
| # for i, ad_keywords in enumerate(ad_keywords_list): | |
| # match_count = sum( | |
| # any( | |
| # ad_keyword in keyword and | |
| # (keyword not in triggered_keywords or current_turn - triggered_keywords[keyword] > window_size) | |
| # ) for keyword in query_keywords | |
| # ) | |
| # if match_count > best_match_distance: | |
| # best_match_distance = match_count | |
| # best_match_index = i | |
| # if best_match_distance >= threshold: | |
| # for keyword in query_keywords: | |
| # if any(ad_keyword in keyword for ad_keyword in ad_keywords_list[best_match_index]): | |
| # triggered_keywords[keyword] = current_turn | |
| # return best_match_distance, best_match_index | |
| def initialize_weaviate_client(): | |
| global weaviate_client | |
| retry_strategy = Retry( | |
| total=3, # 总共重试次数 | |
| status_forcelist=[429, 500, 502, 503, 504], # 需要重试的状态码 | |
| allowed_methods=["HEAD", "GET", "OPTIONS", "POST"], # 需要重试的方法 | |
| backoff_factor=1 # 重试间隔时间的倍数 | |
| ) | |
| adapter = HTTPAdapter(max_retries=retry_strategy) | |
| http = requests.Session() | |
| http.mount("https://", adapter) | |
| http.mount("http://", adapter) | |
| timeout = 5 | |
| WEAVIATE_API_KEY = "RhHxDEJwNWf14qQj982aaGOa0JepD7vtnsnq" | |
| WEAVIATE_URL = "https://f5owzd1vqjilrbwg4zu7w.c0.us-west3.gcp.weaviate.cloud" | |
| weaviate_auth_config = weaviate.AuthApiKey(api_key=WEAVIATE_API_KEY) | |
| def create_client(): | |
| return weaviate.Client( | |
| url=WEAVIATE_URL, | |
| auth_client_secret=weaviate_auth_config, | |
| timeout_config=(timeout, timeout) | |
| ) | |
| try: | |
| weaviate_client = create_client() | |
| except Exception as e: | |
| print(f"连接超时，重新连接") | |
| weaviate_client = create_client() | |
| def encode_keywords_to_avg(keywords, model, tokenizer, device): | |
| embeddings = [] | |
| for keyword in tqdm(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.append(outputs.last_hidden_state.mean(dim=1)) | |
| avg_embedding = sum(embeddings) / len(embeddings) | |
| return avg_embedding | |
| def encode_keywords_to_list(keywords, model, tokenizer, device): | |
| start_time = time.time() | |
| embeddings = [] | |
| model.to(device) | |
| for keyword in tqdm(keywords): | |
| inputs = tokenizer(keyword, return_tensors='pt', padding=True, truncation=True, max_length=512) | |
| inputs = {key: value.to(device) for key, value in inputs.items()} | |
| with torch.no_grad(): | |
| outputs = model(**inputs) | |
| embeddings.append(outputs.last_hidden_state.mean(dim=1).squeeze().tolist()) | |
| end_time=time.time() | |
| print(f"Time taken for encoding: {end_time - start_time}") | |
| return embeddings | |
| def get_response_from_db(keywords_dict, class_name): | |
| avg_vec = encode_keywords_to_avg(keywords_dict.keys(), model, tokenizer, device).numpy() | |
| response = ( | |
| weaviate_client.query | |
| .get(class_name, ['keywords', 'summary']) | |
| .with_near_vector({'vector': avg_vec}) | |
| .with_limit(1) | |
| .with_additional(['distance']) | |
| .do() | |
| ) | |
| if class_name.capitalize() in response['data']['Get']: | |
| result = response['data']['Get'][class_name.capitalize()][0] | |
| return result['_additional']['distance'], result['summary'], result['keywords'] | |
| else: | |
| return None, None, None | |
| def get_candidates_from_db(keywords_dict, class_name,limit=3): | |
| embeddings= encode_keywords_to_list(keywords_dict.keys(), model, tokenizer, device) | |
| candidate_list=[] | |
| for embedding in embeddings: | |
| response = ( | |
| weaviate_client.query | |
| .get(class_name, ['group_id','keyword_list','keyword', 'summary']) | |
| .with_near_vector({'vector': embedding}) | |
| .with_limit(limit) | |
| .with_additional(['distance']) | |
| .do() | |
| ) | |
| class_name=class_name[0].upper()+class_name[1:] | |
| if class_name in response['data']['Get']: | |
| results = response['data']['Get'][class_name] | |
| for result in results: | |
| candidate_list.append({ | |
| 'distance': result['_additional']['distance'], | |
| 'group_id': result['group_id'], | |
| 'keyword_list':result['keyword_list'], | |
| 'summary': result['summary'], | |
| 'keyword': result['keyword'] | |
| }) | |
| return candidate_list | |
| triggered_keywords = {} | |
| # def keyword_match(keywords_dict,candidates): | |
| # for candidate in candidates: | |
| # keywords=candidate['keywords'].split('*') | |
| # candidate_keywords_list=[keyword.split('#')[1] for keyword in keywords if '#' in keyword] | |
| # # print(keywords_dict.keys()) | |
| # print(f"nowdebug candidatekeywordslist{candidate_keywords_list}") | |
| # for keyword in keywords_dict.keys(): | |
| # if any(candidate_keyword in keyword for candidate_keyword in candidate_keywords_list): | |
| # # triggered_keywords[keyword]=True | |
| # print(f"candidate_keyword{candidate_keywords_list},,,,,,,keyword{keyword}") | |
| # return candidate['distance'],candidate['summary'],candidate['keywords'] | |
| # return 1000,None,None | |
| def first_keyword_match(keywords_dict,keyword_match_threshold=2): | |
| if not keywords_dict: | |
| return None,None | |
| data=load_data("train_2000_modified.json",2000) | |
| keywords=[dt['content'] for dt in data] | |
| max_matches=0 | |
| index=0 | |
| for i, lst in enumerate(keywords): | |
| list=lst.split(',') | |
| matches=sum(any(ad_keyword in keyword for keyword in keywords_dict.keys()) for ad_keyword in list) | |
| if matches>max_matches: | |
| max_matches=matches | |
| index=i | |
| if max_matches<=keyword_match_threshold: | |
| return None,None | |
| return data[index]['summary'],keywords[index] | |
| def chatbot_response(message, history, window_size, threshold, score_threshold,user_weight, triggered_weight,candidate_length,api_key): | |
| #初始化openai client | |
| initialize_openai_client(api_key) | |
| initialize_weaviate_client() | |
| #更新轮次，获取窗口历史 | |
| current_turn = len(history) + 1 | |
| combined_user_message = message | |
| combined_assistant_message = "" | |
| for i in range(1, window_size + 1): | |
| if len(history) >= i: | |
| if i % 2 == 1: # 奇数轮次，添加 assistant 的内容 | |
| combined_assistant_message = " ".join([history[-i][1], combined_assistant_message]).strip() | |
| else: # 偶数轮次，添加 user 的内容 | |
| combined_user_message = " ".join([history[-i][0], combined_user_message]).strip() | |
| #提取关键词 | |
| user_keywords = extract_keywords(combined_user_message).split(',') | |
| #获取关键词字典 | |
| keywords_dict = {keyword: user_weight for keyword in user_keywords} | |
| #根据上下文轮数更新关键词列表长度 | |
| max_size = 6 * window_size | |
| if len(keywords_dict) > max_size: | |
| keywords_dict = dict(list(keywords_dict.items())[-max_size:]) | |
| if combined_assistant_message: | |
| assistant_keywords = extract_keywords(combined_assistant_message).split(',') | |
| for keyword in assistant_keywords: | |
| keywords_dict[keyword] = keywords_dict.get(keyword, 0) + 1 | |
| for keyword in list(keywords_dict.keys()): | |
| if keyword in triggered_keywords and current_turn - triggered_keywords[keyword] < window_size: | |
| keywords_dict[keyword] = triggered_weight | |
| start_time = time.time() | |
| ad_summary,ad_keywords=first_keyword_match(keywords_dict) | |
| #关键词匹配命中 | |
| end_time = time.time() | |
| print(f"Time taken for first keyword match: {end_time - start_time}") | |
| if ad_summary: | |
| brands=['腾讯','阿里巴巴','百度','京东','华为','小米','苹果','微软','谷歌','亚马逊'] | |
| brand=random.choice(brands) | |
| ad_message = f"{message} <sep>品牌{brand}<sep>{ad_summary}" | |
| print(f"ad_sumamry: {ad_summary}") | |
| messages = [{"role": "system", "content": "请你将生活化、原汁原味的语言提炼出来，具有亲切感，类似于拉家常的方式推销商品，具有融洽的氛围和口语化的语言。请直接输出融合的对话文本。"}] | |
| 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": ad_message}) | |
| for keyword in keywords_dict.keys(): | |
| if any(ad_keyword in keyword for ad_keyword in ad_keywords.split(',')): | |
| triggered_keywords[keyword] = current_turn | |
| #关键词不中 | |
| else: | |
| start_time=time.time() | |
| # distance, ad_summary, ad_keywords = get_response_from_db(keywords_dict, class_name="ad_DB02") | |
| #数据库索引，数据库关键词平均方式 | |
| candidates=get_candidates_from_db(keywords_dict, class_name="Ad_DB10",limit=candidate_length) | |
| candidates.sort(key=lambda x:x['distance']) | |
| candidates=[candidate for candidate in candidates if candidate['distance']<threshold] | |
| print("----------------------------------------------------------------------") | |
| print(f"keywords:{keywords_dict.keys()}") | |
| print(f"candidates:{candidates[:5]}") | |
| #此时的候选集中所有元素都至少有一个关键词命中了 | |
| #筛选后的候选集进行投票，选出被投票最多的一条 | |
| #投中第一个元素加双倍权重 | |
| group_scores={} | |
| if(candidates): | |
| for candidate in candidates: | |
| group_id=candidate['group_id'] | |
| keyword = candidate['keyword'] | |
| keyword_list = candidate['keyword_list'].split(',') | |
| # 检查 keyword 是否是 keyword_list 中的第一个元素 | |
| if keyword in user_keywords: | |
| if keyword == keyword_list[0]: | |
| score = 6 | |
| else: | |
| score = 2 | |
| else: | |
| if keyword == keyword_list[0]: | |
| score = 3 | |
| else: | |
| score = 1 | |
| if keyword in triggered_keywords and current_turn - triggered_keywords[keyword] < window_size: | |
| if(keyword == keyword_list[0]): | |
| score = triggered_weight*3 | |
| else: | |
| keywords_dict[keyword] = triggered_weight | |
| # 更新 group_scores 字典中的分数 | |
| if group_id in group_scores: | |
| group_scores[group_id] += score | |
| else: | |
| group_scores[group_id] = score | |
| distance=1000 | |
| if group_scores: | |
| max_group_id = max(group_scores, key=group_scores.get) | |
| max_score = group_scores[max_group_id] | |
| if(max_score>=score_threshold): | |
| distance,ad_summary,ad_keywords=[(candidate['distance'],candidate['summary'],candidate['keyword_list']) for candidate in candidates if candidate['group_id']==max_group_id][0] | |
| #触发->标记触发词 | |
| for keyword in keywords_dict.keys(): | |
| if any(ad_keyword in keyword for ad_keyword in ad_keywords.split(',')): | |
| triggered_keywords[keyword] = current_turn | |
| print("ad_keywords: ", ad_keywords) | |
| if group_scores: | |
| sorted_group_scores = sorted(group_scores.items(), key=lambda item: item[1], reverse=True) | |
| print(f"group_scores: {sorted_group_scores}") | |
| end_time=time.time() | |
| print(f"Time taken for vecDB: {end_time - start_time}") | |
| if distance < 1000: | |
| pass | |
| else: | |
| messages = [{"role": "system", "content": "你是一个热情的聊天机器人。"}] | |
| 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}) | |
| if ad_summary: | |
| raw_initial_response=openai_client.chat.completions.create( | |
| model="gpt-4o", | |
| messages=[{"role": "user", "content": message}], | |
| ) | |
| initial_response=raw_initial_response.choices[0].message.content | |
| brands=['腾讯','阿里巴巴','百度','京东','华为','小米','苹果','微软','谷歌','亚马逊'] | |
| brand=random.choice(brands) | |
| fusion_message=f"用户输入(上下文):\n{message}\n\n原始回复:\n{initial_response}\n\n广告信息:\n来自{brand}品牌：{ad_summary}" | |
| with open("system_prompt.txt","r") as f: | |
| system_prompt=f.read() | |
| print(f"fusion_message: {fusion_message} ") | |
| fusion_messages=[{"role":"system","content":system_prompt}] | |
| # fusion_messages=[{"role":"system","content":"请在原回复中巧妙地插入带有广告品牌的广告描述，使得插入后的回复尽可能与前后文都连贯，插入位置和连接方式请根据上下文决定，注意：请只输出插入广告后的回复，不要输出任何其他的信息"}] | |
| fusion_messages.append({"role":"user","content":fusion_message}) | |
| response = openai_client.chat.completions.create( | |
| model="gpt-4o", | |
| messages=fusion_messages | |
| ) | |
| else: | |
| messages = [{"role": "system", "content": "你是一个热情的聊天机器人。你的所有回复应该是简短的一段式回答，不要过于冗长。"}] | |
| 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 = openai_client.chat.completions.create( | |
| model="gpt-4o", | |
| messages=messages, | |
| ) | |
| print(f"triggered_keywords: {triggered_keywords}") | |
| return response.choices[0].message.content | |
| # Gradio UI | |
| demo = gr.ChatInterface( | |
| chatbot_response, | |
| 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=3, step=1, label="Window size"), | |
| gr.Slider(minimum=0.01, maximum=0.3, value=0.25, step=0.01, label="Distance threshold"), | |
| gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Score 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.Slider(minimum=0, maximum=100, value=30, step=5, label="Number of candidates"), | |
| gr.Textbox(label="API Key"), | |
| ], | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch(share=True) | |
| print("happyhappyhappy") | |
| # 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 | |
| # import time | |
| # # 设置 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): | |
| # start_time = time.time() | |
| # avg_vec=np.array(encode_to_avg(query_keywords_dict, model, tokenizer, device)) | |
| # end_time = time.time() | |
| # print(f"Time taken to encode to avg: {end_time - start_time}") | |
| # nearVector = { | |
| # 'vector': avg_vec | |
| # } | |
| # start_time = time.time() | |
| # response = ( | |
| # db_client.query | |
| # .get(class_name, ['keywords', 'summary']) | |
| # .with_near_vector(nearVector) | |
| # .with_limit(1) | |
| # .with_additional(['distance']) | |
| # .do() | |
| # ) | |
| # end_time = time.time() | |
| # print(f"Time taken to search in DB: {end_time - start_time}") | |
| # print(response) | |
| # class_name=class_name[0].upper()+class_name[1:] | |
| # if class_name in response['data']['Get']: | |
| # results = response['data']['Get'][class_name] | |
| # print(results[0]['keywords']) | |
| # 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): | |
| # initialize_clients(api_key) | |
| # return respond(message, history, max_tokens, temperature, top_p, window_size, distance_threshold, weight_keywords_users, weight_keywords_triggered) | |
| # #触发词及触发回合字典 | |
| # triggered_keywords = {} | |
| # def respond( | |
| # message, | |
| # history: list[tuple[str, str]], | |
| # max_tokens, | |
| # temperature, | |
| # top_p, | |
| # window_size, | |
| # distance_threshold, | |
| # weight_keywords_users, | |
| # weight_keywords_triggered, | |
| # ): | |
| # 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"\ncurrent_turn: {current_turn}\n") | |
| # # 检查历史记录的长度 | |
| # 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 = "" | |
| # start_time = time.time() | |
| # key_words_users=get_keywords(combined_message_user).split(',') | |
| # key_words_assistant=get_keywords(combined_message_assistant).split(',') | |
| # end_time = time.time() | |
| # print(f"Time taken to get keywords: {end_time - start_time}") | |
| # print(f"Initial keywords_users: {key_words_users}") | |
| # print(f"Initial keywords_assistant: {key_words_assistant}") | |
| # keywords_dict = {} | |
| # added_keywords = set() | |
| # for keywords in key_words_users: | |
| # if keywords not in added_keywords: | |
| # if keywords in keywords_dict: | |
| # keywords_dict[keywords] += weight_keywords_users | |
| # else: | |
| # keywords_dict[keywords] = weight_keywords_users | |
| # added_keywords.add(keywords) | |
| # for keywords in key_words_assistant: | |
| # if keywords not in added_keywords: | |
| # if keywords in keywords_dict: | |
| # keywords_dict[keywords] += 1 | |
| # else: | |
| # keywords_dict[keywords] = 1 | |
| # added_keywords.add(keywords) | |
| # #窗口内触发过的关键词权重下调为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) | |
| # start_time = time.time() | |
| # distance,top_keywords_list,top_summary = fetch_response_from_db(keywords_dict,class_name) | |
| # end_time = time.time() | |
| # print(f"Time taken to fetch response from db: {end_time - start_time}") | |
| # 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}) | |
| # start_time = time.time() | |
| # response = client.chat.completions.create( | |
| # model="gpt-3.5-turbo", | |
| # messages=messages, | |
| # max_tokens=max_tokens, | |
| # temperature=temperature, | |
| # top_p=top_p, | |
| # ) | |
| # end_time = time.time() | |
| # print(f"Time taken to get response from GPT: {end_time - start_time}") | |
| # return response.choices[0].message.content | |
| # # 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"), | |
| # ], | |
| # ) | |
| # if __name__ == "__main__": | |
| # demo.launch(share=True) | |
| # 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 和 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 | |
| # ) | |
| # 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 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() | |
| # ) | |
| # 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 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) | |
| # avg_embedding = sum(keyword_embeddings) / sum(keywords_dict.values()) | |
| # return avg_embedding.tolist() | |
| # 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, | |
| # max_tokens, | |
| # temperature, | |
| # top_p, | |
| # window_size, | |
| # distance_threshold, | |
| # weight_keywords_users, | |
| # weight_keywords_triggered, | |
| # state | |
| # ): | |
| # triggered_keywords = state.get('triggered_keywords', {}) | |
| # current_turn = len(history) + 1 | |
| # 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(',') | |
| # keywords_dict = {} | |
| # for keyword in key_words_users: | |
| # if keyword in keywords_dict: | |
| # keywords_dict[keyword] += weight_keywords_users | |
| # else: | |
| # keywords_dict[keyword] = weight_keywords_users | |
| # for keyword in key_words_assistant: | |
| # if keyword in keywords_dict: | |
| # keywords_dict[keyword] += 1 | |
| # else: | |
| # keywords_dict[keyword] = 1 | |
| # 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()) | |
| # 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]: | |
| # 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, | |
| # ) | |
| # 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=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"), | |
| # gr.State(value="state") | |
| # ], | |
| # ) | |
| # if __name__ == "__main__": | |
| # demo.launch(share=True) | |