Lagrange.RagBot/notebook/experiment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.manifold import TSNE\n",
    "import yaml\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import sys\n",
    "import os\n",
    "\n",
    "sys.path.append(os.path.abspath('..'))\n",
    "from prompt import PromptEngine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/zhelonghuang/miniconda3/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "/data/zhelonghuang/miniconda3/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# from BCEmbedding import EmbeddingModel\n",
    "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
    "sentences = ['python 是什么', '请介绍一下 python']\n",
    "# model = EmbeddingModel(model_name_or_path=\"maidalun1020/bce-embedding-base_v1\")\n",
    "model = HuggingFaceEmbeddings(model_name='maidalun1020/bce-embedding-base_v1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddings = model.embed_documents(sentences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['请问 property.json 如何配置？',\n",
       "  '我的自动补全无法使用，是不是有bug？',\n",
       "  '帮我上传一下这份数据',\n",
       "  'surface了解一下？',\n",
       "  '大佬们，为啥我的digital ide启动之后所有功能都没启动捏？我配置了property文件，然后插件的vivado路经和modelsim路经都加上了',\n",
       "  '这群要被chisel夺舍了吗',\n",
       "  'Metals一开直接报错',\n",
       "  '话说digital-ide打开大的verilog卡死了',\n",
       "  '请问一下，第一次点击对文件仿真可以出波形文件，再次点击的时候就会提示unknown module type了。是哪个配置没配置好？',\n",
       "  '怎么调整是哪个版本的vivado来构建工程呢',\n",
       "  '咱们这个插件win7的vscode是不是只能用很早之前的版本',\n",
       "  '帮我将这份数据保存到服务器上',\n",
       "  '他这个意思是 单个功耗很低 但是功耗低那肯定性能就寄 频率肯定不高 靠人多',\n",
       "  '我平时写代码就喜欢喝茶',\n",
       "  '感觉现在啥都在往AI靠',\n",
       "  '请问你们自动对齐插件用的啥？',\n",
       "  '不得不放一下我的咖啡笔记了',\n",
       "  'stm32有什么好玩的应用不',\n",
       "  '别人设置的肯定有点不合适自己的',\n",
       "  'http://hehezhou.cn/register2024/AArch64-regindex.html',\n",
       "  '因为他们py本领不是很强，需要这些东西辅助',\n",
       "  '写C写多了，顺手在pycharm写了个main.c',\n",
       "  '好流畅的にほんじんです',\n",
       "  '有没有接触过UI开发的，想做一款寄存器管理的工具，想把界面做的好看一点',\n",
       "  '现在嘉立创也在做FPGA了？',\n",
       "  '大佬们，更新0.3.3之后，用iverilog仿真，testbench中还是例化模块出错：unknown module type，这是什么原因啊？',\n",
       "  '查了一下记录，2017年买的静电容',\n",
       "  '我小时候电脑刚买回来一星期就被我玩坏了',\n",
       "  'command not found: python',\n",
       "  'path top.v is not a hdlFile 请问报这个错误大概是啥原因啊',\n",
       "  '咖啡喝不了，喝了胃不舒服',\n",
       "  '兄弟们有没有C语言绘图库推荐',\n",
       "  '在企业里面最大的问题是碰见傻逼怎么办？',\n",
       "  '如何使用 digital ide 这个插件？',\n",
       "  '我早上开着机去打论文 回来发现我电脑切换到Linux了',\n",
       "  '我在Windows下遇到的只要问题就是对于C程序，包管理和编译管理器偶尔会不认识彼此但除此之外，都很安稳（win11除外）',\n",
       "  '不能理解在生产环境用arch的人。。',\n",
       "  '请问一下xilinx fpga开发在win和linux平台哪个好？',\n",
       "  '好羡慕你们可以开发自己喜欢的东西',\n",
       "  '???',\n",
       "  '？？？',\n",
       "  '我人麻了',\n",
       "  '艹',\n",
       "  '我人傻了',\n",
       "  '我tm',\n",
       "  'tnnd',\n",
       "  'funny mud goup',\n",
       "  '衣服混起来洗，有一件深色的掉色了，现在我一盆白T恤全变成泥土色了',\n",
       "  '这可是陪伴了我六七年的衣服啊',\n",
       "  '唉神金',\n",
       "  '为啥要用手机号码啊',\n",
       "  '本人于今日12时点了4瓶500ml无糖可乐，收到四瓶888ml',\n",
       "  '我是小趴菜',\n",
       "  '我也想组乐队 www',\n",
       "  '这个乐队谱，我看哭了',\n",
       "  '我的手机最大的用处就是当一个麦克风+相机',\n",
       "  '那你可能更适合iPhone，不过稍微贵点，入门级别5-6k，好一点的得8k-1w',\n",
       "  'F和弦弹不起来太真实了 hhh',\n",
       "  '草，这一套，比我买过的所有电子产品加起来还贵',\n",
       "  '奶茶点少糖，游泳，打乒乓球，结果最近还胖了4斤',\n",
       "  '你感觉有必要搞一个全局的数据库之类的么，比如日程插件和聊天插件可能都会用到用户的一些信息，如果不共享就要写两套用户处理逻辑',\n",
       "  '确切说，前期他在外放声音看庆余年',\n",
       "  '因为这是养蛊的虚拟机，放了些国产垃圾软件，得用国产流氓之王才能镇得住他们',\n",
       "  '真的开线程是要tcl指令去改的',\n",
       "  '下个版本核心就是LSP设计了',\n",
       "  '后面研究下怎么玩这个插件',\n",
       "  '得上 Dirichlet 分布做一下不确定性拟合了',\n",
       "  '用群友的数据训了一下，bias有点大',\n",
       "  '我觉得关键时刻可以防身',\n",
       "  '我记得windows默认max是2吧',\n",
       "  '再过几年毛利大叔就变成毛利老弟了',\n",
       "  '我也感觉自己老的好快',\n",
       "  '？？？',\n",
       "  '我的反撤回还能用',\n",
       "  '关于波形显示的一些建议',\n",
       "  '采用iverilog生成的VCD貌似无法解析仿真数据',\n",
       "  '【v0.3.2】模块调用后netlist生成错误，且仿真报错',\n",
       "  '网表优化与插入文档',\n",
       "  '插件文档导出问题',\n",
       "  '【v0.3.2】testbench修改之后再次仿真会报错',\n",
       "  '[0.3.2] [问题] 含参数的 Verilog 模块自动例化，代码格式不正确',\n",
       "  '【报错】RuntimeError: null function or function signature mismatch',\n",
       "  '报错：verilog解析器无法解析以下代码',\n",
       "  '报错：verilog解析器的bug',\n",
       "  '功能建议-能增加点类似Verilog-Mode的功能么',\n",
       "  '报错：RuntimeError: null function or function signature mismatch、无法识别HDL文件',\n",
       "  '例化模块自动生成tb文件报错Unknown module type',\n",
       "  'Errors happen when parsing d:/danpj/fpga/modelsim/mod1/user/src/count4.v. Error: \"RuntimeError: null function or function signature mismatch\". Just propose a valuable issue in our github repo ',\n",
       "  '自动例化报错',\n",
       "  '【问题】【0.3.2】重复提示 Error: \"RuntimeError: null function or function signature mismatch\"',\n",
       "  '【0.3.2】【问题】1无法解析localparam 2 带参数模块例化',\n",
       "  '基础教程太少',\n",
       "  '.v源文件未被正确识别',\n",
       "  '重复仿真时报错',\n",
       "  '插件不能使用',\n",
       "  '关于netlist的生成错误',\n",
       "  '[0.3.2] 支持对verilator 的dpi-c机制的支持 ',\n",
       "  '[0.3.2] 离线支持+SV支持',\n",
       "  'Bad webstie connection on README',\n",
       "  '在声明数据位宽时使用宏定义会报错',\n",
       "  '0.3.2 无verilog语法检查，且提示RuntimeError',\n",
       "  '[0.3.2] 模块定义跳转偶尔会出现问题',\n",
       "  '[0.3.2] 代码补全有多个内容完全相同的选项',\n",
       "  '[0.3.2] 例化模块的类型，模块名称的代码高亮不变色',\n",
       "  '文档中的params和ports数反了',\n",
       "  '[建议]：优化Formatter与文档生成',\n",
       "  '[0.3.2] Linter(vivado)  启用无效 (还是说我用的vivado2023太新了?)',\n",
       "  '[0.3.2]module的#后的parameter能悬停显示数值, 但内部parameter的不能',\n",
       "  '[0.3.2]param语法错误会弹右下角报错弹窗, TreeView刷新按钮无效',\n",
       "  '0.3.0版本后存在bug,构建项目后仿真无法运行',\n",
       "  '建议：模块例化可以基于文件夹来检索，当文件比较多时更整洁一点。',\n",
       "  'Add Questa-Sim into the linter option',\n",
       "  '悬停提示对 /**/ 型的注释有误',\n",
       "  '仿真时因为文件夹名字存在空格产生错误',\n",
       "  'filetype from json to jsonc (support comments)',\n",
       "  '语法识别错误',\n",
       "  'code to doc',\n",
       "  'WSL环境点击“显示当前文件的FSM图”时会发生扩展远程主机终止的错误',\n",
       "  '在架构里不能解析include后的模块',\n",
       "  'treeview在文件移动时遇到问题',\n",
       "  'treeview在文件变动时产生错误',\n",
       "  '[0.3.0 beta] iverilog指令错误',\n",
       "  'Will verilator be supported?',\n",
       "  '[0.3.0 beta] 高亮颜色错误',\n",
       "  '状态机显示有问题',\n",
       "  'xdc文件无法高亮显示',\n",
       "  'Ubuntu环境下，digital ide对配置环境有问题。',\n",
       "  '[0.3.0 beta] \"定义跳转\"定义位置出错',\n",
       "  '[0.3.0 beta] \"library导入文件\"模块解析报错',\n",
       "  '[0.3.0 beta] \"对当前文件进行仿真\"功能报错',\n",
       "  '[0.3.0 beta] 由于插件不能分析出使用了\"include\"语法, 从而导致Sim失败',\n",
       "  '[0.3.0 beta] 文件跳转功能失效',\n",
       "  '[0.3.0 beta] 例化中的[xx:xx]连线会导致后续颜色错误',\n",
       "  '[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,\n",
       "  1,\n",
       "  2,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  6,\n",
       "  1,\n",
       "  0,\n",
       "  0,\n",
       "  0,\n",
       "  2,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  0,\n",
       "  0,\n",
       "  1,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  0,\n",
       "  6,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  4,\n",
       "  6,\n",
       "  5,\n",
       "  5,\n",
       "  4,\n",
       "  4,\n",
       "  6,\n",
       "  6,\n",
       "  4,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  5,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  6,\n",
       "  4,\n",
       "  6,\n",
       "  3,\n",
       "  1,\n",
       "  1,\n",
       "  3,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  3,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  3,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  3,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1,\n",
       "  1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "engine = PromptEngine('../config/story.yml')\n",
    "engine.merge_stories_from_yml('../config/github-issue.story.yml')\n",
    "\n",
    "sentences = []\n",
    "labels = []\n",
    "for story in engine.stories:\n",
    "    sentences.append(story.message)\n",
    "    labels.append(engine.intent2id[story.intent])\n",
    "sentences, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(137, 768)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding = model.embed_documents(sentences)\n",
    "embedding = np.array(embedding)\n",
    "embedding.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne = TSNE(n_components=2)\n",
    "plots = tsne.fit_transform(embedding)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fd0305bbbd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels = np.array(labels)\n",
    "for label in set(labels):\n",
    "    mask = labels == label\n",
    "    cor_plots = plots[mask]\n",
    "    plt.scatter(cor_plots[:, 0], cor_plots[:, 1], s=50, alpha=0.9, label=engine.id2intent[label])\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "LogisticRegression()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "log_model = LogisticRegression()\n",
    "log_model.fit(embedding, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'others'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_sentence = ['咖啡喝不了，喝了胃不舒服']\n",
    "test_embedding = model.embed_documents(test_sentence)\n",
    "res = log_model.predict(test_embedding)[0]\n",
    "engine.id2intent[res]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['../model/embedding_mapping.sklearn']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import joblib\n",
    "joblib.dump(log_model, '../model/embedding_mapping.sklearn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_model = joblib.load('../model/embedding_mapping.sklearn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'others'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_sentence = ['咖啡喝不了，喝了胃不舒服']\n",
    "test_embedding = model.embed_documents(test_sentence)\n",
    "res = log_model.predict(test_embedding)[0]\n",
    "engine.id2intent[res]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 尝试使用 EDL\n",
    "\n",
    "使用证据网络增加不确定性计算，详细可看： [EDL（Evidential Deep Learning） 原理与代码实现](https://kirigaya.cn/blog/article?seq=154)\n",
    "\n",
    "损失函数\n",
    "\n",
    "$$\n",
    "\\mathcal L(\\theta) = \\sum_{i=1}^N \\mathcal L_i(\\theta) +\\lambda_t \\sum_{i=1}^N \\mathrm{KL}\\left(D(p_i|\\tilde{\\alpha}_i) || D(p_i | \\bold 1)\\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import tqdm\n",
    "\n",
    "class SimpleERNN(nn.Module):\n",
    "    in_dim: int\n",
    "    out_dim: int\n",
    "    alpha_kl: float\n",
    "    def __init__(self, in_dim: int, out_dim: int, focal: int, alpha_kl: float):\n",
    "        super().__init__()\n",
    "        self.in_dim = in_dim\n",
    "        self.out_dim = out_dim\n",
    "        self.alpha_kl = alpha_kl\n",
    "        self.focal = focal\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(in_dim, out_dim),\n",
    "            nn.ELU(),\n",
    "        )\n",
    "    \n",
    "    def forward(self, inputs: torch.FloatTensor) -> tuple[torch.FloatTensor, torch.FloatTensor]:\n",
    "        logits = self.classifier(inputs)\n",
    "        evidence = torch.exp(logits)\n",
    "        prob = F.normalize(evidence + 1, p=1, dim=1)\n",
    "        return evidence, prob\n",
    "\n",
    "    def criterion(self, evidence: torch.FloatTensor, label: torch.LongTensor) -> torch.FloatTensor:\n",
    "        if len(label.shape) == 1:\n",
    "            label = F.one_hot(label, self.out_dim)\n",
    "        alpha = evidence + 1\n",
    "        alpha_0 = alpha.sum(1).unsqueeze(-1).repeat(1, self.out_dim)\n",
    "        loss_ece = torch.sum(label * (torch.digamma(alpha_0) - torch.digamma(alpha)), dim=1)\n",
    "        loss_ece = torch.mean(loss_ece)\n",
    "        if self.alpha_kl > 0:\n",
    "            tilde_alpha = label + (1 - label) * alpha\n",
    "            uncertainty_alpha = torch.ones_like(tilde_alpha).cuda()\n",
    "            estimate_dirichlet = torch.distributions.Dirichlet(tilde_alpha)\n",
    "            uncertainty_dirichlet = torch.distributions.Dirichlet(uncertainty_alpha)\n",
    "            kl = torch.distributions.kl_divergence(estimate_dirichlet, uncertainty_dirichlet)\n",
    "            loss_kl = torch.mean(kl)\n",
    "        else:\n",
    "            loss_kl = 0\n",
    "        return loss_ece + self.alpha_kl * loss_kl    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:00<00:00, 240.91it/s]\n"
     ]
    }
   ],
   "source": [
    "in_dim = embedding.shape[1]\n",
    "out_dim = max(labels) + 1\n",
    "enn_model = SimpleERNN(in_dim, out_dim, 0, 0)\n",
    "optimizer = torch.optim.AdamW(enn_model.parameters(), lr=1e-3)\n",
    "\n",
    "bs = 64\n",
    "sample_num = len(embedding)\n",
    "sample_indice = np.arange(sample_num)\n",
    "bs_num = int(np.ceil(sample_num / bs))\n",
    "\n",
    "training_losses = []\n",
    "\n",
    "for i in tqdm.trange(100):\n",
    "    alpha_kl = min(0.9, i / 10)\n",
    "    np.random.shuffle(sample_indice)    \n",
    "    train_loss = 0\n",
    "    for bs_i in range(bs_num):\n",
    "        start = bs_i * bs\n",
    "        end = min(sample_num, start + bs)\n",
    "        data_indice = sample_indice[start: end]\n",
    "        data = torch.FloatTensor(embedding[data_indice])\n",
    "        label = torch.LongTensor(labels[data_indice])\n",
    "        evidence, prob = enn_model(data)\n",
    "        loss = enn_model.criterion(evidence, label)\n",
    "        train_loss += loss.item()\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    training_losses.append(train_loss / bs_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7dec58da50>]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(training_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.save(enn_model.state_dict(), '../model/intent.enn.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "in_dim = embedding.shape[1]\n",
    "out_dim = max(labels) + 1\n",
    "enn_model = SimpleERNN(in_dim, out_dim, 0, 0)\n",
    "state_dict = torch.load('../model/intent.enn.pth')\n",
    "enn_model.load_state_dict(state_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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]]))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embd = model.embed_documents(['其实是计划给linux适配的，linux和mac都是posix接口，那不是自然就适配mac了吗'])\n",
    "embd = torch.FloatTensor(embd)\n",
    "with torch.no_grad():\n",
    "    evidence, prob = enn_model(embd)\n",
    "\n",
    "e = evidence\n",
    "alpha = e + 1\n",
    "S = alpha.sum(1)\n",
    "b = e / S\n",
    "u = out_dim / S\n",
    "u, prob, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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"
     ]
    }
   ],
   "source": [
    "test_suite = [\n",
    "    { 'input': '如何使用 digital ide 这个插件？', 'expect': 'usage' },\n",
    "    { 'input': '我今天打开 vscode，发现 自动补全失效了，我是哪里没有配置好吗？', 'expect': 'usage,bug' },\n",
    "    { 'input': 'path top.v is not a hdlFile 请问报这个错误大概是啥原因啊', 'expect': 'usage,bug' },\n",
    "    { 'input': '我同学在学习强国看到小麦收割了，然后就买相应的股就赚了', 'expect': 'others' },\n",
    "    { 'input': '我平时写代码就喜欢喝茶', 'expect': 'others' },\n",
    "    { 'input': '请问报这个错误大概是啥原因啊', 'expect': 'usage,bug' },\n",
    "    { 'input': '感觉现在啥都在往AI靠', 'expect': 'others' },\n",
    "    { 'input': '别人设置的肯定有点不合适自己的', 'expect': 'others' },\n",
    "    { 'input': '在企业里面最大的问题是碰见傻逼怎么办？', 'expect': 'others' },\n",
    "    { 'input': '几乎完全不喝牛奶2333', 'expect': 'others' },\n",
    "    { 'input': 'command not found: python', 'expect': 'usage,bug,others' },\n",
    "    { 'input': '兄弟们有没有C语言绘图库推荐', 'expect': 'usage' },\n",
    "    { 'input': '我早上开着机去打论文 回来发现我电脑切换到Linux了', 'expect': 'usage,bug,others' },\n",
    "    { 'input': '我在Windows下遇到的只要问题就是对于C程序，包管理和编译管理器偶尔会不认识彼此但除此之外，都很安稳（win11除外）', 'expect': 'usage,others' },\n",
    "    { 'input': '我的反撤回还能用', 'expect': 'others' },\n",
    "    { 'input': '因为这是养蛊的虚拟机，放了些国产垃圾软件，得用国产流氓之王才能镇得住他们', 'expect': 'others' },\n",
    "    { 'input': '你咋装了个360', 'expect': 'others' },\n",
    "    { 'input': '？？？', 'expect': 'expression' },\n",
    "]\n",
    "for test in test_suite:\n",
    "    embd = model.embed_documents([test['input']])\n",
    "    embd = torch.FloatTensor(embd)\n",
    "    with torch.no_grad():\n",
    "        evidence, prob = enn_model(embd)\n",
    "\n",
    "    e = evidence\n",
    "    alpha = e + 1\n",
    "    S = alpha.sum(1)\n",
    "    b = e / S\n",
    "    u = out_dim / S\n",
    "    pre_label = prob.argmax(1)\n",
    "    name = engine.id2intent[pre_label[0].item()]\n",
    "    ok = '√' if name in test['expect'] else '×'\n",
    "    print(name, test['expect'], ok, u)\n"
   ]
  }
 ],
 "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
}