From 0525539ad84333021ec263b8ef5a0d51fe0ce2bb Mon Sep 17 00:00:00 2001 From: Kirigaya <1193466151@qq.com> Date: Sun, 9 Jun 2024 23:49:25 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E6=88=90=20EDL=20=E7=9A=84=E6=9E=84?= =?UTF-8?q?=E5=BB=BA=EF=BC=8C=E5=AE=8C=E6=88=90=20QA=20=E7=9A=84=E6=8B=92?= =?UTF-8?q?=E7=AD=94=E6=B5=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bot/services/digital-ide.ts | 46 ++++++++++ bot/services/intent.ts | 20 ++-- bot/services/test.ts | 13 ++- config/push-to-server.sh | 1 + notebook/clear-logs.ipynb | 99 ++++++++++++++++++++ notebook/experiment.ipynb | 178 +++++++++++++++++++++++++++++------- rag/services/intent.py | 50 +++++----- test/suite/rag.test.js | 6 ++ 8 files changed, 346 insertions(+), 67 deletions(-) create mode 100644 config/push-to-server.sh create mode 100644 notebook/clear-logs.ipynb diff --git a/bot/services/digital-ide.ts b/bot/services/digital-ide.ts index e69de29..bbf0604 100644 --- a/bot/services/digital-ide.ts +++ b/bot/services/digital-ide.ts @@ -0,0 +1,46 @@ +import '../plugins/image'; + +import { mapper, plugins, LagrangeContext, PrivateMessage, GroupMessage, Send } from 'lagrange.onebot' + +import { apiGetIntentRecogition, apiQueryVecdb } from '../api/vecdb'; + +import { handleGroupIntent } from './intent'; + +let lastCall = undefined; + +export class Impl { + @mapper.onGroup(932987873, { at: false }) + async handleDigitalGroup(c: LagrangeContext) { + const texts = []; + const message = c.message; + for (const msg of message.message) { + if (msg.type === 'text') { + texts.push(msg.data.text); + } + } + const reply: Send.Default[] = []; + const axiosRes = await apiGetIntentRecogition({ query: texts.join('\n') }); + const res = axiosRes.data; + + if (res.code == 200) { + const intentResult = res.data; + // 如果 不确定性 太高,就将意图修改为 + if (intentResult.uncertainty >= 0.33) { + intentResult.name = 'others'; + } + const uncertainty = Math.round(intentResult.uncertainty * 1000) / 1000; + const intentDebug = `【意图: ${intentResult.name} 不确定度: ${uncertainty}】`; + const anwser = await handleGroupIntent(c, intentResult); + if (anwser !== undefined) { + c.sendMessage(anwser + '\n' + intentDebug); + } + + } else { + const now = Date.now(); + if (lastCall === undefined || (now - lastCall) >= 60 * 10 * 1000) { + c.sendMessage('RAG 系统目前离线'); + } + lastCall = Date.now(); + } + } +} diff --git a/bot/services/intent.ts b/bot/services/intent.ts index ca88409..e488ab4 100644 --- a/bot/services/intent.ts +++ b/bot/services/intent.ts @@ -23,13 +23,15 @@ async function useRagLLM(c: LagrangeContext, intentResult: IntentR texts.push(msg.data.text); } } - - - const { data } = await apiQueryVecdb({ query: texts.join(' '), k: 3 }); + const query = texts.join(' ').trim(); + if (query.length === 0) { + return undefined; + } + const { data } = await apiQueryVecdb({ query, k: 3 }); if (data.code === 200) { - const messages: apiQueryVecdbDataItem[] = data.data.filter(m => m.score <= 0.8); + const messages: apiQueryVecdbDataItem[] = data.data.filter(m => m.score <= 0.7); if (messages.length === 0) { - c.sendMessage('未在数据库中检索到相关内容。'); + return '未在数据库中检索到相关内容。'; } else { const query = makePrompt(messages); const res = await llm.answer([ @@ -40,16 +42,16 @@ async function useRagLLM(c: LagrangeContext, intentResult: IntentR ]); if (typeof res === 'string') { const links = messages.map(m => m.source); - - const reference = ['参考链接:', ...links].join('\n'); + const linkSet = new Set(links); + const reference = ['参考链接:', ...linkSet].join('\n'); const anwser = res + '\n\n' + reference; - c.sendMessage(anwser); + return anwser; } } } else { logger.error('apiQueryVecdb 接口访问失败: ' + JSON.stringify(data)); - return false; + return undefined; } } diff --git a/bot/services/test.ts b/bot/services/test.ts index f942aab..9d332dc 100644 --- a/bot/services/test.ts +++ b/bot/services/test.ts @@ -1,6 +1,6 @@ import '../plugins/image'; -import { mapper, plugins, LagrangeContext, PrivateMessage, GroupMessage, Send } from 'lagrange.onebot' +import { mapper, plugins, LagrangeContext, PrivateMessage, GroupMessage, Send, logger } from 'lagrange.onebot' import { apiGetIntentRecogition, apiQueryVecdb } from '../api/vecdb'; @@ -41,9 +41,16 @@ export class Impl { if (intentResult.uncertainty >= 0.33) { intentResult.name = 'others'; } + const uncertainty = Math.round(intentResult.uncertainty * 1000) / 1000; - c.sendMessage(`【意图: ${intentResult.name} 不确定度: ${uncertainty}】`); - handleGroupIntent(c, intentResult); + const intentDebug = `【意图: ${intentResult.name} 不确定度: ${uncertainty}】`; + const anwser = await handleGroupIntent(c, intentResult); + if (anwser === undefined) { + c.sendMessage('拒答' + '\n' + intentDebug); + } else { + c.sendMessage(anwser + '\n' + intentDebug); + } + } else { c.sendMessage('RAG 系统目前离线'); } diff --git a/config/push-to-server.sh b/config/push-to-server.sh new file mode 100644 index 0000000..1ebb872 --- /dev/null +++ b/config/push-to-server.sh @@ -0,0 +1 @@ +scp -r config ubuntu@101.43.239.71:/home/ubuntu/files/data/llm-rag \ No newline at end of file diff --git a/notebook/clear-logs.ipynb b/notebook/clear-logs.ipynb new file mode 100644 index 0000000..854b6e7 --- /dev/null +++ b/notebook/clear-logs.ipynb @@ -0,0 +1,99 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import zipfile\n", + "from typing import *\n", + "import os\n", + "import json\n", + "import yaml\n", + "\n", + "log_home = '../logs'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_log_file_line(file: str, level='DEBUG') -> Generator:\n", + " if file.endswith('.log'):\n", + " for line in open(file, 'r', encoding='utf-8'):\n", + " if level in line:\n", + " yield line\n", + " elif file.endswith('.zip'):\n", + " with zipfile.ZipFile(file, 'r') as zip:\n", + " for zip_file in zip.namelist():\n", + " file_bytes = zip.read(zip_file)\n", + " for line in file_bytes.decode('utf-8').split('\\n'):\n", + " if level in line:\n", + " yield line\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "rag_log_files = [os.path.join(log_home, file) for file in os.listdir(log_home) if file.startswith('rag')]\n", + "\n", + "interesting_data = []\n", + "\n", + "for rag_file in rag_log_files:\n", + " for line in get_log_file_line(rag_file, level='DEBUG'):\n", + " try:\n", + " data = line.split('|')[-1].strip()\n", + " data = eval(data)\n", + " if data['intent']['name'] != 'others':\n", + " interesting_data.append(data)\n", + " except Exception:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "story = {'stories': []}\n", + "for d in interesting_data:\n", + " story['stories'].append({\n", + " 'message': d['query'],\n", + " 'intent': d['intent']['name']\n", + " })\n", + "\n", + "with open('../config/qq.story.yml', 'w', encoding='utf-8') as fp:\n", + " yaml.dump(story, fp, allow_unicode=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebook/experiment.ipynb b/notebook/experiment.ipynb index 8b46834..f839608 100644 --- a/notebook/experiment.ipynb +++ b/notebook/experiment.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -194,7 +194,55 @@ " '[0.3.0 beta]\"显示当前文件的netlist\"无法正确显示出网表',\n", " '[0.3.0 beta] Bitwidth of 1-bit signal is incorrectly recognized as \"Unknown\" in auto instantiation and auto document',\n", " '[0.3.3 beta] 含参数模型的例化存在问题以及拓展快捷键失效的问题',\n", - " \"[0.3.2]数值悬停提示不支持'_'语法\"],\n", + " \"[0.3.2]数值悬停提示不支持'_'语法\",\n", + " '请问有没有verilog的学习PDF啊',\n", + " 'zlib',\n", + " '我只有标准文件',\n", + " '[不会吧]',\n", + " '哟西',\n", + " 'vivado中program device没有把程序固化进板子吧',\n", + " '调试时候下载bit流和ltx,固化需要在xdc约束里面添加spi或bpi相关约束后生成bit流。建议一开始xdc约束当中就添加相关约束,后续生成mcs文件需要先添加flash型号,根据相关型号生成对应的mcs文件后再固化到flash当中。',\n", + " '符号能自己空格',\n", + " '换行能缩进4个字符',\n", + " '现在我们插件的 format 不足是什么',\n", + " 'github 的 discussion',\n", + " 'others',\n", + " '这种也就是在 scope 中进行缩进',\n", + " '不会呐',\n", + " '有点怪,这里没有和竖线对齐',\n", + " '我手动跳过',\n", + " '好了,',\n", + " '自动格式化出来就没对齐',\n", + " '手动能对齐',\n", + " ' 好了',\n", + " '哪个呀?',\n", + " 'https://github.com/Digital-EDA/Digital-IDE/discussions',\n", + " ' \\n 这个格式看着舒服,怎么设置的呀',\n", + " ' \\n 手动',\n", + " '我把wire和reg位置固定了',\n", + " '采用iverilog生成的VCD貌似无法解析仿真数据,这是为什么',\n", + " ' 我们目前上线了一个 QA 机器人,正在迭代中,它会根据问题自动进行回答,并给出对应的链接。我们设置了拒答流,并不是所有问题它都会进行回答,当然,意图检查模块仍然在迭代中,我们需要更多的数据。',\n", + " '请问什么时候会支持verilator',\n", + " 'at 触发不够人性化,很多用户不知道 Tip 的存在就不会去使用它',\n", + " '支持verilator',\n", + " '应该不会',\n", + " '非问句会触发吗',\n", + " 'tql',\n", + " 'qwq',\n", + " '目前digital ide的netlist是用什么综合出的?',\n", + " '目前Digital-IDE插件的netlist是用什么综合出的?',\n", + " '微调不了,数据太少了',\n", + " '大模型只是其中的一个组件',\n", + " '摸了',\n", + " '这个可以伪造转发消息吗?',\n", + " '这个机器人有回答修正功能吗',\n", + " '我回去把格式发你',\n", + " '这个垃圾插件不好用',\n", + " '我靠,牛',\n", + " '但是可以帮我敲顺序的状态机定义和寄存器地址',\n", + " '或者自己写脚本解决',\n", + " '后台就要我有时间才能统一上传',\n", + " '网络问题应该是'],\n", " [0,\n", " 1,\n", " 2,\n", @@ -331,7 +379,55 @@ " 1,\n", " 1,\n", " 1,\n", - " 1])" + " 1,\n", + " 0,\n", + " 6,\n", + " 6,\n", + " 4,\n", + " 5,\n", + " 0,\n", + " 3,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 4,\n", + " 6,\n", + " 4,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 1,\n", + " 1,\n", + " 4,\n", + " 4,\n", + " 6,\n", + " 6,\n", + " 4,\n", + " 6,\n", + " 1,\n", + " 6,\n", + " 1,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 4,\n", + " 4,\n", + " 0,\n", + " 0,\n", + " 6,\n", + " 6,\n", + " 4,\n", + " 1,\n", + " 1,\n", + " 6,\n", + " 1,\n", + " 4,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 6])" ] }, "execution_count": 5, @@ -342,6 +438,7 @@ "source": [ "engine = PromptEngine('../config/story.yml')\n", "engine.merge_stories_from_yml('../config/github-issue.story.yml')\n", + "engine.merge_stories_from_yml('../config/qq.story.yml')\n", "\n", "sentences = []\n", "labels = []\n", @@ -359,7 +456,7 @@ { "data": { "text/plain": [ - "(137, 768)" + "(185, 768)" ] }, "execution_count": 6, @@ -391,7 +488,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -400,7 +497,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -536,7 +633,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -588,14 +685,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:00<00:00, 240.91it/s]\n" + "100%|██████████| 200/200 [00:00<00:00, 230.43it/s]\n" ] } ], @@ -612,7 +709,7 @@ "\n", "training_losses = []\n", "\n", - "for i in tqdm.trange(100):\n", + "for i in tqdm.trange(200):\n", " alpha_kl = min(0.9, i / 10)\n", " np.random.shuffle(sample_indice) \n", " train_loss = 0\n", @@ -635,22 +732,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 66, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -665,16 +762,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "# torch.save(enn_model.state_dict(), '../model/intent.enn.pth')" + "torch.save(enn_model.state_dict(), '../model/intent.enn.pth')" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -683,7 +780,7 @@ "" ] }, - "execution_count": 16, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -698,18 +795,18 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(tensor([0.2663]),\n", - " tensor([[0.1731, 0.2171, 0.0566, 0.0640, 0.0702, 0.0589, 0.3601]]),\n", - " tensor([[0.1351, 0.1791, 0.0185, 0.0259, 0.0321, 0.0209, 0.3221]]))" + "(tensor([0.0972]),\n", + " tensor([[0.2197, 0.1341, 0.0202, 0.0307, 0.0252, 0.0267, 0.5433]]),\n", + " tensor([[0.2059, 0.1202, 0.0064, 0.0168, 0.0113, 0.0129, 0.5295]]))" ] }, - "execution_count": 18, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -730,18 +827,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'model' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[1], line 22\u001b[0m\n\u001b[1;32m 1\u001b[0m test_suite \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 2\u001b[0m { \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m如何使用 digital ide 这个插件?\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpect\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124musage\u001b[39m\u001b[38;5;124m'\u001b[39m },\n\u001b[1;32m 3\u001b[0m { \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m我今天打开 vscode,发现 自动补全失效了,我是哪里没有配置好吗?\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpect\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124musage,bug\u001b[39m\u001b[38;5;124m'\u001b[39m },\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 19\u001b[0m { \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m???\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpect\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpression\u001b[39m\u001b[38;5;124m'\u001b[39m },\n\u001b[1;32m 20\u001b[0m ]\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m test \u001b[38;5;129;01min\u001b[39;00m test_suite:\n\u001b[0;32m---> 22\u001b[0m embd \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241m.\u001b[39membed_documents([test[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m]])\n\u001b[1;32m 23\u001b[0m embd \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mFloatTensor(embd)\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n", - "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined" + "name": "stdout", + "output_type": "stream", + "text": [ + "usage usage √ tensor([0.0501])\n", + "bug usage,bug √ tensor([0.0773])\n", + "bug usage,bug √ tensor([0.0758])\n", + "others others √ tensor([0.1678])\n", + "others others √ tensor([0.0887])\n", + "bug usage,bug √ tensor([0.0902])\n", + "others others √ tensor([0.0453])\n", + "others others √ tensor([0.0424])\n", + "others others √ tensor([0.1416])\n", + "others others √ tensor([0.1441])\n", + "bug usage,bug,others √ tensor([0.1615])\n", + "usage usage √ tensor([0.0562])\n", + "others usage,bug,others √ tensor([0.0820])\n", + "others usage,others √ tensor([0.0798])\n", + "others others √ tensor([0.1282])\n", + "others others √ tensor([0.1034])\n", + "others others √ tensor([0.0967])\n", + "expression expression √ tensor([0.0802])\n" ] } ], diff --git a/rag/services/intent.py b/rag/services/intent.py index e287fc2..a0d6e4c 100644 --- a/rag/services/intent.py +++ b/rag/services/intent.py @@ -8,6 +8,7 @@ import torch from rag.db.embedding import embedding from rag.api.constant import StatusCode, MsgCode from rag.api.admin import app +from rag.api.admin import logger from rag.api.config import necessary_files from rag.model.enn import LinearEnn, train_enn @@ -60,30 +61,31 @@ def reload_embedding_mapping(): response.status_code = StatusCode.success.value return response +# TODO: 删除该接口 @app.route('/intent/retrain-embedding-mapping', methods=['post']) def retrain_embedding_mapping(): - engine = PromptEngine(necessary_files['intent-story']) - engine.merge_stories_from_yml(necessary_files['issue-story']) - sentences = [] - labels = [] - for story in engine.stories: - sentences.append(story.message) - labels.append(engine.intent2id[story.intent]) - try: - labels = np.array(labels) - embed = embedding.embed_documents(sentences) - enn_model = intent_recogition.classifier - train_enn(enn_model, embed, labels, bs=64, lr=1e-3, epoch=100) - torch.save(enn_model.state_dict(), necessary_files['intent-classifier']) + # engine = PromptEngine(necessary_files['intent-story']) + # engine.merge_stories_from_yml(necessary_files['issue-story']) + # sentences = [] + # labels = [] + # for story in engine.stories: + # sentences.append(story.message) + # labels.append(engine.intent2id[story.intent]) + # try: + # labels = np.array(labels) + # embed = embedding.embed_documents(sentences) + # enn_model = intent_recogition.classifier + # train_enn(enn_model, embed, labels, bs=64, lr=1e-3, epoch=100) + # torch.save(enn_model.state_dict(), necessary_files['intent-classifier']) - except Exception as e: - response = jsonify({ - 'code': StatusCode.process_error.value, - 'data': str(e), - 'msg': MsgCode.query_not_empty.value - }) - response.status_code = StatusCode.success.value - return response + # except Exception as e: + # response = jsonify({ + # 'code': StatusCode.process_error.value, + # 'data': str(e), + # 'msg': MsgCode.query_not_empty.value + # }) + # response.status_code = StatusCode.success.value + # return response response = jsonify({ 'code': StatusCode.success.value, @@ -113,6 +115,12 @@ def get_intent_recogition(): result = intent_recogition.get_intent_recogition(query) + logger_chunk = json.dumps({ + 'query': query, + 'intent': result + }, ensure_ascii=False) + logger.debug(logger_chunk) + response = jsonify({ 'code': StatusCode.success.value, 'data': result, diff --git a/test/suite/rag.test.js b/test/suite/rag.test.js index 14749bb..070c92f 100644 --- a/test/suite/rag.test.js +++ b/test/suite/rag.test.js @@ -42,6 +42,12 @@ suite('test intent recogition', () => { { input: '因为这是养蛊的虚拟机,放了些国产垃圾软件,得用国产流氓之王才能镇得住他们', expect: 'others' }, { input: '你咋装了个360', expect: 'others' }, { input: '???', expect: 'expression,others' }, + { input: '有点怪,这里没有和竖线对齐', expect: 'others' }, + { input: '调试时候下载bit流和ltx,固化需要在xdc约束里面添加spi或bpi相关约束后生成bit流。建议一开始xdc约束当中就添加相关约束,后续生成mcs文件需要先添加flash型号,根据相关型号生成对应的mcs文件后再固化到flash当中。', expect: 'advice,others' }, + { input: 'at 触发不够人性化,很多用户不知道 Tip 的存在就不会去使用它', expect: 'expression,others' }, + { input: '非问句会触发吗', expect: 'expression,others' }, + { input: 'zlib', expect: 'expression,others' }, + { input: 'https://github.com/Digital-EDA/Digital-IDE/discussions', expect: 'others' }, ]; for (const s of intent_suites) {