Lagrange.RagBot/notebook/experiment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": 3,
   "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",
       "  '请问有没有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",
       "  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,\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,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "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": [
       "(185, 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 0x7f76e6a3d8d0>"
      ]
     },
     "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": 9,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 200/200 [00:00<00:00, 230.43it/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(200):\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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f76e602f190>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGfCAYAAAB8wYmvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKjklEQVR4nO3dd1hTZ/8G8DtshYADBURFnDhxFlEBlTqrxT3aum2tWqt122qp2mLVOlpqq1aL1IF7b1HcgIqKoNaJi42gQdnk+f1hm9+bgkoQOEm4P9f1vS45eRLv857Kud/kJJEBECAiIiLSYgZSByAiIiJ6GxYWIiIi0nosLERERKT1WFiIiIhI67GwEBERkdZjYSEiIiKtx8JCREREWo+FhYiIiLQeCwsRERFpPRYWIiIi0npGmiyeOXMm+vTpAycnJ6Snp+P8+fOYMWMGbt++/dr7jB49GkOHDkWjRo0AAGFhYfj6669x8eJF1Ro/Pz8MHz5c7X6HDx9Gt27dCpytSpUqSE1N1WR3iIiISGJyuRwxMTFvXadRYfHw8MCKFStw8eJFGBkZwcfHB0ePHkWDBg2QlpaW733at2+PgIAAnD9/HhkZGZgxYwaOHj2Khg0bqgU8dOgQRowYofo5MzOzwLmqVKmC6OhoTXaFiIiItIS9vf1bS4sM7/Dlh9bW1khMTIS7uzvOnDlToPsYGBggJSUFX3zxBdavXw/g1TMs5cqVQ+/evQuVQy6XQ6FQwN7ens+yEBER6Qi5XI7o6GhYWlq+9fyt0TMs/2VlZQUASE5OLvB9ypYtC2Nj4zz3ad++PeLj45GSkoITJ05g9uzZr31cExMTmJqaqn6Wy+UAgNTUVBYWIiIiPSUKMzKZTOzbt0+cOXNGo/utWLFC3L17V5iamqq2DRw4UPTs2VM0atRIeHl5ievXr4vQ0FBhYGCQ72N4e3uL/Mjl8kLtC4fD4XA4nJIfuVyuyfm7cH/Jb7/9JqKiooS9vX2B7zNjxgzx9OlT0bhx4zeuc3R0FEII0bFjx3xvNzExEXK5XDVVqlRhYeFwOBwOR8em2AuLr6+vePTokahRo0aB7zNlyhSRkpIiWrRoUaD1CQkJ4rPPPiuOHeZwOBwOh6MFU6yFxdfXVzx58kTUrl27wPeZNm2aePbsmXBxcSnQent7e5Gbmyt69uxZHDvM4XA4HA5HC6bYCsuKFStESkqKcHd3FzY2NqoxMzNTrfH39xc+Pj6qn6dPny4yMjJEnz591O5jbm4uAAhzc3OxaNEi4eLiIhwcHETHjh3FpUuXxK1bt4SJiUlx7DCHw+FwOBwtmGIrLK8zbNgw1ZqgoCDh5+en+jkqKirf+3h7ewsAwszMTBw+fFjEx8eLzMxMERUVJVatWiUqV65cXDvM4XA4HA5HC0aT8/c7fQ6Ltvj3c1gK8j5uIiIi0g6anL/5XUJERESk9VhYiIiISOuxsBAREZHWY2EhIiIircfCQkRERFqPheUNDI2N0e6j/uj37QypoxAREZVqLCxvYF3NHl7TJ8K1fy9Ua9RA6jhERESlFgvLG8Tff4BL+w4BAD6YNFbiNERERKUXC8tbHP1tLXKyslDHpSXquraSOg4REVGpxMLyFimxcTi3ZScAoPtEPstCREQkBRaWAjj+hz8yXr5EtYb10aRTB6njEBERlTosLAXwMuUZTq3bBADoNmEMDAwNJU5ERERUurCwFNCpvzbjRXIKKjs6oJVXd6njEBERlSosLAWUmZaGwD/8AQCdx42GkampxImIiIhKDxYWDQRv3YXkmFiUs6kMt4/6SR2HiIio1GBh0UBOVhaOrFgDAPD8dDgsKpSXOBEREVHpwMKiobB9h/D4+k2UkVug6xefSR2HiIioVGBh0ZAQAnsWLgcAuPTpCbu6taUNREREVAqwsBRC1JVruHo4EAaGhvCaNlHqOERERHqPhaWQ9i9dgezMTNRp3RJO7VpLHYeIiEivsbAUUkpsHM5u3AYA6DH5C8gM+D8lERFRceFZ9h0cX/sX0p4rYFenFlp+2E3qOERERHqLheUdpCtSEbh6HQCg6xefwdiMHyZHRERUHFhY3tG5zTuQHP3Ph8l9PFDqOERERHqJheUd5WRl4ZDvSgCA5+ihMC9fTtpAREREeoiFpQhcOXgMT27cgpmFOd7/bLjUcYiIiPQOC0sREEJg/9JfAQBtB/ZFxWpVJU5ERESkX1hYisid0Eu4eTYYhsZG8Jr2pdRxiIiI9AoLSxHau+hn5GbnoGEHN9R3ayN1HCIiIr3BwlKEEqIe4vT6zQCAXjO/gpGJicSJiIiI9AMLSxE7tsoPzxMSYV29KjyGDpY6DhERkV5gYSlimWlp2Lfk1QW47382HOVsbSROREREpPtYWIrBlYNHcS/sCkzKmKHn1AlSxyEiItJ5LCzFZJfPEihzc9G0iyfquLSUOg4REZFOY2EpJrG37+Hc5h0AgF6zJsPAyFDiRERERLqLhaUYHV7xB1KfJsO2liPafdRf6jhEREQ6i4WlGGWkvsDB5b8DALqMHQ25dUWJExEREekmFpZidnHPATy8dh1mFubo8dV4qeMQERHpJBaWYiaEeHUBrlKJlh92g2OzJlJHIiIi0jksLCXg8fWbuLBzHwCg99dTIDPg/+xERESa0OjMOXPmTFy4cAEKhQLx8fHYtWsX6tat+9b79evXDzdv3kR6ejquXbuGbt265Vkzd+5cxMTEIC0tDceOHUPt2rU1iab1Dv6yEmkKBeyd6sK1fy+p4xAREekUjQqLh4cHVqxYgdatW6NTp04wNjbG0aNHUbZs2dfex9XVFQEBAVi7di2aNWuG3bt3Y/fu3WjYsKFqzfTp0/Hll1/i888/h4uLC16+fIkjR47A1NS08HumZV6mPMNh39UAgG5fjoF5+XLSBiIiItIxorBjbW0thBDCzc3ttWs2b94s9u3bp7YtODhY/P7776qfY2JixJQpU1Q/W1paivT0dDFw4MAC5ZDL5UIIIeRyeaH3pSTGwNBQTN7mL5ZEBIv+3jMlz8PhcDgcjpSjyfn7nS6msLKyAgAkJye/do2rqysCAwPVth05cgSurq4AAEdHR9jZ2amtUSgUCA0NVa35LxMTE8jlcrXRBcrcXOz8YQkA4L0+PVG9cQOJExEREemGQhcWmUyG5cuX4+zZs7h+/fpr19na2iI+Pl5tW3x8PGxtbVW3/7vtdWv+a9asWVAoFKqJjo4u7G6UuAdXr+HingMwMDBAn2+m8gJcIiKiAij02XLFihVo1KgRBg0aVJR5CmTBggWwtLRUjb29fYlneBf7l61AuiIV1RrWR+u+XlLHISIi0nqFKiy+vr7o0aMHOnTo8NZnN+Li4mBjY6O2zcbGBnFxcarb/932ujX/lZWVhdTUVLXRJS+epuDwilcX4Haf+DnMy1lJnIiIiEi7aVxYfH190bt3b3Ts2BEPHjx46/rg4GB4enqqbevUqROCg4MBAFFRUYiNjVVbI5fL4eLiolqjj85v2YXov2+jrJUluk8cK3UcIiIirVfgq3lXrFghUlJShLu7u7CxsVGNmZmZao2/v7/w8fFR/ezq6iqysrLE5MmTRb169YS3t7fIzMwUDRs2VK2ZPn26SE5OFj179hSNGjUSu3btEvfu3ROmpqZFfpWxNk2Npk3EkohgsSQiWFRv0lDyPBwOh8PhlORoeP4u+AO/zrBhw1RrgoKChJ+fn9r9+vXrJ/7++2+RkZEhIiIiRLdu3fI89ty5c0VsbKxIT08Xx44dE3Xq1CmuHdaqGTj/G7EkIlhM2uInZAYGkufhcDgcDqekRpPzt+yfP+g0uVwOhUIBS0tLnbuexaJCeczctwVlLOXYPn8RgrfukjoSERFRidDk/M331ErsRXIKDv36Pxfg8hNwiYiI8mBh0QLBW3ch+uZtlLW0xAe8AJeIiCgPFhYt8OoTcH8CALj0/RDVmzR8yz2IiIhKFxYWLfEgPAIXdu0HAPT9Zho/AZeIiOh/8KyoRQ4s/w1pCgWqNqgH1/69pI5DRESkNVhYtMiL5BQc9n11AW63L8fwAlwiIqJ/sLBomfNbd+HJjVuvLsCdNE7qOERERFqBhUXLCKUSO33+uQC3T084ODeSOBEREZH0WFi00MPwSITu3AeAF+ASEREBLCxa698LcO3r10WbgX2kjkNERCQpFhYt9TLlGQ79sgrAq0/ArWBvJ3EiIiIi6bCwaLHgbbtxL+wKzMzNMej7OZDJZFJHIiIikgQLixYTSiU2z/4emWlpqNWyGdyGDJQ6EhERkSRYWLRc8pMY7F38CwCg+5efo1KN6hInIiIiKnksLDogZPse3DoXAmNTU/T/biZfGiIiolKHhUVHbJu38NVLQy2aoXW/XlLHISIiKlEsLDoiJSZO9a6hHpPHw8qmksSJiIiISg4Liw45G7AdD8MjYWZhjh6Tv5A6DhERUYlhYdEhQqnEjh8WQ6lUonn3znBs1kTqSERERCWChUXHRN+8jdCdewEAvWdN4cf2ExFRqcCznQ469MsqpCtSX31s/4DeUschIiIqdiwsOuhlyjMc+nU1AKDH5C9gU7OGtIGIiIiKGQuLjjq/eQdunQuBSRkzfLJoHoxMTKSOREREVGxYWHSUEAIB38xH6tNkVKlXBx9MGid1JCIiomLDwqLDUp8mY/Oc7wEA7T7qB7u6tSVOREREVDxYWHTc32eCcfVwIAwMDdF71mSp4xARERULFhY9sG/Jr8jOyEStls3g3MVT6jhERERFjoVFDzyLi8eJP9cDAHpO+QImZcwkTkRERFS0WFj0RJDfBiRHx6K8nS26jPtU6jhERERFioVFT2RnZGLHD4sBAO5DBqJqg3oSJyIiIio6LCx65O8zwbhy6BgMDA3R33sWDAwNpY5ERERUJFhY9MzuhcuQ9lyBqg3qwf2TgVLHISIiKhIsLHrmxdMU7PvJFwDQZfynqGBvJ3EiIiKid8fCoocu7N6PuxfCYFLGDP3mTJc6DhER0TtjYdFT2+b+iOzMTNRr2xotenSVOg4REdE7YWHRU0mPnuDYSj8AQO9Zk1HezlbiRERERIXHwqLHgvw24EF4BMpYyjHY51vIDHi4iYhIN/EMpseUubnYNHMuMl6+RK2WzdBhxCdSRyIiIioUFhY99/RJNHb5LAUAdBk/Gra1a0qciIiISHMaFxY3Nzfs3bsX0dHREELAy8vrjev9/PwghMgzkZGRqjXe3t55br9586bme0P5urT3ICJPnIKRsTEGzvuGHyhHREQ6R+PCYm5ujvDwcIwfP75A6ydOnAhbW1vVVK1aFU+fPsW2bdvU1kVGRqqta9eunabR6A12fP8T0hQKVG/cAO5DBkkdh4iISCNGmt7h8OHDOHz4cIHXKxQKKBQK1c9eXl4oX748/Pz81Nbl5OQgPj5e0zhUQIrEJOxd9DMGfT8HXb/4FNdPnkHig0dSxyIiIiqQEr+GZdSoUQgMDMSjR+onyzp16iA6Ohr37t3Dhg0bUK1atZKOpvcu7jmIv8+GwNjUFAPnfcN3DRERkc4o0TOWnZ0dunXrhjVr1qhtDw0NxfDhw9G1a1eMHTsWjo6OOHPmDCwsLPJ9HBMTE8jlcrWhgtk290dkvHwJx2ZN0HZQX6njEBERFZgo7AghhJeXV4HXz5w5UyQmJgpjY+M3rrOyshLPnj0TI0eOzPd2b29vkR+5XF7ofSlN49q/t1gSESx8Qk+IClWrSJ6Hw+FwOKVz5HJ5gc/fJfoMy8iRI7F+/XpkZ2e/cd3z589x+/Zt1K5dO9/bFyxYAEtLS9XY29sXR1y9FbJ9N+5eCINp2TIY8N0sqeMQERG9VYkVFg8PD9SpUwdr165961pzc3PUqlULsbGx+d6elZWF1NRUtaGCE0Jgq/cCZKVnoI5LS7Tu5yV1JCIiojcq1NuanZ2d4ezsDABwdHSEs7Oz6iJZHx8f+Pv757nfqFGjEBISguvXr+e5bfHixXB3d4eDgwNcXV2xa9cu5ObmIiAgQNN4VEBPn0Tj4C8rAQA9p0xAOZvKEiciIiJ6M41eb/Lw8Mj3+hE/Pz8BQPj5+YmgoCC1+1haWoqXL1+K0aNH5/uYAQEBIjo6WmRkZIjHjx+LgIAAUbNmzWJ5DYzz/yMzMBAT1q8WSyKCxdg/VwgDI0PJM3E4HA6n9Iwm52/ZP3/QaXK5HAqFApaWlnx5SEOValTHpIA/YWZhjnObd2DnDz9JHYmIiEoJTc7f/CCOUi7xwSNsnPkdlEol2g7qC9cBvaWORERElAcLC+HGqbM49M/1LL1mTEJlRweJExEREaljYSEAwIm163HzzHkYmZhgwHezIJPJpI5ERESkwsJCKtvnLUJmWhocmzvzpSEiItIqLCyk8iwuHgd//h0A8MFX42BZyVriRERERK+wsJCac5t34mF4JMzMzdFl3Gip4xAREQFgYaH/EEol9i7+BQDwXu8esKnlKHEiIiIiFhbKx4PwCFw7FgQDQ0N8MGmc1HGIiIhYWCh/B37+Hbk5OWjYvh3qtXGROg4REZVyLCyUr6SHjxG8bTcAYOiSH1C1QT1pAxERUanGwkKvtW/Jr7h78TLMLMzx2crlsKlZQ+pIRERUSrGw0GvlZGbizwnT8CjiBszLl8PQpT4wNDKSOhYREZVCLCz0Rpkv07Bm3GSkPk2GbS1HtB/+sdSRiIioFGJhobd6+ew59iz6GQDQacwIVKxqL3EiIiIqbVhYqECuHDyK2yEXYWxmir6zp0odh4iIShkWFiqwHd8vRnZmJuq1bc2XhoiIqESxsFCBJT18jD0LX7009MGksajVqrnEiYiIqLRgYSGNBG/bhYt7DsDA0BBDFs+H3Lqi1JGIiKgUYGEhjW2fvxjRf9+GvGIF9JszTeo4RERUCrCwkMZyMjOx6et5yMnORqOOHmja9X2pIxERkZ5jYaFCibtzD4Gr1wEA+nw9BRYVyksbiIiI9BoLCxXaiTV/IebWHZiXL4dBP8yBzID/ORERUfHgGYYKLTcnB5u+nofsjEzUb+eKLuNGSx2JiIj0FAsLvZPY23exde4CAK8+BbdRR3eJExERkT5iYaF3dnn/EZzesAUAMHDeN7CsZC1xIiIi0jcsLFQk9i3xxePrN1HWyhL9vp0hdRwiItIzLCxUJJQ5uQj4Zj5ysrLQsH07tPywu9SRiIhIj7CwUJGJvxeFwyv+AAD0mvkVbGvXlDgRERHpCxYWKlKn/ANw79IVlJFb4LOVy1HezlbqSEREpAdYWKhIKXNz4TdxBmLv3IOVTSV8tmo5ylhaSh2LiIh0HAsLFbl0RSr+GPsVUmLjUNnRAYO+/0bqSEREpONYWKhYPI9PhN+XM5CTlYVGHdzR7qN+UkciIiIdxsJCxSb679vYt8QXANBzygTYO9WVOBEREekqFhYqVmc3bUfkiVMwMjHBYJ9vYWhsLHUkIiLSQSwsVOy2ei9A6tNk2NWphc6fj5Q6DhER6SAWFip2L589x475iwAAHUZ+gqoNnCROREREuoaFhUpExPFTuHLwKAyNjPDxj9/BzMJc6khERKRDWFioxOxasBTP4hNQ2dEBnyyaB5kB//MjIqKC4RmDSszLZ8/x54RpyErPQH23Nug55QupIxERkY5gYaESFX3zNgJmzwcAeAwdDOcunhInIiIiXaBxYXFzc8PevXsRHR0NIQS8vLzeuN7DwwNCiDxjY2Ojtm7cuHGIiopCeno6QkJC0KpVK02jkY64dvQEAv/wBwD0956JClWrSJyIiIi0ncaFxdzcHOHh4Rg/frxG96tbty5sbW1Vk5CQoLptwIABWLp0KebOnYvmzZsjPDwcR44cQaVKlTSNRzriyIo/EHU5HGXkFhiyeD4MjYykjkRERFpOFHaEEMLLy+uNazw8PIQQQlhZWb12TUhIiPD19VX9LJPJxJMnT8SMGTMKlEMulwshhJDL5YXeF07JTzlbGzH/7BGxJCJY9Jw6QfI8HA6HwynZ0eT8XWLXsFy9ehUxMTE4evQo2rRpo9pubGyMFi1aIDAwULVNCIHAwEC4urrm+1gmJiaQy+VqQ7rnWVw8Nv9zPUv7YR+hvlubt9yDiIhKq2IvLLGxsRgzZgz69u2Lvn374vHjxzh58iSaNWsGALC2toaRkRHi4+PV7hcfHw9bW9t8H3PWrFlQKBSqiY6OLu7doGJy/eRZnN6wBQAw+Ic5sLLhy4BERJRXsReW27dvY/Xq1bh8+TKCg4MxatQonD9/Hl999VWhH3PBggWwtLRUjb29fREmppK2f+kKPL7xN8zLl8MnC+fBwMhQ6khERKRlJHlb84ULF1C7dm0AQFJSEnJycvK8a8jGxgZxcXH53j8rKwupqalqQ7orNzsb66fOQXrqC9Rs0RTdvxwrdSQiItIykhSWpk2bIjY2FgCQnZ2NsLAweHr+/+dxyGQyeHp6Ijg4WIp4JIGnj59gy5zvAQAdRnyMRh09JE5ERETaROP3kpqbm6ueHQEAR0dHODs7Izk5GY8fP4aPjw/s7e0xbNgwAMDEiRMRFRWF69evw8zMDKNHj0bHjh3RuXNn1WMsXboU/v7+uHTpEi5cuIBJkybB3Nwcfn5+RbCLpCsijp/CSf9NaD/sIwz6fjaWDbiLp094fRIREb2i0VuQ/n2b8n/5+fkJAMLPz08EBQWp1k+bNk3cuXNHpKWliaSkJHHixAnRvn37PI87fvx48eDBA5GRkSFCQkLEe++9Vyxvi+Jo9xgYGYov/FeKJRHBYvJWf2Fkaip5Jg6Hw+EUz2hy/pb98wedJpfLoVAoYGlpyetZ9IBl5UqYvHUd5BUrIHTHXmz9boHUkYiIqBhocv7mdwmR1lEkJGLjDG8olUq49P0QH3w1TupIREQkMRYW0kp3Qi9hz8JlAICOI4egn/cMyAz4nysRUWnFMwBprbObtmPLnB+gzM2Fa79e6DJutNSRiIhIIiwspNUu7N6PzbNfvd2546ghsHeqK3EiIiKSAgsLab2w/Ydx9chxGBoZYeC8b/hJuEREpRALC+mEXQuW4OWz57CvXxedxoyUOg4REZUwFhbSCS+epmDXgqUAgM6fj8R7vXtKnIiIiEoSCwvpjCsHj+LE2r8AAP29Z6Dx++2lDURERCWGhYV0yoHlvyNk+x4YGBrik0Xz0LCDm9SRiIioBLCwkM7ZPn8Rrhw6BiNjYwxb4sMvSiQiKgVYWEjnCKUSm2bNxeWDR2FobIShP32Pmi2aSh2LiIiKEQsL6SRlbi42zZqLq4cDYWhshI8WeKOMpVzqWEREVExYWEhnCaUSW70XIPHhY5S3s0W/OdOljkRERMWEhYV0WmZaGjbO8EZudg6adn0f7T7qJ3UkIiIqBiwspPMeX7+JQ7+uAgD0njUFLn34GS1ERPqGhYX0QtCfG3DqrwAAQD/vmWjRs5vEiYiIqCixsJDe2Lv4F5zZuBUGBgYY8N1M2NfnFyUSEekLFhbSK7t/XIbIE6dgZGKCoT/9ADMLc6kjERFREWBhIb2zeY4PkqNjYV29Kvp/N0vqOEREVARYWEjvpCsUWD9t9qt3DnXxxPufDZc6EhERvSMWFtJLjyJuYKfPTwCAbhPGoGnX9yVORERE74KFhfRWyPY9OLluEwBg0Pez0bSLp8SJiIiosFhYSK/tX7YC1wJPwtjUFEN++h59vpkKIxMTqWMREZGGWFhIrwmlEuunzsax1X5QKpVoO6gv+n07Q+pYRESkIRYW0nvK3Fwc9l2NP7+YBqVSiVZe3VHXtZXUsYiISAMsLFRq3DxzHmc3bQMA9J0zHcZmphInIiKigmJhoVLlsO9qPIuLh3W1qug5ZQJkBvwnQESkC/jbmkqVzLQ07Pzh1dud2w7qiy/+WonKjg4SpyIiordhYaFS5/rJs9g8ez7SU1+ghnNjfLVlHa9pISLSciwsVCpd3HMQP/X+GHdCLsGkjBlG+i5Gffe2UsciIqLXYGGhUutZfAL+GDcZEcdPwdjUFMOXL0C9tq2ljkVERPlgYaFSLTc7G39N/QZXDh2DkbExhiyeD5uaNaSORURE/8HCQqWeMicXAV/Pw71LV1BGboGRvy6GeTkrqWMREdH/YGEhApCbkwP/r2Yh6fETWFeripG+i/k5LUREWoSFhegfL589x9rxU5GmUKBG08YYsmg+DAwNpY5FRERgYSFSkxD1EGvHT0N2RiYadnBD39nTpI5ERERgYSHK48HVa1g/fQ6Uublo3c8L7kMGSR2JiKjUY2Ehysf1oDPY+5MvAKDnlC9Qr42LxImIiEo3Fhai1zizYQtCd+6DgaEhhvz0PRq/317qSEREpRYLC9Eb7Ph+sertzsOXLcBgn29hWras1LGIiEodjQuLm5sb9u7di+joaAgh4OXl9cb1vXv3xtGjR5GQkIDnz5/j/Pnz6Ny5s9oab29vCCHU5ubNm5pGIypyudnZWPXplzi22g/K3Fy07NkNI35ZCENjY6mjERGVKhoXFnNzc4SHh2P8+PEFWu/u7o5jx46he/fuaNGiBYKCgrBv3z40bdpUbV1kZCRsbW1V065dO02jERWL3JwcHPZdjd9GjEPGy5eo49ISg3+YA5lMJnU0IqJSRRR2hBDCy8tL4/tFRkaKOXPmqH729vYWV65cKXQOuVwuhBBCLpcX+jE4nIJMXddWYuHl02JJRLDwmj5J8jwcDoejy6PJ+bvEr2GRyWSQy+VITk5W216nTh1ER0fj3r172LBhA6pVq/baxzAxMYFcLlcbopJwO/giNs/+HgDgPmQg2g//WOJERESlQ4kXlqlTp8LCwgJbt25VbQsNDcXw4cPRtWtXjB07Fo6Ojjhz5gwsLCzyfYxZs2ZBoVCoJjo6uqTiE+HKwaPYs/hnAK/e8tyiR1eJExERlQ6FfipH05eEBg8eLF68eCE8PT3fuM7Kyko8e/ZMjBw5Mt/bTUxMhFwuV02VKlX4khCnxKfnlAliSUSwWHz1rGg7qK/keTgcDkfXRpOXhIxQQgYOHIg1a9agf//+OH78+BvXPn/+HLdv30bt2rXzvT0rKwtZWVnFEZOowPYv/RWm5mXh2r8X+nwzFeXtbHHg598hlEqpoxER6Z0SeUlo0KBB8PPzw+DBg3Hw4MG3rjc3N0etWrUQGxtbAumICkcIge3zFuLgLysBAB1GfoIxq3+GZSVriZMREemfQr2t2dnZGc7OzgAAR0dHODs7qy6S9fHxgb+/v2r94MGD8ddff2HKlCkIDQ2FjY0NbGxsYGlpqVqzePFiuLu7w8HBAa6urti1axdyc3MREBDwrvtHVOyO/+GPDTO8kZmWhjouLTFl+1+o3qSh1LGIiPSORq83eXh4iPz4+fkJAMLPz08EBQWp1gcFBb1xPQAREBAgoqOjRUZGhnj8+LEICAgQNWvWLJbXwDic4ppKNaqLyVv9xZKIYOEdtF9Y2VSSPBOHw+Fo82hy/pb98wedJpfLoVAoYGlpidTUVKnjUClmUsYME9avRpV6dfDw2nX8NmIccni9FRFRvjQ5f/O7hIiKUFZ6BvwmzUTacwUcmjTEgLmzIDPgPzMionfF36RERSz5SQzWT5uN3JwctOjRFQPnfcPSQkT0jvhblKgY3A6+iA0zvJGbk4NWXt0xbKkPqjZwkjoWEZHO4jUsRMWo8fvtMWTRfBgav/rIoyc3bmHdVzOREhMncTIiIunxGhYiLREReBK/Dv8clw8eRXZGJqo2qIehP/0AQ6MS+8xGIiK9wMJCVMweXbuOjTO8sfDDQUh7rkD1xg3QfdJYqWMREekUFhaiEpISG4fNs+cDANoP+wjNunWSOBERke5gYSEqQddPnsXp9VsAAJ8smgfPT4dJnIiISDewsBCVsH1LfHF6w6vS0v3LzzFw/jeQyWQSpyIi0m4sLEQlTJmbiz0Ll2Pb3B+Rm52D93r1QK9Zk6WORUSk1VhYiCQSsn0PNn09F0qlEu0G90PPKRNgZGoqdSwiIq3EwkIkoauHA7Hj+8UAgPbDP8K3gXvQ7cvPYVLGTOJkRETahYWFSGIh23Yj4Jv5ePokBublrPD+p8Mw8pfFfLaFiOh/sLAQaYFLew9iwQf94T/5a2S8fIk6rVti+PIFMDQ2ljoaEZFWYGEh0hJCqcS1Y0FYM3YyMtPSUb+dK8as/hnyihWkjkZEJDkWFiItE3XlGtZ+MRUZL16iVstm+GrrOjg2ayJ1LCIiSbGwEGmhexcvY/ngkYi7ex9WlSvh87W/okWPrlLHIiKSDAsLkZZKfPAIP380GuFHT8DI2BgfLfBGl3Gj+SFzRFQqsbAQabGs9HSsnzobx9f8BQDoPHYUPlu1HJaVrCVORkRUslhYiLScEAIHf/4dm2fPR2ZaOuq6voepO9ajVstmUkcjIioxLCxEOuLinoNYPmgEnty4BfPy5fDpymVo2MFN6lhERCWChYVIhyREPYTvkM8QeeIUjE1NMWypD1p+2F3qWERExY6FhUjH5GRlwX/yN7iwez8MjYww+Ic5cB8ySOpYRETFioWFSAcpc3Ox9VsfnPTfBADwmj4RXSd8JnEqIqLiw8JCpKOEENj3ky8OLP8dANDpsxHoO3saZAb8Z01E+oe/2Yh03Im1f2HbvIVQKpVoM7APPlk4l1+cSER6h4WFSA+EbNuNDdO/RU52Npp2fR9fblgN6+pVpY5FRFRkWFiI9ET4keP44/OvkPo0GfZOdfHVlnVo91F/fuMzEekFFhYiPXL3QhiWDhiO+2FXYWZhjt6zJmPG3s1wcnOVOhoR0TthYSHSM4qERPw+6gtsm/sjnickomLVKhj5yyI07eIpdTQiokJjYSHSQ8rcXIRs34MFH/THpb2HYGhkhI8XzkWLnt2kjkZEVCgsLER6LDsjE5tnz0fojr0wMDTERz7fYtD3c1DGUi51NCIijbCwEOk5IQS2zf0RgX/4Q6lUopVXd0zbuRH13dpIHY2IqMBkAITUId6VXC6HQqGApaUlUlNTpY5DpLUcnBth0PzZqOzoAODVFyruWbQc6Qr+uyGikqfJ+ZvPsBCVIg/DI7Gk/zAE+W38/2dbdm1Effe2UkcjInojPsNCVEr999mWiOOnEOS3AQ/DIyVORkSlhSbnbxYWolLMyNQUXcd/Co+hg2BgaAgAuB92FXsX/4LH129KnI6I9B0LCxFpxKaWIzyGDkaLHl1gZGICpVKJi7sPYM/C5chMS5M6HhHpKRYWIioUy0rW+GDSOLT88NXntdwJvYQ146YgJytL4mREpI+K9aJbNzc37N27F9HR0RBCwMvL66338fDwQFhYGDIyMnDnzh0MGzYsz5px48YhKioK6enpCAkJQatWrTSNRkTvSJGYhIBv5mHFiHHIePkSdVxaYsjieTAwMpQ6GhGVchoXFnNzc4SHh2P8+PEFWl+jRg0cOHAAQUFBaNq0KZYvX441a9agc+fOqjUDBgzA0qVLMXfuXDRv3hzh4eE4cuQIKlWqpGk8IioC9y9dwZ9fTEN2ZiYadfTAwHnfQCaTSR2LiEo5UdgRQggvL683rvnxxx9FRESE2raAgABx6NAh1c8hISHC19dX9bNMJhNPnjwRM2bMKFAOuVwuhBBCLpcXel84HE7eaeDRTiy6ckYsiQgWvWdNljwPh8PRr9Hk/F3sn8Pi6uqKwMBAtW1HjhyBq+urb481NjZGixYt1NYIIRAYGKhaQ0TSuHHqLDbPng+lUol2H/XHqBU/4cPpE+Havzc/3p+ISpRRcf8Ftra2iI+PV9sWHx8PKysrmJmZoXz58jAyMsp3jZOTU76PaWJiAlNTU9XPcjl/cRIVl8sHjsLMwgJ9Z09Dg//5gLkPp32JsP2HcWD5b/ykXCIqdsVeWIrDrFmz8N1330kdg6jUOL9lJ+Lu3kf1Rg1gUaE86rVrjSp1a8O1fy9UrFoFqz//CkKplDomEemxYn9JKC4uDjY2NmrbbGxs8Pz5c2RkZCApKQk5OTn5romLi8v3MRcsWABLS0vV2NvbF1t+InrlfthVnPTfhP3LVmBJ3yFY+emXyExLR13X99B1/KdSxyMiPVfshSU4OBienp5q2zp16oTg4GAAQHZ2NsLCwtTWyGQyeHp6qtb8V1ZWFlJTU9WGiErWnZCL2PbdAgDA+58NR8dRQ1HO1uYt9yIiKjyNrug1NzcXzs7OwtnZWQghxKRJk4Szs7OoVq2aACB8fHyEv7+/an2NGjXEixcvxMKFC0W9evXE2LFjRXZ2tujcubNqzYABA0R6eroYOnSocHJyEitXrhTJycmicuXKRX6VMYfDKdrpNfMrsSQiWDUjfRcL07JlJc/F4XC0fzQ8f2v24B4eHiI/fn5+AoDw8/MTQUFBee5z+fJlkZGRIe7evSuGDRuW53HHjx8vHjx4IDIyMkRISIh47733imuHORxOEY6BoaFoO7ifGLfuN7E4/JxYEhEsJqxfLcwszCXPxuFwtHs0OX/zo/mJqMhUa1gfn61ejrKWlngUeQObZs1F4oNHUsciIi1VrB/NT0T0Oo+v38TKURPwMuUZqjdqgGk7N6Ln1AmQW1eUOhoR6Tg+w0JERa5iVXt4zZiEhu3bAQByc3Jw8/Q5hOzYh1vnQqDMzZU4IRFpA35bMxFphXptW6PTmBFwbNZEte15fCJOb9iCk+s2SpiMiLQBCwsRaRWbmjXwXp+eaPVhd5iXLwcAOLd5B3b5LIEQOv8riIgKiYWFiLSSobEx2gzojQ+nT4SBgQGCt+3G7oXLkZOZKXU0IpIAL7olIq2Um52NMxu3YsucH6BUKuHavxe+PbYbXb/4jF+mSERvxMJCRCXu0t6D+Gvy13j6JAbm5cuh05gRmLpjPWq1ai51NCLSUnxJiIgkY2BoiIYd3PDBxLGoVKM6lEolQrbvwfE//PEsLv7tD0BEOo3XsBCRTjEpY4YPp02Ea/9eAICc7Gxc2LkPB39ZhXSFQtpwRFRsWFiISCfVbNkMnceMRJ3WLQEAiqSn2LVgKa4dPSFxMiIqDiwsRKTTarZshr6zp8G2liMA4E7IJez96RfE3LojcTIiKkosLESk8wyNjeE5eig6jhoCY1NTKJVKhB85jhNr17O4EOkJFhYi0hvlq9ii+8SxaN69s2pbZNBp7F+6gl+sSKTjWFiISO/Y1a2NjqOGoGkXTxgYGiI3OwehO/cieNtuPuNCpKNYWIhIb1WqUR09Jo9How7uqm0xt+5g14KluB92VbpgRKQxFhYi0nu1WjZDm0F90aiDG4xMTKDMzcWR39bg+Jq/IJRKqeMRUQGwsBBRqVHGUg6v6RPRyusDAED0zds4tupPRJ44zS9WJNJyLCxEVOq0/LA7es+aDDMLcwBA7J17CFzlh/BjQXzGhUhLsbAQUalUxtIS7kMGwu3jASgjtwAAxN2Lwr4lvvj7TLDE6Yjov1hYiKhUM5NboN1H/eExZBDKWlkCAG6eDcb2uQv5HUVEWoSFhYgIgJmFOd7/bATcPhkAI2NjKJKewm/iDDy6dl3qaEQEFhap4xCRlrF2qIZhS35AlXp1kJ2ZiUt7DyE5OgZ3L15meSGSEAsLEdF/mJYti49//A4NO7ipbQ9cvQ5HflsDZW6uRMmISi8WFiKifMgMDODcqQNs69aCXZ1aqg+fu3vxMg77rkLUlWsSJyQqXVhYiIgKoFm3Tuj/3UyYli0LAIj++zbCj57ArXMhiL55m5/jQlTMWFiIiArIunpVdBw5BM0/6AJjM1PV9qgr1/DXlG+gSEySMB2RfmNhISLSUBlLSzTt4gmndi6o0/o9mJYtA0ViEtZP/xb3L12ROh6RXmJhISJ6BxWrVcWIn3+EXZ1aAICkR08QeeI0zm3ZgeQnMRKnI9IfLCxERO/IpEwZ9J41Gc26d4Kx6auXinJzchB+5DiOr12PuDv3JE5IpPtYWIiIiohJmTKo19YFrv28UK9ta9X26yfP4ujva/Hkxt8SpiPSbSwsRETFwL5+XXQcNRRNOnWAgYEBlEolzm/ZiYM//47Ml2lSxyPSOSwsRETFyLp6VXQeOwotenQFAChzc5GdmYUXycnYu/gXRJ44LXFCIt3AwkJEVALquLRE39nTUKlGddU2pVKJPQuX4eym7RImI9INLCxERCVEJpNBbl0RRibG6DDiE7QZ2AcAEHPrDqL/voMbp87i2rEgiVMSaScWFiIiiXQcNQTdJoyBgaGhalvE8VPYPm8hXiSnSJiMSPuwsBARSciyciVUa1APNVs0Q7uP+8PI2BiZael4fP0mHkfcwM0z5xF15Rq/cJFKPRYWIiItYVe3Ngb/MAf2TnXVtr9ITkHw9t0IWrsBmWl8hxGVTiwsRERaRCaTwaaWI6o1qo9aLZuhYXs3lLWyBAAokp7i4M+/4+LuAxKnJCp5LCxERFrMwMgQDdu74YNJ41DJoRoAIPzoCWz9bgEyUl9InI6o5LCwEBHpAEMjI7gPHYSuX3wGI2NjKJKe4nHkTSQ+eITzW3fh6eMnUkckKlaanL8NCvMXjBs3DlFRUUhPT0dISAhatWr12rVBQUEQQuSZ/fv3q9b4+fnluf3QoUOFiUZEpDNyc3IQ9OcG/DpkDJIeP4GldUU0bN8O7Yd/hCnb/0Lr/r0gk8lgaGQkdVQiyWn8DMuAAQPw119/4fPPP0doaCgmTZqE/v37o169ekhMTMyzvnz58jAxMVH9XLFiRYSHh2P06NHw9/cH8Kqw2NjYYMSIEap1mZmZePbsWYEy8RkWItJ1RqamcGzaGBWrV0Wzbp1Qu1VztdufJyTizIYtOL91F78GgPRGsb4kFBISgosXL2LChAmvHkAmw+PHj+Hr64uFCxe+9f4TJ07EvHnzYGdnh7R/roz38/NDuXLl0Lt3b02iqLCwEJE+kclkcPtkILpNGAOTMmZqt6UrUnFx70GEbNuN+PsPpAlIVESKrbAYGxsjLS0N/fr1w549e1Tb161bh3LlyqFXr15vfYxr164hODgYY8aMUW3z8/NDr169kJWVhZSUFJw4cQKzZ89GcnJyvo9hYmIC03++7h14tcPR0dEsLESkV4zNTGFatixyc3LRsH07dBw1BDY1a6huT4h6iDuhl3D5wFE8uHpNuqBEhaRJYdHohVFra2sYGRkhPj5ebXt8fDycnJzeev9WrVqhcePGGDVqlNr2w4cPY+fOnYiKikKtWrXg4+ODQ4cOwdXVFUqlMs/jzJo1C999950m0YmIdE52RiayMzIBAJf2HkTYvkOo6/oeWvfvhYbt26GyowMqOzqg7aC+iDh+CvuXrUDSw8cSpyYqHho9w2JnZ4eYmBi4uroiJCREtX3hwoXw8PBA69at33j/lStXwtXVFc7Ozm9c5+joiPv378PT0xMnTpzIczufYSGi0s5MboHarZqjYQc3tOzZDQaGhlAqlbgTchGhO/ch4vhJKHP4Sbqk3YrtXUJJSUnIycmBjY2N2nYbGxvExcW98b5ly5bFoEGDsHbt2rf+PVFRUUhMTETt2rXzvT0rKwupqalqQ0RUmmSkvkDkidPYMucH/NTnE1w/eRYGBgao18YFQ3/6HjP3bUHrfl4w+p//c0ekyzQqLNnZ2QgLC4Onp6dqm0wmg6enJ4KDg9943/79+8PU1BQbNmx4699jb2+PihUrIjY2VpN4RESlUvz9B/hzwjT80K0vjq3yQ+rTZFSsao/+3jMx99QBfLxwLuq7tYHMoFCfZEGkFQr1tmZ/f3+MGTMGFy5cwKRJkzBgwAA4OTkhISEB/v7+iI6Oxtdff612v9OnTyM6OhqDBw9W225ubg5vb2/s2LEDcXFxqFWrFhYtWgS5XI7GjRsjKyvrrZn4LiEiov9nbGaK1n294D50ECpUsVNtT46OxcXd+xF15RoeX7+JjBcvJUxJVIwX3QLA1q1bUalSJcybNw+2tra4evUqunbtioSEBABA9erV81woW7duXbi5uaFTp055Hi83NxdNmjTBsGHDUK5cOcTExODo0aOYM2dOgcoKERGpy87IxJmNW3F20zZUa9wAzbp2QssPu6GCvR26jP8UAKDMzUXE8VM49VcAHoZHSpyY6O340fxERKWAkakpmnX1RL22rVG9cQNUrGqvuu1ZXDwehEfi7zPnEXbgCC/WpRLD7xIiIqI3sq1dE+6fDETzHl1g/D8X5iY9foLA1etw7VgQP1GXih0LCxERFYhJmTKo1tAJNVs2Q9tBfSGvWAEAkJOdjXsXwhC0bhPuhFyUOCXpKxYWIiLSmEkZM7Qd3A/v9eqByo4Oqu2RQacRuGodHl+/KWE60kcsLERE9E4q1aiOtoP6os3APqpvi34WF4/bwRcRf/8BYm7dxp2QSxBC508hJCEWFiIiKhKVHR3Q+fORaNC+HUzLllW77VHkDexd/AuiLodLlI50HQsLEREVKSMTE9RxaYlqDZ1Q2dEB9d3bwszCHAAQe+cebodcxLWjQfwSRtIICwsRERUri4rl0WXcp3Dp01P1khEAPL5+E2c3bUdE4ElkpvFdRvRmLCxERFQiylpZorZLSzRwb4umXTxhbPbqLdJZ6Rm4cfoc7l+6gkcRNxBz6w5yc3IkTkvahoWFiIhKnHk5K7j09UIrr+5q7zICgOzMTET/fRvXg87i7KatyErPkCglaRMWFiIiklTVBk5o4NEW1Zs0RPVGDWBezkp1myLpKYL+3IDIoNNIfhIjYUqSGgsLERFplYrVqqJ2q2boOHoorKtVVW1PevQEV48cx+X9hxF//4F0AUkSLCxERKSVDI2M8F6fnmjevTMcmjSCofH/X7CbHBOLRxE3EHX5Km6eDsbTJ9ESJqWSwMJCRERaz7RsWTi5uaL5B51Rv10btfICvPqgOkXiUzxPSMTJdZv4lmk9xMJCREQ6xbRsWVRt6IQazo1Rp3VL1GzeVK3A5Obk4Mhva3B6/WYoc3L5jiM9wcJCREQ6zdS8LGxr14RF+XJw7uKJFj26qt2emZaO5OgYxN6+i4O/rERKTJxESeldsLAQEZFeadGzG3rNnISylpZ5bkt7rsCmr+fh5ulzEiSjd8HCQkREesfA0BDGpqYwMDKEeTkrWFevis5jR8OhSUMAQNzd+4i7ex9RV67hetAZpMTyWRdtx8JCRESlgqGREXpOnQC3jwfkuS3uXhQeR97Ao4gbuHnmPF820kIsLEREVKpYVrKGXd3asHeqA6d2rnBs1gQGhoZqa6L/vo3IE6cReeI0Ym7dkSgp/S8WFiIiKtXKWlmiRtMmqNbQCbVaNc9TYLIzMqFISkL8/Qc4t3kH/j4TLGHa0ouFhYiI6H+Yl7NCffe2aNTRHfXauMCkjJna7bF37uHgzytx49RZiRKWTiwsREREr2FobAwrm0qwqmSNRp4eaN3PC2bm5gCAW+dCEH3rDuQVKyIlNg4Xdu5DSmwcqjaoh6oN6yP8yHGkK3ieKSosLERERAVkJreA56ghcB8yCEYmJmq3KZVKpCY+hZVNJQCv3om0aswkKBISUalGdShzcvkVAu+AhYWIiEhDFatVRdvBfQEAL1OeofZ7LVC3dSsArz6oLicrC+blrJAcHYvn8QlwbO6MnKwsbJ+3EBf3HJQyus5iYSEiIioC1g7VUKGKLaKuXINFhfIYs+pnVKpRPc+60xu24PRfm/nZLxpiYSEiIioGFhXKo9uEMa+ub9l9AK37fogu40arbk+Ieoj4+w+QEhuHRxE3cOPkWWSmpUmYWLuxsBAREZWQhh3c0H7YR3BwbgRDI/VvnM7OzMSjyBtIV6RCkZCEc5t3IO7ufYmSah8WFiIiohJmJreAY9MmKF/FFhWr2qOBR1tUdnRQW6NUKnFp70Fc2LUfjyJuIDc7W6K02oGFhYiISAvY1qkF25o1YCa3QF3X9+DcuaPqtuyMTNy7dAXXAoNw98Jl5GRlIis9E+kKhYSJSxYLCxERkRaq1qgBPIYOQu33WkBesUK+axIfPMK9S1eQ+OARFE+fIv5uFKL/vl3CSUsGCwsREZGWs6nliEYd3NG4U3vYONaAgZEhjIyN8137LD4BN0+fx41T53An9CKyMzJLOG3xYGEhIiLSQWZyCzg2c0bN5k1gZVMZlpWsUb1xQ5iWLaNak52RiTuhl3DzzHnkZGbByrYyXqY8w9XDgUh7rlsvJ7GwEBER6QkjExPUatUcDTzaooFHW1SoYpfvupzsbESeOI0zG7biwdVrJZyycFhYiIiI9JRt7Zpo4NEWdVq3Qm5ODhTxiahSvy6qNXBSrXkUcQNRV8KRHB2Dm2dC8PTxEwkTvx4LCxERUSlTpV4dtB3UFy16doWxqalqe05WFk78uQGn/DfBvFw5lLG0gCLxKVKTngIyGYxNTZGVni5JZhYWIiKiUsqiYnk09mwP6+pVUa1RfdRq0SzfdcrcXBgYGgIAYm7fxba5P+LRteslGZWFhYiIiF5p0qkDes34ClY2lZCVnoH01FTIK1ZQlZV/KZVKXNpzEA+uXsPzhERYV6+KCvZVEHXlGiJPnIZQKos8GwsLERERqcgMDFBGbqF6F5GBoSHMy5eDMicHBkZG+GDSOLTy6v7a+yc+fIxTfwXg4p6DyMksurdUs7AQERGRRmq1ao6GHdxgW8sRlpWs8fRJNFKTkuHcuSPKWlkiJysL33fujdSnyUX2d2p6/haazrhx40RUVJRIT08XISEholWrVq9dO2zYMPFf6enpedbNnTtXxMTEiLS0NHHs2DFRu3btAueRy+VCCCHkcrnG+8LhcDgcDuf1Y1KmjGj3UX/RZdzoIn9sDc/fmj34gAEDREZGhhg+fLioX7++WLVqlUhOThaVKlXKd/2wYcPEs2fPhI2NjWoqV66stmb69OkiJSVFfPjhh6Jx48Zi9+7d4t69e8LU1LQ4dpjD4XA4HI4WTLEWlpCQEOHr66v6WSaTiSdPnogZM2bku37YsGEiJSXljY8ZExMjpkyZovrZ0tJSpKeni4EDBxbHDnM4HA6Hw9GC0eT8bQANGBsbo0WLFggMDFRtE0IgMDAQrq6ur72fhYUFHjx4gEePHmH37t1o0KCB6jZHR0fY2dmpPaZCoUBoaOgbH5OIiIhKD40Ki7W1NYyMjBAfH6+2PT4+Hra2tvne59atWxg5ciS8vLzwySefwMDAAOfPn4e9vT0AqO6nyWOamJhALperDREREekvjQpLYYSEhGD9+vUIDw/H6dOn0adPHyQmJmLMmDGFfsxZs2ZBoVCoJjo6uggTExERkbbRqLAkJSUhJycHNjY2atttbGwQFxdXoMfIycnBlStXULt2bQBQ3U+Tx1ywYAEsLS1V8++zNURERKSfNCos2dnZCAsLg6enp2qbTCaDp6cngoODC/YXGhigcePGiI2NBQBERUUhNjZW7THlcjlcXFxe+5hZWVlITU1VGyIiItJvGl3RO2DAAJGeni6GDh0qnJycxMqVK0VycrLqrcr+/v7Cx8dHtX7OnDmiU6dOwtHRUTRr1kxs2rRJpKWlifr166vWTJ8+XSQnJ4uePXuKRo0aiV27dvFtzRwOh8Ph6Plocv42goa2bt2KSpUqYd68ebC1tcXVq1fRtWtXJCQkAACqV68O5f9830D58uXxxx9/wNbWFikpKQgLC0ObNm1w8+ZN1ZpFixbB3Nwcq1evRrly5XD27Fl07doVmUX48b9ERESku/jR/ERERCQJTc7fxf4uISIiIqJ3xcJCREREWo+FhYiIiLQeCwsRERFpPY3fJaTN+BH9REREukOT87ZeFJZ/d5gf0U9ERKR75HL5W98lpBdvawaAKlWqFMtbmuVyOaKjo2Fvb6+3b5nW933U9/0DuI/6QN/3D+A+6oPi2D+5XI6YmJi3rtOLZ1gAFGhn30Vp+AoAfd9Hfd8/gPuoD/R9/wDuoz4oyv0r6OPwolsiIiLSeiwsREREpPVYWN4iMzMT3333nV5/r5G+76O+7x/AfdQH+r5/APdRH0i5f3pz0S0RERHpLz7DQkRERFqPhYWIiIi0HgsLERERaT0WFiIiItJ6LCxvMW7cOERFRSE9PR0hISFo1aqV1JEKZebMmbhw4QIUCgXi4+Oxa9cu1K1bV21NUFAQhBBq8/vvv0uUWHPe3t558t+8eVN1u6mpKX799VckJSUhNTUV27dvR+XKlSVMrJmoqKg8+yeEwK+//gpAN4+fm5sb9u7di+joaAgh4OXllWfN3LlzERMTg7S0NBw7dgy1a9dWu718+fLYsGEDnj9/jpSUFKxZswbm5uYltQtv9aZ9NDIywo8//ohr167hxYsXiI6Ohr+/P+zs7NQeI79jP2PGjJLelXy97Rj6+fnlyX7o0CG1Nbp8DAHk++9SCIGpU6eq1mjzMSzI+aEgvz+rVauG/fv34+XLl4iPj8eiRYtgaGhYZDlZWN5gwIABWLp0KebOnYvmzZsjPDwcR44cQaVKlaSOpjEPDw+sWLECrVu3RqdOnWBsbIyjR4+ibNmyautWr14NW1tb1UyfPl2ixIUTGRmplr9du3aq25YtW4aePXuif//+8PDwQJUqVbBz504J02qmVatWavv2/vvvAwC2bdumWqNrx8/c3Bzh4eEYP358vrdPnz4dX375JT7//HO4uLjg5cuXOHLkCExNTVVrNm7ciIYNG6JTp07o0aMH3N3dsXr16pLahbd60z6WLVsWzZs3x/z589G8eXP06dMH9erVw969e/OsnTNnjtqx9fX1LYn4b/W2YwgAhw4dUss+ePBgtdt1+RgCUNs3W1tbjBgxAkqlEjt27FBbp63HsCDnh7f9/jQwMMCBAwdgYmKCNm3aYNiwYRg+fDjmzZtXpFkFJ/8JCQkRvr6+qp9lMpl48uSJmDFjhuTZ3nWsra2FEEK4ubmptgUFBYlly5ZJnq2w4+3tLa5cuZLvbZaWliIzM1P07dtXta1evXpCCCFcXFwkz16YWbZsmbhz547eHD8hhPDy8lLbFhMTI6ZMmaJ2HNPT08XAgQMFAOHk5CSEEKJFixaqNV26dBG5ubnCzs5O8n0qyD7+d1q2bCmEEKJatWqqbVFRUWLixImS5y/M/vn5+Yldu3a99j76eAx37dolAgMD1bbpyjEE8p4fCvL7s2vXriInJ0dUrlxZtWbMmDHi2bNnwtjYuEhy8RmW1zA2NkaLFi0QGBio2iaEQGBgIFxdXSVMVjSsrKwAAMnJyWrbP/74YyQmJiIiIgI+Pj4oU6aMFPEKrU6dOoiOjsa9e/ewYcMGVKtWDQDQokULmJiYqB3PW7du4eHDhzp5PI2NjfHJJ5/gzz//VNuu68fvfzk6OsLOzk7tmCkUCoSGhqqOmaurK1JSUhAWFqZaExgYCKVSCRcXlxLPXBSsrKygVCrx7Nkzte0zZ85EUlISLl++jKlTpxbpU+3FrX379oiPj8fff/+N3377DRUqVFDdpm/HsHLlyvjggw+wdu3aPLfpyjH87/mhIL8/XV1dERERgYSEBNWaI0eOwMrKCg0bNiySXHrz5YdFzdraGkZGRoiPj1fbHh8fDycnJ4lSFQ2ZTIbly5fj7NmzuH79umr7pk2b8PDhQ8TExKBJkyZYuHAh6tWrh759+0qYtuBCQ0MxfPhw3Lp1C3Z2dvD29saZM2fQqFEj2NraIjMzE8+fP1e7T3x8PGxtbSVKXHi9evVCuXLlsG7dOtU2XT9+//Xvccnv3+C/t9na2qr9ggSA3NxcJCcn6+RxNTU1xcKFCxEQEKD2hXC//PILLl++jOTkZLRp0wYLFiyAnZ0dpkyZImHagjl8+DB27tyJqKgo1KpVCz4+Pjh06BBcXV2hVCr17hgOGzYMqampeV5u1pVjmN/5oSC/P21tbfP9t/rvbUWBhaUUWrFiBRo1aqR2fQcA/PHHH6o/R0ZGIjY2FidOnEDNmjVx//79ko6pscOHD6v+HBERgdDQUDx8+BADBgxAenq6hMmK3qhRo3Do0CHExsaqtun68SvtjIyMsHXrVshkMowdO1bttmXLlqn+HBERgaysLKxatQqzZs1CVlZWSUfVyJYtW1R/joyMxLVr13D//n20b98eJ06ckDBZ8Rg5ciQ2btyY56PrdeUYvu78oA34ktBrJCUlIScnBzY2NmrbbWxsEBcXJ1Gqd+fr64sePXqgQ4cOiI6OfuPa0NBQAMjzrgxd8fz5c9y+fRu1a9dGXFwcTE1NVU91/ksXj2f16tXx/vvvY82aNW9cp+vH79/j8qZ/g3FxcXneqWBoaIgKFSro1HH9t6w4ODigU6dOas+u5Cc0NBTGxsaoUaNGyQQsQlFRUUhMTFT9d6kvxxAA2rVrBycnp7f+2wS08xi+7vxQkN+fcXFx+f5b/fe2osDC8hrZ2dkICwuDp6enaptMJoOnpyeCg4MlTFZ4vr6+6N27Nzp27IgHDx68dX3Tpk0BQO3/xesSc3Nz1KpVC7GxsQgLC0NWVpba8axbty4cHBx07niOGDECCQkJOHDgwBvX6frxi4qKQmxsrNoxk8vlcHFxUR2z4OBglC9fHs2bN1et6dixIwwMDFSFTdv9W1bq1KmD999/P891Zflp2rQpcnNz87yUogvs7e1RsWJF1X+X+nAM/zVq1ChcunQJ165de+tabTuGbzo/FOT3Z3BwMBo3bqz2LtpOnTrh+fPnuHHjRpHllPyKZG2dAQMGiPT0dDF06FDh5OQkVq5cKZKTk9WugtaVWbFihUhJSRHu7u7CxsZGNWZmZgKAqFmzppg9e7Zo3ry5cHBwED179hR3794VJ0+elDx7QWfx4sXC3d1dODg4CFdXV3H06FGRkJAgrK2tBQDx22+/iQcPHoj27duL5s2bi3Pnzolz585JnluTkclk4sGDB2LBggVq23X1+JmbmwtnZ2fh7OwshBBi0qRJwtnZWfUOmenTp4vk5GTRs2dP0ahRI7Fr1y5x7949YWpqqnqMgwcPirCwMNGqVSvRpk0bcevWLbFx40bJ960g+2hkZCR2794tHj16JJo0aaL2b/Pfd1a0bt1aTJw4UTRp0kQ4OjqKjz76SMTHx4t169ZJvm9v2z9zc3OxaNEi4eLiIhwcHETHjh3FpUuXxK1bt4SJiYleHMN/18jlcvHixQsxZsyYPPfX9mP4tvMD8PbfnwYGBuLatWvi8OHDokmTJqJz584iPj5e/PDDD0WZVfr/sbR5xo8fLx48eCAyMjJESEiIeO+99yTPVJh5nWHDhgkAomrVquLkyZMiKSlJpKeni9u3b4uFCxcKuVwuefaCTkBAgIiOjhYZGRni8ePHIiAgQNSsWVN1u6mpqfj111/F06dPxYsXL8SOHTuEjY2N5Lk1mU6dOgkhhKhTp47adl09fh4eHvn+d+nn56daM3fuXBEbGyvS09PFsWPH8ux7+fLlxcaNG4VCoRDPnj0Ta9euFebm5pLvW0H20cHB4bX/Nj08PAQA0axZMxEcHCxSUlJEWlqauH79upg5c6baCV9b98/MzEwcPnxYxMfHi8zMTBEVFSVWrVqV5//06fIx/HfNp59+Kl6+fCksLS3z3F/bj+Hr/Ht+AAr2+7N69eriwIED4uXLlyIhIUEsXrxYGBoaFllO2T9/ICIiItJavIaFiIiItB4LCxEREWk9FhYiIiLSeiwsREREpPVYWIiIiEjrsbAQERGR1mNhISIiIq3HwkJERERaj4WFiIiItB4LCxEREWk9FhYiIiLSeiwsREREpPX+D1+4NgsTw8srAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(training_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(enn_model.state_dict(), '../model/intent.enn.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 19,
     "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": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(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": 20,
     "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": 21,
   "metadata": {},
   "outputs": [
    {
     "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"
     ]
    }
   ],
   "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
}