no stream test

解决new bing 报错200 (fix new bing error code 200 )

.github/workflows/build-with-chatglm.yml

@@ -1,5 +1,5 @@
 # https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#publishing-images-to-github-packages
-name: Create and publish a Docker image for ChatGLM support
+name: build-with-chatglm
 
 on:
   push:

.github/workflows/build-with-jittorllms.yml

@@ -1,5 +1,5 @@
 # https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#publishing-images-to-github-packages
-name: Create and publish a Docker image for ChatGLM support
+name: build-with-jittorllms
 
 on:
   push:

.github/workflows/build-with-latex.yml

@@ -1,5 +1,5 @@
 # https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#publishing-images-to-github-packages
-name: Create and publish a Docker image for Latex support
+name: build-with-latex
 
 on:
   push:

.github/workflows/build-without-local-llms.yml

@@ -1,5 +1,5 @@
 # https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#publishing-images-to-github-packages
-name: Create and publish a Docker image
+name: build-without-local-llms
 
 on:
   push:

README.md

@@ -1,13 +1,11 @@
 > **Note**
 >
-> 2023.7.5: Gradio依赖调整。请及时**更新代码**
->
-> 2023.7.8: pydantic出现兼容问题，已修改 `requirements.txt`。安装依赖时，请严格选择`requirements.txt`中**指定的版本**
+> 2023.7.8: Gradio, Pydantic依赖调整，已修改 `requirements.txt`。请及时**更新代码**，安装依赖时，请严格选择`requirements.txt`中**指定的版本**
 >
 > `pip install -r requirements.txt`
 
 
-# <div align=center><img src="docs/logo.png" width="40" > GPT 学术优化 (GPT Academic)</div>
+# <div align=center><img src="docs/logo.png" width="40"> GPT 学术优化 (GPT Academic)</div>
 
 **如果喜欢这个项目，请给它一个Star；如果您发明了好用的快捷键或函数插件，欢迎发pull requests！**
 
@@ -20,14 +18,14 @@ To translate this project to arbitary language with GPT, read and run [`multi_la
 >
 > 2.本项目中每个文件的功能都在自译解[`self_analysis.md`](https://github.com/binary-husky/gpt_academic/wiki/chatgpt-academic%E9%A1%B9%E7%9B%AE%E8%87%AA%E8%AF%91%E8%A7%A3%E6%8A%A5%E5%91%8A)详细说明。随着版本的迭代，您也可以随时自行点击相关函数插件，调用GPT重新生成项目的自我解析报告。常见问题汇总在[`wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98)当中。[安装方法](#installation)。
 > 
-> 3.本项目兼容并鼓励尝试国产大语言模型ChatGLM和Moss等等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,api2d-key3"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交后即可生效。
+> 3.本项目兼容并鼓励尝试国产大语言模型ChatGLM和Moss等等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,azure-key3,api2d-key4"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交后即可生效。
 
 
  
 
 <div align="center">
 
-功能 | 描述
+功能（⭐= 近期新增功能） | 描述
 --- | ---
 一键润色 | 支持一键润色、一键查找论文语法错误
 一键中英互译 | 一键中英互译
@@ -43,15 +41,18 @@ Markdown[中英互译](https://www.bilibili.com/video/BV1yo4y157jV/) | [函数
 chat分析报告生成 | [函数插件] 运行后自动生成总结汇报
 [PDF论文全文翻译功能](https://www.bilibili.com/video/BV1KT411x7Wn) | [函数插件] PDF论文提取题目&摘要+翻译全文（多线程）
 [Arxiv小助手](https://www.bilibili.com/video/BV1LM4y1279X) | [函数插件] 输入arxiv文章url即可一键翻译摘要+下载PDF
+Latex论文一键校对 | [函数插件] 仿Grammarly对Latex文章进行语法、拼写纠错+输出对照PDF
 [谷歌学术统合小助手](https://www.bilibili.com/video/BV19L411U7ia) | [函数插件] 给定任意谷歌学术搜索页面URL，让gpt帮你[写relatedworks](https://www.bilibili.com/video/BV1GP411U7Az/)
 互联网信息聚合+GPT | [函数插件] 一键[让GPT从互联网获取信息](https://www.bilibili.com/video/BV1om4y127ck)回答问题，让信息永不过时
-⭐Arxiv论文精细翻译 | [函数插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
+⭐Arxiv论文精细翻译 ([Docker](https://github.com/binary-husky/gpt_academic/pkgs/container/gpt_academic_with_latex)) | [函数插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
+⭐[实时语音对话输入](https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md) | [函数插件] 异步[监听音频](https://www.bilibili.com/video/BV1AV4y187Uy/)，自动断句，自动寻找回答时机
 公式/图片/表格显示 | 可以同时显示公式的[tex形式和渲染形式](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png)，支持公式、代码高亮
 多线程函数插件支持 | 支持多线调用chatgpt，一键处理[海量文本](https://www.bilibili.com/video/BV1FT411H7c5/)或程序
 启动暗色[主题](https://github.com/binary-husky/gpt_academic/issues/173) | 在浏览器url后面添加```/?__theme=dark```可以切换dark主题
-[多LLM模型](https://www.bilibili.com/video/BV1wT411p7yf)支持 | 同时被GPT3.5、GPT4、[清华ChatGLM](https://github.com/THUDM/ChatGLM-6B)、[复旦MOSS](https://github.com/OpenLMLab/MOSS)同时伺候的感觉一定会很不错吧？
+[多LLM模型](https://www.bilibili.com/video/BV1wT411p7yf)支持 | 同时被GPT3.5、GPT4、[清华ChatGLM2](https://github.com/THUDM/ChatGLM2-6B)、[复旦MOSS](https://github.com/OpenLMLab/MOSS)同时伺候的感觉一定会很不错吧？
+⭐ChatGLM2微调模型 | 支持加载ChatGLM2微调模型，提供ChatGLM2微调辅助插件
 更多LLM模型接入，支持[huggingface部署](https://huggingface.co/spaces/qingxu98/gpt-academic) | 加入Newbing接口(新必应)，引入清华[Jittorllms](https://github.com/Jittor/JittorLLMs)支持[LLaMA](https://github.com/facebookresearch/llama)和[盘古α](https://openi.org.cn/pangu/)
-更多新功能展示(图像生成等) …… | 见本文档结尾处 ……
+更多新功能展示 (图像生成等) …… | 见本文档结尾处 ……
 
 </div>
 
@@ -115,12 +116,12 @@ python -m pip install -r requirements.txt # 这个步骤和pip安装一样的步
 ```
 
 
-<details><summary>如果需要支持清华ChatGLM/复旦MOSS作为后端，请点击展开此处</summary>
+<details><summary>如果需要支持清华ChatGLM2/复旦MOSS作为后端，请点击展开此处</summary>
 <p>
 
-【可选步骤】如果需要支持清华ChatGLM/复旦MOSS作为后端，需要额外安装更多依赖（前提条件：熟悉Python + 用过Pytorch + 电脑配置够强）：
+【可选步骤】如果需要支持清华ChatGLM2/复旦MOSS作为后端，需要额外安装更多依赖（前提条件：熟悉Python + 用过Pytorch + 电脑配置够强）：
 ```sh
-# 【可选步骤I】支持清华ChatGLM。清华ChatGLM备注：如果遇到"Call ChatGLM fail 不能正常加载ChatGLM的参数" 错误，参考如下： 1：以上默认安装的为torch+cpu版，使用cuda需要卸载torch重新安装torch+cuda； 2：如因本机配置不够无法加载模型，可以修改request_llm/bridge_chatglm.py中的模型精度, 将 AutoTokenizer.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True) 都修改为 AutoTokenizer.from_pretrained("THUDM/chatglm-6b-int4", trust_remote_code=True)
+# 【可选步骤I】支持清华ChatGLM2。清华ChatGLM备注：如果遇到"Call ChatGLM fail 不能正常加载ChatGLM的参数" 错误，参考如下： 1：以上默认安装的为torch+cpu版，使用cuda需要卸载torch重新安装torch+cuda； 2：如因本机配置不够无法加载模型，可以修改request_llm/bridge_chatglm.py中的模型精度, 将 AutoTokenizer.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True) 都修改为 AutoTokenizer.from_pretrained("THUDM/chatglm-6b-int4", trust_remote_code=True)
 python -m pip install -r request_llm/requirements_chatglm.txt  
 
 # 【可选步骤II】支持复旦MOSS
@@ -144,6 +145,8 @@ python main.py
 ### 安装方法II：使用Docker
 
 1. 仅ChatGPT（推荐大多数人选择，等价于docker-compose方案1）
+[![basic](https://github.com/binary-husky/gpt_academic/actions/workflows/build-without-local-llms.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-without-local-llms.yml)
+[![basiclatex](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-latex.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-latex.yml)
 
 ``` sh
 git clone https://github.com/binary-husky/gpt_academic.git  # 下载项目
@@ -151,14 +154,15 @@ cd gpt_academic                                 # 进入路径
 nano config.py                                      # 用任意文本编辑器编辑config.py, 配置 “Proxy”， “API_KEY” 以及 “WEB_PORT” (例如50923) 等
 docker build -t gpt-academic .                      # 安装
 
-#（最后一步-选择1）在Linux环境下，用`--net=host`更方便快捷
+#（最后一步-Linux操作系统）用`--net=host`更方便快捷
 docker run --rm -it --net=host gpt-academic
-#（最后一步-选择2）在macOS/windows环境下，只能用-p选项将容器上的端口(例如50923)暴露给主机上的端口
+#（最后一步-MacOS/Windows操作系统）只能用-p选项将容器上的端口(例如50923)暴露给主机上的端口
 docker run --rm -it -e WEB_PORT=50923 -p 50923:50923 gpt-academic
 ```
 P.S. 如果需要依赖Latex的插件功能，请见Wiki。另外，您也可以直接使用docker-compose获取Latex功能（修改docker-compose.yml，保留方案4并删除其他方案）。
 
-2. ChatGPT + ChatGLM + MOSS（需要熟悉Docker）
+2. ChatGPT + ChatGLM2 + MOSS（需要熟悉Docker）
+[![chatglm](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-chatglm.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-chatglm.yml)
 
 ``` sh
 # 修改docker-compose.yml，保留方案2并删除其他方案。修改docker-compose.yml中方案2的配置，参考其中注释即可
@@ -166,6 +170,8 @@ docker-compose up
 ```
 
 3. ChatGPT + LLAMA + 盘古 + RWKV（需要熟悉Docker）
+[![jittorllms](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-jittorllms.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-jittorllms.yml)
+
 ``` sh
 # 修改docker-compose.yml，保留方案3并删除其他方案。修改docker-compose.yml中方案3的配置，参考其中注释即可
 docker-compose up
@@ -284,6 +290,9 @@ Tip：不指定文件直接点击 `载入对话历史存档` 可以查看历史h
 
 ### II：版本:
 - version 3.5(Todo): 使用自然语言调用本项目的所有函数插件（高优先级）
+- version 3.46: 支持完全脱手操作的实时语音对话
+- version 3.45: 支持自定义ChatGLM2微调模型
+- version 3.44: 正式支持Azure，优化界面易用性
 - version 3.4: +arxiv论文翻译、latex论文批改功能
 - version 3.3: +互联网信息综合功能
 - version 3.2: 函数插件支持更多参数接口 (保存对话功能, 解读任意语言代码+同时询问任意的LLM组合)
@@ -305,7 +314,7 @@ gpt_academic开发者QQ群-2：610599535
     - 官方Gradio目前有很多兼容性Bug，请务必使用`requirement.txt`安装Gradio
 
 ### III：主题
-
+可以通过修改`THEME`选项（config.py）变更主题
 1. `Chuanhu-Small-and-Beautiful` [网址](https://github.com/GaiZhenbiao/ChuanhuChatGPT/)
 
 
@@ -314,8 +323,8 @@ gpt_academic开发者QQ群-2：610599535
 ```
 代码中参考了很多其他优秀项目中的设计，顺序不分先后：
 
-# 清华ChatGLM-6B:
-https://github.com/THUDM/ChatGLM-6B
+# 清华ChatGLM2-6B:
+https://github.com/THUDM/ChatGLM2-6B
 
 # 清华JittorLLMs:
 https://github.com/Jittor/JittorLLMs

check_proxy.py

@@ -117,7 +117,7 @@ def auto_update(raise_error=False):
         with open('./version', 'r', encoding='utf8') as f:
             current_version = f.read()
             current_version = json.loads(current_version)['version']
-        if (remote_version - current_version) >= 0.01:
+        if (remote_version - current_version) >= 0.01-1e-5:
             from colorful import print亮黄
             print亮黄(
                 f'\n新版本可用。新版本:{remote_version}，当前版本:{current_version}。{new_feature}')
@@ -139,7 +139,7 @@ def auto_update(raise_error=False):
         else:
             return
     except:
-        msg = '自动更新程序：已禁用'
+        msg = '自动更新程序：已禁用。建议排查：代理网络配置。'
         if raise_error:
             from toolbox import trimmed_format_exc
             msg += trimmed_format_exc()

config.py

@@ -32,9 +32,9 @@ else:
 
 # ------------------------------------ 以下配置可以优化体验, 但大部分场合下并不需要修改 ------------------------------------
 
-# 重新URL重新定向，实现更换API_URL的作用（常规情况下，不要修改!! 高危设置！通过修改此设置，您将把您的API-KEY和对话隐私完全暴露给您设定的中间人！）
-# 格式 API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "在这里填写重定向的api.openai.com的URL"} 
-# 例如 API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions":"https://reverse-proxy-url/v1/chat/completions"}
+# 重新URL重新定向，实现更换API_URL的作用（高危设置! 常规情况下不要修改! 通过修改此设置，您将把您的API-KEY和对话隐私完全暴露给您设定的中间人！）
+# 格式: API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "在这里填写重定向的api.openai.com的URL"} 
+# 举例: API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "https://reverse-proxy-url/v1/chat/completions"}
 API_URL_REDIRECT = {}
 
 
@@ -71,7 +71,11 @@ MAX_RETRY = 2
 # 模型选择是 (注意: LLM_MODEL是默认选中的模型, 它*必须*被包含在AVAIL_LLM_MODELS列表中 )
 LLM_MODEL = "gpt-3.5-turbo" # 可选 ↓↓↓
 AVAIL_LLM_MODELS = ["gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "chatglm", "moss", "newbing", "stack-claude"]
-# P.S. 其他可用的模型还包括 ["gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "newbing-free", "jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"]
+# P.S. 其他可用的模型还包括 ["gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "claude-1-100k", "claude-2", "internlm", "jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"]
+
+
+# ChatGLM(2) Finetune Model Path （如果使用ChatGLM2微调模型，需要把"chatglmft"加入AVAIL_LLM_MODELS中）
+ChatGLM_PTUNING_CHECKPOINT = "" # 例如"/home/hmp/ChatGLM2-6B/ptuning/output/6b-pt-128-1e-2/checkpoint-100"
 
 
 # 本地LLM模型如ChatGLM的执行方式 CPU/GPU
@@ -85,9 +89,11 @@ CONCURRENT_COUNT = 100
 # 是否在提交时自动清空输入框
 AUTO_CLEAR_TXT = False
 
+
 # 色彩主体，可选 ["Default", "Chuanhu-Small-and-Beautiful"]
 THEME = "Default"
 
+
 # 加一个live2d装饰
 ADD_WAIFU = False
 
@@ -123,11 +129,11 @@ put your new bing cookies here
 """
 
 
-# 阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https://help.aliyun.com/document_detail/450255.html
+# 阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md
 ENABLE_AUDIO = False
 ALIYUN_TOKEN=""    # 例如 f37f30e0f9934c34a992f6f64f7eba4f
 ALIYUN_APPKEY=""   # 例如 RoPlZrM88DnAFkZK
 
 
-# ChatGLM Finetune Model Path
-ChatGLM_PTUNING_CHECKPOINT = ""
+# Claude API KEY
+ANTHROPIC_API_KEY = ""

crazy_functional.py

@@ -392,7 +392,7 @@ def get_crazy_functions():
         })
         from crazy_functions.Latex输出PDF结果 import Latex翻译中文并重新编译PDF
         function_plugins.update({
-            "Arixv翻译（输入arxivID）[需Latex]": {
+            "Arixv论文精细翻译（输入arxivID）[需Latex]": {
                 "Color": "stop",
                 "AsButton": False,
                 "AdvancedArgs": True,
@@ -403,7 +403,7 @@ def get_crazy_functions():
             }
         })
         function_plugins.update({
-            "本地论文翻译（上传Latex压缩包）[需Latex]": {
+            "本地Latex论文精细翻译（上传Latex项目）[需Latex]": {
                 "Color": "stop",
                 "AsButton": False,
                 "AdvancedArgs": True,
@@ -432,18 +432,18 @@ def get_crazy_functions():
     except:
         print('Load function plugin failed')
         
-    try:
-        from crazy_functions.虚空终端 import 终端
-        function_plugins.update({
-            "超级终端": {
-                "Color": "stop",
-                "AsButton": False,
-                # "AdvancedArgs": True,
-                # "ArgsReminder": "",
-                "Function": HotReload(终端)
-            }
-        })
-    except:
-        print('Load function plugin failed')
+    # try:
+    #     from crazy_functions.虚空终端 import 终端
+    #     function_plugins.update({
+    #         "超级终端": {
+    #             "Color": "stop",
+    #             "AsButton": False,
+    #             # "AdvancedArgs": True,
+    #             # "ArgsReminder": "",
+    #             "Function": HotReload(终端)
+    #         }
+    #     })
+    # except:
+    #     print('Load function plugin failed')
 
     return function_plugins

crazy_functions/Langchain知识库.py

@@ -30,7 +30,7 @@ def 知识库问答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_pro
         )
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         from .crazy_utils import try_install_deps
-        try_install_deps(['zh_langchain==0.2.1'])
+        try_install_deps(['zh_langchain==0.2.1', 'pypinyin'])
     
     # < --------------------读取参数--------------- >
     if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")

crazy_functions/chatglm微调工具.py

@@ -18,6 +18,13 @@ def string_to_options(arguments):
     parser.add_argument("--prompt_prefix", type=str, help="Prompt prefix", default='')
     parser.add_argument("--system_prompt", type=str, help="System prompt", default='')
     parser.add_argument("--batch", type=int, help="System prompt", default=50)
+    parser.add_argument("--pre_seq_len", type=int, help="pre_seq_len", default=50)
+    parser.add_argument("--learning_rate", type=float, help="learning_rate", default=2e-2)
+    parser.add_argument("--num_gpus", type=int, help="num_gpus", default=1)
+    parser.add_argument("--json_dataset", type=str, help="json_dataset", default="")
+    parser.add_argument("--ptuning_directory", type=str, help="ptuning_directory", default="")
+
+
 
     # Parse the arguments
     args = parser.parse_args(shlex.split(arguments))
@@ -72,7 +79,8 @@ def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
 
 
 
-def 启动微调(arguments):
+@CatchException
+def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -82,24 +90,35 @@ def 启动微调(arguments):
     system_prompt   给gpt的静默提醒
     web_port        当前软件运行的端口号
     """
-    history = []    # 清空历史，以免输入溢出
     import subprocess
-    PRE_SEQ_LEN = 128
-    LR = 2e-2
-    NUM_GPUS = 1
-    JSON_FILE = 't_code.json'
-    tune_work_path = '/home/hmp/ChatGLM2-6B/ptuning'
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append(("这是什么功能？", "[Local Message] 微调数据集生成"))
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    args = plugin_kwargs.get("advanced_arg", None)
+    if args is None: 
+        chatbot.append(("没给定指令", "退出"))
+        yield from update_ui(chatbot=chatbot, history=history); return
+    else:
+        arguments = string_to_options(arguments=args)
+      
 
-    command = f"torchrun --standalone --nnodes=1 --nproc-per-node={NUM_GPUS} main.py \
+
+    pre_seq_len = arguments.pre_seq_len             # 128
+    learning_rate = arguments.learning_rate                               # 2e-2
+    num_gpus = arguments.num_gpus                   # 1
+    json_dataset = arguments.json_dataset                 # 't_code.json'
+    ptuning_directory = arguments.ptuning_directory       # '/home/hmp/ChatGLM2-6B/ptuning'
+
+    command = f"torchrun --standalone --nnodes=1 --nproc-per-node={num_gpus} main.py \
         --do_train \
-        --train_file AdvertiseGen/{JSON_FILE} \
-        --validation_file AdvertiseGen/{JSON_FILE} \
+        --train_file AdvertiseGen/{json_dataset} \
+        --validation_file AdvertiseGen/{json_dataset} \
         --preprocessing_num_workers 20 \
         --prompt_column content \
         --response_column summary \
         --overwrite_cache \
         --model_name_or_path THUDM/chatglm2-6b \
-        --output_dir output/clothgen-chatglm2-6b-pt-{PRE_SEQ_LEN}-{LR} \
+        --output_dir output/clothgen-chatglm2-6b-pt-{pre_seq_len}-{learning_rate} \
         --overwrite_output_dir \
         --max_source_length 256 \
         --max_target_length 256 \
@@ -110,16 +129,13 @@ def 启动微调(arguments):
         --max_steps 100 \
         --logging_steps 10 \
         --save_steps 20 \
-        --learning_rate {LR} \
-        --pre_seq_len {PRE_SEQ_LEN} \
+        --learning_rate {learning_rate} \
+        --pre_seq_len {pre_seq_len} \
         --quantization_bit 4"
 
-    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=tune_work_path)
+    process = subprocess.Popen(command, shell=True, cwd=ptuning_directory)
     try:
-        stdout, stderr = process.communicate(timeout=3600*5)
+        process.communicate(timeout=3600*24)
     except subprocess.TimeoutExpired:
         process.kill()
-        stdout, stderr = process.communicate()
-        print("Process timed out!")
-        return False
     return

crazy_functions/crazy_functions_test.py

@@ -212,11 +212,17 @@ def test_Latex():
     #     cli_printer.print(cb)   #  print(cb)
 
 def test_chatglm_finetune():
-    from crazy_functions.chatglm微调工具 import 微调数据集生成
+    from crazy_functions.chatglm微调工具 import 微调数据集生成, 启动微调
     txt = 'build/dev.json'
     plugin_kwargs = {"advanced_arg":"--llm_to_learn=gpt-3.5-turbo --prompt_prefix='根据下面的服装类型提示，想象一个穿着者，对这个人外貌、身处的环境、内心世界、人设进行描写。要求：100字以内，用第二人称。' --system_prompt=''" }
 
-    for cookies, cb, hist, msg in (微调数据集生成)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    # for cookies, cb, hist, msg in (微调数据集生成)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    #     cli_printer.print(cb)
+
+    plugin_kwargs = {"advanced_arg":
+    "      --pre_seq_len=128 --learning_rate=2e-2 --num_gpus=1 --json_dataset='t_code.json' --ptuning_directory='/home/hmp/ChatGLM2-6B/ptuning'     " }
+
+    for cookies, cb, hist, msg in (启动微调)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
         cli_printer.print(cb)
 
 

crazy_functions/latex_utils.py

@@ -147,7 +147,7 @@ def 寻找Latex主文件(file_manifest, mode):
     for texf in file_manifest:
         if os.path.basename(texf).startswith('merge'):
             continue
-        with open(texf, 'r', encoding='utf8') as f:
+        with open(texf, 'r', encoding='utf8', errors='ignore') as f:
             file_content = f.read()
         if r'\documentclass' in file_content:
             canidates.append(texf)
@@ -165,7 +165,7 @@ def 寻找Latex主文件(file_manifest, mode):
         expected_words = ['\input', '\ref', '\cite']
         for texf in canidates:
             canidates_score.append(0)
-            with open(texf, 'r', encoding='utf8') as f:
+            with open(texf, 'r', encoding='utf8', errors='ignore') as f:
                 file_content = f.read()
             for uw in unexpected_words:
                 if uw in file_content:

crazy_functions/live_audio/aliyunASR.py

@@ -23,7 +23,7 @@ class AliyunASR():
         pass
 
     def test_on_close(self, *args):
-        # print("on_close: args=>{}".format(args))
+        self.aliyun_service_ok = False
         pass
 
     def test_on_result_chg(self, message, *args):
@@ -50,7 +50,7 @@ class AliyunASR():
         rad.clean_up()
         temp_folder = tempfile.gettempdir()
         TOKEN, APPKEY = get_conf('ALIYUN_TOKEN', 'ALIYUN_APPKEY')
-
+        self.aliyun_service_ok = True
         URL="wss://nls-gateway.aliyuncs.com/ws/v1"
         sr = nls.NlsSpeechTranscriber(
                     url=URL,
@@ -86,4 +86,8 @@ class AliyunASR():
                 for i in slices: sr.send_audio(bytes(i))
             else:
                 time.sleep(0.1)
+
+            if not self.aliyun_service_ok:
+                self.stop = True
+                self.stop_msg = 'Aliyun音频服务异常，请检查ALIYUN_TOKEN和ALIYUN_APPKEY是否过期。'
         r = sr.stop()

crazy_functions/test_project/cpp/cppipc/buffer.cpp

@@ -0,0 +1,87 @@
+#include "libipc/buffer.h"
+#include "libipc/utility/pimpl.h"
+
+#include <cstring>
+
+namespace ipc {
+
+bool operator==(buffer const & b1, buffer const & b2) {
+    return (b1.size() == b2.size()) && (std::memcmp(b1.data(), b2.data(), b1.size()) == 0);
+}
+
+bool operator!=(buffer const & b1, buffer const & b2) {
+    return !(b1 == b2);
+}
+
+class buffer::buffer_ : public pimpl<buffer_> {
+public:
+    void*       p_;
+    std::size_t s_;
+    void*       a_;
+    buffer::destructor_t d_;
+
+    buffer_(void* p, std::size_t s, buffer::destructor_t d, void* a)
+        : p_(p), s_(s), a_(a), d_(d) {
+    }
+
+    ~buffer_() {
+        if (d_ == nullptr) return;
+        d_((a_ == nullptr) ? p_ : a_, s_);
+    }
+};
+
+buffer::buffer()
+    : buffer(nullptr, 0, nullptr, nullptr) {
+}
+
+buffer::buffer(void* p, std::size_t s, destructor_t d)
+    : p_(p_->make(p, s, d, nullptr)) {
+}
+
+buffer::buffer(void* p, std::size_t s, destructor_t d, void* additional)
+    : p_(p_->make(p, s, d, additional)) {
+}
+
+buffer::buffer(void* p, std::size_t s)
+    : buffer(p, s, nullptr) {
+}
+
+buffer::buffer(char const & c)
+    : buffer(const_cast<char*>(&c), 1) {
+}
+
+buffer::buffer(buffer&& rhs)
+    : buffer() {
+    swap(rhs);
+}
+
+buffer::~buffer() {
+    p_->clear();
+}
+
+void buffer::swap(buffer& rhs) {
+    std::swap(p_, rhs.p_);
+}
+
+buffer& buffer::operator=(buffer rhs) {
+    swap(rhs);
+    return *this;
+}
+
+bool buffer::empty() const noexcept {
+    return (impl(p_)->p_ == nullptr) || (impl(p_)->s_ == 0);
+}
+
+void* buffer::data() noexcept {
+    return impl(p_)->p_;
+}
+
+void const * buffer::data() const noexcept {
+    return impl(p_)->p_;
+}
+
+std::size_t buffer::size() const noexcept {
+    return impl(p_)->s_;
+}
+
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/ipc.cpp

@@ -0,0 +1,701 @@
+
+#include <type_traits>
+#include <cstring>
+#include <algorithm>
+#include <utility>          // std::pair, std::move, std::forward
+#include <atomic>
+#include <type_traits>      // aligned_storage_t
+#include <string>
+#include <vector>
+#include <array>
+#include <cassert>
+
+#include "libipc/ipc.h"
+#include "libipc/def.h"
+#include "libipc/shm.h"
+#include "libipc/pool_alloc.h"
+#include "libipc/queue.h"
+#include "libipc/policy.h"
+#include "libipc/rw_lock.h"
+#include "libipc/waiter.h"
+
+#include "libipc/utility/log.h"
+#include "libipc/utility/id_pool.h"
+#include "libipc/utility/scope_guard.h"
+#include "libipc/utility/utility.h"
+
+#include "libipc/memory/resource.h"
+#include "libipc/platform/detail.h"
+#include "libipc/circ/elem_array.h"
+
+namespace {
+
+using msg_id_t = std::uint32_t;
+using acc_t    = std::atomic<msg_id_t>;
+
+template <std::size_t DataSize, std::size_t AlignSize>
+struct msg_t;
+
+template <std::size_t AlignSize>
+struct msg_t<0, AlignSize> {
+    msg_id_t     cc_id_;
+    msg_id_t     id_;
+    std::int32_t remain_;
+    bool         storage_;
+};
+
+template <std::size_t DataSize, std::size_t AlignSize>
+struct msg_t : msg_t<0, AlignSize> {
+    std::aligned_storage_t<DataSize, AlignSize> data_ {};
+
+    msg_t() = default;
+    msg_t(msg_id_t cc_id, msg_id_t id, std::int32_t remain, void const * data, std::size_t size)
+        : msg_t<0, AlignSize> {cc_id, id, remain, (data == nullptr) || (size == 0)} {
+        if (this->storage_) {
+            if (data != nullptr) {
+                // copy storage-id
+                *reinterpret_cast<ipc::storage_id_t*>(&data_) =
+                     *static_cast<ipc::storage_id_t const *>(data);
+            }
+        }
+        else std::memcpy(&data_, data, size);
+    }
+};
+
+template <typename T>
+ipc::buff_t make_cache(T& data, std::size_t size) {
+    auto ptr = ipc::mem::alloc(size);
+    std::memcpy(ptr, &data, (ipc::detail::min)(sizeof(data), size));
+    return { ptr, size, ipc::mem::free };
+}
+
+struct cache_t {
+    std::size_t fill_;
+    ipc::buff_t buff_;
+
+    cache_t(std::size_t f, ipc::buff_t && b)
+        : fill_(f), buff_(std::move(b))
+    {}
+
+    void append(void const * data, std::size_t size) {
+        if (fill_ >= buff_.size() || data == nullptr || size == 0) return;
+        auto new_fill = (ipc::detail::min)(fill_ + size, buff_.size());
+        std::memcpy(static_cast<ipc::byte_t*>(buff_.data()) + fill_, data, new_fill - fill_);
+        fill_ = new_fill;
+    }
+};
+
+auto cc_acc() {
+    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
+    return static_cast<acc_t*>(acc_h.get());
+}
+
+IPC_CONSTEXPR_ std::size_t align_chunk_size(std::size_t size) noexcept {
+    return (((size - 1) / ipc::large_msg_align) + 1) * ipc::large_msg_align;
+}
+
+IPC_CONSTEXPR_ std::size_t calc_chunk_size(std::size_t size) noexcept {
+    return ipc::make_align(alignof(std::max_align_t), align_chunk_size(
+           ipc::make_align(alignof(std::max_align_t), sizeof(std::atomic<ipc::circ::cc_t>)) + size));
+}
+
+struct chunk_t {
+    std::atomic<ipc::circ::cc_t> &conns() noexcept {
+        return *reinterpret_cast<std::atomic<ipc::circ::cc_t> *>(this);
+    }
+
+    void *data() noexcept {
+        return reinterpret_cast<ipc::byte_t *>(this)
+             + ipc::make_align(alignof(std::max_align_t), sizeof(std::atomic<ipc::circ::cc_t>));
+    }
+};
+
+struct chunk_info_t {
+    ipc::id_pool<> pool_;
+    ipc::spin_lock lock_;
+
+    IPC_CONSTEXPR_ static std::size_t chunks_mem_size(std::size_t chunk_size) noexcept {
+        return ipc::id_pool<>::max_count * chunk_size;
+    }
+
+    ipc::byte_t *chunks_mem() noexcept {
+        return reinterpret_cast<ipc::byte_t *>(this + 1);
+    }
+
+    chunk_t *at(std::size_t chunk_size, ipc::storage_id_t id) noexcept {
+        if (id < 0) return nullptr;
+        return reinterpret_cast<chunk_t *>(chunks_mem() + (chunk_size * id));
+    }
+};
+
+auto& chunk_storages() {
+    class chunk_handle_t {
+        ipc::shm::handle handle_;
+
+    public:
+        chunk_info_t *get_info(std::size_t chunk_size) {
+            if (!handle_.valid() &&
+                !handle_.acquire( ("__CHUNK_INFO__" + ipc::to_string(chunk_size)).c_str(), 
+                                  sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
+                ipc::error("[chunk_storages] chunk_shm.id_info_.acquire failed: chunk_size = %zd\n", chunk_size);
+                return nullptr;
+            }
+            auto info = static_cast<chunk_info_t*>(handle_.get());
+            if (info == nullptr) {
+                ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
+                return nullptr;
+            }
+            return info;
+        }
+    };
+    static ipc::map<std::size_t, chunk_handle_t> chunk_hs;
+    return chunk_hs;
+}
+
+chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
+    auto &storages = chunk_storages();
+    std::decay_t<decltype(storages)>::iterator it;
+    {
+        static ipc::rw_lock lock;
+        IPC_UNUSED_ std::shared_lock<ipc::rw_lock> guard {lock};
+        if ((it = storages.find(chunk_size)) == storages.end()) {
+            using chunk_handle_t = std::decay_t<decltype(storages)>::value_type::second_type;
+            guard.unlock();
+            IPC_UNUSED_ std::lock_guard<ipc::rw_lock> guard {lock};
+            it = storages.emplace(chunk_size, chunk_handle_t{}).first;
+        }
+    }
+    return it->second.get_info(chunk_size);
+}
+
+std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ::cc_t conns) {
+    std::size_t chunk_size = calc_chunk_size(size);
+    auto info = chunk_storage_info(chunk_size);
+    if (info == nullptr) return {};
+
+    info->lock_.lock();
+    info->pool_.prepare();
+    // got an unique id
+    auto id = info->pool_.acquire();
+    info->lock_.unlock();
+
+    auto chunk = info->at(chunk_size, id);
+    if (chunk == nullptr) return {};
+    chunk->conns().store(conns, std::memory_order_relaxed);
+    return { id, chunk->data() };
+}
+
+void *find_storage(ipc::storage_id_t id, std::size_t size) {
+    if (id < 0) {
+        ipc::error("[find_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
+        return nullptr;
+    }
+    std::size_t chunk_size = calc_chunk_size(size);
+    auto info = chunk_storage_info(chunk_size);
+    if (info == nullptr) return nullptr;
+    return info->at(chunk_size, id)->data();
+}
+
+void release_storage(ipc::storage_id_t id, std::size_t size) {
+    if (id < 0) {
+        ipc::error("[release_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
+        return;
+    }
+    std::size_t chunk_size = calc_chunk_size(size);
+    auto info = chunk_storage_info(chunk_size);
+    if (info == nullptr) return;
+    info->lock_.lock();
+    info->pool_.release(id);
+    info->lock_.unlock();
+}
+
+template <ipc::relat Rp, ipc::relat Rc>
+bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::unicast>, 
+            std::atomic<ipc::circ::cc_t> &/*conns*/, ipc::circ::cc_t /*curr_conns*/, ipc::circ::cc_t /*conn_id*/) noexcept {
+    return true;
+}
+
+template <ipc::relat Rp, ipc::relat Rc>
+bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::broadcast>, 
+            std::atomic<ipc::circ::cc_t> &conns, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) noexcept {
+    auto last_conns = curr_conns & ~conn_id;
+    for (unsigned k = 0;;) {
+        auto chunk_conns  = conns.load(std::memory_order_acquire);
+        if (conns.compare_exchange_weak(chunk_conns, chunk_conns & last_conns, std::memory_order_release)) {
+            return (chunk_conns & last_conns) == 0;
+        }
+        ipc::yield(k);
+    }
+}
+
+template <typename Flag>
+void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
+    if (id < 0) {
+        ipc::error("[recycle_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
+        return;
+    }
+    std::size_t chunk_size = calc_chunk_size(size);
+    auto info = chunk_storage_info(chunk_size);
+    if (info == nullptr) return;
+
+    auto chunk = info->at(chunk_size, id);
+    if (chunk == nullptr) return;
+
+    if (!sub_rc(Flag{}, chunk->conns(), curr_conns, conn_id)) {
+        return;
+    }
+    info->lock_.lock();
+    info->pool_.release(id);
+    info->lock_.unlock();
+}
+
+template <typename MsgT>
+bool clear_message(void* p) {
+    auto msg = static_cast<MsgT*>(p);
+    if (msg->storage_) {
+        std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg->remain_;
+        if (r_size <= 0) {
+            ipc::error("[clear_message] invalid msg size: %d\n", (int)r_size);
+            return true;
+        }
+        release_storage(
+            *reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
+            static_cast<std::size_t>(r_size));
+    }
+    return true;
+}
+
+struct conn_info_head {
+
+    ipc::string name_;
+    msg_id_t    cc_id_; // connection-info id
+    ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
+    ipc::shm::handle acc_h_;
+
+    conn_info_head(char const * name)
+        : name_     {name}
+        , cc_id_    {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
+        , cc_waiter_{("__CC_CONN__" + name_).c_str()}
+        , wt_waiter_{("__WT_CONN__" + name_).c_str()}
+        , rd_waiter_{("__RD_CONN__" + name_).c_str()}
+        , acc_h_    {("__AC_CONN__" + name_).c_str(), sizeof(acc_t)} {
+    }
+
+    void quit_waiting() {
+        cc_waiter_.quit_waiting();
+        wt_waiter_.quit_waiting();
+        rd_waiter_.quit_waiting();
+    }
+
+    auto acc() {
+        return static_cast<acc_t*>(acc_h_.get());
+    }
+
+    auto& recv_cache() {
+        thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
+        return tls;
+    }
+};
+
+template <typename W, typename F>
+bool wait_for(W& waiter, F&& pred, std::uint64_t tm) {
+    if (tm == 0) return !pred();
+    for (unsigned k = 0; pred();) {
+        bool ret = true;
+        ipc::sleep(k, [&k, &ret, &waiter, &pred, tm] {
+            ret = waiter.wait_if(std::forward<F>(pred), tm);
+            k   = 0;
+        });
+        if (!ret) return false; // timeout or fail
+        if (k == 0) break; // k has been reset
+    }
+    return true;
+}
+
+template <typename Policy,
+          std::size_t DataSize  = ipc::data_length,
+          std::size_t AlignSize = (ipc::detail::min)(DataSize, alignof(std::max_align_t))>
+struct queue_generator {
+
+    using queue_t = ipc::queue<msg_t<DataSize, AlignSize>, Policy>;
+
+    struct conn_info_t : conn_info_head {
+        queue_t que_;
+
+        conn_info_t(char const * name)
+            : conn_info_head{name}
+            , que_{("__QU_CONN__" +
+                    ipc::to_string(DataSize) + "__" +
+                    ipc::to_string(AlignSize) + "__" + name).c_str()} {
+        }
+
+        void disconnect_receiver() {
+            bool dis = que_.disconnect();
+            this->quit_waiting();
+            if (dis) {
+                this->recv_cache().clear();
+            }
+        }
+    };
+};
+
+template <typename Policy>
+struct detail_impl {
+
+using policy_t    = Policy;
+using flag_t      = typename policy_t::flag_t;
+using queue_t     = typename queue_generator<policy_t>::queue_t;
+using conn_info_t = typename queue_generator<policy_t>::conn_info_t;
+
+constexpr static conn_info_t* info_of(ipc::handle_t h) noexcept {
+    return static_cast<conn_info_t*>(h);
+}
+
+constexpr static queue_t* queue_of(ipc::handle_t h) noexcept {
+    return (info_of(h) == nullptr) ? nullptr : &(info_of(h)->que_);
+}
+
+/* API implementations */
+
+static void disconnect(ipc::handle_t h) {
+    auto que = queue_of(h);
+    if (que == nullptr) {
+        return;
+    }
+    que->shut_sending();
+    assert(info_of(h) != nullptr);
+    info_of(h)->disconnect_receiver();
+}
+
+static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
+    assert(ph != nullptr);
+    assert(*ph != nullptr);
+    auto que = queue_of(*ph);
+    if (que == nullptr) {
+        return false;
+    }
+    if (start_to_recv) {
+        que->shut_sending();
+        if (que->connect()) { // wouldn't connect twice
+            info_of(*ph)->cc_waiter_.broadcast();
+            return true;
+        }
+        return false;
+    }
+    // start_to_recv == false
+    if (que->connected()) {
+        info_of(*ph)->disconnect_receiver();
+    }
+    return que->ready_sending();
+}
+
+static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
+    assert(ph != nullptr);
+    if (*ph == nullptr) {
+        *ph = ipc::mem::alloc<conn_info_t>(name);
+    }
+    return reconnect(ph, start_to_recv);
+}
+
+static void destroy(ipc::handle_t h) {
+    disconnect(h);
+    ipc::mem::free(info_of(h));
+}
+
+static std::size_t recv_count(ipc::handle_t h) noexcept {
+    auto que = queue_of(h);
+    if (que == nullptr) {
+        return ipc::invalid_value;
+    }
+    return que->conn_count();
+}
+
+static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm) {
+    auto que = queue_of(h);
+    if (que == nullptr) {
+        return false;
+    }
+    return wait_for(info_of(h)->cc_waiter_, [que, r_count] {
+        return que->conn_count() < r_count;
+    }, tm);
+}
+
+template <typename F>
+static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t size) {
+    if (data == nullptr || size == 0) {
+        ipc::error("fail: send(%p, %zd)\n", data, size);
+        return false;
+    }
+    auto que = queue_of(h);
+    if (que == nullptr) {
+        ipc::error("fail: send, queue_of(h) == nullptr\n");
+        return false;
+    }
+    if (que->elems() == nullptr) {
+        ipc::error("fail: send, queue_of(h)->elems() == nullptr\n");
+        return false;
+    }
+    if (!que->ready_sending()) {
+        ipc::error("fail: send, que->ready_sending() == false\n");
+        return false;
+    }
+    ipc::circ::cc_t conns = que->elems()->connections(std::memory_order_relaxed);
+    if (conns == 0) {
+        ipc::error("fail: send, there is no receiver on this connection.\n");
+        return false;
+    }
+    // calc a new message id
+    auto acc = info_of(h)->acc();
+    if (acc == nullptr) {
+        ipc::error("fail: send, info_of(h)->acc() == nullptr\n");
+        return false;
+    }
+    auto msg_id   = acc->fetch_add(1, std::memory_order_relaxed);
+    auto try_push = std::forward<F>(gen_push)(info_of(h), que, msg_id);
+    if (size > ipc::large_msg_limit) {
+        auto   dat = acquire_storage(size, conns);
+        void * buf = dat.second;
+        if (buf != nullptr) {
+            std::memcpy(buf, data, size);
+            return try_push(static_cast<std::int32_t>(size) - 
+                            static_cast<std::int32_t>(ipc::data_length), &(dat.first), 0);
+        }
+        // try using message fragment
+        //ipc::log("fail: shm::handle for big message. msg_id: %zd, size: %zd\n", msg_id, size);
+    }
+    // push message fragment
+    std::int32_t offset = 0;
+    for (std::int32_t i = 0; i < static_cast<std::int32_t>(size / ipc::data_length); ++i, offset += ipc::data_length) {
+        if (!try_push(static_cast<std::int32_t>(size) - offset - static_cast<std::int32_t>(ipc::data_length),
+                      static_cast<ipc::byte_t const *>(data) + offset, ipc::data_length)) {
+            return false;
+        }
+    }
+    // if remain > 0, this is the last message fragment
+    std::int32_t remain = static_cast<std::int32_t>(size) - offset;
+    if (remain > 0) {
+        if (!try_push(remain - static_cast<std::int32_t>(ipc::data_length),
+                      static_cast<ipc::byte_t const *>(data) + offset, 
+                      static_cast<std::size_t>(remain))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
+    return send([tm](auto info, auto que, auto msg_id) {
+        return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
+            if (!wait_for(info->wt_waiter_, [&] {
+                    return !que->push(
+                        [](void*) { return true; },
+                        info->cc_id_, msg_id, remain, data, size);
+                }, tm)) {
+                ipc::log("force_push: msg_id = %zd, remain = %d, size = %zd\n", msg_id, remain, size);
+                if (!que->force_push(
+                        clear_message<typename queue_t::value_t>,
+                        info->cc_id_, msg_id, remain, data, size)) {
+                    return false;
+                }
+            }
+            info->rd_waiter_.broadcast();
+            return true;
+        };
+    }, h, data, size);
+}
+
+static bool try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
+    return send([tm](auto info, auto que, auto msg_id) {
+        return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
+            if (!wait_for(info->wt_waiter_, [&] {
+                    return !que->push(
+                        [](void*) { return true; },
+                        info->cc_id_, msg_id, remain, data, size);
+                }, tm)) {
+                return false;
+            }
+            info->rd_waiter_.broadcast();
+            return true;
+        };
+    }, h, data, size);
+}
+
+static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
+    auto que = queue_of(h);
+    if (que == nullptr) {
+        ipc::error("fail: recv, queue_of(h) == nullptr\n");
+        return {};
+    }
+    if (!que->connected()) {
+        // hasn't connected yet, just return.
+        return {};
+    }
+    auto& rc = info_of(h)->recv_cache();
+    for (;;) {
+        // pop a new message
+        typename queue_t::value_t msg;
+        if (!wait_for(info_of(h)->rd_waiter_, [que, &msg] {
+                return !que->pop(msg);
+            }, tm)) {
+            // pop failed, just return.
+            return {};
+        }
+        info_of(h)->wt_waiter_.broadcast();
+        if ((info_of(h)->acc() != nullptr) && (msg.cc_id_ == info_of(h)->cc_id_)) {
+            continue; // ignore message to self
+        }
+        // msg.remain_ may minus & abs(msg.remain_) < data_length
+        std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg.remain_;
+        if (r_size <= 0) {
+            ipc::error("fail: recv, r_size = %d\n", (int)r_size);
+            return {};
+        }
+        std::size_t msg_size = static_cast<std::size_t>(r_size);
+        // large message
+        if (msg.storage_) {
+            ipc::storage_id_t buf_id = *reinterpret_cast<ipc::storage_id_t*>(&msg.data_);
+            void* buf = find_storage(buf_id, msg_size);
+            if (buf != nullptr) {
+                struct recycle_t {
+                    ipc::storage_id_t storage_id;
+                    ipc::circ::cc_t   curr_conns;
+                    ipc::circ::cc_t   conn_id;
+                } *r_info = ipc::mem::alloc<recycle_t>(recycle_t{
+                    buf_id, que->elems()->connections(std::memory_order_relaxed), que->connected_id()
+                });
+                if (r_info == nullptr) {
+                    ipc::log("fail: ipc::mem::alloc<recycle_t>.\n");
+                    return ipc::buff_t{buf, msg_size}; // no recycle
+                } else {
+                    return ipc::buff_t{buf, msg_size, [](void* p_info, std::size_t size) {
+                        auto r_info = static_cast<recycle_t *>(p_info);
+                        IPC_UNUSED_ auto finally = ipc::guard([r_info] {
+                            ipc::mem::free(r_info);
+                        });
+                        recycle_storage<flag_t>(r_info->storage_id, size, r_info->curr_conns, r_info->conn_id);
+                    }, r_info};
+                }
+            } else {
+                ipc::log("fail: shm::handle for large message. msg_id: %zd, buf_id: %zd, size: %zd\n", msg.id_, buf_id, msg_size);
+                continue;
+            }
+        }
+        // find cache with msg.id_
+        auto cac_it = rc.find(msg.id_);
+        if (cac_it == rc.end()) {
+            if (msg_size <= ipc::data_length) {
+                return make_cache(msg.data_, msg_size);
+            }
+            // gc
+            if (rc.size() > 1024) {
+                std::vector<msg_id_t> need_del;
+                for (auto const & pair : rc) {
+                    auto cmp = std::minmax(msg.id_, pair.first);
+                    if (cmp.second - cmp.first > 8192) {
+                        need_del.push_back(pair.first);
+                    }
+                }
+                for (auto id : need_del) rc.erase(id);
+            }
+            // cache the first message fragment
+            rc.emplace(msg.id_, cache_t { ipc::data_length, make_cache(msg.data_, msg_size) });
+        }
+        // has cached before this message
+        else {
+            auto& cac = cac_it->second;
+            // this is the last message fragment
+            if (msg.remain_ <= 0) {
+                cac.append(&(msg.data_), msg_size);
+                // finish this message, erase it from cache
+                auto buff = std::move(cac.buff_);
+                rc.erase(cac_it);
+                return buff;
+            }
+            // there are remain datas after this message
+            cac.append(&(msg.data_), ipc::data_length);
+        }
+    }
+}
+
+static ipc::buff_t try_recv(ipc::handle_t h) {
+    return recv(h, 0);
+}
+
+}; // detail_impl<Policy>
+
+template <typename Flag>
+using policy_t = ipc::policy::choose<ipc::circ::elem_array, Flag>;
+
+} // internal-linkage
+
+namespace ipc {
+
+template <typename Flag>
+ipc::handle_t chan_impl<Flag>::inited() {
+    ipc::detail::waiter::init();
+    return nullptr;
+}
+
+template <typename Flag>
+bool chan_impl<Flag>::connect(ipc::handle_t * ph, char const * name, unsigned mode) {
+    return detail_impl<policy_t<Flag>>::connect(ph, name, mode & receiver);
+}
+
+template <typename Flag>
+bool chan_impl<Flag>::reconnect(ipc::handle_t * ph, unsigned mode) {
+    return detail_impl<policy_t<Flag>>::reconnect(ph, mode & receiver);
+}
+
+template <typename Flag>
+void chan_impl<Flag>::disconnect(ipc::handle_t h) {
+    detail_impl<policy_t<Flag>>::disconnect(h);
+}
+
+template <typename Flag>
+void chan_impl<Flag>::destroy(ipc::handle_t h) {
+    detail_impl<policy_t<Flag>>::destroy(h);
+}
+
+template <typename Flag>
+char const * chan_impl<Flag>::name(ipc::handle_t h) {
+    auto info = detail_impl<policy_t<Flag>>::info_of(h);
+    return (info == nullptr) ? nullptr : info->name_.c_str();
+}
+
+template <typename Flag>
+std::size_t chan_impl<Flag>::recv_count(ipc::handle_t h) {
+    return detail_impl<policy_t<Flag>>::recv_count(h);
+}
+
+template <typename Flag>
+bool chan_impl<Flag>::wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm) {
+    return detail_impl<policy_t<Flag>>::wait_for_recv(h, r_count, tm);
+}
+
+template <typename Flag>
+bool chan_impl<Flag>::send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
+    return detail_impl<policy_t<Flag>>::send(h, data, size, tm);
+}
+
+template <typename Flag>
+buff_t chan_impl<Flag>::recv(ipc::handle_t h, std::uint64_t tm) {
+    return detail_impl<policy_t<Flag>>::recv(h, tm);
+}
+
+template <typename Flag>
+bool chan_impl<Flag>::try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
+    return detail_impl<policy_t<Flag>>::try_send(h, data, size, tm);
+}
+
+template <typename Flag>
+buff_t chan_impl<Flag>::try_recv(ipc::handle_t h) {
+    return detail_impl<policy_t<Flag>>::try_recv(h);
+}
+
+template struct chan_impl<ipc::wr<relat::single, relat::single, trans::unicast  >>;
+// template struct chan_impl<ipc::wr<relat::single, relat::multi , trans::unicast  >>; // TBD
+// template struct chan_impl<ipc::wr<relat::multi , relat::multi , trans::unicast  >>; // TBD
+template struct chan_impl<ipc::wr<relat::single, relat::multi , trans::broadcast>>;
+template struct chan_impl<ipc::wr<relat::multi , relat::multi , trans::broadcast>>;
+
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/policy.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <type_traits>
+
+#include "libipc/def.h"
+#include "libipc/prod_cons.h"
+
+#include "libipc/circ/elem_array.h"
+
+namespace ipc {
+namespace policy {
+
+template <template <typename, std::size_t...> class Elems, typename Flag>
+struct choose;
+
+template <typename Flag>
+struct choose<circ::elem_array, Flag> {
+    using flag_t = Flag;
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    using elems_t = circ::elem_array<ipc::prod_cons_impl<flag_t>, DataSize, AlignSize>;
+};
+
+} // namespace policy
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/pool_alloc.cpp

@@ -0,0 +1,17 @@
+#include "libipc/pool_alloc.h"
+
+#include "libipc/memory/resource.h"
+
+namespace ipc {
+namespace mem {
+
+void* pool_alloc::alloc(std::size_t size) {
+    return async_pool_alloc::alloc(size);
+}
+
+void pool_alloc::free(void* p, std::size_t size) {
+    async_pool_alloc::free(p, size);
+}
+
+} // namespace mem
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/prod_cons.h

@@ -0,0 +1,433 @@
+#pragma once
+
+#include <atomic>
+#include <utility>
+#include <cstring>
+#include <type_traits>
+#include <cstdint>
+
+#include "libipc/def.h"
+
+#include "libipc/platform/detail.h"
+#include "libipc/circ/elem_def.h"
+#include "libipc/utility/log.h"
+#include "libipc/utility/utility.h"
+
+namespace ipc {
+
+////////////////////////////////////////////////////////////////
+/// producer-consumer implementation
+////////////////////////////////////////////////////////////////
+
+template <typename Flag>
+struct prod_cons_impl;
+
+template <>
+struct prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> rd_; // read index
+    alignas(cache_line_size) std::atomic<circ::u2_t> wt_; // write index
+
+    constexpr circ::u2_t cursor() const noexcept {
+        return 0;
+    }
+
+    template <typename W, typename F, typename E>
+    bool push(W* /*wrapper*/, F&& f, E* elems) {
+        auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed));
+        if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) {
+            return false; // full
+        }
+        std::forward<F>(f)(&(elems[cur_wt].data_));
+        wt_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+
+    /**
+     * In single-single-unicast, 'force_push' means 'no reader' or 'the only one reader is dead'.
+     * So we could just disconnect all connections of receiver, and return false.
+    */
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&&, E*) {
+        wrapper->elems()->disconnect_receiver(~static_cast<circ::cc_t>(0u));
+        return false;
+    }
+
+    template <typename W, typename F, typename R, typename E>
+    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
+        auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed));
+        if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) {
+            return false; // empty
+        }
+        std::forward<F>(f)(&(elems[cur_rd].data_));
+        std::forward<R>(out)(true);
+        rd_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::single, relat::multi , trans::unicast>>
+     : prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&&, E*) {
+        wrapper->elems()->disconnect_receiver(1);
+        return false;
+    }
+
+    template <typename W, typename F, typename R, 
+              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
+    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
+        byte_t buff[DS];
+        for (unsigned k = 0;;) {
+            auto cur_rd = rd_.load(std::memory_order_relaxed);
+            if (circ::index_of(cur_rd) ==
+                circ::index_of(wt_.load(std::memory_order_acquire))) {
+                return false; // empty
+            }
+            std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
+            if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
+                std::forward<F>(f)(buff);
+                std::forward<R>(out)(true);
+                return true;
+            }
+            ipc::yield(k);
+        }
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::multi , relat::multi, trans::unicast>>
+     : prod_cons_impl<wr<relat::single, relat::multi, trans::unicast>> {
+
+    using flag_t = std::uint64_t;
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> ct_; // commit index
+
+    template <typename W, typename F, typename E>
+    bool push(W* /*wrapper*/, F&& f, E* elems) {
+        circ::u2_t cur_ct, nxt_ct;
+        for (unsigned k = 0;;) {
+            cur_ct = ct_.load(std::memory_order_relaxed);
+            if (circ::index_of(nxt_ct = cur_ct + 1) ==
+                circ::index_of(rd_.load(std::memory_order_acquire))) {
+                return false; // full
+            }
+            if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        auto* el = elems + circ::index_of(cur_ct);
+        std::forward<F>(f)(&(el->data_));
+        // set flag & try update wt
+        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
+        while (1) {
+            auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
+            if (cur_ct != wt_.load(std::memory_order_relaxed)) {
+                return true;
+            }
+            if ((~cac_ct) != cur_ct) {
+                return true;
+            }
+            if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
+                return true;
+            }
+            wt_.store(nxt_ct, std::memory_order_release);
+            cur_ct = nxt_ct;
+            nxt_ct = cur_ct + 1;
+            el = elems + circ::index_of(cur_ct);
+        }
+        return true;
+    }
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&&, E*) {
+        wrapper->elems()->disconnect_receiver(1);
+        return false;
+    }
+
+    template <typename W, typename F, typename R, 
+              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
+    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
+        byte_t buff[DS];
+        for (unsigned k = 0;;) {
+            auto cur_rd = rd_.load(std::memory_order_relaxed);
+            auto cur_wt = wt_.load(std::memory_order_acquire);
+            auto id_rd  = circ::index_of(cur_rd);
+            auto id_wt  = circ::index_of(cur_wt);
+            if (id_rd == id_wt) {
+                auto* el = elems + id_wt;
+                auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
+                if ((~cac_ct) != cur_wt) {
+                    return false; // empty
+                }
+                if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
+                    wt_.store(cur_wt + 1, std::memory_order_release);
+                }
+                k = 0;
+            }
+            else {
+                std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
+                if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
+                    std::forward<F>(f)(buff);
+                    std::forward<R>(out)(true);
+                    return true;
+                }
+                ipc::yield(k);
+            }
+        }
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::single, relat::multi, trans::broadcast>> {
+
+    using rc_t = std::uint64_t;
+
+    enum : rc_t {
+        ep_mask = 0x00000000ffffffffull,
+        ep_incr = 0x0000000100000000ull
+    };
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+        std::atomic<rc_t> rc_ { 0 }; // read-counter
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> wt_;   // write index
+    alignas(cache_line_size) rc_t epoch_ { 0 };             // only one writer
+
+    circ::u2_t cursor() const noexcept {
+        return wt_.load(std::memory_order_acquire);
+    }
+
+    template <typename W, typename F, typename E>
+    bool push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            circ::cc_t rem_cc = cur_rc & ep_mask;
+            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch_)) {
+                return false; // has not finished yet
+            }
+            // consider rem_cc to be 0 here
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        std::forward<F>(f)(&(el->data_));
+        wt_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        epoch_ += ep_incr;
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            circ::cc_t rem_cc = cur_rc & ep_mask;
+            if (cc & rem_cc) {
+                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
+                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
+                if (cc == 0) return false; // no reader
+            }
+            // just compare & exchange
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        std::forward<F>(f)(&(el->data_));
+        wt_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename R, typename E>
+    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E* elems) {
+        if (cur == cursor()) return false; // acquire
+        auto* el = elems + circ::index_of(cur++);
+        std::forward<F>(f)(&(el->data_));
+        for (unsigned k = 0;;) {
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            if ((cur_rc & ep_mask) == 0) {
+                std::forward<R>(out)(true);
+                return true;
+            }
+            auto nxt_rc = cur_rc & ~static_cast<rc_t>(wrapper->connected_id());
+            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
+                std::forward<R>(out)((nxt_rc & ep_mask) == 0);
+                return true;
+            }
+            ipc::yield(k);
+        }
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::multi, relat::multi, trans::broadcast>> {
+
+    using rc_t   = std::uint64_t;
+    using flag_t = std::uint64_t;
+
+    enum : rc_t {
+        rc_mask = 0x00000000ffffffffull,
+        ep_mask = 0x00ffffffffffffffull,
+        ep_incr = 0x0100000000000000ull,
+        ic_mask = 0xff000000ffffffffull,
+        ic_incr = 0x0000000100000000ull
+    };
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+        std::atomic<rc_t  > rc_   { 0 }; // read-counter
+        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> ct_;   // commit index
+    alignas(cache_line_size) std::atomic<rc_t> epoch_ { 0 };
+
+    circ::u2_t cursor() const noexcept {
+        return ct_.load(std::memory_order_acquire);
+    }
+
+    constexpr static rc_t inc_rc(rc_t rc) noexcept {
+        return (rc & ic_mask) | ((rc + ic_incr) & ~ic_mask);
+    }
+
+    constexpr static rc_t inc_mask(rc_t rc) noexcept {
+        return inc_rc(rc) & ~rc_mask;
+    }
+
+    template <typename W, typename F, typename E>
+    bool push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        circ::u2_t cur_ct;
+        rc_t epoch = epoch_.load(std::memory_order_acquire);
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_relaxed);
+            circ::cc_t rem_cc = cur_rc & rc_mask;
+            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch)) {
+                return false; // has not finished yet
+            }
+            else if (!rem_cc) {
+                auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
+                if ((cur_fl != cur_ct) && cur_fl) {
+                    return false; // full
+                }
+            }
+            // consider rem_cc to be 0 here
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed) &&
+                epoch_.compare_exchange_weak(epoch, epoch, std::memory_order_acq_rel)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        // only one thread/process would touch here at one time
+        ct_.store(cur_ct + 1, std::memory_order_release);
+        std::forward<F>(f)(&(el->data_));
+        // set flag & try update wt
+        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        circ::u2_t cur_ct;
+        rc_t epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            circ::cc_t rem_cc = cur_rc & rc_mask;
+            if (cc & rem_cc) {
+                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
+                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
+                if (cc == 0) return false; // no reader
+            }
+            // just compare & exchange
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed)) {
+                if (epoch == epoch_.load(std::memory_order_acquire)) {
+                    break;
+                }
+                else if (push(wrapper, std::forward<F>(f), elems)) {
+                    return true;
+                }
+                epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
+            }
+            ipc::yield(k);
+        }
+        // only one thread/process would touch here at one time
+        ct_.store(cur_ct + 1, std::memory_order_release);
+        std::forward<F>(f)(&(el->data_));
+        // set flag & try update wt
+        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename R, typename E, std::size_t N>
+    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E(& elems)[N]) {
+        auto* el = elems + circ::index_of(cur);
+        auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
+        if (cur_fl != ~static_cast<flag_t>(cur)) {
+            return false; // empty
+        }
+        ++cur;
+        std::forward<F>(f)(&(el->data_));
+        for (unsigned k = 0;;) {
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            if ((cur_rc & rc_mask) == 0) {
+                std::forward<R>(out)(true);
+                el->f_ct_.store(cur + N - 1, std::memory_order_release);
+                return true;
+            }
+            auto nxt_rc = inc_rc(cur_rc) & ~static_cast<rc_t>(wrapper->connected_id());
+            bool last_one = false;
+            if ((last_one = (nxt_rc & rc_mask) == 0)) {
+                el->f_ct_.store(cur + N - 1, std::memory_order_release);
+            }
+            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
+                std::forward<R>(out)(last_one);
+                return true;
+            }
+            ipc::yield(k);
+        }
+    }
+};
+
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/queue.h

@@ -0,0 +1,216 @@
+#pragma once
+
+#include <type_traits>
+#include <new>
+#include <utility>  // [[since C++14]]: std::exchange
+#include <algorithm>
+#include <atomic>
+#include <tuple>
+#include <thread>
+#include <chrono>
+#include <string>
+#include <cassert>  // assert
+
+#include "libipc/def.h"
+#include "libipc/shm.h"
+#include "libipc/rw_lock.h"
+
+#include "libipc/utility/log.h"
+#include "libipc/platform/detail.h"
+#include "libipc/circ/elem_def.h"
+
+namespace ipc {
+namespace detail {
+
+class queue_conn {
+protected:
+    circ::cc_t connected_ = 0;
+    shm::handle elems_h_;
+
+    template <typename Elems>
+    Elems* open(char const * name) {
+        if (name == nullptr || name[0] == '\0') {
+            ipc::error("fail open waiter: name is empty!\n");
+            return nullptr;
+        }
+        if (!elems_h_.acquire(name, sizeof(Elems))) {
+            return nullptr;
+        }
+        auto elems = static_cast<Elems*>(elems_h_.get());
+        if (elems == nullptr) {
+            ipc::error("fail acquire elems: %s\n", name);
+            return nullptr;
+        }
+        elems->init();
+        return elems;
+    }
+
+    void close() {
+        elems_h_.release();
+    }
+
+public:
+    queue_conn() = default;
+    queue_conn(const queue_conn&) = delete;
+    queue_conn& operator=(const queue_conn&) = delete;
+
+    bool connected() const noexcept {
+        return connected_ != 0;
+    }
+
+    circ::cc_t connected_id() const noexcept {
+        return connected_;
+    }
+
+    template <typename Elems>
+    auto connect(Elems* elems) noexcept
+                         /*needs 'optional' here*/
+     -> std::tuple<bool, bool, decltype(std::declval<Elems>().cursor())> {
+        if (elems == nullptr) return {};
+        // if it's already connected, just return
+        if (connected()) return {connected(), false, 0};
+        connected_ = elems->connect_receiver();
+        return {connected(), true, elems->cursor()};
+    }
+
+    template <typename Elems>
+    bool disconnect(Elems* elems) noexcept {
+        if (elems == nullptr) return false;
+        // if it's already disconnected, just return false
+        if (!connected()) return false;
+        elems->disconnect_receiver(std::exchange(connected_, 0));
+        return true;
+    }
+};
+
+template <typename Elems>
+class queue_base : public queue_conn {
+    using base_t = queue_conn;
+
+public:
+    using elems_t  = Elems;
+    using policy_t = typename elems_t::policy_t;
+
+protected:
+    elems_t * elems_ = nullptr;
+    decltype(std::declval<elems_t>().cursor()) cursor_ = 0;
+    bool sender_flag_ = false;
+
+public:
+    using base_t::base_t;
+
+    queue_base() = default;
+
+    explicit queue_base(char const * name)
+        : queue_base{} {
+        elems_ = open<elems_t>(name);
+    }
+
+    explicit queue_base(elems_t * elems) noexcept
+        : queue_base{} {
+        assert(elems != nullptr);
+        elems_ = elems;
+    }
+
+    /* not virtual */ ~queue_base() {
+        base_t::close();
+    }
+
+    elems_t       * elems()       noexcept { return elems_; }
+    elems_t const * elems() const noexcept { return elems_; }
+
+    bool ready_sending() noexcept {
+        if (elems_ == nullptr) return false;
+        return sender_flag_ || (sender_flag_ = elems_->connect_sender());
+    }
+
+    void shut_sending() noexcept {
+        if (elems_ == nullptr) return;
+        if (!sender_flag_) return;
+        elems_->disconnect_sender();
+    }
+
+    bool connect() noexcept {
+        auto tp = base_t::connect(elems_);
+        if (std::get<0>(tp) && std::get<1>(tp)) {
+            cursor_ = std::get<2>(tp);
+            return true;
+        }
+        return std::get<0>(tp);
+    }
+
+    bool disconnect() noexcept {
+        return base_t::disconnect(elems_);
+    }
+
+    std::size_t conn_count() const noexcept {
+        return (elems_ == nullptr) ? static_cast<std::size_t>(invalid_value) : elems_->conn_count();
+    }
+
+    bool valid() const noexcept {
+        return elems_ != nullptr;
+    }
+
+    bool empty() const noexcept {
+        return !valid() || (cursor_ == elems_->cursor());
+    }
+
+    template <typename T, typename F, typename... P>
+    bool push(F&& prep, P&&... params) {
+        if (elems_ == nullptr) return false;
+        return elems_->push(this, [&](void* p) {
+            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
+        });
+    }
+
+    template <typename T, typename F, typename... P>
+    bool force_push(F&& prep, P&&... params) {
+        if (elems_ == nullptr) return false;
+        return elems_->force_push(this, [&](void* p) {
+            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
+        });
+    }
+
+    template <typename T, typename F>
+    bool pop(T& item, F&& out) {
+        if (elems_ == nullptr) {
+            return false;
+        }
+        return elems_->pop(this, &(this->cursor_), [&item](void* p) {
+            ::new (&item) T(std::move(*static_cast<T*>(p)));
+        }, std::forward<F>(out));
+    }
+};
+
+} // namespace detail
+
+template <typename T, typename Policy>
+class queue final : public detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>> {
+    using base_t = detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>>;
+
+public:
+    using value_t = T;
+
+    using base_t::base_t;
+
+    template <typename... P>
+    bool push(P&&... params) {
+        return base_t::template push<T>(std::forward<P>(params)...);
+    }
+
+    template <typename... P>
+    bool force_push(P&&... params) {
+        return base_t::template force_push<T>(std::forward<P>(params)...);
+    }
+
+    bool pop(T& item) {
+        return base_t::pop(item, [](bool) {});
+    }
+
+    template <typename F>
+    bool pop(T& item, F&& out) {
+        return base_t::pop(item, std::forward<F>(out));
+    }
+};
+
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/shm.cpp

@@ -0,0 +1,103 @@
+
+#include <string>
+#include <utility>
+
+#include "libipc/shm.h"
+
+#include "libipc/utility/pimpl.h"
+#include "libipc/memory/resource.h"
+
+namespace ipc {
+namespace shm {
+
+class handle::handle_ : public pimpl<handle_> {
+public:
+    shm::id_t id_ = nullptr;
+    void*     m_  = nullptr;
+
+    ipc::string n_;
+    std::size_t s_ = 0;
+};
+
+handle::handle()
+    : p_(p_->make()) {
+}
+
+handle::handle(char const * name, std::size_t size, unsigned mode)
+    : handle() {
+    acquire(name, size, mode);
+}
+
+handle::handle(handle&& rhs)
+    : handle() {
+    swap(rhs);
+}
+
+handle::~handle() {
+    release();
+    p_->clear();
+}
+
+void handle::swap(handle& rhs) {
+    std::swap(p_, rhs.p_);
+}
+
+handle& handle::operator=(handle rhs) {
+    swap(rhs);
+    return *this;
+}
+
+bool handle::valid() const noexcept {
+    return impl(p_)->m_ != nullptr;
+}
+
+std::size_t handle::size() const noexcept {
+    return impl(p_)->s_;
+}
+
+char const * handle::name() const noexcept {
+    return impl(p_)->n_.c_str();
+}
+
+std::int32_t handle::ref() const noexcept {
+    return shm::get_ref(impl(p_)->id_);
+}
+
+void handle::sub_ref() noexcept {
+    shm::sub_ref(impl(p_)->id_);
+}
+
+bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
+    release();
+    impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
+    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
+    return valid();
+}
+
+std::int32_t handle::release() {
+    if (impl(p_)->id_ == nullptr) return -1;
+    return shm::release(detach());
+}
+
+void* handle::get() const {
+    return impl(p_)->m_;
+}
+
+void handle::attach(id_t id) {
+    if (id == nullptr) return;
+    release();
+    impl(p_)->id_ = id;
+    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
+}
+
+id_t handle::detach() {
+    auto old = impl(p_)->id_;
+    impl(p_)->id_ = nullptr;
+    impl(p_)->m_  = nullptr;
+    impl(p_)->s_  = 0;
+    impl(p_)->n_.clear();
+    return old;
+}
+
+} // namespace shm
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/waiter.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <utility>
+#include <string>
+#include <mutex>
+#include <atomic>
+
+#include "libipc/def.h"
+#include "libipc/mutex.h"
+#include "libipc/condition.h"
+#include "libipc/platform/detail.h"
+
+namespace ipc {
+namespace detail {
+
+class waiter {
+    ipc::sync::condition cond_;
+    ipc::sync::mutex     lock_;
+    std::atomic<bool>    quit_ {false};
+
+public:
+    static void init();
+
+    waiter() = default;
+    waiter(char const *name) {
+        open(name);
+    }
+
+    ~waiter() {
+        close();
+    }
+
+    bool valid() const noexcept {
+        return cond_.valid() && lock_.valid();
+    }
+
+    bool open(char const *name) noexcept {
+        quit_.store(false, std::memory_order_relaxed);
+        if (!cond_.open((std::string{"_waiter_cond_"} + name).c_str())) {
+            return false;
+        }
+        if (!lock_.open((std::string{"_waiter_lock_"} + name).c_str())) {
+            cond_.close();
+            return false;
+        }
+        return valid();
+    }
+
+    void close() noexcept {
+        cond_.close();
+        lock_.close();
+    }
+
+    template <typename F>
+    bool wait_if(F &&pred, std::uint64_t tm = ipc::invalid_value) noexcept {
+        IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_};
+        while ([this, &pred] {
+                    return !quit_.load(std::memory_order_relaxed)
+                        && std::forward<F>(pred)();
+                }()) {
+            if (!cond_.wait(lock_, tm)) return false;
+        }
+        return true;
+    }
+
+    bool notify() noexcept {
+        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
+        return cond_.notify(lock_);
+    }
+
+    bool broadcast() noexcept {
+        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
+        return cond_.broadcast(lock_);
+    }
+
+    bool quit_waiting() {
+        quit_.store(true, std::memory_order_release);
+        return broadcast();
+    }
+};
+
+} // namespace detail
+} // namespace ipc

crazy_functions/test_project/cpp/cppipc/来源

@@ -0,0 +1,3 @@
+https://github.com/mutouyun/cpp-ipc
+
+A high-performance inter-process communication library using shared memory on Linux/Windows.

crazy_functions/test_project/cpp/libJPG/jpgd.h

@@ -0,0 +1,316 @@
+// jpgd.h - C++ class for JPEG decompression.
+// Public domain, Rich Geldreich <richgel99@gmail.com>
+#ifndef JPEG_DECODER_H
+#define JPEG_DECODER_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <setjmp.h>
+
+namespace jpgd
+{
+  typedef unsigned char  uint8;
+  typedef   signed short int16;
+  typedef unsigned short uint16;
+  typedef unsigned int   uint;
+  typedef   signed int   int32;
+
+  // Loads a JPEG image from a memory buffer or a file.
+  // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
+  // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
+  // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly.
+  // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
+// BEGIN EPIC MOD
+//unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps);
+  unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps, int format);
+// END EPIC MOD
+  unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps);
+
+  // Success/failure error codes.
+  enum jpgd_status
+  {
+    JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
+    JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE, 
+    JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS, 
+    JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
+    JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
+    JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
+    JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
+    JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
+    JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM
+  };
+    
+  // Input stream interface.
+  // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available.
+  // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set.
+  // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer.
+  // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding.
+  class jpeg_decoder_stream
+  {
+  public:
+    jpeg_decoder_stream() { }
+    virtual ~jpeg_decoder_stream() { }
+
+    // The read() method is called when the internal input buffer is empty.
+    // Parameters:
+    // pBuf - input buffer
+    // max_bytes_to_read - maximum bytes that can be written to pBuf
+    // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
+    // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
+    // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
+    virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
+  };
+
+  // stdio FILE stream class.
+  class jpeg_decoder_file_stream : public jpeg_decoder_stream
+  {
+    jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
+    jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &);
+
+    FILE *m_pFile;
+    bool m_eof_flag, m_error_flag;
+
+  public:
+    jpeg_decoder_file_stream();
+    virtual ~jpeg_decoder_file_stream();
+    
+    bool open(const char *Pfilename);
+    void close();
+
+    virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
+  };
+
+  // Memory stream class.
+  class jpeg_decoder_mem_stream : public jpeg_decoder_stream
+  {
+    const uint8 *m_pSrc_data;
+    uint m_ofs, m_size;
+
+  public:
+    jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { }
+    jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { }
+
+    virtual ~jpeg_decoder_mem_stream() { }
+
+    bool open(const uint8 *pSrc_data, uint size);
+    void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; }
+    
+    virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
+  };
+
+  // Loads JPEG file from a jpeg_decoder_stream.
+  unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps);
+
+  enum 
+  { 
+    JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4, 
+    JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384 
+  };
+          
+  typedef int16 jpgd_quant_t;
+  typedef int16 jpgd_block_t;
+
+  class jpeg_decoder
+  {
+  public:
+    // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc.
+    // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
+    jpeg_decoder(jpeg_decoder_stream *pStream);
+
+    ~jpeg_decoder();
+
+    // Call this method after constructing the object to begin decompression.
+    // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
+    int begin_decoding();
+
+    // Returns the next scan line.
+    // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1). 
+    // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4).
+    // Returns JPGD_SUCCESS if a scan line has been returned.
+    // Returns JPGD_DONE if all scan lines have been returned.
+    // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info.
+    int decode(const void** pScan_line, uint* pScan_line_len);
+    
+    inline jpgd_status get_error_code() const { return m_error_code; }
+
+    inline int get_width() const { return m_image_x_size; }
+    inline int get_height() const { return m_image_y_size; }
+
+    inline int get_num_components() const { return m_comps_in_frame; }
+
+    inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
+    inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); }
+
+    // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
+    inline int get_total_bytes_read() const { return m_total_bytes_read; }
+    
+  private:
+    jpeg_decoder(const jpeg_decoder &);
+    jpeg_decoder &operator =(const jpeg_decoder &);
+
+    typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
+
+    struct huff_tables
+    {
+      bool ac_table;
+      uint  look_up[256];
+      uint  look_up2[256];
+      uint8 code_size[256];
+      uint  tree[512];
+    };
+
+    struct coeff_buf
+    {
+      uint8 *pData;
+      int block_num_x, block_num_y;
+      int block_len_x, block_len_y;
+      int block_size;
+    };
+
+    struct mem_block
+    {
+      mem_block *m_pNext;
+      size_t m_used_count;
+      size_t m_size;
+      char m_data[1];
+    };
+
+    jmp_buf m_jmp_state;
+    mem_block *m_pMem_blocks;
+    int m_image_x_size;
+    int m_image_y_size;
+    jpeg_decoder_stream *m_pStream;
+    int m_progressive_flag;
+    uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
+    uint8* m_huff_num[JPGD_MAX_HUFF_TABLES];      // pointer to number of Huffman codes per bit size
+    uint8* m_huff_val[JPGD_MAX_HUFF_TABLES];      // pointer to Huffman codes per bit size
+    jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
+    int m_scan_type;                              // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
+    int m_comps_in_frame;                         // # of components in frame
+    int m_comp_h_samp[JPGD_MAX_COMPONENTS];       // component's horizontal sampling factor
+    int m_comp_v_samp[JPGD_MAX_COMPONENTS];       // component's vertical sampling factor
+    int m_comp_quant[JPGD_MAX_COMPONENTS];        // component's quantization table selector
+    int m_comp_ident[JPGD_MAX_COMPONENTS];        // component's ID
+    int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
+    int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
+    int m_comps_in_scan;                          // # of components in scan
+    int m_comp_list[JPGD_MAX_COMPS_IN_SCAN];      // components in this scan
+    int m_comp_dc_tab[JPGD_MAX_COMPONENTS];       // component's DC Huffman coding table selector
+    int m_comp_ac_tab[JPGD_MAX_COMPONENTS];       // component's AC Huffman coding table selector
+    int m_spectral_start;                         // spectral selection start
+    int m_spectral_end;                           // spectral selection end
+    int m_successive_low;                         // successive approximation low
+    int m_successive_high;                        // successive approximation high
+    int m_max_mcu_x_size;                         // MCU's max. X size in pixels
+    int m_max_mcu_y_size;                         // MCU's max. Y size in pixels
+    int m_blocks_per_mcu;
+    int m_max_blocks_per_row;
+    int m_mcus_per_row, m_mcus_per_col;
+    int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
+    int m_total_lines_left;                       // total # lines left in image
+    int m_mcu_lines_left;                         // total # lines left in this MCU
+    int m_real_dest_bytes_per_scan_line;
+    int m_dest_bytes_per_scan_line;               // rounded up
+    int m_dest_bytes_per_pixel;                   // 4 (RGB) or 1 (Y)
+    huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
+    coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS];
+    coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS];
+    int m_eob_run;
+    int m_block_y_mcu[JPGD_MAX_COMPONENTS];
+    uint8* m_pIn_buf_ofs;
+    int m_in_buf_left;
+    int m_tem_flag;
+    bool m_eof_flag;
+    uint8 m_in_buf_pad_start[128];
+    uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
+    uint8 m_in_buf_pad_end[128];
+    int m_bits_left;
+    uint m_bit_buf;
+    int m_restart_interval;
+    int m_restarts_left;
+    int m_next_restart_num;
+    int m_max_mcus_per_row;
+    int m_max_blocks_per_mcu;
+    int m_expanded_blocks_per_mcu;
+    int m_expanded_blocks_per_row;
+    int m_expanded_blocks_per_component;
+    bool  m_freq_domain_chroma_upsample;
+    int m_max_mcus_per_col;
+    uint m_last_dc_val[JPGD_MAX_COMPONENTS];
+    jpgd_block_t* m_pMCU_coefficients;
+    int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
+    uint8* m_pSample_buf;
+    int m_crr[256];
+    int m_cbb[256];
+    int m_crg[256];
+    int m_cbg[256];
+    uint8* m_pScan_line_0;
+    uint8* m_pScan_line_1;
+    jpgd_status m_error_code;
+    bool m_ready_flag;
+    int m_total_bytes_read;
+
+    void free_all_blocks();
+    // BEGIN EPIC MOD
+    UE_NORETURN void stop_decoding(jpgd_status status);
+    // END EPIC MOD
+    void *alloc(size_t n, bool zero = false);
+    void word_clear(void *p, uint16 c, uint n);
+    void prep_in_buffer();
+    void read_dht_marker();
+    void read_dqt_marker();
+    void read_sof_marker();
+    void skip_variable_marker();
+    void read_dri_marker();
+    void read_sos_marker();
+    int next_marker();
+    int process_markers();
+    void locate_soi_marker();
+    void locate_sof_marker();
+    int locate_sos_marker();
+    void init(jpeg_decoder_stream * pStream);
+    void create_look_ups();
+    void fix_in_buffer();
+    void transform_mcu(int mcu_row);
+    void transform_mcu_expand(int mcu_row);
+    coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y);
+    inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y);
+    void load_next_row();
+    void decode_next_row();
+    void make_huff_table(int index, huff_tables *pH);
+    void check_quant_tables();
+    void check_huff_tables();
+    void calc_mcu_block_order();
+    int init_scan();
+    void init_frame();
+    void process_restart();
+    void decode_scan(pDecode_block_func decode_block_func);
+    void init_progressive();
+    void init_sequential();
+    void decode_start();
+    void decode_init(jpeg_decoder_stream * pStream);
+    void H2V2Convert();
+    void H2V1Convert();
+    void H1V2Convert();
+    void H1V1Convert();
+    void gray_convert();
+    void expanded_convert();
+    void find_eoi();
+    inline uint get_char();
+    inline uint get_char(bool *pPadding_flag);
+    inline void stuff_char(uint8 q);
+    inline uint8 get_octet();
+    inline uint get_bits(int num_bits);
+    inline uint get_bits_no_markers(int numbits);
+    inline int huff_decode(huff_tables *pH);
+    inline int huff_decode(huff_tables *pH, int& extrabits);
+    static inline uint8 clamp(int i);
+    static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
+    static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
+    static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
+    static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
+  };
+  
+} // namespace jpgd
+
+#endif // JPEG_DECODER_H

crazy_functions/test_project/cpp/libJPG/jpge.h

@@ -0,0 +1,172 @@
+
+// jpge.h - C++ class for JPEG compression.
+// Public domain, Rich Geldreich <richgel99@gmail.com>
+// Alex Evans: Added RGBA support, linear memory allocator.
+#ifndef JPEG_ENCODER_H
+#define JPEG_ENCODER_H
+
+#include <stdint.h>
+
+namespace jpge
+{
+  typedef unsigned char  uint8;
+  typedef signed short   int16;
+  typedef signed int     int32;
+  typedef unsigned short uint16;
+  typedef unsigned int   uint32;
+  typedef unsigned int   uint;
+
+  // JPEG chroma subsampling factors. Y_ONLY (grayscale images) and H2V2 (color images) are the most common.
+  enum subsampling_t { Y_ONLY = 0, H1V1 = 1, H2V1 = 2, H2V2 = 3 };
+
+  // JPEG compression parameters structure.
+  struct params
+  {
+    inline params() : m_quality(85), m_subsampling(H2V2), m_no_chroma_discrim_flag(false), m_two_pass_flag(false) { }
+
+    inline bool check_valid() const
+    {
+      if ((m_quality < 1) || (m_quality > 100)) return false;
+      if ((uint)m_subsampling > (uint)H2V2) return false;
+      return true;
+    }
+
+    // Quality: 1-100, higher is better. Typical values are around 50-95.
+    int m_quality;
+
+    // m_subsampling:
+    // 0 = Y (grayscale) only
+    // 1 = YCbCr, no subsampling (H1V1, YCbCr 1x1x1, 3 blocks per MCU)
+    // 2 = YCbCr, H2V1 subsampling (YCbCr 2x1x1, 4 blocks per MCU)
+    // 3 = YCbCr, H2V2 subsampling (YCbCr 4x1x1, 6 blocks per MCU-- very common)
+    subsampling_t m_subsampling;
+
+    // Disables CbCr discrimination - only intended for testing.
+    // If true, the Y quantization table is also used for the CbCr channels.
+    bool m_no_chroma_discrim_flag;
+
+    bool m_two_pass_flag;
+  };
+  
+  // Writes JPEG image to a file. 
+  // num_channels must be 1 (Y) or 3 (RGB), image pitch must be width*num_channels.
+  bool compress_image_to_jpeg_file(const char *pFilename, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params = params());
+
+  // Writes JPEG image to memory buffer. 
+  // On entry, buf_size is the size of the output buffer pointed at by pBuf, which should be at least ~1024 bytes. 
+  // If return value is true, buf_size will be set to the size of the compressed data.
+  bool compress_image_to_jpeg_file_in_memory(void *pBuf, int64_t &buf_size, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params = params());
+    
+  // Output stream abstract class - used by the jpeg_encoder class to write to the output stream. 
+  // put_buf() is generally called with len==JPGE_OUT_BUF_SIZE bytes, but for headers it'll be called with smaller amounts.
+  class output_stream
+  {
+  public:
+    virtual ~output_stream() { };
+    virtual bool put_buf(const void* Pbuf, int64_t len) = 0;
+    template<class T> inline bool put_obj(const T& obj) { return put_buf(&obj, sizeof(T)); }
+  };
+    
+  // Lower level jpeg_encoder class - useful if more control is needed than the above helper functions.
+  class jpeg_encoder
+  {
+  public:
+    jpeg_encoder();
+    ~jpeg_encoder();
+
+    // Initializes the compressor.
+    // pStream: The stream object to use for writing compressed data.
+    // params - Compression parameters structure, defined above.
+    // width, height  - Image dimensions.
+    // channels - May be 1, or 3. 1 indicates grayscale, 3 indicates RGB source data.
+    // Returns false on out of memory or if a stream write fails.
+    bool init(output_stream *pStream, int64_t width, int64_t height, int64_t src_channels, const params &comp_params = params());
+    
+    const params &get_params() const { return m_params; }
+    
+    // Deinitializes the compressor, freeing any allocated memory. May be called at any time.
+    void deinit();
+
+    uint get_total_passes() const { return m_params.m_two_pass_flag ? 2 : 1; }
+    inline uint get_cur_pass() { return m_pass_num; }
+
+    // Call this method with each source scanline.
+    // width * src_channels bytes per scanline is expected (RGB or Y format).
+    // You must call with NULL after all scanlines are processed to finish compression.
+    // Returns false on out of memory or if a stream write fails.
+    bool process_scanline(const void* pScanline);
+        
+  private:
+    jpeg_encoder(const jpeg_encoder &);
+    jpeg_encoder &operator =(const jpeg_encoder &);
+
+    typedef int32 sample_array_t;
+        
+    output_stream *m_pStream;
+    params m_params;
+    uint8 m_num_components;
+    uint8 m_comp_h_samp[3], m_comp_v_samp[3];
+    int m_image_x, m_image_y, m_image_bpp, m_image_bpl;
+    int m_image_x_mcu, m_image_y_mcu;
+    int m_image_bpl_xlt, m_image_bpl_mcu;
+    int m_mcus_per_row;
+    int m_mcu_x, m_mcu_y;
+    uint8 *m_mcu_lines[16];
+    uint8 m_mcu_y_ofs;
+    sample_array_t m_sample_array[64];
+    int16 m_coefficient_array[64];
+    int32 m_quantization_tables[2][64];
+    uint m_huff_codes[4][256];
+    uint8 m_huff_code_sizes[4][256];
+    uint8 m_huff_bits[4][17];
+    uint8 m_huff_val[4][256];
+    uint32 m_huff_count[4][256];
+    int m_last_dc_val[3];
+    enum { JPGE_OUT_BUF_SIZE = 2048 };
+    uint8 m_out_buf[JPGE_OUT_BUF_SIZE];
+    uint8 *m_pOut_buf;
+    uint m_out_buf_left;
+    uint32 m_bit_buffer;
+    uint m_bits_in;
+    uint8 m_pass_num;
+    bool m_all_stream_writes_succeeded;
+        
+    void optimize_huffman_table(int table_num, int table_len);
+    void emit_byte(uint8 i);
+    void emit_word(uint i);
+    void emit_marker(int marker);
+    void emit_jfif_app0();
+    void emit_dqt();
+    void emit_sof();
+    void emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag);
+    void emit_dhts();
+    void emit_sos();
+    void emit_markers();
+    void compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits, uint8 *val);
+    void compute_quant_table(int32 *dst, int16 *src);
+    void adjust_quant_table(int32 *dst, int32 *src);
+    void first_pass_init();
+    bool second_pass_init();
+    bool jpg_open(int p_x_res, int p_y_res, int src_channels);
+    void load_block_8_8_grey(int x);
+    void load_block_8_8(int x, int y, int c);
+    void load_block_16_8(int x, int c);
+    void load_block_16_8_8(int x, int c);
+    void load_quantized_coefficients(int component_num);
+    void flush_output_buffer();
+    void put_bits(uint bits, uint len);
+    void code_coefficients_pass_one(int component_num);
+    void code_coefficients_pass_two(int component_num);
+    void code_block(int component_num);
+    void process_mcu_row();
+    bool terminate_pass_one();
+    bool terminate_pass_two();
+    bool process_end_of_image();
+    void load_mcu(const void* src);
+    void clear();
+    void init();
+  };
+
+} // namespace jpge
+
+#endif // JPEG_ENCODER

crazy_functions/test_project/cpp/libJPG/来源

@@ -0,0 +1,3 @@
+jpge.h - C++ class for JPEG compression.
+Public domain, Rich Geldreich <richgel99@gmail.com>
+Alex Evans: Added RGBA support, linear memory allocator.

crazy_functions/test_project/cpp/longcode/prod_cons.h

@@ -0,0 +1,433 @@
+#pragma once
+
+#include <atomic>
+#include <utility>
+#include <cstring>
+#include <type_traits>
+#include <cstdint>
+
+#include "libipc/def.h"
+
+#include "libipc/platform/detail.h"
+#include "libipc/circ/elem_def.h"
+#include "libipc/utility/log.h"
+#include "libipc/utility/utility.h"
+
+namespace ipc {
+
+////////////////////////////////////////////////////////////////
+/// producer-consumer implementation
+////////////////////////////////////////////////////////////////
+
+template <typename Flag>
+struct prod_cons_impl;
+
+template <>
+struct prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> rd_; // read index
+    alignas(cache_line_size) std::atomic<circ::u2_t> wt_; // write index
+
+    constexpr circ::u2_t cursor() const noexcept {
+        return 0;
+    }
+
+    template <typename W, typename F, typename E>
+    bool push(W* /*wrapper*/, F&& f, E* elems) {
+        auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed));
+        if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) {
+            return false; // full
+        }
+        std::forward<F>(f)(&(elems[cur_wt].data_));
+        wt_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+
+    /**
+     * In single-single-unicast, 'force_push' means 'no reader' or 'the only one reader is dead'.
+     * So we could just disconnect all connections of receiver, and return false.
+    */
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&&, E*) {
+        wrapper->elems()->disconnect_receiver(~static_cast<circ::cc_t>(0u));
+        return false;
+    }
+
+    template <typename W, typename F, typename R, typename E>
+    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
+        auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed));
+        if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) {
+            return false; // empty
+        }
+        std::forward<F>(f)(&(elems[cur_rd].data_));
+        std::forward<R>(out)(true);
+        rd_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::single, relat::multi , trans::unicast>>
+     : prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&&, E*) {
+        wrapper->elems()->disconnect_receiver(1);
+        return false;
+    }
+
+    template <typename W, typename F, typename R, 
+              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
+    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
+        byte_t buff[DS];
+        for (unsigned k = 0;;) {
+            auto cur_rd = rd_.load(std::memory_order_relaxed);
+            if (circ::index_of(cur_rd) ==
+                circ::index_of(wt_.load(std::memory_order_acquire))) {
+                return false; // empty
+            }
+            std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
+            if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
+                std::forward<F>(f)(buff);
+                std::forward<R>(out)(true);
+                return true;
+            }
+            ipc::yield(k);
+        }
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::multi , relat::multi, trans::unicast>>
+     : prod_cons_impl<wr<relat::single, relat::multi, trans::unicast>> {
+
+    using flag_t = std::uint64_t;
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> ct_; // commit index
+
+    template <typename W, typename F, typename E>
+    bool push(W* /*wrapper*/, F&& f, E* elems) {
+        circ::u2_t cur_ct, nxt_ct;
+        for (unsigned k = 0;;) {
+            cur_ct = ct_.load(std::memory_order_relaxed);
+            if (circ::index_of(nxt_ct = cur_ct + 1) ==
+                circ::index_of(rd_.load(std::memory_order_acquire))) {
+                return false; // full
+            }
+            if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        auto* el = elems + circ::index_of(cur_ct);
+        std::forward<F>(f)(&(el->data_));
+        // set flag & try update wt
+        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
+        while (1) {
+            auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
+            if (cur_ct != wt_.load(std::memory_order_relaxed)) {
+                return true;
+            }
+            if ((~cac_ct) != cur_ct) {
+                return true;
+            }
+            if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
+                return true;
+            }
+            wt_.store(nxt_ct, std::memory_order_release);
+            cur_ct = nxt_ct;
+            nxt_ct = cur_ct + 1;
+            el = elems + circ::index_of(cur_ct);
+        }
+        return true;
+    }
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&&, E*) {
+        wrapper->elems()->disconnect_receiver(1);
+        return false;
+    }
+
+    template <typename W, typename F, typename R, 
+              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
+    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
+        byte_t buff[DS];
+        for (unsigned k = 0;;) {
+            auto cur_rd = rd_.load(std::memory_order_relaxed);
+            auto cur_wt = wt_.load(std::memory_order_acquire);
+            auto id_rd  = circ::index_of(cur_rd);
+            auto id_wt  = circ::index_of(cur_wt);
+            if (id_rd == id_wt) {
+                auto* el = elems + id_wt;
+                auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
+                if ((~cac_ct) != cur_wt) {
+                    return false; // empty
+                }
+                if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
+                    wt_.store(cur_wt + 1, std::memory_order_release);
+                }
+                k = 0;
+            }
+            else {
+                std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
+                if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
+                    std::forward<F>(f)(buff);
+                    std::forward<R>(out)(true);
+                    return true;
+                }
+                ipc::yield(k);
+            }
+        }
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::single, relat::multi, trans::broadcast>> {
+
+    using rc_t = std::uint64_t;
+
+    enum : rc_t {
+        ep_mask = 0x00000000ffffffffull,
+        ep_incr = 0x0000000100000000ull
+    };
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+        std::atomic<rc_t> rc_ { 0 }; // read-counter
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> wt_;   // write index
+    alignas(cache_line_size) rc_t epoch_ { 0 };             // only one writer
+
+    circ::u2_t cursor() const noexcept {
+        return wt_.load(std::memory_order_acquire);
+    }
+
+    template <typename W, typename F, typename E>
+    bool push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            circ::cc_t rem_cc = cur_rc & ep_mask;
+            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch_)) {
+                return false; // has not finished yet
+            }
+            // consider rem_cc to be 0 here
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        std::forward<F>(f)(&(el->data_));
+        wt_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        epoch_ += ep_incr;
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            circ::cc_t rem_cc = cur_rc & ep_mask;
+            if (cc & rem_cc) {
+                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
+                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
+                if (cc == 0) return false; // no reader
+            }
+            // just compare & exchange
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        std::forward<F>(f)(&(el->data_));
+        wt_.fetch_add(1, std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename R, typename E>
+    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E* elems) {
+        if (cur == cursor()) return false; // acquire
+        auto* el = elems + circ::index_of(cur++);
+        std::forward<F>(f)(&(el->data_));
+        for (unsigned k = 0;;) {
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            if ((cur_rc & ep_mask) == 0) {
+                std::forward<R>(out)(true);
+                return true;
+            }
+            auto nxt_rc = cur_rc & ~static_cast<rc_t>(wrapper->connected_id());
+            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
+                std::forward<R>(out)((nxt_rc & ep_mask) == 0);
+                return true;
+            }
+            ipc::yield(k);
+        }
+    }
+};
+
+template <>
+struct prod_cons_impl<wr<relat::multi, relat::multi, trans::broadcast>> {
+
+    using rc_t   = std::uint64_t;
+    using flag_t = std::uint64_t;
+
+    enum : rc_t {
+        rc_mask = 0x00000000ffffffffull,
+        ep_mask = 0x00ffffffffffffffull,
+        ep_incr = 0x0100000000000000ull,
+        ic_mask = 0xff000000ffffffffull,
+        ic_incr = 0x0000000100000000ull
+    };
+
+    template <std::size_t DataSize, std::size_t AlignSize>
+    struct elem_t {
+        std::aligned_storage_t<DataSize, AlignSize> data_ {};
+        std::atomic<rc_t  > rc_   { 0 }; // read-counter
+        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
+    };
+
+    alignas(cache_line_size) std::atomic<circ::u2_t> ct_;   // commit index
+    alignas(cache_line_size) std::atomic<rc_t> epoch_ { 0 };
+
+    circ::u2_t cursor() const noexcept {
+        return ct_.load(std::memory_order_acquire);
+    }
+
+    constexpr static rc_t inc_rc(rc_t rc) noexcept {
+        return (rc & ic_mask) | ((rc + ic_incr) & ~ic_mask);
+    }
+
+    constexpr static rc_t inc_mask(rc_t rc) noexcept {
+        return inc_rc(rc) & ~rc_mask;
+    }
+
+    template <typename W, typename F, typename E>
+    bool push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        circ::u2_t cur_ct;
+        rc_t epoch = epoch_.load(std::memory_order_acquire);
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_relaxed);
+            circ::cc_t rem_cc = cur_rc & rc_mask;
+            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch)) {
+                return false; // has not finished yet
+            }
+            else if (!rem_cc) {
+                auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
+                if ((cur_fl != cur_ct) && cur_fl) {
+                    return false; // full
+                }
+            }
+            // consider rem_cc to be 0 here
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed) &&
+                epoch_.compare_exchange_weak(epoch, epoch, std::memory_order_acq_rel)) {
+                break;
+            }
+            ipc::yield(k);
+        }
+        // only one thread/process would touch here at one time
+        ct_.store(cur_ct + 1, std::memory_order_release);
+        std::forward<F>(f)(&(el->data_));
+        // set flag & try update wt
+        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename E>
+    bool force_push(W* wrapper, F&& f, E* elems) {
+        E* el;
+        circ::u2_t cur_ct;
+        rc_t epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
+        for (unsigned k = 0;;) {
+            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
+            if (cc == 0) return false; // no reader
+            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
+            // check all consumers have finished reading this element
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            circ::cc_t rem_cc = cur_rc & rc_mask;
+            if (cc & rem_cc) {
+                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
+                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
+                if (cc == 0) return false; // no reader
+            }
+            // just compare & exchange
+            if (el->rc_.compare_exchange_weak(
+                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed)) {
+                if (epoch == epoch_.load(std::memory_order_acquire)) {
+                    break;
+                }
+                else if (push(wrapper, std::forward<F>(f), elems)) {
+                    return true;
+                }
+                epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
+            }
+            ipc::yield(k);
+        }
+        // only one thread/process would touch here at one time
+        ct_.store(cur_ct + 1, std::memory_order_release);
+        std::forward<F>(f)(&(el->data_));
+        // set flag & try update wt
+        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
+        return true;
+    }
+
+    template <typename W, typename F, typename R, typename E, std::size_t N>
+    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E(& elems)[N]) {
+        auto* el = elems + circ::index_of(cur);
+        auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
+        if (cur_fl != ~static_cast<flag_t>(cur)) {
+            return false; // empty
+        }
+        ++cur;
+        std::forward<F>(f)(&(el->data_));
+        for (unsigned k = 0;;) {
+            auto cur_rc = el->rc_.load(std::memory_order_acquire);
+            if ((cur_rc & rc_mask) == 0) {
+                std::forward<R>(out)(true);
+                el->f_ct_.store(cur + N - 1, std::memory_order_release);
+                return true;
+            }
+            auto nxt_rc = inc_rc(cur_rc) & ~static_cast<rc_t>(wrapper->connected_id());
+            bool last_one = false;
+            if ((last_one = (nxt_rc & rc_mask) == 0)) {
+                el->f_ct_.store(cur + N - 1, std::memory_order_release);
+            }
+            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
+                std::forward<R>(out)(last_one);
+                return true;
+            }
+            ipc::yield(k);
+        }
+    }
+};
+
+} // namespace ipc

crazy_functions/test_project/latex/attention/background.tex

@@ -0,0 +1,58 @@
+The goal of reducing sequential computation also forms the foundation of the Extended Neural GPU \citep{extendedngpu}, ByteNet \citep{NalBytenet2017} and ConvS2S \citep{JonasFaceNet2017}, all of which use convolutional neural networks as basic building block, computing hidden representations in parallel for all input and output positions. In these models, the number of operations required to relate signals from two arbitrary input or output positions grows in the distance between positions, linearly for ConvS2S and logarithmically for ByteNet. This makes it more difficult to learn dependencies between distant positions \citep{hochreiter2001gradient}. In the Transformer this is reduced to a constant number of operations, albeit at the cost of reduced effective resolution due to averaging attention-weighted positions, an effect we counteract with Multi-Head Attention as described in section~\ref{sec:attention}. 
+
+Self-attention, sometimes called intra-attention is an attention mechanism relating different positions of a single sequence in order to compute a representation of the sequence. Self-attention has been used successfully in a variety of tasks including reading comprehension, abstractive summarization, textual entailment and learning task-independent sentence representations \citep{cheng2016long, decomposableAttnModel, paulus2017deep, lin2017structured}.
+
+End-to-end memory networks are based on a recurrent attention mechanism instead of sequence-aligned recurrence and have been shown to perform well on simple-language question answering and language modeling tasks \citep{sukhbaatar2015}.
+
+To the best of our knowledge, however, the Transformer is the first transduction model relying entirely on self-attention to compute representations of its input and output without using sequence-aligned RNNs or convolution.
+In the following sections, we will describe the Transformer, motivate self-attention and discuss its advantages over models such as \citep{neural_gpu, NalBytenet2017} and \citep{JonasFaceNet2017}.
+
+
+%\citep{JonasFaceNet2017} report new SOTA on machine translation for English-to-German (EnDe), Enlish-to-French (EnFr) and English-to-Romanian language pairs. 
+
+%For example,! in MT, we must draw information from both input and previous output words to translate an output word accurately. An attention layer \citep{bahdanau2014neural} can connect a very large number of positions at low computation cost, making it an essential ingredient in competitive recurrent models for machine translation.
+
+%A natural question to ask then is, "Could we replace recurrence with attention?". \marginpar{Don't know if it's the most natural question to ask given the previous statements. Also, need to say that the complexity table summarizes these statements} Such a model would be blessed with the computational efficiency of attention and the power of cross-positional communication. In this work, show that pure attention models work remarkably well for MT, achieving new SOTA results on EnDe and EnFr, and can be trained in under $2$ days on xyz architecture. 
+
+%After the seminal models introduced in \citep{sutskever14, bahdanau2014neural, cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation (MT) and language modeling with recurrent endoder-decoder and recurrent language models. Recent effort \citep{shazeer2017outrageously} has successfully combined the power of conditional computation with sequence models to train very large models for MT, pushing SOTA at lower computational cost.
+
+%Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state precludes processing all timesteps at once, instead requiring long sequences of sequential operations.  In practice, this results in greatly reduced computational efficiency, as on modern computing hardware, a single operation on a large batch is much faster than a large number of operations on small batches.  The problem gets worse at longer sequence lengths. Although sequential computation is not a severe bottleneck at inference time, as autoregressively generating each output requires all previous outputs, the inability to compute scores at all output positions at once hinders us from rapidly training our models over large datasets. Although impressive work such as \citep{Kuchaiev2017Factorization} is able to significantly accelerate the training of LSTMs with factorization tricks, we are still bound by the linear dependence on sequence length.
+
+%If the model could compute hidden states at each time step using only the inputs and outputs,  it would be liberated from the dependence on results from previous time steps during training. This line of thought is the foundation of recent efforts such as the Markovian neural GPU \citep{neural_gpu}, ByteNet \citep{NalBytenet2017} and ConvS2S \citep{JonasFaceNet2017}, all of which use convolutional neural networks as a building block to compute hidden representations simultaneously for all timesteps, resulting in $O(1)$ sequential time complexity. \citep{JonasFaceNet2017} report new SOTA on machine translation for English-to-German (EnDe), Enlish-to-French (EnFr) and English-to-Romanian language pairs. 
+
+%A crucial component for accurate sequence prediction is modeling cross-positional communication. For example, in MT, we must draw information from both input and previous output words to translate an output word accurately. An attention layer \citep{bahdanau2014neural} can connect a very large number of positions at a low computation cost, also $O(1)$ sequential time complexity, making it an essential ingredient in recurrent encoder-decoder architectures for MT. A natural question to ask then is, "Could we replace recurrence with attention?". \marginpar{Don't know if it's the most natural question to ask given the previous statements. Also, need to say that the complexity table summarizes these statements} Such a model would be blessed with the computational efficiency of attention and the power of cross-positional communication. In this work, show that pure attention models work remarkably well for MT, achieving new SOTA results on EnDe and EnFr, and can be trained in under $2$ days on xyz architecture. 
+
+
+
+%Note: Facebook model is no better than RNNs in this regard, since it requires a number of layers proportional to the distance you want to communicate.  Bytenet is more promising, since it requires a logarithmnic number of layers (does bytenet have SOTA results)?   
+
+%Note: An attention  layer can connect a very large number of positions at a low computation cost in O(1) sequential operations.  This is why encoder-decoder attention has been so successful in seq-to-seq models so far.  It is only natural, then, to also use attention to connect the timesteps of the same sequence.
+
+%Note: I wouldn't say that long sequences are not a problem during inference.  It would be great if we could infer with no long sequences.  We could just say later on that, while our training graph is constant-depth, our model still requires sequential operations in the decoder part during inference due to the autoregressive nature of the model.   
+
+%\begin{table}[h!]
+%\caption{Attention models are quite efficient for cross-positional communications when sequence length is smaller than channel depth. $n$ represents the sequence length and $d$ represents the channel depth.}
+%\label{tab:op_complexities}
+%\begin{center}
+%\vspace{-5pt}
+%\scalebox{0.75}{
+
+%\begin{tabular}{l|c|c|c}
+%\hline \hline
+%Layer Type & Receptive & Complexity & Sequential  \\
+%           & Field     &            & Operations  \\
+%\hline
+%Pointwise Feed-Forward & $1$ & $O(n \cdot d^2)$ & $O(1)$ \\
+%\hline
+%Recurrent & $n$ & $O(n \cdot d^2)$ & $O(n)$ \\
+%\hline
+%Convolutional & $r$ & $O(r \cdot n \cdot d^2)$ & $O(1)$ \\
+%\hline
+%Convolutional (separable) & $r$ & $O(r \cdot n \cdot d + n %\cdot d^2)$ & $O(1)$ \\
+%\hline
+%Attention & $r$ & $O(r \cdot n \cdot d)$ & $O(1)$ \\
+%\hline \hline
+%\end{tabular}
+%}
+%\end{center}
+%\end{table}

crazy_functions/test_project/latex/attention/introduction.tex

@@ -0,0 +1,18 @@
+Recurrent neural networks, long short-term memory \citep{hochreiter1997} and gated recurrent \citep{gruEval14} neural networks in particular, have been firmly established as state of the art approaches in sequence modeling and transduction problems such as language modeling and machine translation \citep{sutskever14, bahdanau2014neural, cho2014learning}. Numerous efforts have since continued to push the boundaries of recurrent language models and encoder-decoder architectures \citep{wu2016google,luong2015effective,jozefowicz2016exploring}.
+
+Recurrent models typically factor computation along the symbol positions of the input and output sequences. Aligning the positions to steps in computation time, they generate a sequence of hidden states $h_t$, as a function of the previous hidden state $h_{t-1}$ and the input for position $t$. This inherently sequential nature precludes parallelization within training examples, which becomes critical at longer sequence lengths, as memory constraints limit batching across examples.
+%\marginpar{not sure if the memory constraints are understandable here}
+Recent work has achieved significant improvements in computational efficiency through factorization tricks \citep{Kuchaiev2017Factorization} and conditional computation \citep{shazeer2017outrageously}, while also improving model performance in case of the latter. The fundamental constraint of sequential computation, however, remains.
+
+%\marginpar{@all: there is work on analyzing what attention really does in seq2seq models, couldn't find it right away} 
+
+Attention mechanisms have become an integral part of compelling sequence modeling and transduction models in various tasks, allowing modeling of dependencies without regard to their distance in the input or output sequences \citep{bahdanau2014neural, structuredAttentionNetworks}. In all but a few cases \citep{decomposableAttnModel}, however, such attention mechanisms are used in conjunction with a recurrent network.
+
+%\marginpar{not sure if "cross-positional communication" is understandable without explanation}
+%\marginpar{insert exact training times and stats for the model that reaches sota earliest, maybe even a single GPU model?}
+
+In this work we propose the Transformer, a model architecture eschewing recurrence and instead relying entirely on an attention mechanism to draw global dependencies between input and output. The Transformer allows for significantly more parallelization and can reach a new state of the art in translation quality after being trained for as little as twelve hours on eight P100 GPUs. 
+%\marginpar{you removed the constant number of repetitions part. I wrote it because I wanted to make it clear that the model does not only perform attention once, while it's also not recurrent. I thought that might be important to get across early.}
+
+% Just a standard paragraph with citations, rewrite.
+%After the seminal papers of \citep{sutskever14}, \citep{bahdanau2014neural}, and \citep{cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation and language modeling with recurrent sequence models. Recent effort \citep{shazeer2017outrageously} has combined the power of conditional computation with sequence models to train very large models for machine translation, pushing SOTA at lower computational cost. Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state encumbers recurrnet models to process multiple inputs at once, and their time complexity is a linear function of the length of the input and output, both during training and inference. [What I want to say here is that although this is fine during decoding, at training time, we are given both input and output and this linear nature does not allow the RNN to process all inputs and outputs simultaneously and haven't been used on datasets that are the of the scale of the web. What's the largest dataset we have ? . Talk about Nividia and possibly other's effors to speed up things, and possibly other efforts that alleviate this, but are still limited by it's comptuational nature]. Rest of the intro: What if you could construct the state based on the actual inputs and outputs, then you could construct them all at once. This has been the foundation of many promising recent efforts, bytenet,facenet (Also talk about quasi rnn here). Now we talk about attention!! Along with cell architectures such as long short-term meory (LSTM) \citep{hochreiter1997}, and gated recurrent units (GRUs) \citep{cho2014learning}, attention has emerged as an essential ingredient in successful sequence models, in particular for machine translation. In recent years, many, if not all, state-of-the-art (SOTA) results in machine translation have been achieved with attention-based sequence models \citep{wu2016google,luong2015effective,jozefowicz2016exploring}. Talk about the neon work on how it played with attention to do self attention! Then talk about what we do.

crazy_functions/test_project/latex/attention/model_architecture.tex

@@ -0,0 +1,155 @@
+
+\begin{figure}
+  \centering
+  \includegraphics[scale=0.6]{Figures/ModalNet-21}
+  \caption{The Transformer - model architecture.}
+  \label{fig:model-arch}
+\end{figure}
+
+% Although the primary workhorse of our model is attention, 
+%Our model maintains the encoder-decoder structure that is common to many so-called sequence-to-sequence models \citep{bahdanau2014neural,sutskever14}.  As in all such architectures, the encoder computes a representation of the input sequence, and the decoder consumes these representations along with the output tokens to autoregressively produce the output sequence.  Where, traditionally, the encoder and decoder contain stacks of recurrent or convolutional layers, our encoder and decoder stacks are composed of attention layers and position-wise feed-forward layers (Figure~\ref{fig:model-arch}).  The following sections describe the gross architecture and these particular components in detail.
+
+Most competitive neural sequence transduction models have an encoder-decoder structure \citep{cho2014learning,bahdanau2014neural,sutskever14}. Here, the encoder maps an input sequence of symbol representations $(x_1, ..., x_n)$ to a sequence of continuous representations $\mathbf{z} = (z_1, ..., z_n)$. Given $\mathbf{z}$, the decoder then generates an output sequence $(y_1,...,y_m)$ of symbols one element at a time. At each step the model is auto-regressive \citep{graves2013generating}, consuming the previously generated symbols as additional input when generating the next.
+
+The Transformer follows this overall architecture using stacked self-attention and point-wise, fully connected layers for both the encoder and decoder, shown in the left and right halves of Figure~\ref{fig:model-arch}, respectively.
+
+\subsection{Encoder and Decoder Stacks}
+
+\paragraph{Encoder:}The encoder is composed of a stack of $N=6$ identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, position-wise fully connected feed-forward network.   We employ a residual connection \citep{he2016deep} around each of the two sub-layers, followed by layer normalization \cite{layernorm2016}.  That is, the output of each sub-layer is $\mathrm{LayerNorm}(x + \mathrm{Sublayer}(x))$, where $\mathrm{Sublayer}(x)$ is the function implemented by the sub-layer itself.  To facilitate these residual connections, all sub-layers in the model, as well as the embedding layers, produce outputs of dimension $\dmodel=512$.
+
+\paragraph{Decoder:}The decoder is also composed of a stack of $N=6$ identical layers.  In addition to the two sub-layers in each encoder layer, the decoder inserts a third sub-layer, which performs multi-head attention over the output of the encoder stack.  Similar to the encoder, we employ residual connections around each of the sub-layers, followed by layer normalization.  We also modify the self-attention sub-layer in the decoder stack to prevent positions from attending to subsequent positions.  This masking, combined with fact that the output embeddings are offset by one position, ensures that the predictions for position $i$ can depend only on the known outputs at positions less than $i$.
+
+% In our model (Figure~\ref{fig:model-arch}), the encoder and decoder are composed of stacks of alternating self-attention layers (for cross-positional communication) and position-wise feed-forward layers (for in-place computation).  In addition, the decoder stack contains encoder-decoder attention layers.  Since attention is agnostic to the distances between words, our model requires a "positional encoding" to be added to the encoder and decoder input. The following sections describe all of these components in detail.
+
+\subsection{Attention} \label{sec:attention}
+An attention function can be described as mapping a query and a set of key-value pairs to an output, where the query, keys, values, and output are all vectors.  The output is computed as a weighted sum of the values, where the weight assigned to each value is computed by a compatibility function of the query with the corresponding key.
+
+\subsubsection{Scaled Dot-Product Attention} \label{sec:scaled-dot-prod}
+
+% \begin{figure}
+%   \centering
+%   \includegraphics[scale=0.6]{Figures/ModalNet-19}
+%   \caption{Scaled Dot-Product Attention.}
+%   \label{fig:multi-head-att}
+% \end{figure}
+
+We call our particular attention "Scaled Dot-Product Attention" (Figure~\ref{fig:multi-head-att}).   The input consists of queries and keys of dimension $d_k$, and values of dimension $d_v$.  We compute the dot products of the query with all keys, divide each by $\sqrt{d_k}$, and apply a softmax function to obtain the weights on the values.
+
+In practice, we compute the attention function on a set of queries simultaneously, packed together into a matrix $Q$.   The keys and values are also packed together into matrices $K$ and $V$.  We compute the matrix of outputs as:
+
+\begin{equation}
+   \mathrm{Attention}(Q, K, V) = \mathrm{softmax}(\frac{QK^T}{\sqrt{d_k}})V
+\end{equation}
+
+The two most commonly used attention functions are additive attention \citep{bahdanau2014neural}, and dot-product (multiplicative) attention.  Dot-product attention is identical to our algorithm, except for the scaling factor of $\frac{1}{\sqrt{d_k}}$. Additive attention computes the compatibility function using a feed-forward network with a single hidden layer.  While the two are similar in theoretical complexity, dot-product attention is much faster and more space-efficient in practice, since it can be implemented using highly optimized matrix multiplication code. 
+
+%We scale the dot products by $1/\sqrt{d_k}$ to limit the magnitude of the dot products, which works well in practice. Otherwise, we found applying the softmax to often result in weights very close to 0 or 1, and hence minuscule gradients.
+
+% Already described in the subsequent section
+%When used as part of decoder self-attention, an optional mask function is applied just before the softmax to prevent positions from attending to subsequent positions.   This mask simply sets the logits corresponding to all illegal connections (those outside of the lower triangle) to $-\infty$.
+
+%\paragraph{Comparison to Additive Attention: } We choose dot product attention over additive attention \citep{bahdanau2014neural} since it can be computed using highly optimized matrix multiplication code.  This optimization is particularly important to us, as we employ many attention layers in our model.
+
+While for small values of $d_k$ the two mechanisms perform similarly, additive attention outperforms dot product attention without scaling for larger values of $d_k$ \citep{DBLP:journals/corr/BritzGLL17}. We suspect that for large values of $d_k$, the dot products grow large in magnitude, pushing the softmax function into regions where it has extremely small gradients  \footnote{To illustrate why the dot products get large, assume that the components of $q$ and $k$ are independent random variables with mean $0$ and variance $1$.  Then their dot product, $q \cdot k = \sum_{i=1}^{d_k} q_ik_i$, has mean $0$ and variance $d_k$.}. To counteract this effect, we scale the dot products by $\frac{1}{\sqrt{d_k}}$.
+
+
+%We suspect this to be caused by the dot products growing too large in magnitude to result in useful gradients after applying the softmax function.  To counteract this, we scale the dot product by $1/\sqrt{d_k}$.
+
+
+\subsubsection{Multi-Head Attention} \label{sec:multihead}
+
+\begin{figure}
+\begin{minipage}[t]{0.5\textwidth}
+  \centering
+  Scaled Dot-Product Attention \\
+  \vspace{0.5cm}
+  \includegraphics[scale=0.6]{Figures/ModalNet-19}
+\end{minipage}
+\begin{minipage}[t]{0.5\textwidth}
+  \centering 
+  Multi-Head Attention \\
+  \vspace{0.1cm}
+  \includegraphics[scale=0.6]{Figures/ModalNet-20}  
+\end{minipage}
+
+
+  % \centering
+
+  \caption{(left) Scaled Dot-Product Attention. (right) Multi-Head Attention consists of several attention layers running in parallel.}
+  \label{fig:multi-head-att}
+\end{figure}
+
+Instead of performing a single attention function with $\dmodel$-dimensional keys, values and queries, we found it beneficial to linearly project the queries, keys and values $h$ times with different, learned linear projections to $d_k$, $d_k$ and $d_v$ dimensions, respectively.
+On each of these projected versions of queries, keys and values we then perform the attention function in parallel, yielding $d_v$-dimensional output values. These are concatenated and once again projected, resulting in the final values, as depicted in Figure~\ref{fig:multi-head-att}.
+
+Multi-head attention allows the model to jointly attend to information from different representation subspaces at different positions. With a single attention head, averaging inhibits this.
+
+\begin{align*}
+    \mathrm{MultiHead}(Q, K, V) &= \mathrm{Concat}(\mathrm{head_1}, ..., \mathrm{head_h})W^O\\
+%    \mathrm{where} \mathrm{head_i} &= \mathrm{Attention}(QW_Q_i^{\dmodel \times d_q}, KW_K_i^{\dmodel \times d_k}, VW^V_i^{\dmodel \times d_v})\\
+    \text{where}~\mathrm{head_i} &= \mathrm{Attention}(QW^Q_i, KW^K_i, VW^V_i)\\
+\end{align*}
+
+Where the projections are parameter matrices $W^Q_i \in \mathbb{R}^{\dmodel \times d_k}$, $W^K_i \in \mathbb{R}^{\dmodel \times d_k}$, $W^V_i \in \mathbb{R}^{\dmodel \times d_v}$ and $W^O \in \mathbb{R}^{hd_v \times \dmodel}$.
+
+
+%find it better (and no more expensive) to have multiple parallel attention layers (each over the full set of positions) with proportionally lower-dimensional keys, values and queries.  We call this "Multi-Head Attention" (Figure~\ref{fig:multi-head-att}).  The keys, values, and queries for each of these parallel attention layers are computed by learned linear transformations of the inputs to the multi-head attention.  We use different linear transformations across different parallel attention layers.  The output of the parallel attention layers are concatenated, and then passed through a final learned linear transformation. 
+
+In this work we employ $h=8$ parallel attention layers, or heads. For each of these we use $d_k=d_v=\dmodel/h=64$.
+Due to the reduced dimension of each head, the total computational cost is similar to that of single-head attention with full dimensionality.
+
+\subsubsection{Applications of Attention in our Model}
+
+The Transformer uses multi-head attention in three different ways: 
+\begin{itemize}
+ \item In "encoder-decoder attention" layers, the queries come from the previous decoder layer, and the memory keys and values come from the output of the encoder.   This allows every position in the decoder to attend over all positions in the input sequence.  This mimics the typical encoder-decoder attention mechanisms in sequence-to-sequence models such as \citep{wu2016google, bahdanau2014neural,JonasFaceNet2017}.
+
+ \item The encoder contains self-attention layers.  In a self-attention layer all of the keys, values and queries come from the same place, in this case, the output of the previous layer in the encoder.   Each position in the encoder can attend to all positions in the previous layer of the encoder.
+
+ \item Similarly, self-attention layers in the decoder allow each position in the decoder to attend to all positions in the decoder up to and including that position.  We need to prevent leftward information flow in the decoder to preserve the auto-regressive property.  We implement this inside of scaled dot-product attention by masking out (setting to $-\infty$) all values in the input of the softmax which correspond to illegal connections.  See Figure~\ref{fig:multi-head-att}.
+
+\end{itemize}
+
+\subsection{Position-wise Feed-Forward Networks}\label{sec:ffn}
+
+In addition to attention sub-layers, each of the layers in our encoder and decoder contains a fully connected feed-forward network, which is applied to each position separately and identically.  This consists of two linear transformations with a ReLU activation in between.
+
+\begin{equation}
+   \mathrm{FFN}(x)=\max(0, xW_1 + b_1) W_2 + b_2
+\end{equation}
+
+While the linear transformations are the same across different positions, they use different parameters from layer to layer. Another way of describing this is as two convolutions with kernel size 1.  The dimensionality of input and output is $\dmodel=512$, and the inner-layer has dimensionality $d_{ff}=2048$.
+
+
+
+%In the appendix, we describe how the position-wise feed-forward network can also be seen as a form of attention.
+
+%from Jakob: The number of operations required for the model to relate signals from two arbitrary input or output positions grows in the distance between positions in input or output, linearly for ConvS2S and logarithmically for ByteNet, making it harder to learn dependencies between these positions \citep{hochreiter2001gradient}. In the transformer this is reduced to a constant number of operations, albeit at the cost of effective resolution caused by averaging attention-weighted positions, an effect we aim to counteract with multi-headed attention.
+
+
+%Figure~\ref{fig:simple-att} presents a simple attention function, $A$, with a single head, that forms the basis of our multi-head attention. $A$ takes a query key vector $\kq$, matrices of memory keys $\km$ and memory values $\vm$ ,and produces a query value vector $\vq$ as 
+%\begin{equation*} \label{eq:attention}
+%    A(\kq, \km, \vm) = {\vm}^T (Softmax(\km \kq).
+%\end{equation*}
+%We linearly transform $\kq,\,\km$, and $\vm$ with learned matrices ${\Wkq \text{,} \, \Wkm}$, and ${\Wvm}$ before calling the attention function, and transform the output query with $\Wvq$ before handing it to the feed forward layer. Each attention layer has it's own set of transformation matrices, which are shared across all query positions. $A$ is applied in parallel for each query position, and is implemented very efficiently as a batch of matrix multiplies. The self-attention and encoder-decoder attention layers use $A$, but with different arguments. For example, in encdoder self-attention, queries in encoder layer $i$ attention to memories in encoder layer $i-1$. To ensure that decoder self-attention layers do not look at future words, we add $- \inf$ to the softmax logits in positions $j+1$ to query length for query position $l$.  
+
+%In simple attention, the query value is a weighted combination of the memory values where the attention weights sum to one. Although this function performs well in practice, the constraint on attention weights can restrict the amount of information that flows from memories to queries because the query cannot focus on multiple memory positions at once, which might be desirable when translating long sequences. \marginpar{@usz, could you think of an example of this ?} We remedy this by maintaining multiple attention heads at each query position that attend to all memory positions in parallel, with a different set of parameters  per attention head $h$. 
+%\marginpar{}
+
+\subsection{Embeddings and Softmax}
+Similarly to other sequence transduction models, we use learned embeddings to convert the input tokens and output tokens to vectors of dimension $\dmodel$.  We also use the usual learned linear transformation and softmax function to convert the decoder output to predicted next-token probabilities.  In our model, we share the same weight matrix between the two embedding layers and the pre-softmax linear transformation, similar to \citep{press2016using}.   In the embedding layers, we multiply those weights by $\sqrt{\dmodel}$.
+
+
+\subsection{Positional Encoding}
+Since our model contains no recurrence and no convolution, in order for the model to make use of the order of the sequence, we must inject some information about the relative or absolute position of the tokens in the sequence.  To this end, we add "positional encodings" to the input embeddings at the bottoms of the encoder and decoder stacks.  The positional encodings have the same dimension $\dmodel$ as the embeddings, so that the two can be summed.   There are many choices of positional encodings, learned and fixed \citep{JonasFaceNet2017}.
+
+In this work, we use sine and cosine functions of different frequencies:
+
+\begin{align*}
+    PE_{(pos,2i)} = sin(pos / 10000^{2i/\dmodel}) \\
+    PE_{(pos,2i+1)} = cos(pos / 10000^{2i/\dmodel})
+\end{align*}
+
+where $pos$ is the position and $i$ is the dimension.  That is, each dimension of the positional encoding corresponds to a sinusoid.  The wavelengths form a geometric progression from $2\pi$ to $10000 \cdot 2\pi$.  We chose this function because we hypothesized it would allow the model to easily learn to attend by relative positions, since for any fixed offset $k$, $PE_{pos+k}$ can be represented as a linear function of $PE_{pos}$.
+
+We also experimented with using learned positional embeddings \citep{JonasFaceNet2017} instead, and found that the two versions produced nearly identical results (see Table~\ref{tab:variations} row (E)).  We chose the sinusoidal version because it may allow the model to extrapolate to sequence lengths longer than the ones encountered during training.

crazy_functions/test_project/latex/attention/parameter_attention.tex

@@ -0,0 +1,45 @@
+\pagebreak
+\section*{Two Feed-Forward Layers = Attention over Parameters}\label{sec:parameter_attention}
+
+In addition to attention layers, our model contains position-wise feed-forward networks (Section \ref{sec:ffn}), which consist of two linear transformations with a ReLU activation in between.  In fact, these networks too can be seen as a form of attention.  Compare the formula for such a network with the formula for a simple dot-product attention layer (biases and scaling factors omitted):
+
+\begin{align*}
+    FFN(x, W_1, W_2) = ReLU(xW_1)W_2 \\
+    A(q, K, V) = Softmax(qK^T)V
+\end{align*}
+
+Based on the similarity of these formulae, the two-layer feed-forward network can be seen as a kind of attention, where the keys and values are the rows of the trainable parameter matrices $W_1$ and $W_2$, and where we use ReLU instead of Softmax in the compatibility function.
+
+%the compatablity function is $compat(q, k_i) = ReLU(q \cdot k_i)$ instead of $Softmax(qK_T)_i$.
+
+Given this similarity, we experimented with replacing the position-wise feed-forward networks with attention layers similar to the ones we use everywhere else our model. The multi-head-attention-over-parameters sublayer is identical to the multi-head attention described in \ref{sec:multihead}, except that the "keys" and "values" inputs to each attention head are trainable model parameters, as opposed to being linear projections of a previous layer.  These parameters are scaled up by a factor of $\sqrt{d_{model}}$ in order to be more similar to activations.
+
+In our first experiment, we replaced each position-wise feed-forward network with a multi-head-attention-over-parameters sublayer with $h_p=8$ heads, key-dimensionality $d_{pk}=64$, and value-dimensionality $d_{pv}=64$, using $n_p=1536$ key-value pairs for each attention head.  The sublayer has a total of $2097152$ parameters, including the parameters in the query projection and the output projection.  This matches the number of parameters in the position-wise feed-forward network that we replaced.  While the theoretical amount of computation is also the same, in practice, the attention version caused the step times to be about 30\% longer.
+
+In our second experiment, we used $h_p=8$ heads, and $n_p=512$ key-value pairs for each attention head, again matching the total number of parameters in the base model.
+
+Results for the first experiment were slightly worse than for the base model, and results for the second experiment were slightly better, see Table~\ref{tab:parameter_attention}.
+
+\begin{table}[h]
+\caption{Replacing the position-wise feed-forward networks with multihead-attention-over-parameters produces similar results to the base model.  All metrics are on the English-to-German translation development set, newstest2013.}
+\label{tab:parameter_attention}
+\begin{center}
+\vspace{-2mm}
+%\scalebox{1.0}{
+\begin{tabular}{c|cccccc|cccc}
+\hline\rule{0pt}{2.0ex}
+ & \multirow{2}{*}{$\dmodel$} & \multirow{2}{*}{$\dff$} &
+\multirow{2}{*}{$h_p$} & \multirow{2}{*}{$d_{pk}$} & \multirow{2}{*}{$d_{pv}$} &
+ \multirow{2}{*}{$n_p$} &
+ PPL & BLEU & params & training\\
+ & & & & & &  & (dev) & (dev) & $\times10^6$ & time \\
+\hline\rule{0pt}{2.0ex}
+base & 512 & 2048 & & & & & 4.92 & 25.8 & 65 & 12 hours\\
+\hline\rule{0pt}{2.0ex}
+AOP$_1$ & 512 & & 8 & 64 & 64 & 1536 & 4.92& 25.5  & 65 & 16 hours\\
+AOP$_2$ & 512 & & 16 & 64 & 64 & 512 & \textbf{4.86} & \textbf{25.9}  & 65 & 16 hours \\
+\hline
+\end{tabular}
+%}
+\end{center}
+\end{table}

crazy_functions/test_project/latex/attention/来源

@@ -0,0 +1,8 @@
+chatgpt的老祖宗《Attention is all you need》
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin
+
+真实的摘要如下
+The dominant sequence transduction models are based on complex recurrent or convolutional neural networks in an encoder-decoder configuration. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task, improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training costs of the best models from the literature. We show that the Transformer generalizes well to other tasks by applying it successfully to English constituency parsing both with large and limited training data.
+
+https://arxiv.org/abs/1706.03762

crazy_functions/test_project/python/dqn/__init__.py

@@ -0,0 +1,2 @@
+from stable_baselines3.dqn.dqn import DQN
+from stable_baselines3.dqn.policies import CnnPolicy, MlpPolicy

crazy_functions/test_project/python/dqn/dqn.py

@@ -0,0 +1,245 @@
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
+
+import gym
+import numpy as np
+import torch as th
+from torch.nn import functional as F
+
+from stable_baselines3.common import logger
+from stable_baselines3.common.off_policy_algorithm import OffPolicyAlgorithm
+from stable_baselines3.common.preprocessing import maybe_transpose
+from stable_baselines3.common.type_aliases import GymEnv, MaybeCallback, Schedule
+from stable_baselines3.common.utils import get_linear_fn, is_vectorized_observation, polyak_update
+from stable_baselines3.dqn.policies import DQNPolicy
+
+
+class DQN(OffPolicyAlgorithm):
+    """
+    Deep Q-Network (DQN)
+
+    Paper: https://arxiv.org/abs/1312.5602, https://www.nature.com/articles/nature14236
+    Default hyperparameters are taken from the nature paper,
+    except for the optimizer and learning rate that were taken from Stable Baselines defaults.
+
+    :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)
+    :param env: The environment to learn from (if registered in Gym, can be str)
+    :param learning_rate: The learning rate, it can be a function
+        of the current progress remaining (from 1 to 0)
+    :param buffer_size: size of the replay buffer
+    :param learning_starts: how many steps of the model to collect transitions for before learning starts
+    :param batch_size: Minibatch size for each gradient update
+    :param tau: the soft update coefficient ("Polyak update", between 0 and 1) default 1 for hard update
+    :param gamma: the discount factor
+    :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit
+        like ``(5, "step")`` or ``(2, "episode")``.
+    :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)
+        Set to ``-1`` means to do as many gradient steps as steps done in the environment
+        during the rollout.
+    :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer
+        at a cost of more complexity.
+        See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195
+    :param target_update_interval: update the target network every ``target_update_interval``
+        environment steps.
+    :param exploration_fraction: fraction of entire training period over which the exploration rate is reduced
+    :param exploration_initial_eps: initial value of random action probability
+    :param exploration_final_eps: final value of random action probability
+    :param max_grad_norm: The maximum value for the gradient clipping
+    :param tensorboard_log: the log location for tensorboard (if None, no logging)
+    :param create_eval_env: Whether to create a second environment that will be
+        used for evaluating the agent periodically. (Only available when passing string for the environment)
+    :param policy_kwargs: additional arguments to be passed to the policy on creation
+    :param verbose: the verbosity level: 0 no output, 1 info, 2 debug
+    :param seed: Seed for the pseudo random generators
+    :param device: Device (cpu, cuda, ...) on which the code should be run.
+        Setting it to auto, the code will be run on the GPU if possible.
+    :param _init_setup_model: Whether or not to build the network at the creation of the instance
+    """
+
+    def __init__(
+        self,
+        policy: Union[str, Type[DQNPolicy]],
+        env: Union[GymEnv, str],
+        learning_rate: Union[float, Schedule] = 1e-4,
+        buffer_size: int = 1000000,
+        learning_starts: int = 50000,
+        batch_size: Optional[int] = 32,
+        tau: float = 1.0,
+        gamma: float = 0.99,
+        train_freq: Union[int, Tuple[int, str]] = 4,
+        gradient_steps: int = 1,
+        optimize_memory_usage: bool = False,
+        target_update_interval: int = 10000,
+        exploration_fraction: float = 0.1,
+        exploration_initial_eps: float = 1.0,
+        exploration_final_eps: float = 0.05,
+        max_grad_norm: float = 10,
+        tensorboard_log: Optional[str] = None,
+        create_eval_env: bool = False,
+        policy_kwargs: Optional[Dict[str, Any]] = None,
+        verbose: int = 0,
+        seed: Optional[int] = None,
+        device: Union[th.device, str] = "auto",
+        _init_setup_model: bool = True,
+    ):
+
+        super(DQN, self).__init__(
+            policy,
+            env,
+            DQNPolicy,
+            learning_rate,
+            buffer_size,
+            learning_starts,
+            batch_size,
+            tau,
+            gamma,
+            train_freq,
+            gradient_steps,
+            action_noise=None,  # No action noise
+            policy_kwargs=policy_kwargs,
+            tensorboard_log=tensorboard_log,
+            verbose=verbose,
+            device=device,
+            create_eval_env=create_eval_env,
+            seed=seed,
+            sde_support=False,
+            optimize_memory_usage=optimize_memory_usage,
+            supported_action_spaces=(gym.spaces.Discrete,),
+        )
+
+        self.exploration_initial_eps = exploration_initial_eps
+        self.exploration_final_eps = exploration_final_eps
+        self.exploration_fraction = exploration_fraction
+        self.target_update_interval = target_update_interval
+        self.max_grad_norm = max_grad_norm
+        # "epsilon" for the epsilon-greedy exploration
+        self.exploration_rate = 0.0
+        # Linear schedule will be defined in `_setup_model()`
+        self.exploration_schedule = None
+        self.q_net, self.q_net_target = None, None
+
+        if _init_setup_model:
+            self._setup_model()
+
+    def _setup_model(self) -> None:
+        super(DQN, self)._setup_model()
+        self._create_aliases()
+        self.exploration_schedule = get_linear_fn(
+            self.exploration_initial_eps, self.exploration_final_eps, self.exploration_fraction
+        )
+
+    def _create_aliases(self) -> None:
+        self.q_net = self.policy.q_net
+        self.q_net_target = self.policy.q_net_target
+
+    def _on_step(self) -> None:
+        """
+        Update the exploration rate and target network if needed.
+        This method is called in ``collect_rollouts()`` after each step in the environment.
+        """
+        if self.num_timesteps % self.target_update_interval == 0:
+            polyak_update(self.q_net.parameters(), self.q_net_target.parameters(), self.tau)
+
+        self.exploration_rate = self.exploration_schedule(self._current_progress_remaining)
+        logger.record("rollout/exploration rate", self.exploration_rate)
+
+    def train(self, gradient_steps: int, batch_size: int = 100) -> None:
+        # Update learning rate according to schedule
+        self._update_learning_rate(self.policy.optimizer)
+
+        losses = []
+        for _ in range(gradient_steps):
+            # Sample replay buffer
+            replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)
+
+            with th.no_grad():
+                # Compute the next Q-values using the target network
+                next_q_values = self.q_net_target(replay_data.next_observations)
+                # Follow greedy policy: use the one with the highest value
+                next_q_values, _ = next_q_values.max(dim=1)
+                # Avoid potential broadcast issue
+                next_q_values = next_q_values.reshape(-1, 1)
+                # 1-step TD target
+                target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values
+
+            # Get current Q-values estimates
+            current_q_values = self.q_net(replay_data.observations)
+
+            # Retrieve the q-values for the actions from the replay buffer
+            current_q_values = th.gather(current_q_values, dim=1, index=replay_data.actions.long())
+
+            # Compute Huber loss (less sensitive to outliers)
+            loss = F.smooth_l1_loss(current_q_values, target_q_values)
+            losses.append(loss.item())
+
+            # Optimize the policy
+            self.policy.optimizer.zero_grad()
+            loss.backward()
+            # Clip gradient norm
+            th.nn.utils.clip_grad_norm_(self.policy.parameters(), self.max_grad_norm)
+            self.policy.optimizer.step()
+
+        # Increase update counter
+        self._n_updates += gradient_steps
+
+        logger.record("train/n_updates", self._n_updates, exclude="tensorboard")
+        logger.record("train/loss", np.mean(losses))
+
+    def predict(
+        self,
+        observation: np.ndarray,
+        state: Optional[np.ndarray] = None,
+        mask: Optional[np.ndarray] = None,
+        deterministic: bool = False,
+    ) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+        """
+        Overrides the base_class predict function to include epsilon-greedy exploration.
+
+        :param observation: the input observation
+        :param state: The last states (can be None, used in recurrent policies)
+        :param mask: The last masks (can be None, used in recurrent policies)
+        :param deterministic: Whether or not to return deterministic actions.
+        :return: the model's action and the next state
+            (used in recurrent policies)
+        """
+        if not deterministic and np.random.rand() < self.exploration_rate:
+            if is_vectorized_observation(maybe_transpose(observation, self.observation_space), self.observation_space):
+                n_batch = observation.shape[0]
+                action = np.array([self.action_space.sample() for _ in range(n_batch)])
+            else:
+                action = np.array(self.action_space.sample())
+        else:
+            action, state = self.policy.predict(observation, state, mask, deterministic)
+        return action, state
+
+    def learn(
+        self,
+        total_timesteps: int,
+        callback: MaybeCallback = None,
+        log_interval: int = 4,
+        eval_env: Optional[GymEnv] = None,
+        eval_freq: int = -1,
+        n_eval_episodes: int = 5,
+        tb_log_name: str = "DQN",
+        eval_log_path: Optional[str] = None,
+        reset_num_timesteps: bool = True,
+    ) -> OffPolicyAlgorithm:
+
+        return super(DQN, self).learn(
+            total_timesteps=total_timesteps,
+            callback=callback,
+            log_interval=log_interval,
+            eval_env=eval_env,
+            eval_freq=eval_freq,
+            n_eval_episodes=n_eval_episodes,
+            tb_log_name=tb_log_name,
+            eval_log_path=eval_log_path,
+            reset_num_timesteps=reset_num_timesteps,
+        )
+
+    def _excluded_save_params(self) -> List[str]:
+        return super(DQN, self)._excluded_save_params() + ["q_net", "q_net_target"]
+
+    def _get_torch_save_params(self) -> Tuple[List[str], List[str]]:
+        state_dicts = ["policy", "policy.optimizer"]
+
+        return state_dicts, []

crazy_functions/test_project/python/dqn/policies.py

@@ -0,0 +1,237 @@
+from typing import Any, Dict, List, Optional, Type
+
+import gym
+import torch as th
+from torch import nn
+
+from stable_baselines3.common.policies import BasePolicy, register_policy
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor, FlattenExtractor, NatureCNN, create_mlp
+from stable_baselines3.common.type_aliases import Schedule
+
+
+class QNetwork(BasePolicy):
+    """
+    Action-Value (Q-Value) network for DQN
+
+    :param observation_space: Observation space
+    :param action_space: Action space
+    :param net_arch: The specification of the policy and value networks.
+    :param activation_fn: Activation function
+    :param normalize_images: Whether to normalize images or not,
+         dividing by 255.0 (True by default)
+    """
+
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        features_extractor: nn.Module,
+        features_dim: int,
+        net_arch: Optional[List[int]] = None,
+        activation_fn: Type[nn.Module] = nn.ReLU,
+        normalize_images: bool = True,
+    ):
+        super(QNetwork, self).__init__(
+            observation_space,
+            action_space,
+            features_extractor=features_extractor,
+            normalize_images=normalize_images,
+        )
+
+        if net_arch is None:
+            net_arch = [64, 64]
+
+        self.net_arch = net_arch
+        self.activation_fn = activation_fn
+        self.features_extractor = features_extractor
+        self.features_dim = features_dim
+        self.normalize_images = normalize_images
+        action_dim = self.action_space.n  # number of actions
+        q_net = create_mlp(self.features_dim, action_dim, self.net_arch, self.activation_fn)
+        self.q_net = nn.Sequential(*q_net)
+
+    def forward(self, obs: th.Tensor) -> th.Tensor:
+        """
+        Predict the q-values.
+
+        :param obs: Observation
+        :return: The estimated Q-Value for each action.
+        """
+        return self.q_net(self.extract_features(obs))
+
+    def _predict(self, observation: th.Tensor, deterministic: bool = True) -> th.Tensor:
+        q_values = self.forward(observation)
+        # Greedy action
+        action = q_values.argmax(dim=1).reshape(-1)
+        return action
+
+    def _get_constructor_parameters(self) -> Dict[str, Any]:
+        data = super()._get_constructor_parameters()
+
+        data.update(
+            dict(
+                net_arch=self.net_arch,
+                features_dim=self.features_dim,
+                activation_fn=self.activation_fn,
+                features_extractor=self.features_extractor,
+            )
+        )
+        return data
+
+
+class DQNPolicy(BasePolicy):
+    """
+    Policy class with Q-Value Net and target net for DQN
+
+    :param observation_space: Observation space
+    :param action_space: Action space
+    :param lr_schedule: Learning rate schedule (could be constant)
+    :param net_arch: The specification of the policy and value networks.
+    :param activation_fn: Activation function
+    :param features_extractor_class: Features extractor to use.
+    :param features_extractor_kwargs: Keyword arguments
+        to pass to the features extractor.
+    :param normalize_images: Whether to normalize images or not,
+         dividing by 255.0 (True by default)
+    :param optimizer_class: The optimizer to use,
+        ``th.optim.Adam`` by default
+    :param optimizer_kwargs: Additional keyword arguments,
+        excluding the learning rate, to pass to the optimizer
+    """
+
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule: Schedule,
+        net_arch: Optional[List[int]] = None,
+        activation_fn: Type[nn.Module] = nn.ReLU,
+        features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        normalize_images: bool = True,
+        optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
+        optimizer_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        super(DQNPolicy, self).__init__(
+            observation_space,
+            action_space,
+            features_extractor_class,
+            features_extractor_kwargs,
+            optimizer_class=optimizer_class,
+            optimizer_kwargs=optimizer_kwargs,
+        )
+
+        if net_arch is None:
+            if features_extractor_class == FlattenExtractor:
+                net_arch = [64, 64]
+            else:
+                net_arch = []
+
+        self.net_arch = net_arch
+        self.activation_fn = activation_fn
+        self.normalize_images = normalize_images
+
+        self.net_args = {
+            "observation_space": self.observation_space,
+            "action_space": self.action_space,
+            "net_arch": self.net_arch,
+            "activation_fn": self.activation_fn,
+            "normalize_images": normalize_images,
+        }
+
+        self.q_net, self.q_net_target = None, None
+        self._build(lr_schedule)
+
+    def _build(self, lr_schedule: Schedule) -> None:
+        """
+        Create the network and the optimizer.
+
+        :param lr_schedule: Learning rate schedule
+            lr_schedule(1) is the initial learning rate
+        """
+
+        self.q_net = self.make_q_net()
+        self.q_net_target = self.make_q_net()
+        self.q_net_target.load_state_dict(self.q_net.state_dict())
+
+        # Setup optimizer with initial learning rate
+        self.optimizer = self.optimizer_class(self.parameters(), lr=lr_schedule(1), **self.optimizer_kwargs)
+
+    def make_q_net(self) -> QNetwork:
+        # Make sure we always have separate networks for features extractors etc
+        net_args = self._update_features_extractor(self.net_args, features_extractor=None)
+        return QNetwork(**net_args).to(self.device)
+
+    def forward(self, obs: th.Tensor, deterministic: bool = True) -> th.Tensor:
+        return self._predict(obs, deterministic=deterministic)
+
+    def _predict(self, obs: th.Tensor, deterministic: bool = True) -> th.Tensor:
+        return self.q_net._predict(obs, deterministic=deterministic)
+
+    def _get_constructor_parameters(self) -> Dict[str, Any]:
+        data = super()._get_constructor_parameters()
+
+        data.update(
+            dict(
+                net_arch=self.net_args["net_arch"],
+                activation_fn=self.net_args["activation_fn"],
+                lr_schedule=self._dummy_schedule,  # dummy lr schedule, not needed for loading policy alone
+                optimizer_class=self.optimizer_class,
+                optimizer_kwargs=self.optimizer_kwargs,
+                features_extractor_class=self.features_extractor_class,
+                features_extractor_kwargs=self.features_extractor_kwargs,
+            )
+        )
+        return data
+
+
+MlpPolicy = DQNPolicy
+
+
+class CnnPolicy(DQNPolicy):
+    """
+    Policy class for DQN when using images as input.
+
+    :param observation_space: Observation space
+    :param action_space: Action space
+    :param lr_schedule: Learning rate schedule (could be constant)
+    :param net_arch: The specification of the policy and value networks.
+    :param activation_fn: Activation function
+    :param features_extractor_class: Features extractor to use.
+    :param normalize_images: Whether to normalize images or not,
+         dividing by 255.0 (True by default)
+    :param optimizer_class: The optimizer to use,
+        ``th.optim.Adam`` by default
+    :param optimizer_kwargs: Additional keyword arguments,
+        excluding the learning rate, to pass to the optimizer
+    """
+
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule: Schedule,
+        net_arch: Optional[List[int]] = None,
+        activation_fn: Type[nn.Module] = nn.ReLU,
+        features_extractor_class: Type[BaseFeaturesExtractor] = NatureCNN,
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        normalize_images: bool = True,
+        optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
+        optimizer_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        super(CnnPolicy, self).__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch,
+            activation_fn,
+            features_extractor_class,
+            features_extractor_kwargs,
+            normalize_images,
+            optimizer_class,
+            optimizer_kwargs,
+        )
+
+
+register_policy("MlpPolicy", MlpPolicy)
+register_policy("CnnPolicy", CnnPolicy)

crazy_functions/test_project/python/dqn/来源

@@ -0,0 +1,2 @@
+github stablebaseline3
+https://github.com/DLR-RM/stable-baselines3

crazy_functions/test_project/其他测试

@@ -0,0 +1,27 @@
+"In practice, we found that a high-entropy initial state is more likely to increase the speed of training.
+The entropy is calculated by:
+$$H=-\sum_{k= 1}^{n_k} p(k) \cdot \log p(k), p(k)=\frac{|A_k|}{|\mathcal{A}|}$$
+where $H$ is the entropy, $|A_k|$ is the number of agent nodes in $k$-th cluster, $|\mathcal{A}|$ is the total number of agents.
+To ensure the Cooperation Graph initialization has higher entropy,
+we will randomly generate multiple initial states, 
+rank by their entropy and then pick the one with maximum $H$."
+
+```
+FROM ubuntu:latest
+
+RUN apt-get update && \
+    apt-get install -y python3 python3-pip && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN echo '[global]' > /etc/pip.conf && \
+    echo 'index-url = https://mirrors.aliyun.com/pypi/simple/' >> /etc/pip.conf && \
+    echo 'trusted-host = mirrors.aliyun.com' >> /etc/pip.conf
+
+RUN pip3 install gradio requests[socks] mdtex2html
+
+COPY . /gpt
+WORKDIR /gpt
+
+
+CMD ["python3", "main.py"]
+```

crazy_functions/下载arxiv论文翻译摘要.py

@@ -144,11 +144,11 @@ def 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, hi
 
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
     try:
-        import pdfminer, bs4
+        import bs4
     except:
         report_execption(chatbot, history, 
             a = f"解析项目: {txt}", 
-            b = f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade pdfminer beautifulsoup4```。")
+            b = f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade beautifulsoup4```。")
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         return
 

crazy_functions/对话历史存档.py

@@ -12,7 +12,7 @@ def write_chat_to_file(chatbot, history=None, file_name=None):
         file_name = 'chatGPT对话历史' + time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) + '.html'
     os.makedirs('./gpt_log/', exist_ok=True)
     with open(f'./gpt_log/{file_name}', 'w', encoding='utf8') as f:
-        from theme.theme import advanced_css
+        from themes.theme import advanced_css
         f.write(f'<!DOCTYPE html><head><meta charset="utf-8"><title>对话历史</title><style>{advanced_css}</style></head>')
         for i, contents in enumerate(chatbot):
             for j, content in enumerate(contents):

crazy_functions/语音助手.py

@@ -14,9 +14,11 @@ class WatchDog():
         self.bark_fn = bark_fn
         self.interval = interval
         self.msg = msg
+        self.kill_dog = False
     
     def watch(self):
         while True:
+            if self.kill_dog: break
             if time.time() - self.last_feed > self.timeout:
                 if len(self.msg) > 0: print(self.msg)
                 self.bark_fn()
@@ -87,6 +89,9 @@ class InterviewAssistant(AliyunASR):
 
     def __del__(self):
         self.stop = True
+        self.stop_msg = ""
+        self.commit_wd.kill_dog = True
+        self.plugin_wd.kill_dog = True
 
     def init(self, chatbot):
         # 初始化音频采集线程
@@ -119,7 +124,7 @@ class InterviewAssistant(AliyunASR):
         self.commit_wd = WatchDog(timeout=self.commit_after_pause_n_second, bark_fn=self.no_audio_for_a_while, interval=0.2)
         self.commit_wd.begin_watch()
 
-        while True:
+        while not self.stop:
             self.event_on_result_chg.wait(timeout=0.25)  # run once every 0.25 second
             chatbot = self.agt.update_chatbot(chatbot)   # 将子线程的gpt结果写入chatbot
             history = chatbot2history(chatbot)
@@ -158,6 +163,8 @@ class InterviewAssistant(AliyunASR):
                 chatbot.append(["[请讲话]", "[正在等您说完问题]"])
                 yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
 
+        if len(self.stop_msg) != 0:
+            raise RuntimeError(self.stop_msg)
 
 
 

docker-compose.yml

@@ -63,7 +63,7 @@ services:
 version: '3'
 services:
   gpt_academic_with_rwkv:
-    image: fuqingxu/gpt_academic:jittorllms
+    image: ghcr.io/binary-husky/gpt_academic_jittorllms:master
     environment:
       # 请查阅 `config.py` 以查看所有的配置信息
       API_KEY:                  '    sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,fkxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  '
@@ -85,28 +85,13 @@ services:
     # 与宿主的网络融合
     network_mode: "host"
 
-    # 使用代理网络拉取最新代码
-    # command: >
-    #   bash -c "       truncate -s -1 /etc/proxychains.conf &&
-    #                   echo \"socks5 127.0.0.1 10880\" >> /etc/proxychains.conf &&
-    #                   echo '[gpt-academic] 正在从github拉取最新代码...' &&
-    #                   proxychains git pull &&
-    #                   echo '[jittorllms] 正在从github拉取最新代码...' &&
-    #                   proxychains git --git-dir=request_llm/jittorllms/.git --work-tree=request_llm/jittorllms pull --force &&
-    #                   python3 -u main.py"
-
     # 不使用代理网络拉取最新代码
     command: >
-      bash -c "       echo '[gpt-academic] 正在从github拉取最新代码...' &&
-                      git pull &&
-                      pip install -r requirements.txt &&
-                      echo '[jittorllms] 正在从github拉取最新代码...' &&
-                      git --git-dir=request_llm/jittorllms/.git --work-tree=request_llm/jittorllms pull --force &&
-                      python3 -u main.py"
+      python3 -u main.py
 
 
 ## ===================================================
-## 【方案四】 chatgpt + Latex
+## 【方案四】 ChatGPT + Latex
 ## ===================================================
 version: '3'
 services:

docs/Dockerfile+JittorLLM

@@ -26,7 +26,7 @@ RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3.8
 RUN $useProxyNetwork python3 -m pip install torch --extra-index-url https://download.pytorch.org/whl/cu113
 # 下载分支
 WORKDIR /gpt
-RUN $useProxyNetwork git clone https://github.com/binary-husky/chatgpt_academic.git -b jittor
+RUN $useProxyNetwork git clone https://github.com/binary-husky/chatgpt_academic.git
 WORKDIR /gpt/chatgpt_academic
 RUN $useProxyNetwork python3 -m pip install -r requirements.txt
 RUN $useProxyNetwork python3 -m pip install -r request_llm/requirements_chatglm.txt

docs/GithubAction+JittorLLMs

@@ -13,7 +13,7 @@ RUN python3 -m pip install torch --extra-index-url https://download.pytorch.org/
 
 # 下载分支
 WORKDIR /gpt
-RUN git clone https://github.com/binary-husky/chatgpt_academic.git -b jittor
+RUN git clone https://github.com/binary-husky/chatgpt_academic.git
 WORKDIR /gpt/chatgpt_academic
 RUN python3 -m pip install -r requirements.txt
 RUN python3 -m pip install -r request_llm/requirements_chatglm.txt

docs/translate_english.json

@@ -1890,6 +1890,7 @@
     "暗色模式 / 亮色模式": "Dark mode / Light mode",
     "检测到arxiv文档连接": "Detected arXiv document link",
     "此插件Windows支持最佳": "This plugin has best support for Windows",
+    "from crazy_functions.虚空终端 import 终端": "from crazy_functions.null_terminal import Terminal",
     "本地论文翻译": "Local paper translation",
     "输出html调试文件": "Output HTML debugging file",
     "以下所有配置也都支持利用环境变量覆写": "All the following configurations can also be overridden using environment variables",
@@ -1961,178 +1962,128 @@
     "语音助手": "VoiceAssistant",
     "微调数据集生成": "FineTuneDatasetGeneration",
     "chatglm微调工具": "ChatGLMFineTuningTool",
-    "解析一个Rect项目": "ParseARectProject",
-    "用于灵活调整复杂功能的各种参数": "Various parameters for flexible adjustment of complex functions",
-    "阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https": "Aliyun real-time speech recognition has high configuration difficulty and is only recommended for advanced users. Refer to https",
-    "/* 设定聊天气泡的样式": "/* Set the style of chat bubbles",
-    "解析整个React项目": "Parsing the entire React project",
-    "后来也传播到了其他游戏中": "Later it spread to other games",
-    "多线程demo": "Multithreading demo",
-    "最初起源于游戏《CSGO》": "Originally originated from the game 'CSGO'",
-    "首先你在中文语境下通读整篇论文": "First, you read the entire paper in a Chinese context",
-    "避免线程阻塞": "Avoid thread blocking",
-    "其中第1份搜索结果中的一篇文章也指出": "One article in the first search result also points out",
-    "3. 更新速度": "3. Update speed",
-    "极少数情况下": "In very few cases",
-    "例如 RoPlZrM88DnAFkZK": "For example, RoPlZrM88DnAFkZK",
-    "每秒采样数量": "Number of samples per second",
-    "以及其中不少玩家以极端立场宣扬的想法和言论": "And many players promote extreme ideas and opinions",
-    "音频助手": "Audio assistant",
-    "还需要填写组织": "Also need to fill in the organization",
-    "计算平方和": "Calculate the sum of squares",
-    "请向下翻": "Please scroll down",
-    "起源于哪里": "Where does it originate from",
-    "并且网友们还 给这位UP主起了“苍蝇侠”的外号": "And netizens also gave this UP host the nickname 'Flyman'",
-    "第一次调用": "First call",
-    "点击“停止”键可终止程序": "Click the 'Stop' button to terminate the program",
-    "在执行完成之后": "After execution is complete",
-    "老六是网络流行语": "Lao Liu is an internet slang",
-    "请先将.doc文档转换为.docx文档": "Please convert the .doc document to .docx document first",
-    "从第0份、第1份、第2份搜索结果可以看出": "It can be seen from the 0th, 1st, and 2nd search results",
-    "如 绿帽子*深蓝色衬衫*黑色运动裤": "Such as green hat * dark blue shirt * black sports pants",
-    "对这个人外貌、身处的环境、内心世界、过去经历进行描写": "Describing the appearance, environment, inner world, and past experiences of this person",
-    "沙特和伊朗于3月10日达成了恢复两国外交关系的协议": "Saudi Arabia and Iran reached an agreement on March 10th to restore diplomatic relations between the two countries",
-    "例如 f37f30e0f9934c34a992f6f64f7eba4f": "For example, f37f30e0f9934c34a992f6f64f7eba4f",
-    "避免多用户干扰": "Avoiding interference from multiple users",
-    "AutoGPT是一个基于GPT-4语言模型的开源应用程序": "AutoGPT is an open-source application based on the GPT-4 language model",
-    "开始最终总结": "Start the final summary",
-    "包括事件分析、营销方案撰写、代码编程、数学运算等等": "Including event analysis, writing marketing plans, coding, mathematical calculations, etc.",
-    "包括背景颜色、内、外边距、圆角": "Including background color, padding, margin, and border-radius",
-    "只读": "Read-only",
-    "/* 设置表头单元格的内边距为0.5em和0.2em. */": "/* Set the padding of the table header cells to 0.5em and 0.2em. */",
-    "游戏中的一个情节": "A plot in the game",
-    "如果一句话小于7个字": "If a sentence is less than 7 words",
-    "赋予插件状态": "Assigning plugin status",
-    "用第二人称": "Using the second person",
-    "上传本地文件/压缩包供函数插件调用": "Upload local files/compressed packages for function plugin calls",
-    "要求": "Requirements",
-    "正在等您说完问题": "Waiting for you to finish the question",
-    "后来逐渐演变成指玩得比较阴险的玩家": "Later it gradually evolved to refer to players who play in a more cunning way",
-    "当下一次用户提交时": "When the next user submits",
-    "色彩主体": "Color theme",
-    "例如 “Espe-": "For example, 'Espe-'",
-    "为每一位访问的用户赋予一个独一无二的uuid编码": "Assign a unique UUID code to each visiting user",
-    "清空label": "Clear label",
-    "对话助手函数插件": "Conversation assistant function plugin",
-    "Chuanhu-Small-and-Beautiful主题": "Chuanhu-Small-and-Beautiful theme",
-    "初始化音频采集线程": "Initialize the audio capture thread",
-    "“我们称之为高效”这 一用语来源于群星": "The phrase 'we call it efficient' comes from the stars",
-    "给观众留下了等待的时间过长的印象": "Leaving the audience with the impression of waiting for too long",
-    "在一个异步线程中采集音频": "Collect audio in an asynchronous thread",
-    "正在听您讲话": "Listening to you speak",
-    "指游戏中玩家中独来独往、游离于队伍之外的“自由人”或玩得比较菜或者玩得比较阴险的人": "Refers to players in the game who are independent, play poorly, or play cunningly and stay away from the team",
-    "函数插件模板Demo": "Function plugin template Demo",
-    "比如巨像": "Such as giant",
-    "格式如org-123456789abcdefghijklmno的": "The format is like org-123456789abcdefghijklmno",
-    "插件锁定中": "Plugin locked",
-    "/* 去掉列表前缀的默认间距": "/* Remove the default spacing of the list prefix",
-    "内部单元格之间边框合并": "Merge borders between internal cells",
-    "可以将自身的状态存储到cookie中": "Can store its own state in a cookie",
-    "解除插件锁定": "Unlock plugin",
-    "/* 设定代码块的样式": "/* Set the style of the code block",
-    "右下角更换模型菜单中可切换openai": "You can switch openai in the lower right corner model menu",
-    "颜色为--border-color-primary. */": "The color is --border-color-primary. */",
-    "引用了一群游戏玩家对于需要对P社玩家进行枪毙的讨论": "Quoted a discussion among a group of gamers about the need to execute P community players",
-    "这个话题的本质是玩家们对于P 社游戏中的政治与历史元素的不同看法": "The essence of this topic is the different views of players on the political and historical elements in P community games",
-    "我将为您查找相关壁纸": "I will find related wallpapers for you",
-    "640个字节为一组": "640 bytes per group",
-    "赋予插件锁定 锁定插件回调路径": "Assign plugin lock, lock plugin callback path",
-    "等游戏": "Waiting for the game",
-    "将文件添加到chatbot cookie中": "Add file to chatbot cookie",
-    "处理个别特殊插件的锁定状态": "Handle the lock status of individual special plugins",
-    "/* 设置表头背景颜色为rgba": "/* Set the background color of the table header to rgba",
-    "读 docs\\use_azure.md": "Read docs\\use_azure.md",
-    "边框粗细为1.2px": "The border thickness is 1.2px",
-    "这个用语最初可能是在群星": "This term may have originated in the stars",
-    "请输入关键词": "Please enter keywords",
-    "给出实现的步骤和实现细节": "Provide implementation steps and details",
-    "可以得知失败的man是指一位在B站购买了蜘蛛侠COS服后穿上后被网友嘲笑的UP主": "The 'failed man' refers to a UP main who bought a Spiderman COS costume on Bilibili and was mocked by netizens after wearing it.",
-    "最近它在GitHub上爆火": "Recently, it has become popular on GitHub.",
-    "提取总结": "Extract summary",
-    "正在锁定插件": "Locking the plugin",
-    "给出指令": "Give instructions",
-    "避免遗忘导致死锁": "Avoid forgetting causing deadlock",
-    "建议直接在API_KEY处填写": "It is recommended to fill in directly at API_KEY",
-    "详情见https": "For details, see https",
-    "因此有人就以枪毙这些玩家来回应此类言论": "Therefore, some people respond to such comments by executing these players",
-    "而“失败的man”是蜘蛛侠英文名“spiderman”的谐音梗": "And 'failed man' is a pun on the English name 'Spiderman'",
-    "格式如org-xxxxxxxxxxxxxxxxxxxxxxxx": "The format is like org-xxxxxxxxxxxxxxxxxxxxxxxx",
-    "根据第1份搜索结果": "According to the first search result",
-    "GPT 学术优化": "GPT academic optimization",
-    "等待用户的再次调用": "Waiting for user's call again",
-    "把文件复制过去": "Copy the file over",
-    "该选项即将被弃用": "This option will be deprecated",
-    "对这个人外貌、身处的环境、内心世界、人设进行描写": "Describe this person's appearance, environment, inner world, and character setting",
-    "例如您可以将以下命令复制到下方": "For example, you can copy the following command below",
-    "使用": "Use",
-    "找不到": "Not found",
-    "正常状态": "Normal state",
-    "记住当前的label": "Remember the current label",
-    "成为了业内最热门的项目之一": "Has become one of the hottest projects in the industry",
-    "它可以根据用户需求自主执行任务": "It can independently perform tasks according to user needs",
-    "时而快时而慢": "Sometimes fast, sometimes slow",
-    "它们都是关于一个知乎用户所发的帖子": "They are all about a post made by a Zhihu user",
-    "解决插件锁定时的界面显示问题": "Resolve interface display issues when the plugin is locked",
-    "azure和api2d请求源": "Azure and api2d request sources",
-    "并不应该被当做真实的态度或者观点": "Should not be taken as a real attitude or viewpoint",
-    "没有阿里云语音识别APPKEY和TOKEN": "No Alibaba Cloud Speech Recognition APPKEY and TOKEN",
-    "Rainbow Six Siege 游戏中 Smoke 的 Canister 中装有何种物质相关的官方信息": "Official information related to the substance contained in Smoke's Canister in the game Rainbow Six Siege",
-    "此处填API密钥": "Fill in API key here",
-    "使其与文本线对齐. */": "Align it with the text line. */",
-    "先删除": "Delete first",
-    "100字以内": "Within 100 characters",
-    "并完全不需要用户插手": "And does not require user intervention at all",
-    "插件可读取“输入区”文本/路径作为参数": "The plugin can read the text/path in the 'input area' as a parameter",
-    "但是这个话题本身并没有实质内容": "But this topic itself has no substantive content",
-    "会直接转到该函数": "Will directly go to that function",
-    "因此这种说法没有实际意义": "Therefore, this statement has no practical meaning",
-    "它可以自己思考": "It can think for itself",
-    "/* 行内代码的背景设为淡灰色": "/* Set the background of inline code to light gray",
-    "请直接提交即可": "Please submit directly",
-    "计算欧几里得距离矩阵": "Calculate the Euclidean distance matrix",
-    "空单元格显示. */": "Display empty cells. */",
-    "openai的官方KEY需要伴随组织编码": "The official KEY of OpenAI needs to be accompanied by organizational coding",
-    "最近在中国的斡旋下": "Recently, under the mediation of China",
-    "将子线程的gpt结果写入chatbot": "Write the GPT results of the sub-thread into the chatbot",
-    "罗小黑战记的更新时间不定": "The update time of Luo Xiaohei's Adventure is uncertain",
-    "/* 设置表格单元格的内边距为5px": "/* Set the inner padding of table cells to 5px",
-    "透明度为0.2. */": "Opacity is 0.2. */",
-    "暂不提交": "Do not submit temporarily",
-    "用户们用来形容一些游戏策略或行为非常高效且能够带来好的效果的用语": "Terms used by users to describe game strategies or behaviors that are very efficient and can bring good results",
-    "等待GPT响应": "Waiting for GPT response",
-    "计算输入数组X中所有样本点的两两距离矩阵": "Calculate the pairwise distance matrix of all sample points in the input array X",
-    "因此": "Therefore",
-    "包括圆角、最大宽度和阴影等. */": "Including rounded corners, maximum width, and shadows, etc. */",
-    "初始化插件状态": "Initialize plugin status",
+    "启动微调": "StartFineTuning",
     "请讲话": "Please speak",
-    "可选": "Optional",
-    "甚至可以自问自答执 行任务": "You can even ask and answer questions to perform tasks",
-    "add gpt task 创建子线程请求gpt": "add gpt task Create a sub-thread request gpt",
-    "失败的man是指这位UP主在穿上蜘蛛侠COS服后被网友嘲笑的情况": "The failed man refers to the situation where this UP master was mocked by netizens after wearing Spider-Man COS clothes",
-    "这个游戏里面流行起来的": "Popular in this game",
-    "获取关键词": "Get keywords",
-    "设定圆角和间距. */": "Set rounded corners and spacing. */",
-    "/* 设置表格的外边距为1em": "/* Set the margin of the table to 1em",
-    "只是一个玩笑或者恶搞": "Just a joke or a prank",
-    "双手离开鼠标键盘吧": "Take your hands off the mouse and keyboard",
-    "上传文件自动修正路径": "Automatically correct the path when uploading files",
-    "找不到任何Rect文件": "Cannot find any Rect files",
-    "先上传数据集": "Upload the dataset first",
-    "如果已经存在": "If it already exists",
-    "使用时": "When using",
-    "解除插件状态": "Release plugin status",
-    "cially” 转换为 “Especially”": "Convert 'cially' to 'Especially'",
-    "这表明两国关系已经重新回到正常化状态": "This indicates that the relationship between the two countries has returned to a normal state",
-    "由于提问含不合规内容被Azure过滤": "Due to the Azure filtering of questions containing non-compliant content",
-    "填入你亲手写的部署名": "Fill in the deployment name you wrote by hand",
-    "想象一个穿着者": "Imagine a wearer",
-    "建议使用英文单词": "It is recommended to use English words",
-    "没给定指令": "No instruction given",
+    "正在听您讲话": "Listening to you",
+    "对这个人外貌、身处的环境、内心世界、过去经历进行描写": "Describe the appearance, environment, inner world, and past experiences of this person",
+    "请向下翻": "Please scroll down",
     "实时音频采集": "Real-time audio collection",
-    "“我们称之为高效”是指在游戏社区中": "'We call it efficient' refers to the game community",
-    "找 API_ORG 设置项": "Find API_ORG settings",
-    "虚空终端": "VoidTerminal",
-    "请查看terminal的输出或耐心等待": "Please check the output of the terminal or wait patiently",
-    "发送到openai音频解析terminal": "Send to openai audio parsing terminal",
-    "超级terminal": "Super terminal"
+    "找不到": "Not found",
+    "在一个异步线程中采集音频": "Collect audio in an asynchronous thread",
+    "azure和api2d请求源": "Azure and API2D request source",
+    "等待ChatGLMFT响应中": "Waiting for ChatGLMFT response",
+    "如果使用ChatGLM2微调模型": "If using ChatGLM2 fine-tuning model",
+    "把文件复制过去": "Copy the file over",
+    "可选": "Optional",
+    "ChatGLMFT响应异常": "ChatGLMFT response exception",
+    "上传本地文件/压缩包供函数插件调用": "Upload local files/compressed packages for function plugin calls",
+    "例如 f37f30e0f9934c34a992f6f64f7eba4f": "For example, f37f30e0f9934c34a992f6f64f7eba4f",
+    "正在等您说完问题": "Waiting for you to finish the question",
+    "解除插件状态": "Release plugin status",
+    "详情见https": "See details at https",
+    "避免线程阻塞": "Avoid thread blocking",
+    "先上传数据集": "Upload dataset first",
+    "请直接提交即可": "Submit directly",
+    "Call ChatGLMFT fail 不能正常加载ChatGLMFT的参数": "Call ChatGLMFT fail, cannot load ChatGLMFT parameters",
+    "插件可读取“输入区”文本/路径作为参数": "The plugin can read text/path in the input area as parameters",
+    "给出指令": "Give instructions",
+    "暂不提交": "Do not submit for now",
+    "如 绿帽子*深蓝色衬衫*黑色运动裤": "E.g. green hat * dark blue shirt * black sports pants",
+    "阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https": "Aliyun real-time speech recognition has high configuration difficulty and is only recommended for advanced users. Refer to https",
+    "ChatGLMFT尚未加载": "ChatGLMFT has not been loaded yet",
+    "输入 clear 以清空对话历史": "Enter 'clear' to clear the conversation history",
+    "可以将自身的状态存储到cookie中": "You can store your own status in cookies",
+    "填入你亲手写的部署名": "Fill in the deployment name you wrote by yourself",
+    "该选项即将被弃用": "This option will be deprecated soon",
+    "代理网络配置": "Proxy network configuration",
+    "每秒采样数量": "Number of samples per second",
+    "使用时": "When using",
+    "想象一个穿着者": "Imagine a wearer",
+    "如果已经存在": "If it already exists",
+    "例如您可以将以下命令复制到下方": "For example, you can copy the following command below",
+    "正在锁定插件": "Locking plugin",
+    "使用": "Use",
+    "读 docs\\use_azure.md": "Read docs\\use_azure.md",
+    "开始最终总结": "Start final summary",
+    "openai的官方KEY需要伴随组织编码": "Openai's official KEY needs to be accompanied by organizational code",
+    "将子线程的gpt结果写入chatbot": "Write the GPT result of the sub-thread into the chatbot",
+    "Arixv论文精细翻译": "Fine translation of Arixv paper",
+    "开始接收chatglmft的回复": "Start receiving replies from chatglmft",
+    "请先将.doc文档转换为.docx文档": "Please convert .doc documents to .docx documents first",
+    "避免多用户干扰": "Avoid multiple user interference",
+    "清空label": "Clear label",
+    "解除插件锁定": "Unlock plugin",
+    "请以以下方式load模型！！！": "Please load the model in the following way!!!",
+    "没给定指令": "No instruction given",
+    "100字以内": "Within 100 words",
+    "获取关键词": "Get keywords",
+    "欢迎使用 MOSS 人工智能助手！": "Welcome to use MOSS AI assistant!",
+    "音频助手": "Audio assistant",
+    "上传Latex项目": "Upload Latex project",
+    "对话助手函数插件": "Chat assistant function plugin",
+    "如果一句话小于7个字": "If a sentence is less than 7 words",
+    "640个字节为一组": "640 bytes per group",
+    "右下角更换模型菜单中可切换openai": "OpenAI can be switched in the model menu in the lower right corner",
+    "双手离开鼠标键盘吧": "Take your hands off the mouse and keyboard",
+    "先删除": "Delete first",
+    "如果要使用ChatGLMFT": "If you want to use ChatGLMFT",
+    "例如 RoPlZrM88DnAFkZK": "For example, RoPlZrM88DnAFkZK",
+    "提取总结": "Extract summary",
+    "ChatGLMFT消耗大量的内存": "ChatGLMFT consumes a lot of memory",
+    "格式如org-123456789abcdefghijklmno的": "In the format of org-123456789abcdefghijklmno",
+    "在执行完成之后": "After execution is complete",
+    "此处填API密钥": "Fill in the API key here",
+    "chatglmft 没有 sys_prompt 接口": "ChatGLMFT does not have a sys_prompt interface",
+    "用第二人称": "Use the second person",
+    "Chuanhu-Small-and-Beautiful主题": "Chuanhu-Small-and-Beautiful theme",
+    "请检查ALIYUN_TOKEN和ALIYUN_APPKEY是否过期": "Please check if ALIYUN_TOKEN and ALIYUN_APPKEY have expired",
+    "还需要填写组织": "You also need to fill in the organization",
+    "会直接转到该函数": "Will directly jump to the function",
+    "初始化插件状态": "Initializing plugin status",
+    "插件锁定中": "Plugin is locked",
+    "如果这里报错": "If there is an error here",
+    "本地Latex论文精细翻译": "Local Latex paper fine translation",
+    "极少数情况下": "In very few cases",
+    "首先你在中文语境下通读整篇论文": "First, read the entire paper in a Chinese context",
+    "点击“停止”键可终止程序": "Click the 'Stop' button to terminate the program",
+    "建议排查": "Suggested troubleshooting",
+    "没有阿里云语音识别APPKEY和TOKEN": "No Aliyun voice recognition APPKEY and TOKEN",
+    "避免遗忘导致死锁": "Avoid forgetting to cause deadlock",
+    "第一次调用": "First call",
+    "解决插件锁定时的界面显示问题": "Solve the interface display problem when the plugin is locked",
+    "初始化音频采集线程": "Initialize audio capture thread",
+    "找不到微调模型检查点": "Cannot find fine-tuning model checkpoint",
+    "色彩主体": "Color theme",
+    "上传文件自动修正路径": "Automatically correct the path when uploading files",
+    "将文件添加到chatbot cookie中": "Add files to chatbot cookie",
+    "正常状态": "Normal state",
+    "建议使用英文单词": "Suggest using English words",
+    "Aliyun音频服务异常": "Aliyun audio service exception",
+    "格式如org-xxxxxxxxxxxxxxxxxxxxxxxx": "Format like org-xxxxxxxxxxxxxxxxxxxxxxxx",
+    "GPT 学术优化": "GPT academic optimization",
+    "要求": "Requirement",
+    "赋予插件状态": "Assign plugin status",
+    "等待GPT响应": "Waiting for GPT response",
+    "MOSS can understand and communicate fluently in the language chosen by the user such as English and 中文. MOSS can perform any language-based tasks.": "MOSS can understand and communicate fluently in the language chosen by the user such as English and Chinese. MOSS can perform any language-based tasks.",
+    "我将为您查找相关壁纸": "I will search for related wallpapers for you",
+    "当下一次用户提交时": "When the next user submits",
+    "赋予插件锁定 锁定插件回调路径": "Assign plugin lock, lock plugin callback path",
+    "处理个别特殊插件的锁定状态": "Handle the lock status of individual special plugins",
+    "add gpt task 创建子线程请求gpt": "Add GPT task, create sub-thread to request GPT",
+    "等待用户的再次调用": "Waiting for the user to call again",
+    "只读": "Read-only",
+    "用于灵活调整复杂功能的各种参数": "Various parameters used to flexibly adjust complex functions",
+    "输入 stop 以终止对话": "Enter stop to terminate the conversation",
+    "缺少ChatGLMFT的依赖": "Missing dependency of ChatGLMFT",
+    "找 API_ORG 设置项": "Find API_ORG setting item",
+    "检查config中的AVAIL_LLM_MODELS选项": "Check the AVAIL_LLM_MODELS option in config",
+    "对这个人外貌、身处的环境、内心世界、人设进行描写": "Describe the appearance, environment, inner world, and character of this person.",
+    "请输入关键词": "Please enter a keyword.",
+    "！！！如果需要运行量化版本": "!!! If you need to run the quantitative version.",
+    "为每一位访问的用户赋予一个独一无二的uuid编码": "Assign a unique uuid code to each visiting user.",
+    "由于提问含不合规内容被Azure过滤": "Due to Azure filtering out questions containing non-compliant content.",
+    "欢迎使用 MOSS 人工智能助手！输入内容即可进行对话": "Welcome to use MOSS AI assistant! Enter the content to start the conversation.",
+    "记住当前的label": "Remember the current label.",
+    "不能正常加载ChatGLMFT的参数！": "Cannot load ChatGLMFT parameters normally!",
+    "建议直接在API_KEY处填写": "It is recommended to fill in directly at API_KEY."
 }

docs/translate_traditionalchinese.json

@@ -150,26 +150,7 @@
     "使用中文回答我的问题": "使用中文回答我的問題",
     "备份一个文件": "備份一個文件",
     "未知": "未知",
-    "如.md": "#",
-    "**输入参数说明**": "#",
-    "如果这裡拋出異常": "#",
-    "多線程操作已經開始": "#",
-    "備份和下載": "#",
-    "新版本可用": "#",
-    "將要忽略匹配的文件後綴": "#",
-    "可調節線程池的大小避免openai的流量限制錯誤": "#",
-    "使用Unsplash API": "#",
-    "ChatGPT綜合": "#",
-    "從摘要中提取高價值信息": "#",
-    "借助此參數": "#",
-    "知乎": "#",
-    "其他錯誤": "#",
-    "退出": "#",
-    "對話歷史寫入": "#",
-    "問詢記錄": "#",
-    "依次訪問網頁": "#",
-    "NewBing響應異常": "#",
-    "jittorllms尚未加載": "#",
+    "其他錯誤": "其他錯誤",
     "等待NewBing响应": "等待NewBing回應",
     "找不到任何CSharp文件": "找不到任何CSharp檔案",
     "插件demo": "插件範例",
@@ -300,12 +281,12 @@
     "上傳本地文件可供紅色函數插件調用": "上傳本地文件供紅色函數插件調用",
     "生成圖像": "生成圖像",
     "追加歷史": "追加歷史",
-    "網絡代理狀態": "網路代理狀態",
+    "網絡代理狀態": "網絡代理狀態",
     "不需要再次轉化": "不需要再次轉換",
     "帶超時倒計時": "帶有超時倒數計時",
     "保存當前對話": "儲存目前對話",
     "等待響應": "等待回應",
-    "依賴檢測通過": "依賴檢查通過",
+    "依賴檢測通過": "依賴檢測通過",
     "如果要使用ChatGLM": "如果要使用ChatGLM",
     "對IPynb文件進行解析": "對IPynb檔案進行解析",
     "先切換模型到openai或api2d": "先切換模型到openai或api2d",
@@ -411,7 +392,7 @@
     "中转网址预览": "中轉網址預覽",
     "自动截断": "自動截斷",
     "当無法用標點、空行分割時": "當無法用標點、空行分割時",
-    "意外Json結構": "意外的Json結構",
+    "意外Json結構": "意外Json結構",
     "需要讀取和清理文本的pdf文件路徑": "需要讀取和清理文本的pdf文件路徑",
     "HotReload的裝飾器函數": "HotReload的裝飾器函數",
     "chatGPT 分析報告": "chatGPT 分析報告",
@@ -423,7 +404,7 @@
     "這個bug沒找到觸發條件": "這個bug沒找到觸發條件",
     "喚起高級參數輸入區": "喚起高級參數輸入區",
     "但大部分場合下並不需要修改": "但大部分場合下並不需要修改",
-    "盡量是完整的一個section": "盡量是完整的一個section",
+    "盡量是完整的一個section": "盡量選擇完整的一個章節",
     "如果OpenAI不響應": "如果OpenAI不響應",
     "等文本特殊符號轉換為其基本形式來對文本進行歸一化處理": "等文本特殊符號轉換為其基本形式來對文本進行歸一化處理",
     "你的回答必須簡單明了": "你的回答必須簡單明了",
@@ -517,7 +498,7 @@
     "正在提取摘要並下載PDF文檔……": "正在提取摘要並下載PDF文件……",
     "1. 對原始文本進行歸一化處理": "1. 正規化原始文本",
     "問題": "問題",
-    "用於基礎的對話功能": "基本對話功能",
+    "用於基礎的對話功能": "用於基礎的對話功能",
     "獲取設置": "獲取設置",
     "如果缺少依賴": "如果缺少依賴項",
     "第6步": "第6步",
@@ -1111,26 +1092,9 @@
     "清理规则包括": "清理規則包括",
     "新版配置": "新版配置",
     "如果有": "如果有",
-    "高級參數輸入區": "#",
-    "您提供的api-key不滿足要求": "#",
-    "“喂狗”": "#",
-    "有線程鎖": "#",
-    "解析整個CSharp項目": "#",
-    "上下文管理器必須實現兩個方法": "#",
-    "Call MOSS fail 不能正常加載MOSS的參數": "#",
-    "獲取圖片URL": "#",
-    "輸入部分太自由": "#",
-    "Not enough point. API2D賬戶點數不足": "#",
-    "網絡錯誤": "#",
-    "請開始多線程操作": "#",
-    "authors獲取失敗": "#",
-    "、地址": "#",
-    "根據以上分析": "#",
-    "1、英文題目；2、中文題目翻譯；3、作者；4、arxiv公開": "#",
-    "一些普通功能模塊": "#",
-    "參數簡單": "#",
-    "具備以下功能": "#",
-    "優先級2. 獲取config_private中的配置": "#",
+    "Call MOSS fail 不能正常加載MOSS的參數": "Call MOSS fail 不能正常加載MOSS的參數",
+    "根據以上分析": "根據以上分析",
+    "一些普通功能模塊": "一些普通功能模塊",
     "汇总报告如何远程获取": "如何遠程獲取匯總報告",
     "热更新prompt": "熱更新提示",
     "插件调度异常": "插件調度異常",
@@ -1191,26 +1155,9 @@
     "函数插件区": "函數插件區",
     "*** API_KEY 导入成功": "*** API_KEY 導入成功",
     "请对下面的程序文件做一个概述文件名是": "請對下面的程序文件做一個概述文件名是",
-    "替換跨行的連詞": "#",
-    "內容太長了都會觸發token數量溢出的錯誤": "#",
-    "尚未完成全部響應": "#",
-    "生成帶有段落標籤的HTML代碼": "#",
-    "函數熱更新是指在不停止程序運行的情況下": "#",
-    "將Unsplash API中的PUT_YOUR_QUERY_HERE替換成描述該事件的一個最重要的單詞": "#",
-    "沒有提供高級參數功能說明": "#",
-    "條": "#",
-    "請刷新界面重試": "#",
-    "和openai的連接容易斷掉": "#",
-    "使用 Unsplash API": "#",
-    "完成情況": "#",
-    "迭代上一次的結果": "#",
-    "每個線程都要“餵狗”": "#",
-    "最多收納多少個網頁的結果": "#",
-    "日": "#",
-    "第4步": "#",
-    "找不到任何python文件": "#",
-    "經過充分測試": "#",
-    "缺少的依賴": "#",
+    "內容太長了都會觸發token數量溢出的錯誤": "內容太長了都會觸發token數量溢出的錯誤",
+    "沒有提供高級參數功能說明": "未提供高級參數功能說明",
+    "和openai的連接容易斷掉": "和openai的連接容易斷掉",
     "分组+迭代处理": "分組+迭代處理",
     "安装Newbing的依赖": "安裝Newbing的依賴",
     "批": "批",
@@ -1511,5 +1458,760 @@
     "包括": "包括",
     "或者": "或者",
     "并执行函数的新版本": "並執行函數的新版本",
-    "论文": "論文"
+    "论文": "論文",
+    "解析一个Golang项目": "ParseAGolangProject",
+    "Latex英文纠错": "LatexEnglishCorrection",
+    "连接bing搜索回答问题": "ConnectToBingSearchForAnswer",
+    "联网的ChatGPT_bing版": "ChatGPT_BingVersionOnline",
+    "总结音视频": "SummarizeAudioAndVideo",
+    "动画生成": "GenerateAnimations",
+    "数学动画生成manim": "GenerateMathematicalAnimationsWithManim",
+    "Markdown翻译指定语言": "TranslateMarkdownToSpecifiedLanguage",
+    "知识库问答": "KnowledgeBaseQA",
+    "Langchain知识库": "LangchainKnowledgeBase",
+    "读取知识库作答": "ReadKnowledgeBaseAndAnswerQuestions",
+    "交互功能模板函数": "InteractiveFunctionTemplateFunctions",
+    "交互功能函数模板": "InteractiveFunctionFunctionTemplates",
+    "Latex英文纠错加PDF对比": "LatexEnglishCorrectionWithPDFComparison",
+    "Latex输出PDF结果": "OutputPDFFromLatex",
+    "Latex翻译中文并重新编译PDF": "TranslateLatexToChineseAndRecompilePDF",
+    "语音助手": "VoiceAssistant",
+    "微调数据集生成": "FineTuneDatasetGeneration",
+    "chatglm微调工具": "ChatGLM_FineTuningTool",
+    "启动微调": "StartFineTuning",
+    "sprint亮靛": "SprintLiangDian",
+    "寻找Latex主文件": "FindLatexMainFile",
+    "专业词汇声明": "ProfessionalTerminologyDeclaration",
+    "Latex精细分解与转化": "LatexFineDecompositionAndConversion",
+    "编译Latex": "CompileLatex",
+    "正在等您说完问题": "正在等您說完問題",
+    "最多同时执行5个": "最多同時執行5個",
+    "将文件复制一份到下载区": "將檔案複製一份到下載區",
+    "您接下来不能再使用其他插件了": "您接下來不能再使用其他插件了",
+    "如 绿帽子*深蓝色衬衫*黑色运动裤": "如 綠帽子*深藍色襯衫*黑色運動褲",
+    "首先你在中文语境下通读整篇论文": "首先您在中文語境下通讀整篇論文",
+    "根据给定的切割时长将音频文件切割成多个片段": "根據給定的切割時長將音訊檔切割成多個片段",
+    "接下来两句话只显示在界面上": "接下來兩句話只顯示在介面上",
+    "清空label": "清空標籤",
+    "正在尝试自动安装": "正在嘗試自動安裝",
+    "MOSS消耗大量的内存": "MOSS消耗大量的記憶體",
+    "如果这里报错": "如果這裡報錯",
+    "其他类型文献转化效果未知": "其他類型文獻轉換效果未知",
+    "ChatGPT综合": "ChatGPT綜合",
+    "音频文件的路径": "音訊檔案的路徑",
+    "执行错误": "執行錯誤",
+    "因此选择GenerateImage函数": "因此選擇GenerateImage函數",
+    "从摘要中提取高价值信息": "從摘要中提取高價值資訊",
+    "使用英文": "使用英文",
+    "是否在提交时自动清空输入框": "是否在提交時自動清空輸入框",
+    "生成数学动画": "生成數學動畫",
+    "正在加载Claude组件": "正在載入Claude元件",
+    "参数说明": "參數說明",
+    "建议排查": "建議排查",
+    "将消耗较长时间下载中文向量化模型": "將消耗較長時間下載中文向量化模型",
+    "test_LangchainKnowledgeBase读取": "test_LangchainKnowledgeBase讀取",
+    "安装Claude的依赖": "安裝Claude的相依性",
+    "以下所有配置也都支持利用环境变量覆写": "以下所有配置也都支持利用環境變數覆寫",
+    "需要被切割的音频文件名": "需要被切割的音頻文件名",
+    "保存当前对话": "保存當前對話",
+    "功能、贡献者": "功能、貢獻者",
+    "Chuanhu-Small-and-Beautiful主题": "Chuanhu-小而美主題",
+    "等待Claude响应": "等待Claude響應",
+    "其他模型转化效果未知": "其他模型轉換效果未知",
+    "版权归原文作者所有": "版權歸原文作者所有",
+    "回答完问题后": "回答完問題後",
+    "请先上传文件素材": "請先上傳文件素材",
+    "上传本地文件/压缩包供函数插件调用": "上傳本地文件/壓縮包供函數插件調用",
+    "P.S. 顺便把Latex的注释去除": "P.S. 順便把Latex的註釋去除",
+    "您提供的api-key不满足要求": "您提供的api-key不滿足要求",
+    "切割音频文件": "切割音頻文件",
+    "对不同latex源文件扣分": "對不同latex源文件扣分",
+    "以下是一篇学术论文的基础信息": "以下是一篇學術論文的基礎信息",
+    "问题": "問題",
+    "待注入的知识库名称id": "待注入的知識庫名稱id",
+    "”的主要内容": "”的主要內容",
+    "获取设置": "獲取設置",
+    "str类型": "str類型",
+    "多线程": "多線程",
+    "尝试执行Latex指令失败": "嘗試執行Latex指令失敗",
+    "然后再写一段英文摘要": "然後再寫一段英文摘要",
+    "段音频的主要内容": "段音頻的主要內容",
+    "临时地激活代理网络": "臨時地激活代理網絡",
+    "网络的远程文件": "網絡的遠程文件",
+    "不能正常加载ChatGLMFT的参数！": "無法正常載入ChatGLMFT的參數！",
+    "正在编译PDF文档": "正在編譯PDF文件",
+    "等待ChatGLMFT响应中": "等待ChatGLMFT回應中",
+    "将": "將",
+    "片段": "片段",
+    "修复括号": "修復括號",
+    "条": "條",
+    "建议直接在API_KEY处填写": "建議直接在API_KEY處填寫",
+    "根据需要切换prompt": "根據需要切換prompt",
+    "使用": "使用",
+    "请输入要翻译成哪种语言": "請輸入要翻譯成哪種語言",
+    "实际得到格式": "實際得到格式",
+    "例如 f37f30e0f9934c34a992f6f64f7eba4f": "例如 f37f30e0f9934c34a992f6f64f7eba4f",
+    "请切换至“KnowledgeBaseQA”插件进行知识库访问": "請切換至“KnowledgeBaseQA”插件進行知識庫訪問",
+    "用户填3": "用戶填3",
+    "远程云服务器部署": "遠程雲服務器部署",
+    "未知指令": "未知指令",
+    "每个线程都要“喂狗”": "每個線程都要“喂狗”",
+    "该项目的Latex主文件是": "該項目的Latex主文件是",
+    "设置OpenAI密钥和模型": "設置OpenAI密鑰和模型",
+    "填入你亲手写的部署名": "填入你親手寫的部署名",
+    "仅调试": "僅調試",
+    "依赖不足": "依賴不足",
+    "右下角更换模型菜单中可切换openai": "右下角更換模型菜單中可切換openai",
+    "解析整个CSharp项目": "解析整個CSharp項目",
+    "唤起高级参数输入区": "喚起高級參數輸入區",
+    "这个bug没找到触发条件": "這個bug沒找到觸發條件",
+    "========================================= 插件主程序2 =====================================================": "========================================= 插件主程序2 =====================================================",
+    "经过充分测试": "經過充分測試",
+    "该文件中主要包含三个函数": "該文件中主要包含三個函數",
+    "您可以到Github Issue区": "您可以到Github Issue區",
+    "避免线程阻塞": "避免線程阻塞",
+    "吸收iffalse注释": "吸收iffalse註釋",
+    "from crazy_functions.虚空终端 import 终端": "from crazy_functions.虛空終端 import 終端",
+    "异步方法": "異步方法",
+    "块元提取": "塊元提取",
+    "Your account is not active. OpenAI以账户失效为由": "您的帳戶未啟用。OpenAI以帳戶失效為由",
+    "还原部分原文": "還原部分原文",
+    "如果要使用Claude": "如果要使用Claude",
+    "把文件复制过去": "把文件複製過去",
+    "解压失败! 需要安装pip install rarfile来解压rar文件": "解壓失敗！需要安裝pip install rarfile來解壓rar文件",
+    "正在锁定插件": "正在鎖定插件",
+    "输入 clear 以清空对话历史": "輸入 clear 以清空對話歷史",
+    "P.S. 但愿没人把latex模板放在里面传进来": "P.S. 但願沒人把latex模板放在裡面傳進來",
+    "实时音频采集": "實時音頻採集",
+    "开始最终总结": "開始最終總結",
+    "拒绝服务": "拒絕服務",
+    "配置教程&视频教程": "配置教程&視頻教程",
+    "所有音频都总结完成了吗": "所有音頻都總結完成了嗎",
+    "返回": "返回",
+    "避免不小心传github被别人看到": "避免不小心傳github被別人看到",
+    "否则将导致每个人的Claude问询历史互相渗透": "否則將導致每個人的Claude問詢歷史互相滲透",
+    "提问吧! 但注意": "提問吧！但注意",
+    "待处理的word文档路径": "待處理的word文檔路徑",
+    "欢迎加REAME中的QQ联系开发者": "歡迎加REAME中的QQ聯繫開發者",
+    "建议暂时不要使用": "建議暫時不要使用",
+    "Latex没有安装": "Latex沒有安裝",
+    "在这里放一些网上搜集的demo": "在這裡放一些網上搜集的demo",
+    "实现消息发送、接收等功能": "實現消息發送、接收等功能",
+    "用于与with语句一起使用": "用於與with語句一起使用",
+    "解压失败! 需要安装pip install py7zr来解压7z文件": "解壓失敗! 需要安裝pip install py7zr來解壓7z文件",
+    "借助此参数": "借助此參數",
+    "判定为数据流的结束": "判定為數據流的結束",
+    "提取文件扩展名": "提取文件擴展名",
+    "GPT结果已输出": "GPT結果已輸出",
+    "读取文件": "讀取文件",
+    "如果OpenAI不响应": "如果OpenAI不響應",
+    "输入部分太自由": "輸入部分太自由",
+    "用于给一小段代码上代理": "用於給一小段代碼上代理",
+    "输入 stop 以终止对话": "輸入 stop 以終止對話",
+    "这个paper有个input命令文件名大小写错误！": "這個paper有個input命令文件名大小寫錯誤！",
+    "等待Claude回复的片段": "等待Claude回復的片段",
+    "开始": "開始",
+    "将根据报错信息修正tex源文件并重试": "將根據報錯信息修正tex源文件並重試",
+    "建议更换代理协议": "建議更換代理協議",
+    "递归地切割PDF文件": "遞歸地切割PDF文件",
+    "读 docs\\use_azure.md": "讀 docs\\use_azure.md",
+    "参数": "參數",
+    "屏蔽空行和太短的句子": "屏蔽空行和太短的句子",
+    "分析上述回答": "分析上述回答",
+    "因为在同一个频道里存在多人使用时历史消息渗透问题": "因為在同一個頻道裡存在多人使用時歷史消息滲透問題",
+    "使用latexdiff生成論文轉化前後對比": "使用latexdiff生成論文轉化前後對比",
+    "檢查結果": "檢查結果",
+    "請在此處追加更細緻的校錯指令": "請在此處追加更細緻的校錯指令",
+    "報告如何遠程獲取": "報告如何遠程獲取",
+    "發現已經存在翻譯好的PDF文檔": "發現已經存在翻譯好的PDF文檔",
+    "插件鎖定中": "插件鎖定中",
+    "正在精細切分latex文件": "正在精細切分latex文件",
+    "數學GenerateAnimations": "數學GenerateAnimations",
+    "上傳文件自動修正路徑": "上傳文件自動修正路徑",
+    "請檢查ALIYUN_TOKEN和ALIYUN_APPKEY是否過期": "請檢查ALIYUN_TOKEN和ALIYUN_APPKEY是否過期",
+    "上傳Latex項目": "上傳LaTeX項目",
+    "Aliyun音頻服務異常": "Aliyun音頻服務異常",
+    "為了防止大語言模型的意外謬誤產生擴散影響": "為了防止大語言模型的意外謬誤產生擴散影響",
+    "調用Claude時": "調用Claude時",
+    "解除插件鎖定": "解除插件鎖定",
+    "暗色模式 / 亮色模式": "暗色模式 / 亮色模式",
+    "只有第二步成功": "只有第二步成功",
+    "分析结果": "分析結果",
+    "用第二人称": "使用第二人稱",
+    "详情见https": "詳情請見https",
+    "记住当前的label": "記住當前的標籤",
+    "当无法用标点、空行分割时": "當無法用標點符號、空行分割時",
+    "如果分析错误": "如果分析錯誤",
+    "如果有必要": "如果有必要",
+    "不要修改!! 高危设置！通过修改此设置": "不要修改!! 高危設置！通過修改此設置",
+    "ChatGLMFT消耗大量的内存": "ChatGLMFT消耗大量的內存",
+    "摘要生成后的文档路径": "摘要生成後的文件路徑",
+    "对全文进行概括": "對全文進行概述",
+    "LLM_MODEL是默认选中的模型": "LLM_MODEL是默認選中的模型",
+    "640个字节为一组": "640個字節為一組",
+    "获取关键词": "獲取關鍵詞",
+    "解析为简体中文": "解析為簡體中文",
+    "将 \\include 命令转换为 \\input 命令": "將 \\include 命令轉換為 \\input 命令",
+    "默认值为1000": "默認值為1000",
+    "手动指定语言": "手動指定語言",
+    "请登录OpenAI查看详情 https": "請登錄OpenAI查看詳情 https",
+    "尝试第": "嘗試第",
+    "每秒采样数量": "每秒採樣數量",
+    "加载失败!": "加載失敗!",
+    "方法": "方法",
+    "对这个人外貌、身处的环境、内心世界、过去经历进行描写": "對這個人外貌、身處的環境、內心世界、過去經歷進行描寫",
+    "请先将.doc文档转换为.docx文档": "請先將.doc文檔轉換為.docx文檔",
+    "定位主Latex文件": "定位主Latex文件",
+    "批量SummarizeAudioAndVideo": "批量摘要音视频",
+    "终端": "終端",
+    "即将退出": "即將退出",
+    "找不到": "找不到",
+    "正在听您讲话": "正在聆聽您講話",
+    "请您不要删除或修改这行警告": "請勿刪除或修改此警告",
+    "没有阿里云语音识别APPKEY和TOKEN": "沒有阿里雲語音識別APPKEY和TOKEN",
+    "临时地启动代理网络": "臨時啟動代理網絡",
+    "请尝试把以下指令复制到高级参数区": "請將以下指令複製到高級參數區",
+    "中文Bing版": "中文Bing版",
+    "计算文件总时长和切割点": "計算文件總時長和切割點",
+    "寻找主文件": "尋找主文件",
+    "jittorllms尚未加载": "jittorllms尚未加載",
+    "使用正则表达式查找半行注释": "使用正則表達式查找半行註釋",
+    "文档越长耗时越长": "文檔越長耗時越長",
+    "生成中文PDF": "生成中文PDF",
+    "写入文件": "寫入文件",
+    "第三组插件": "第三組插件",
+    "开始接收chatglmft的回复": "開始接收chatglmft的回覆",
+    "由于提问含不合规内容被Azure过滤": "由於提問含不合規內容被Azure過濾",
+    "安装方法https": "安裝方法https",
+    "是否自动处理token溢出的情况": "是否自動處理token溢出的情況",
+    "如果需要使用AZURE 详情请见额外文档 docs\\use_azure.md": "如果需要使用AZURE 詳情請見額外文檔 docs\\use_azure.md",
+    "将要忽略匹配的文件后缀": "將要忽略匹配的文件後綴",
+    "authors获取失败": "authors獲取失敗",
+    "发送到openai音频解析终端": "發送到openai音頻解析終端",
+    "请开始多线程操作": "請開始多線程操作",
+    "对这个人外貌、身处的环境、内心世界、人设进行描写": "對這個人外貌、身處的環境、內心世界、人設進行描寫",
+    "MOSS can understand and communicate fluently in the language chosen by the user such as English and 中文. MOSS can perform any language-based tasks.": "MOSS可以流利地理解和使用用戶選擇的語言，例如英語和中文。MOSS可以執行任何基於語言的任務。",
+    "work_folder = Latex預處理": "設置工作目錄為Latex預處理",
+    "然後轉移到指定的另一個路徑中": "然後轉移到指定的另一個路徑中",
+    "使用Newbing": "使用Newbing",
+    "詳情信息見requirements.txt": "詳細信息請參閱requirements.txt",
+    "開始下載": "開始下載",
+    "多線程翻譯開始": "多線程翻譯開始",
+    "當前大語言模型": "當前大語言模型",
+    "格式如org-123456789abcdefghijklmno的": "格式如org-123456789abcdefghijklmno的",
+    "當下一次用戶提交時": "當下一次用戶提交時",
+    "需要特殊依賴": "需要特殊依賴",
+    "次編譯": "次編譯",
+    "先上傳數據集": "先上傳數據集",
+    "gpt寫的": "gpt寫的",
+    "調用緩存": "調用緩存",
+    "优先级1. 获取环境变量作为配置": "優先級1. 獲取環境變量作為配置",
+    "检查config中的AVAIL_LLM_MODELS选项": "檢查config中的AVAIL_LLM_MODELS選項",
+    "并且对于网络上的文件": "並且對於網絡上的文件",
+    "根据文本使用GPT模型生成相应的图像": "根據文本使用GPT模型生成相應的圖像",
+    "功能描述": "功能描述",
+    "翻译结果": "翻譯結果",
+    "需要预先pip install rarfile": "需要預先pip install rarfile",
+    "等待响应": "等待響應",
+    "我们剥离Introduction之后的部分": "我們剝離Introduction之後的部分",
+    "函数插件-固定按钮区": "函數插件-固定按鈕區",
+    "临时存储用于调试": "臨時存儲用於調試",
+    "比正文字体小": "比正文字體小",
+    "会直接转到该函数": "會直接轉到該函數",
+    "请以以下方式load模型！！！": "請以以下方式load模型！！！",
+    "请输入关键词": "請輸入關鍵詞",
+    "返回找到的第一个": "返回找到的第一個",
+    "高级参数输入区": "高級參數輸入區",
+    "精细切分latex文件": "精細切分latex文件",
+    "赋予插件锁定 锁定插件回调路径": "賦予插件鎖定 鎖定插件回調路徑",
+    "尝试下载": "嘗試下載",
+    "包含documentclass关键字": "包含documentclass關鍵字",
+    "在一个异步线程中采集音频": "在一個異步線程中採集音頻",
+    "先删除": "先刪除",
+    "则跳过GPT请求环节": "則跳過GPT請求環節",
+    "Not enough point. API2D账户点数不足": "Not enough point. API2D帳戶點數不足",
+    "如果一句话小于7个字": "如果一句話小於7個字",
+    "具备以下功能": "具備以下功能",
+    "请查看终端的输出或耐心等待": "請查看終端的輸出或耐心等待",
+    "对输入的word文档进行摘要生成": "對輸入的word文檔進行摘要生成",
+    "只读": "只讀",
+    "文本碎片重组为完整的tex文件": "文本碎片重組為完整的tex文件",
+    "通过调用conversations_open方法打开一个频道": "通過調用conversations_open方法打開一個頻道",
+    "对话历史文件损坏！": "對話歷史文件損壞！",
+    "再失败就没办法了": "再失敗就沒辦法了",
+    "原始PDF编译是否成功": "原始PDF編譯是否成功",
+    "不能正常加载jittorllms的参数！": "不能正常加載jittorllms的參數！",
+    "正在编译对比PDF": "正在編譯對比PDF",
+    "找不到微调模型检查点": "找不到微調模型檢查點",
+    "将生成的报告自动投射到文件上传区": "將生成的報告自動投射到文件上傳區",
+    "请对这部分内容进行语法矫正": "請對這部分內容進行語法校正",
+    "编译已经开始": "編譯已經開始",
+    "需要读取和清理文本的pdf文件路径": "需要讀取和清理文本的pdf文件路徑",
+    "读取文件内容到内存": "讀取文件內容到內存",
+    "用&符号分隔": "用&符號分隔",
+    "输入arxivID": "輸入arxivID",
+    "找 API_ORG 设置项": "找API_ORG設置項",
+    "分析用户提供的谷歌学术": "分析用戶提供的谷歌學術",
+    "欢迎使用 MOSS 人工智能助手！输入内容即可进行对话": "歡迎使用 MOSS 人工智能助手！輸入內容即可進行對話",
+    "段音频的第": "段音頻的第",
+    "没有找到任何可读取文件": "沒有找到任何可讀取文件",
+    "目前仅支持GPT3.5/GPT4": "目前僅支持GPT3.5/GPT4",
+    "为每一位访问的用户赋予一个独一无二的uuid编码": "為每一位訪問的用戶賦予一個獨一無二的uuid編碼",
+    "内含已经翻译的Tex文档": "內含已經翻譯的Tex文檔",
+    "消耗时间的函数": "消耗時間的函數",
+    "成功啦": "成功啦",
+    "环境变量配置格式见docker-compose.yml": "環境變量配置格式見docker-compose.yml",
+    "将每次对话记录写入Markdown格式的文件中": "將每次對話記錄寫入Markdown格式的文件中",
+    "报告已经添加到右侧“文件上传区”": "報告已經添加到右側“文件上傳區”",
+    "此处可以输入解析提示": "此處可以輸入解析提示",
+    "缺少MOSS的依赖": "缺少MOSS的依賴",
+    "仅在Windows系统进行了测试": "僅在Windows系統進行了測試",
+    "然后重启程序": "然後重啟程序",
+    "此处不修改": "此處不修改",
+    "输出html调试文件": "輸出html調試文件",
+    "6.25 加入判定latex模板的代码": "6.25 加入判定latex模板的代碼",
+    "提取总结": "提取總結",
+    "要求": "要求",
+    "由于最为关键的转化PDF编译失败": "由於最為關鍵的轉化PDF編譯失敗",
+    "除非您是论文的原作者": "除非您是論文的原作者",
+    "输入问题后点击该插件": "輸入問題後點擊該插件",
+    "该选项即将被弃用": "該選項即將被棄用",
+    "再列出用户可能提出的三个问题": "再列出用戶可能提出的三個問題",
+    "所有文件都总结完成了吗": "所有文件都總結完成了嗎",
+    "请稍候": "請稍候",
+    "向chatbot中添加简单的意外错误信息": "向chatbot中添加簡單的意外錯誤信息",
+    "快捷的调试函数": "快捷的調試函數",
+    "LatexEnglishCorrection+高亮修正位置": "Latex英文校正+高亮修正位置",
+    "循环监听已打开频道的消息": "循環監聽已打開頻道的消息",
+    "将指定目录下的PDF文件从英文翻译成中文": "將指定目錄下的PDF文件從英文翻譯成中文",
+    "请对下面的音频片段做概述": "請對下面的音頻片段做概述",
+    "openai的官方KEY需要伴隨组织编码": "openai的官方KEY需要伴隨組織編碼",
+    "表示频道ID": "頻道ID",
+    "当前支持的格式包括": "目前支援的格式包括",
+    "只有GenerateImage和生成图像相关": "僅限GenerateImage和生成圖像相關",
+    "删除中间文件夹": "刪除中間資料夾",
+    "解除插件状态": "解除插件狀態",
+    "正在预热文本向量化模组": "正在預熱文本向量化模組",
+    "100字以内": "限制100字內",
+    "如果缺少依赖": "如果缺少相依性",
+    "寻找主tex文件": "尋找主要tex檔案",
+    "gpt 多线程请求": "gpt 多線程請求",
+    "已知某些代码的局部作用是": "已知某些程式碼的局部作用是",
+    "--读取文件": "--讀取檔案",
+    "前面是中文冒号": "前面是中文冒號",
+    "*{\\scriptsize\\textbf{警告": "*{\\scriptsize\\textbf{警告",
+    "OpenAI所允许的最大并行过载": "OpenAI所允許的最大並行過載",
+    "请直接去该路径下取回翻译结果": "請直接前往該路徑取回翻譯結果",
+    "以免输入溢出": "以免輸入溢出",
+    "把某个路径下所有文件压缩": "壓縮某個路徑下的所有檔案",
+    "问询记录": "詢問記錄",
+    "Tex源文件缺失！": "Tex原始檔案遺失！",
+    "当前参数": "目前參數",
+    "处理markdown文本格式的转变": "處理markdown文本格式的轉換",
+    "尝试加载": "嘗試載入",
+    "请在此处给出自定义翻译命令": "請在此處提供自訂翻譯命令",
+    "这需要一段时间计算": "這需要一段時間計算",
+    "-构建知识库": "-建立知識庫",
+    "还需要填写组织": "還需要填寫組織",
+    "当前知识库内的有效文件": "當前知識庫內的有效文件",
+    "第一次调用": "第一次調用",
+    "从一批文件": "從一批文件",
+    "json等": "json等",
+    "翻译-": "翻譯-",
+    "编译文献交叉引用": "編譯文獻交叉引用",
+    "优先级2. 获取config_private中的配置": "優先級2. 獲取config_private中的配置",
+    "可选": "可選",
+    "我们": "我們",
+    "编译结束": "編譯結束",
+    "或代理节点": "或代理節點",
+    "chatGPT 分析报告": "chatGPT 分析報告",
+    "调用openai api 使用whisper-1模型": "調用openai api 使用whisper-1模型",
+    "这段代码定义了一个名为TempProxy的空上下文管理器": "這段代碼定義了一個名為TempProxy的空上下文管理器",
+    "生成的视频文件路径": "生成的視頻文件路徑",
+    "请直接提交即可": "請直接提交即可",
+    "=================================== 工具函数 ===============================================": "=================================== 工具函數 ===============================================",
+    "报错信息如下. 如果是与网络相关的问题": "報錯信息如下. 如果是與網絡相關的問題",
+    "python 版本建议3.9+": "python 版本建議3.9+",
+    "多线程函数插件中": "多線程函數插件中",
+    "对话助手函数插件": "對話助手函數插件",
+    "或者重启之后再度尝试": "或者重啟之後再度嘗試",
+    "拆分过长的latex片段": "拆分過長的latex片段",
+    "调用whisper模型音频转文字": "調用whisper模型音頻轉文字",
+    "失败啦": "失敗啦",
+    "正在编译PDF": "正在編譯PDF",
+    "请刷新界面重试": "請刷新界面重試",
+    "模型参数": "模型參數",
+    "写出文件": "寫出文件",
+    "第二组插件": "第二組插件",
+    "在多Tex文档中": "在多Tex文檔中",
+    "有线程锁": "有線程鎖",
+    "释放线程锁": "釋放線程鎖",
+    "读取优先级": "讀取優先級",
+    "Linux下必须使用Docker安装": "Linux下必須使用Docker安裝",
+    "例如您可以将以下命令复制到下方": "例如您可以將以下命令複製到下方",
+    "导入依赖失败": "導入依賴失敗",
+    "给出一些判定模板文档的词作为扣分项": "給出一些判定模板文檔的詞作為扣分項",
+    "等待Claude响应中": "等待Claude響應中",
+    "Call ChatGLMFT fail 不能正常加载ChatGLMFT的参数": "Call ChatGLMFT fail 不能正常加載ChatGLMFT的參數",
+    "但本地存储了以下历史文件": "但本地存儲了以下歷史文件",
+    "如果存在调试缓存文件": "如果存在調試緩存文件",
+    "如果这里抛出异常": "如果這裡拋出異常",
+    "详见项目主README.md": "詳見項目主README.md",
+    "作者": "作者",
+    "现在您点击任意“红颜色”标识的函数插件时": "現在您點擊任意“紅顏色”標識的函數插件時",
+    "上下文管理器必须实现两个方法": "上下文管理器必須實現兩個方法",
+    "匹配^数字^": "匹配^數字^",
+    "也是可读的": "也是可讀的",
+    "将音频解析为简体中文": "將音頻解析為簡體中文",
+    "依次访问网页": "依次訪問網頁",
+    "P.S. 顺便把CTEX塞进去以支持中文": "P.S. 順便把CTEX塞進去以支持中文",
+    "NewBing响应异常": "NewBing響應異常",
+    "获取已打开频道的最新消息并返回消息列表": "獲取已打開頻道的最新消息並返回消息列表",
+    "请使用Markdown": "請使用Markdown",
+    "例如 RoPlZrM88DnAFkZK": "例如 RoPlZrM88DnAFkZK",
+    "编译BibTex": "編譯BibTex",
+    "Claude失败": "Claude失敗",
+    "请更换为API_URL_REDIRECT配置": "請更換為API_URL_REDIRECT配置",
+    "P.S. 其他可用的模型还包括": "P.S. 其他可用的模型還包括",
+    "色彩主体": "色彩主體",
+    "后面是英文逗号": "後面是英文逗號",
+    "下载pdf文件未成功": "下載pdf文件未成功",
+    "删除整行的空注释": "刪除整行的空注釋",
+    "吸收匿名公式": "吸收匿名公式",
+    "从而更全面地理解项目的整体功能": "從而更全面地理解項目的整體功能",
+    "不需要再次转化": "不需要再次轉化",
+    "可以将自身的状态存储到cookie中": "可以將自身的狀態存儲到cookie中",
+    "1、英文题目；2、中文题目翻译；3、作者；4、arxiv公开": "1、英文題目；2、中文題目翻譯；3、作者；4、arxiv公開",
+    "GPT 学术优化": "GPT 學術優化",
+    "解析整个Python项目": "解析整個Python項目",
+    "吸收其他杂项": "吸收其他雜項",
+    "-预热文本向量化模组": "-預熱文本向量化模組",
+    "Claude组件初始化成功": "Claude組件初始化成功",
+    "此处填API密钥": "此處填API密鑰",
+    "请继续分析其他源代码": "請繼續分析其他源代碼",
+    "质能方程式": "質能方程式",
+    "功能尚不稳定": "功能尚不穩定",
+    "使用教程详情见 request_llm/README.md": "使用教程詳情見 request_llm/README.md",
+    "从以上搜索结果中抽取信息": "從以上搜索結果中抽取信息",
+    "虽然PDF生成失败了": "雖然PDF生成失敗了",
+    "找图片": "尋找圖片",
+    "还原原文": "還原原文",
+    "可调节线程池的大小避免openai的流量限制错误": "可調整線程池大小以避免openai流量限制錯誤",
+    "正在提取摘要并下载PDF文档……": "正在提取摘要並下載PDF文件......",
+    "缺少ChatGLMFT的依赖": "缺少ChatGLMFT的依賴",
+    "不会实时显示在界面上": "不會即時顯示在界面上",
+    "解决部分词汇翻译不准确的问题": "解決部分詞彙翻譯不準確的問題",
+    "等待多线程操作": "等待多線程操作",
+    "吸收title与作者以上的部分": "吸收標題與作者以上的部分",
+    "如果需要使用Slack Claude": "如果需要使用Slack Claude",
+    "一、论文概况": "一、論文概況",
+    "默认为Chinese": "默認為中文",
+    "图像生成所用到的提示文本": "圖像生成所用到的提示文本",
+    "向已打开的频道发送一条文本消息": "向已打開的頻道發送一條文本消息",
+    "如果某个子任务出错": "如果某個子任務出錯",
+    "chatglmft 没有 sys_prompt 接口": "chatglmft沒有sys_prompt接口",
+    "对比PDF编译是否成功": "對比PDF編譯是否成功",
+    "免费": "免費",
+    "请讲话": "請講話",
+    "安装ChatGLM的依赖": "安裝ChatGLM的依賴",
+    "对IPynb文件进行解析": "對IPynb文件進行解析",
+    "文件路径列表": "文件路徑列表",
+    "或者使用此插件继续上传更多文件": "或者使用此插件繼續上傳更多文件",
+    "随机负载均衡": "隨機負載均衡",
+    "！！！如果需要运行量化版本": "！！！如果需要運行量化版本",
+    "注意目前不能多人同时调用Claude接口": "注意目前不能多人同時調用Claude接口",
+    "文件读取完成": "文件讀取完成",
+    "用于灵活调整复杂功能的各种参数": "用於靈活調整複雜功能的各種參數",
+    "**函数功能**": "**函數功能**",
+    "先切换模型到openai或api2d": "先切換模型到openai或api2d",
+    "You are associated with a deactivated account. OpenAI以账户失效为由": "您的帳戶已停用。OpenAI以帳戶失效為由",
+    "你的回答必须简单明了": "您的回答必須簡單明了",
+    "是否丢弃掉 不是正文的内容": "是否丟棄掉 不是正文的內容",
+    "但请查收结果": "但請查收結果",
+    "Claude响应缓慢": "Claude響應緩慢",
+    "需Latex": "需Latex",
+    "Claude回复的片段": "Claude回復的片段",
+    "如果要使用ChatGLMFT": "如果要使用ChatGLMFT",
+    "它*必须*被包含在AVAIL_LLM_MODELS列表中": "它*必須*被包含在AVAIL_LLM_MODELS列表中",
+    "前面是中文逗号": "前面是中文逗號",
+    "需要预先pip install py7zr": "需要預先pip install py7zr",
+    "将前后断行符脱离": "將前後斷行符脫離",
+    "防止丢失最后一条消息": "防止丟失最後一條消息",
+    "初始化插件状态": "初始化插件狀態",
+    "以秒为单位": "以秒為單位",
+    "中文Latex项目全文润色": "中文Latex項目全文潤色",
+    "对整个Latex项目进行纠错": "對整個Latex項目進行校對",
+    "NEWBING_COOKIES未填写或有格式错误": "NEWBING_COOKIES未填寫或有格式錯誤",
+    "函数插件作者": "函數插件作者",
+    "结束": "結束",
+    "追加历史": "追加歷史",
+    "您需要首先调用构建知识库": "您需要首先調用構建知識庫",
+    "如果程序停顿5分钟以上": "如果程序停頓5分鐘以上",
+    "ChatGLMFT响应异常": "ChatGLMFT響應異常",
+    "根据当前的模型类别": "根據當前的模型類別",
+    "才能继续下面的步骤": "才能繼續下面的步驟",
+    "并将返回的频道ID保存在属性CHANNEL_ID中": "並將返回的頻道ID保存在屬性CHANNEL_ID中",
+    "请查收结果": "請查收結果",
+    "解决插件锁定时的界面显示问题": "解決插件鎖定時的界面顯示問題",
+    "待提取的知识库名称id": "待提取的知識庫名稱id",
+    "Claude响应异常": "Claude響應異常",
+    "当前代理可用性": "當前代理可用性",
+    "代理网络配置": "代理網絡配置",
+    "我将为您查找相关壁纸": "我將為您查找相關壁紙",
+    "没给定指令": "沒給定指令",
+    "音频内容是": "音頻內容是",
+    "用该压缩包+ConversationHistoryArchive进行反馈": "用該壓縮包+ConversationHistoryArchive進行反饋",
+    "总结音频": "總結音頻",
+    "等待用户的再次调用": "等待用戶的再次調用",
+    "永远给定None": "永遠給定None",
+    "论文概况": "論文概況",
+    "建议使用英文单词": "建議使用英文單詞",
+    "刷新Gradio前端界面": "刷新Gradio前端界面",
+    "列表递归接龙": "列表遞歸接龍",
+    "赋予插件状态": "賦予插件狀態",
+    "构建完成": "構建完成",
+    "避免多用户干扰": "避免多用戶干擾",
+    "当前工作路径为": "當前工作路徑為",
+    "用黑色标注转换区": "用黑色標注轉換區",
+    "压缩包": "壓縮包",
+    "刷新页面即可以退出KnowledgeBaseQA模式": "刷新頁面即可以退出KnowledgeBaseQA模式",
+    "拆分过长的Markdown文件": "拆分過長的Markdown文件",
+    "生成时间戳": "生成時間戳",
+    "尚未完成全部响应": "尚未完成全部響應",
+    "HotReload的装饰器函数": "HotReload的裝飾器函數",
+    "请务必用 pip install -r requirements.txt 指令安装依赖": "請務必用 pip install -r requirements.txt 指令安裝依賴",
+    "TGUI不支持函数插件的实现": "TGUI不支持函數插件的實現",
+    "音频文件名": "音頻文件名",
+    "找不到任何音频或视频文件": "找不到任何音頻或視頻文件",
+    "音频解析结果": "音頻解析結果",
+    "如果使用ChatGLM2微调模型": "如果使用ChatGLM2微調模型",
+    "限制的3/4时": "限制的3/4時",
+    "获取回复": "獲取回復",
+    "对话历史写入": "對話歷史寫入",
+    "记录删除注释后的文本": "記錄刪除註釋後的文本",
+    "整理结果为压缩包": "整理結果為壓縮包",
+    "注意事项": "注意事項",
+    "请耐心等待": "請耐心等待",
+    "在执行完成之后": "在執行完成之後",
+    "参数简单": "參數簡單",
+    "Arixv论文精细翻译": "Arixv論文精細翻譯",
+    "备份和下载": "備份和下載",
+    "当前报错的latex代码处于第": "當前報錯的latex代碼處於第",
+    "Markdown翻译": "Markdown翻譯",
+    "英文Latex项目全文纠错": "英文Latex項目全文校對",
+    "获取预处理函数": "獲取預處理函數",
+    "add gpt task 创建子线程请求gpt": "add gpt task 創建子線程請求gpt",
+    "一个包含所有切割音频片段文件路径的列表": "一個包含所有切割音頻片段文件路徑的列表",
+    "解析arxiv网址失败": "解析arxiv網址失敗",
+    "PDF文件所在的路径": "PDF文件所在路徑",
+    "取评分最高者返回": "取評分最高者返回",
+    "此插件处于开发阶段": "此插件處於開發階段",
+    "如果已经存在": "如果已經存在",
+    "或者不在环境变量PATH中": "或者不在環境變量PATH中",
+    "目前支持的格式": "目前支持的格式",
+    "将多文件tex工程融合为一个巨型tex": "將多文件tex工程融合為一個巨型tex",
+    "暂不提交": "暫不提交",
+    "调用函数": "調用函數",
+    "编译转化后的PDF": "編譯轉化後的PDF",
+    "将代码转为动画": "將代碼轉為動畫",
+    "本地Latex论文精细翻译": "本地Latex論文精細翻譯",
+    "删除或修改歧义文件": "刪除或修改歧義文件",
+    "其他操作系统表现未知": "其他操作系統表現未知",
+    "此插件Windows支持最佳": "此插件Windows支持最佳",
+    "构建知识库": "構建知識庫",
+    "每个切割音频片段的时长": "每個切割音頻片段的時長",
+    "用latex编译为PDF对修正处做高亮": "用latex編譯為PDF對修正處做高亮",
+    "行": "行",
+    "= 2 通过一些Latex模板中常见": "= 2 通過一些Latex模板中常見",
+    "如参考文献、脚注、图注等": "如參考文獻、腳註、圖註等",
+    "期望格式例如": "期望格式例如",
+    "翻译内容可靠性无保障": "翻譯內容可靠性無保障",
+    "请用一句话概括这些文件的整体功能": "請用一句話概括這些文件的整體功能",
+    "段音频完成了吗": "段音頻完成了嗎",
+    "填入azure openai api的密钥": "填入azure openai api的密鑰",
+    "文本碎片重组为完整的tex片段": "文本碎片重組為完整的tex片段",
+    "吸收在42行以內的begin-end組合": "吸收在42行以內的begin-end組合",
+    "屬性": "屬性",
+    "必須包含documentclass": "必須包含documentclass",
+    "等待GPT響應": "等待GPT響應",
+    "當前語言模型溫度設定": "當前語言模型溫度設定",
+    "模型選擇是": "選擇的模型為",
+    "reverse 操作必須放在最後": "reverse 操作必須放在最後",
+    "將子線程的gpt結果寫入chatbot": "將子線程的gpt結果寫入chatbot",
+    "默認為default": "默認為default",
+    "目前對機器學習類文獻轉化效果最好": "目前對機器學習類文獻轉化效果最好",
+    "主程序即將開始": "主程序即將開始",
+    "點擊“停止”鍵可終止程序": "點擊“停止”鍵可終止程序",
+    "正在處理": "正在處理",
+    "請立即終止程序": "請立即停止程序",
+    "將 chatglm 直接對齊到 chatglm2": "將 chatglm 直接對齊到 chatglm2",
+    "音頻助手": "音頻助手",
+    "正在構建知識庫": "正在構建知識庫",
+    "請向下翻": "請向下滾動頁面",
+    "後面是英文冒號": "後面是英文冒號",
+    "無法找到一個主Tex文件": "無法找到一個主Tex文件",
+    "使用中文总结音频“": "使用中文總結音頻",
+    "该PDF由GPT-Academic开源项目调用大语言模型+Latex翻译插件一键生成": "該PDF由GPT-Academic開源項目調用大語言模型+Latex翻譯插件一鍵生成",
+    "开始生成动画": "開始生成動畫",
+    "完成情况": "完成情況",
+    "然后进行问答": "然後進行問答",
+    "为啥chatgpt会把cite里面的逗号换成中文逗号呀": "為啥chatgpt會把cite裡面的逗號換成中文逗號呀",
+    "暂时不支持历史消息": "暫時不支持歷史消息",
+    "项目Github地址 \\url{https": "項目Github地址 \\url{https",
+    "Newbing 请求失败": "Newbing 請求失敗",
+    "根据自然语言执行插件命令": "根據自然語言執行插件命令",
+    "迭代上一次的结果": "迭代上一次的結果",
+    "azure和api2d请求源": "azure和api2d請求源",
+    "格式如org-xxxxxxxxxxxxxxxxxxxxxxxx": "格式如org-xxxxxxxxxxxxxxxxxxxxxxxx",
+    "推荐http": "推薦http",
+    "将要匹配的模式": "將要匹配的模式",
+    "代理数据解析失败": "代理數據解析失敗",
+    "创建存储切割音频的文件夹": "創建存儲切割音頻的文件夾",
+    "用红色标注处保留区": "用紅色標注處保留區",
+    "至少一个线程任务Token溢出而失败": "至少一個線程任務Token溢出而失敗",
+    "获取Slack消息失败": "獲取Slack消息失敗",
+    "极少数情况下": "極少數情況下",
+    "辅助gpt生成代码": "輔助gpt生成代碼",
+    "生成图像": "生成圖像",
+    "最多收纳多少个网页的结果": "最多收納多少個網頁的結果",
+    "获取图片URL": "獲取圖片URL",
+    "正常状态": "正常狀態",
+    "编译原始PDF": "編譯原始PDF",
+    "SummarizeAudioAndVideo内容": "音視頻摘要內容",
+    "Latex文件融合完成": "Latex文件融合完成",
+    "获取线程锁": "獲取線程鎖",
+    "SlackClient类用于与Slack API进行交互": "SlackClient類用於與Slack API進行交互",
+    "检测到arxiv文档连接": "檢測到arxiv文檔連接",
+    "--读取参数": "--讀取參數",
+    "如果您是论文原作者": "如果您是論文原作者",
+    "5刀": "5美元",
+    "转化PDF编译是否成功": "轉換PDF編譯是否成功",
+    "生成带有段落标签的HTML代码": "生成帶有段落標籤的HTML代碼",
+    "目前不支持历史消息查询": "目前不支持歷史消息查詢",
+    "将文件添加到chatbot cookie中": "將文件添加到chatbot cookie中",
+    "多线程操作已经开始": "多線程操作已經開始",
+    "请求子进程": "請求子進程",
+    "将Unsplash API中的PUT_YOUR_QUERY_HERE替换成描述该事件的一个最重要的单词": "將Unsplash API中的PUT_YOUR_QUERY_HERE替換成描述該事件的一個最重要的單詞",
+    "不能加载Claude组件": "不能加載Claude組件",
+    "请仔细鉴别并以原文为准": "請仔細鑒別並以原文為準",
+    "否则结束循环": "否則結束循環",
+    "插件可读取“输入区”文本/路径作为参数": "插件可讀取“輸入區”文本/路徑作為參數",
+    "网络错误": "網絡錯誤",
+    "想象一个穿着者": "想像一個穿著者",
+    "避免遗忘导致死锁": "避免遺忘導致死鎖",
+    "保证括号正确": "保證括號正確",
+    "报错信息": "錯誤信息",
+    "提取视频中的音频": "提取視頻中的音頻",
+    "初始化音频采集线程": "初始化音頻採集線程",
+    "参考文献转Bib": "參考文獻轉Bib",
+    "阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https": "阿里云即時語音識別配置難度較高，僅建議高手用戶使用，參考 https",
+    "使用时": "使用時",
+    "处理个别特殊插件的锁定状态": "處理個別特殊插件的鎖定狀態",
+    "但通常不会出现在正文": "但通常不會出現在正文",
+    "此函数逐渐地搜索最长的条目进行剪辑": "此函數逐漸地搜索最長的條目進行剪輯",
+    "给出指令": "給出指令",
+    "读取音频文件": "讀取音頻文件",
+    "========================================= 插件主程序1 =====================================================": "========================================= 插件主程序1 =====================================================",
+    "带超时倒计时": "帶超時倒計時",
+    "禁止移除或修改此警告": "禁止移除或修改此警告",
+    "ChatGLMFT尚未加载": "ChatGLMFT尚未加載",
+    "双手离开鼠标键盘吧": "雙手離開鼠標鍵盤吧",
+    "缺少的依赖": "缺少的依賴",
+    "的单词": "的單詞",
+    "中读取数据构建知识库": "中讀取數據構建知識庫",
+    "函数热更新是指在不停止程序运行的情况下": "函數熱更新是指在不停止程序運行的情況下",
+    "建议低于1": "建議低於1",
+    "转化PDF编译已经成功": "轉換PDF編譯已經成功",
+    "出问题了": "出問題了",
+    "欢迎使用 MOSS 人工智能助手！": "歡迎使用 MOSS 人工智能助手！",
+    "正在精细切分latex文件": "正在精細切分LaTeX文件",
+    "”补上": "”補上",
+    "网络代理状态": "網路代理狀態",
+    "依赖检测通过": "依賴檢測通過",
+    "默认为default": "預設為default",
+    "Call MOSS fail 不能正常加载MOSS的参数": "呼叫MOSS失敗，無法正常載入MOSS參數",
+    "音频助手": "音頻助手",
+    "次编译": "次編譯",
+    "其他错误": "其他錯誤",
+    "属性": "屬性",
+    "主程序即将开始": "主程式即將開始",
+    "Aliyun音频服务异常": "Aliyun音頻服務異常",
+    "response中会携带traceback报错信息": "response中會攜帶traceback錯誤信息",
+    "一些普通功能模块": "一些普通功能模組",
+    "和openai的连接容易断掉": "和openai的連線容易斷掉",
+    "请检查ALIYUN_TOKEN和ALIYUN_APPKEY是否过期": "請檢查ALIYUN_TOKEN和ALIYUN_APPKEY是否過期",
+    "调用Claude时": "呼叫Claude時",
+    "插件锁定中": "插件鎖定中",
+    "将子线程的gpt结果写入chatbot": "將子線程的gpt結果寫入chatbot",
+    "当下一次用户提交时": "當下一次使用者提交時",
+    "先上传数据集": "先上傳資料集",
+    "请在此处追加更细致的矫错指令": "請在此處追加更細緻的矯錯指令",
+    "无法找到一个主Tex文件": "無法找到一個主Tex文件",
+    "gpt写的": "gpt寫的",
+    "预处理": "預處理",
+    "但大部分场合下并不需要修改": "但大部分場合下並不需要修改",
+    "正在构建知识库": "正在建構知識庫",
+    "开始请求": "開始請求",
+    "根据以上分析": "根據以上分析",
+    "需要特殊依赖": "需要特殊依賴",
+    "用于基础的对话功能": "用於基礎的對話功能",
+    "且没有代码段": "且沒有程式碼段",
+    "取决于": "取決於",
+    "openai的官方KEY需要伴隨組織編碼": "請填入組織編碼",
+    "等待newbing回覆的片段": "等待newbing回覆的片段",
+    "调用缓存": "呼叫快取",
+    "模型选择是": "模型選擇為",
+    "当前大语言模型": "當前大語言模型",
+    "然后转移到指定的另一个路径中": "然後轉移到指定的另一個路徑中",
+    "请向下翻": "請向下滾動",
+    "内容太长了都会触发token数量溢出的错误": "內容太長會觸發token數量溢出的錯誤",
+    "每一块": "每一塊",
+    "详情信息见requirements.txt": "詳細信息見requirements.txt",
+    "没有提供高级参数功能说明": "沒有提供高級參數功能說明",
+    "上传Latex项目": "上傳Latex項目",
+    "请立即终止程序": "請立即終止程式",
+    "解除插件锁定": "解除插件鎖定",
+    "意外Json结构": "意外Json結構",
+    "必须包含documentclass": "必須包含documentclass",
+    "10个文件为一组": "10個文件為一組",
+    "openai的官方KEY需要伴随组织编码": "openai的官方KEY需要伴隨組織編碼",
+    "重置文件的创建时间": "重置文件的創建時間",
+    "尽量是完整的一个section": "盡量是完整的一個section",
+    "报告如何远程获取": "報告如何遠程獲取",
+    "work_folder = Latex预处理": "work_folder = Latex預處理",
+    "吸收在42行以内的begin-end组合": "吸收在42行以內的begin-end組合",
+    "后面是英文冒号": "後面是英文冒號",
+    "使用latexdiff生成论文转化前后对比": "使用latexdiff生成論文轉化前後對比",
+    "首先你在英文语境下通读整篇论文": "首先你在英文語境下通讀整篇論文",
+    "为了防止大语言模型的意外谬误产生扩散影响": "為了防止大語言模型的意外謬誤產生擴散影響",
+    "发现已经存在翻译好的PDF文档": "發現已經存在翻譯好的PDF文檔",
+    "点击“停止”键可终止程序": "點擊“停止”鍵可終止程序",
+    "数学GenerateAnimations": "數學GenerateAnimations",
+    "随变按钮的回调函数注册": "隨變按鈕的回調函數註冊",
+    "history至少释放二分之一": "history至少釋放二分之一",
+    "当前语言模型温度设定": "當前語言模型溫度設定",
+    "等待GPT响应": "等待GPT響應",
+    "正在处理": "正在處理",
+    "多线程翻译开始": "多線程翻譯開始",
+    "reverse 操作必须放在最后": "reverse 操作必須放在最後",
+    "等待newbing回复的片段": "等待newbing回覆的片段",
+    "开始下载": "開始下載",
+    "将 chatglm 直接对齐到 chatglm2": "將 chatglm 直接對齊到 chatglm2",
+    "以上材料已经被写入": "以上材料已經被寫入",
+    "上传文件自动修正路径": "上傳文件自動修正路徑",
+    "然后请使用Markdown格式封装": "然後請使用Markdown格式封裝",
+    "目前对机器学习类文献转化效果最好": "目前對機器學習類文獻轉化效果最好",
+    "检查结果": "檢查結果",
+    "、地址": "地址",
+    "如.md": "如.md",
+    "使用Unsplash API": "使用Unsplash API",
+    "**输入参数说明**": "**輸入參數說明**",
+    "新版本可用": "新版本可用",
+    "找不到任何python文件": "找不到任何python文件",
+    "知乎": "知乎",
+    "日": "日",
+    "“喂狗”": "“喂狗”",
+    "第4步": "第4步",
+    "退出": "退出",
+    "使用 Unsplash API": "使用 Unsplash API"
 }

docs/use_audio.md

@@ -0,0 +1,54 @@
+# 使用音频交互功能
+
+
+## 1. 安装额外依赖
+```
+pip install --upgrade pyOpenSSL scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git
+```
+
+如果因为特色网络问题导致上述命令无法执行：
+1. git clone alibabacloud-nls-python-sdk这个项目（或者直接前往Github对应网址下载压缩包）.
+命令行输入： `git clone https://github.com/aliyun/alibabacloud-nls-python-sdk.git`
+1. 进入alibabacloud-nls-python-sdk目录命令行输入：`python setup.py install`
+
+
+## 2. 配置音频功能开关 和 阿里云APPKEY（config.py/config_private.py/环境变量）
+
+- 注册阿里云账号
+- 开通 智能语音交互 （有免费白嫖时长）
+- 获取token和appkey
+- 未来将逐步用其他更廉价的云服务取代阿里云
+
+```
+ENABLE_AUDIO = True
+ALIYUN_TOKEN = "554a50fcd0bb476c8d07bb630e94d20c"    # 此token已经失效
+ALIYUN_APPKEY = "RoPlZrM88DnAFkZK"   # 此appkey已经失效
+```
+
+参考 https://help.aliyun.com/document_detail/450255.html
+先有阿里云开发者账号，登录之后，需要开通 智能语音交互 的功能，可以免费获得一个token，然后在 全部项目 中，创建一个项目，可以获得一个appkey.
+
+## 3.启动
+
+启动gpt-academic `python main.py`
+
+## 4.点击record from microphe，授权音频采集
+
+I 如果需要监听自己说话（不监听电脑音频），直接在浏览器中选择对应的麦即可
+
+II 如果需要监听电脑音频（不监听自己说话），需要安装`VB-Audio VoiceMeeter`，打开声音控制面板(sound control panel)
+- 1 `[把电脑的所有外放声音用VoiceMeeter截留]` 在输出区（playback）选项卡，把VoiceMeeter Input虚拟设备set as default设为默认播放设备。
+- 2 `[把截留的声音释放到gpt-academic]` 打开gpt-academic主界面，授权音频采集后，在浏览器地址栏或者类似的地方会出现一个麦克风图标，打开后，按照浏览器的提示，选择VoiceMeeter虚拟麦克风。然后刷新页面，重新授权音频采集。
+- 3 `[把截留的声音同时释放到耳机或音响]` 完成第一步之后，您应处于听不到电脑声音的状态。为了在截获音频的同时，避免影响正常使用，请完成这最后一步配置。在声音控制面板(sound control panel)输入区（recording）选项卡，把VoiceMeeter Output虚拟设备set as default。双击进入VoiceMeeter Output虚拟设备的设置。
+  - 3-1 进入VoiceMeeter Output虚拟设备子菜单，打开listen选项卡。
+  - 3-2 勾选Listen to this device。
+  - 3-3 在playback through this device下拉菜单中选择你的正常耳机或音响。
+
+III `[把特殊软件（如腾讯会议）的外放声音用VoiceMeeter截留]` 在完成步骤II的基础上，在特殊软件（如腾讯会议）中，打开声音菜单，选择扬声器VoiceMeeter Input，选择麦克风为正常耳机麦。
+
+VI 两种音频监听模式切换时，需要刷新页面才有效。
+
+## 5.点击函数插件区“实时音频采集” 或者其他音频交互功能
+
+
+

main.py

@@ -14,7 +14,7 @@ def main():
     if not AUTHENTICATION: AUTHENTICATION = None
 
     from check_proxy import get_current_version
-    from theme.theme import adjust_theme, advanced_css, theme_declaration
+    from themes.theme import adjust_theme, advanced_css, theme_declaration
     initial_prompt = "Serve me as a writing and programming assistant."
     title_html = f"<h1 align=\"center\">GPT 学术优化 {get_current_version()}</h1>{theme_declaration}"
     description =  """代码开源和更新[地址🚀](https://github.com/binary-husky/chatgpt_academic)，感谢热情的[开发者们❤️](https://github.com/binary-husky/chatgpt_academic/graphs/contributors)"""
@@ -22,8 +22,10 @@ def main():
     # 问询记录, python 版本建议3.9+（越新越好）
     import logging, uuid
     os.makedirs("gpt_log", exist_ok=True)
-    try:logging.basicConfig(filename="gpt_log/chat_secrets.log", level=logging.INFO, encoding="utf-8")
-    except:logging.basicConfig(filename="gpt_log/chat_secrets.log", level=logging.INFO)
+    try:logging.basicConfig(filename="gpt_log/chat_secrets.log", level=logging.INFO, encoding="utf-8", format="%(asctime)s %(levelname)-8s %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    except:logging.basicConfig(filename="gpt_log/chat_secrets.log", level=logging.INFO,  format="%(asctime)s %(levelname)-8s %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    # Disable logging output from the 'httpx' logger
+    logging.getLogger("httpx").setLevel(logging.WARNING)
     print("所有问询记录将自动保存在本地目录./gpt_log/chat_secrets.log, 请注意自我隐私保护哦！")
 
     # 一些普通功能模块
@@ -52,7 +54,7 @@ def main():
         CHATBOT_HEIGHT /= 2
 
     cancel_handles = []
-    with gr.Blocks(title="ChatGPT 学术优化", theme=set_theme, analytics_enabled=False, css=advanced_css) as demo:
+    with gr.Blocks(title="GPT 学术优化", theme=set_theme, analytics_enabled=False, css=advanced_css) as demo:
         gr.HTML(title_html)
         cookies = gr.State(load_chat_cookies())
         with gr_L1():
@@ -72,7 +74,7 @@ def main():
                         clearBtn = gr.Button("清除", variant="secondary", visible=False); clearBtn.style(size="sm")
                     if ENABLE_AUDIO: 
                         with gr.Row():
-                            audio_mic = gr.Audio(source="microphone", type="numpy", streaming=True, show_label=False)
+                            audio_mic = gr.Audio(source="microphone", type="numpy", streaming=True, show_label=False).style(container=False)
                     with gr.Row():
                         status = gr.Markdown(f"Tip: 按Enter提交, 按Shift+Enter换行。当前模型: {LLM_MODEL} \n {proxy_info}", elem_id="state-panel")
                 with gr.Accordion("基础功能区", open=True, elem_id="basic-panel") as area_basic_fn:

request_llm/bridge_all.py

@@ -168,7 +168,31 @@ model_info = {
 }
 
 
-AVAIL_LLM_MODELS, = get_conf("AVAIL_LLM_MODELS")
+AVAIL_LLM_MODELS, LLM_MODEL = get_conf("AVAIL_LLM_MODELS", "LLM_MODEL")
+AVAIL_LLM_MODELS = AVAIL_LLM_MODELS + [LLM_MODEL]
+if "claude-1-100k" in AVAIL_LLM_MODELS or "claude-2" in AVAIL_LLM_MODELS:
+    from .bridge_claude import predict_no_ui_long_connection as claude_noui
+    from .bridge_claude import predict as claude_ui
+    model_info.update({
+        "claude-1-100k": {
+            "fn_with_ui": claude_ui,
+            "fn_without_ui": claude_noui,
+            "endpoint": None,
+            "max_token": 8196,
+            "tokenizer": tokenizer_gpt35,
+            "token_cnt": get_token_num_gpt35,
+        },
+    })
+    model_info.update({
+        "claude-2": {
+            "fn_with_ui": claude_ui,
+            "fn_without_ui": claude_noui,
+            "endpoint": None,
+            "max_token": 8196,
+            "tokenizer": tokenizer_gpt35,
+            "token_cnt": get_token_num_gpt35,
+        },
+    })
 if "jittorllms_rwkv" in AVAIL_LLM_MODELS:
     from .bridge_jittorllms_rwkv import predict_no_ui_long_connection as rwkv_noui
     from .bridge_jittorllms_rwkv import predict as rwkv_ui
@@ -224,7 +248,6 @@ if "moss" in AVAIL_LLM_MODELS:
 if "stack-claude" in AVAIL_LLM_MODELS:
     from .bridge_stackclaude import predict_no_ui_long_connection as claude_noui
     from .bridge_stackclaude import predict as claude_ui
-    # claude
     model_info.update({
         "stack-claude": {
             "fn_with_ui": claude_ui,
@@ -239,7 +262,6 @@ if "newbing-free" in AVAIL_LLM_MODELS:
     try:
         from .bridge_newbingfree import predict_no_ui_long_connection as newbingfree_noui
         from .bridge_newbingfree import predict as newbingfree_ui
-        # claude
         model_info.update({
             "newbing-free": {
                 "fn_with_ui": newbingfree_ui,
@@ -256,7 +278,6 @@ if "newbing" in AVAIL_LLM_MODELS:   # same with newbing-free
     try:
         from .bridge_newbingfree import predict_no_ui_long_connection as newbingfree_noui
         from .bridge_newbingfree import predict as newbingfree_ui
-        # claude
         model_info.update({
             "newbing": {
                 "fn_with_ui": newbingfree_ui,
@@ -273,7 +294,6 @@ if "chatglmft" in AVAIL_LLM_MODELS:   # same with newbing-free
     try:
         from .bridge_chatglmft import predict_no_ui_long_connection as chatglmft_noui
         from .bridge_chatglmft import predict as chatglmft_ui
-        # claude
         model_info.update({
             "chatglmft": {
                 "fn_with_ui": chatglmft_ui,
@@ -286,7 +306,22 @@ if "chatglmft" in AVAIL_LLM_MODELS:   # same with newbing-free
         })
     except:
         print(trimmed_format_exc())
-
+if "internlm" in AVAIL_LLM_MODELS:
+    try:
+        from .bridge_internlm import predict_no_ui_long_connection as internlm_noui
+        from .bridge_internlm import predict as internlm_ui
+        model_info.update({
+            "internlm": {
+                "fn_with_ui": internlm_ui,
+                "fn_without_ui": internlm_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
 
 def LLM_CATCH_EXCEPTION(f):
     """

request_llm/bridge_chatglmft.py

@@ -64,12 +64,12 @@ class GetGLMFTHandle(Process):
                     # with open(conf, 'r', encoding='utf8') as f:
                     #     model_args = json.loads(f.read())
                     ChatGLM_PTUNING_CHECKPOINT, = get_conf('ChatGLM_PTUNING_CHECKPOINT')
+                    assert os.path.exists(ChatGLM_PTUNING_CHECKPOINT), "找不到微调模型检查点"
                     conf = os.path.join(ChatGLM_PTUNING_CHECKPOINT, "config.json")
                     with open(conf, 'r', encoding='utf8') as f:
-                        model_args_ = json.loads(f.read())
-                        model_args_.update(model_args)
-                        model_args = model_args_
-
+                        model_args = json.loads(f.read())
+                    if 'model_name_or_path' not in model_args:
+                        model_args['model_name_or_path'] = model_args['_name_or_path']
                     self.chatglmft_tokenizer = AutoTokenizer.from_pretrained(
                         model_args['model_name_or_path'], trust_remote_code=True)
                     config = AutoConfig.from_pretrained(

request_llm/bridge_chatgpt.py

@@ -141,7 +141,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
     yield from update_ui(chatbot=chatbot, history=history, msg="等待响应") # 刷新界面
 
     try:
-        headers, payload = generate_payload(inputs, llm_kwargs, history, system_prompt, stream)
+        headers, payload = generate_payload(inputs, llm_kwargs, history, system_prompt, stream=False)
     except RuntimeError as e:
         chatbot[-1] = (inputs, f"您提供的api-key不满足要求，不包含任何可用于{llm_kwargs['llm_model']}的api-key。您可能选择了错误的模型或请求源。")
         yield from update_ui(chatbot=chatbot, history=history, msg="api-key不满足要求") # 刷新界面
@@ -156,7 +156,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             from .bridge_all import model_info
             endpoint = model_info[llm_kwargs['llm_model']]['endpoint']
             response = requests.post(endpoint, headers=headers, proxies=proxies,
-                                    json=payload, stream=True, timeout=TIMEOUT_SECONDS);break
+                                    json=payload, stream=False, timeout=TIMEOUT_SECONDS);break
         except:
             retry += 1
             chatbot[-1] = ((chatbot[-1][0], timeout_bot_msg))
@@ -174,11 +174,18 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                 chunk = next(stream_response)
             except StopIteration:
                 # 非OpenAI官方接口的出现这样的报错，OpenAI和API2D不会走这里
-                from toolbox import regular_txt_to_markdown; tb_str = '```\n' + trimmed_format_exc() + '```'
-                chatbot[-1] = (chatbot[-1][0], f"[Local Message] 远程返回错误: \n\n{tb_str} \n\n{regular_txt_to_markdown(chunk.decode())}")
-                yield from update_ui(chatbot=chatbot, history=history, msg="远程返回错误:" + chunk.decode()) # 刷新界面
-                return
-            
+                chunk_decoded = chunk.decode()
+                if '"finish_reason":"stop"' in chunk_decoded:
+                    history[-1] = json.loads(chunk_decoded)['choices'][0]['message']['content']
+                    chatbot[-1] = (history[-2], history[-1])
+                    yield from update_ui(chatbot=chatbot, history=history, msg='OK') # 刷新界面
+                    return
+                else:
+                    error_msg = chunk_decoded
+                    chatbot, history = handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
+                    yield from update_ui(chatbot=chatbot, history=history, msg="非Openai官方接口返回了错误:" + chunk.decode()) # 刷新界面
+                    return
+                
             # print(chunk.decode()[6:])
             if is_head_of_the_stream and (r'"object":"error"' not in chunk.decode()):
                 # 数据流的第一帧不携带content
@@ -187,7 +194,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             if chunk:
                 try:
                     chunk_decoded = chunk.decode()
-                    # 前者API2D的
+                    # 前者是API2D的结束条件，后者是OPENAI的结束条件
                     if ('data: [DONE]' in chunk_decoded) or (len(json.loads(chunk_decoded[6:])['choices'][0]["delta"]) == 0):
                         # 判定为数据流的结束，gpt_replying_buffer也写完了
                         logging.info(f'[response] {gpt_replying_buffer}')
@@ -200,41 +207,45 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                     history[-1] = gpt_replying_buffer
                     chatbot[-1] = (history[-2], history[-1])
                     yield from update_ui(chatbot=chatbot, history=history, msg=status_text) # 刷新界面
-
                 except Exception as e:
-                    traceback.print_exc()
                     yield from update_ui(chatbot=chatbot, history=history, msg="Json解析不合常规") # 刷新界面
                     chunk = get_full_error(chunk, stream_response)
                     chunk_decoded = chunk.decode()
                     error_msg = chunk_decoded
-                    openai_website = ' 请登录OpenAI查看详情 https://platform.openai.com/signup'
-                    if "reduce the length" in error_msg:
-                        if len(history) >= 2: history[-1] = ""; history[-2] = "" # 清除当前溢出的输入：history[-2] 是本次输入, history[-1] 是本次输出
-                        history = clip_history(inputs=inputs, history=history, tokenizer=model_info[llm_kwargs['llm_model']]['tokenizer'], 
-                                               max_token_limit=(model_info[llm_kwargs['llm_model']]['max_token'])) # history至少释放二分之一
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Reduce the length. 本次输入过长, 或历史数据过长. 历史缓存数据已部分释放, 您可以请再次尝试. (若再次失败则更可能是因为输入过长.)")
-                        # history = []    # 清除历史
-                    elif "does not exist" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], f"[Local Message] Model {llm_kwargs['llm_model']} does not exist. 模型不存在, 或者您没有获得体验资格.")
-                    elif "Incorrect API key" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Incorrect API key. OpenAI以提供了不正确的API_KEY为由, 拒绝服务. " + openai_website)
-                    elif "exceeded your current quota" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] You exceeded your current quota. OpenAI以账户额度不足为由, 拒绝服务." + openai_website)
-                    elif "account is not active" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Your account is not active. OpenAI以账户失效为由, 拒绝服务." + openai_website)
-                    elif "associated with a deactivated account" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] You are associated with a deactivated account. OpenAI以账户失效为由, 拒绝服务." + openai_website)
-                    elif "bad forward key" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Bad forward key. API2D账户额度不足.")
-                    elif "Not enough point" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Not enough point. API2D账户点数不足.")
-                    else:
-                        from toolbox import regular_txt_to_markdown
-                        tb_str = '```\n' + trimmed_format_exc() + '```'
-                        chatbot[-1] = (chatbot[-1][0], f"[Local Message] 异常 \n\n{tb_str} \n\n{regular_txt_to_markdown(chunk_decoded)}")
+                    chatbot, history = handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
                     yield from update_ui(chatbot=chatbot, history=history, msg="Json异常" + error_msg) # 刷新界面
+                    print(error_msg)
                     return
 
+def handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg):
+    from .bridge_all import model_info
+    openai_website = ' 请登录OpenAI查看详情 https://platform.openai.com/signup'
+    if "reduce the length" in error_msg:
+        if len(history) >= 2: history[-1] = ""; history[-2] = "" # 清除当前溢出的输入：history[-2] 是本次输入, history[-1] 是本次输出
+        history = clip_history(inputs=inputs, history=history, tokenizer=model_info[llm_kwargs['llm_model']]['tokenizer'], 
+                                               max_token_limit=(model_info[llm_kwargs['llm_model']]['max_token'])) # history至少释放二分之一
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Reduce the length. 本次输入过长, 或历史数据过长. 历史缓存数据已部分释放, 您可以请再次尝试. (若再次失败则更可能是因为输入过长.)")
+                        # history = []    # 清除历史
+    elif "does not exist" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], f"[Local Message] Model {llm_kwargs['llm_model']} does not exist. 模型不存在, 或者您没有获得体验资格.")
+    elif "Incorrect API key" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Incorrect API key. OpenAI以提供了不正确的API_KEY为由, 拒绝服务. " + openai_website)
+    elif "exceeded your current quota" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] You exceeded your current quota. OpenAI以账户额度不足为由, 拒绝服务." + openai_website)
+    elif "account is not active" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Your account is not active. OpenAI以账户失效为由, 拒绝服务." + openai_website)
+    elif "associated with a deactivated account" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] You are associated with a deactivated account. OpenAI以账户失效为由, 拒绝服务." + openai_website)
+    elif "bad forward key" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Bad forward key. API2D账户额度不足.")
+    elif "Not enough point" in error_msg:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Not enough point. API2D账户点数不足.")
+    else:
+        from toolbox import regular_txt_to_markdown
+        tb_str = '```\n' + trimmed_format_exc() + '```'
+        chatbot[-1] = (chatbot[-1][0], f"[Local Message] 异常 \n\n{tb_str} \n\n{regular_txt_to_markdown(chunk_decoded)}")
+    return chatbot, history
+
 def generate_payload(inputs, llm_kwargs, history, system_prompt, stream):
     """
     整合所有信息，选择LLM模型，生成http请求，为发送请求做准备

request_llm/bridge_claude.py

@@ -0,0 +1,231 @@
+# 借鉴了 https://github.com/GaiZhenbiao/ChuanhuChatGPT 项目
+
+"""
+    该文件中主要包含2个函数
+
+    不具备多线程能力的函数：
+    1. predict: 正常对话时使用，具备完备的交互功能，不可多线程
+
+    具备多线程调用能力的函数
+    2. predict_no_ui_long_connection：在实验过程中发现调用predict_no_ui处理长文档时，和openai的连接容易断掉，这个函数用stream的方式解决这个问题，同样支持多线程
+"""
+
+import os
+import json
+import time
+import gradio as gr
+import logging
+import traceback
+import requests
+import importlib
+
+# config_private.py放自己的秘密如API和代理网址
+# 读取时首先看是否存在私密的config_private配置文件（不受git管控），如果有，则覆盖原config文件
+from toolbox import get_conf, update_ui, trimmed_format_exc, ProxyNetworkActivate
+proxies, TIMEOUT_SECONDS, MAX_RETRY, ANTHROPIC_API_KEY = \
+    get_conf('proxies', 'TIMEOUT_SECONDS', 'MAX_RETRY', 'ANTHROPIC_API_KEY')
+
+timeout_bot_msg = '[Local Message] Request timeout. Network error. Please check proxy settings in config.py.' + \
+                  '网络错误，检查代理服务器是否可用，以及代理设置的格式是否正确，格式须是[协议]://[地址]:[端口]，缺一不可。'
+
+def get_full_error(chunk, stream_response):
+    """
+        获取完整的从Openai返回的报错
+    """
+    while True:
+        try:
+            chunk += next(stream_response)
+        except:
+            break
+    return chunk
+
+
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=None, console_slience=False):
+    """
+    发送至chatGPT，等待回复，一次性完成，不显示中间过程。但内部用stream的方法避免中途网线被掐。
+    inputs：
+        是本次问询的输入
+    sys_prompt:
+        系统静默prompt
+    llm_kwargs：
+        chatGPT的内部调优参数
+    history：
+        是之前的对话列表
+    observe_window = None：
+        用于负责跨越线程传递已经输出的部分，大部分时候仅仅为了fancy的视觉效果，留空即可。observe_window[0]：观测窗。observe_window[1]：看门狗
+    """
+    from anthropic import Anthropic
+    watch_dog_patience = 5 # 看门狗的耐心, 设置5秒即可
+    prompt = generate_payload(inputs, llm_kwargs, history, system_prompt=sys_prompt, stream=True)
+    retry = 0
+    if len(ANTHROPIC_API_KEY) == 0:
+        raise RuntimeError("没有设置ANTHROPIC_API_KEY选项")
+
+    while True:
+        try:
+            # make a POST request to the API endpoint, stream=False
+            from .bridge_all import model_info
+            anthropic = Anthropic(api_key=ANTHROPIC_API_KEY)
+            # endpoint = model_info[llm_kwargs['llm_model']]['endpoint']
+            # with ProxyNetworkActivate()
+            stream = anthropic.completions.create(
+                prompt=prompt,
+                max_tokens_to_sample=4096,       # The maximum number of tokens to generate before stopping.
+                model=llm_kwargs['llm_model'],
+                stream=True,
+                temperature = llm_kwargs['temperature']
+            )
+            break
+        except Exception as e:
+            retry += 1
+            traceback.print_exc()
+            if retry > MAX_RETRY: raise TimeoutError
+            if MAX_RETRY!=0: print(f'请求超时，正在重试 ({retry}/{MAX_RETRY}) ……')
+    result = ''
+    try: 
+        for completion in stream:
+            result += completion.completion
+            if not console_slience: print(completion.completion, end='')
+            if observe_window is not None: 
+                # 观测窗，把已经获取的数据显示出去
+                if len(observe_window) >= 1: observe_window[0] += completion.completion
+                # 看门狗，如果超过期限没有喂狗，则终止
+                if len(observe_window) >= 2:  
+                    if (time.time()-observe_window[1]) > watch_dog_patience:
+                        raise RuntimeError("用户取消了程序。")
+    except Exception as e:
+        traceback.print_exc()
+
+    return result
+
+
+def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+    """
+    发送至chatGPT，流式获取输出。
+    用于基础的对话功能。
+    inputs 是本次问询的输入
+    top_p, temperature是chatGPT的内部调优参数
+    history 是之前的对话列表（注意无论是inputs还是history，内容太长了都会触发token数量溢出的错误）
+    chatbot 为WebUI中显示的对话列表，修改它，然后yeild出去，可以直接修改对话界面内容
+    additional_fn代表点击的哪个按钮，按钮见functional.py
+    """
+    from anthropic import Anthropic
+    if len(ANTHROPIC_API_KEY) == 0:
+        chatbot.append((inputs, "没有设置ANTHROPIC_API_KEY"))
+        yield from update_ui(chatbot=chatbot, history=history, msg="等待响应") # 刷新界面
+        return
+    
+    if additional_fn is not None:
+        import core_functional
+        importlib.reload(core_functional)    # 热更新prompt
+        core_functional = core_functional.get_core_functions()
+        if "PreProcess" in core_functional[additional_fn]: inputs = core_functional[additional_fn]["PreProcess"](inputs)  # 获取预处理函数（如果有的话）
+        inputs = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"]
+
+    raw_input = inputs
+    logging.info(f'[raw_input] {raw_input}')
+    chatbot.append((inputs, ""))
+    yield from update_ui(chatbot=chatbot, history=history, msg="等待响应") # 刷新界面
+
+    try:
+        prompt = generate_payload(inputs, llm_kwargs, history, system_prompt, stream)
+    except RuntimeError as e:
+        chatbot[-1] = (inputs, f"您提供的api-key不满足要求，不包含任何可用于{llm_kwargs['llm_model']}的api-key。您可能选择了错误的模型或请求源。")
+        yield from update_ui(chatbot=chatbot, history=history, msg="api-key不满足要求") # 刷新界面
+        return
+
+    history.append(inputs); history.append("")
+
+    retry = 0
+    while True:
+        try:
+            # make a POST request to the API endpoint, stream=True
+            from .bridge_all import model_info
+            anthropic = Anthropic(api_key=ANTHROPIC_API_KEY)
+            # endpoint = model_info[llm_kwargs['llm_model']]['endpoint']
+            # with ProxyNetworkActivate()
+            stream = anthropic.completions.create(
+                prompt=prompt,
+                max_tokens_to_sample=4096,       # The maximum number of tokens to generate before stopping.
+                model=llm_kwargs['llm_model'],
+                stream=True,
+                temperature = llm_kwargs['temperature']
+            )
+            
+            break
+        except:
+            retry += 1
+            chatbot[-1] = ((chatbot[-1][0], timeout_bot_msg))
+            retry_msg = f"，正在重试 ({retry}/{MAX_RETRY}) ……" if MAX_RETRY > 0 else ""
+            yield from update_ui(chatbot=chatbot, history=history, msg="请求超时"+retry_msg) # 刷新界面
+            if retry > MAX_RETRY: raise TimeoutError
+
+    gpt_replying_buffer = ""
+    
+    for completion in stream:
+        try:
+            gpt_replying_buffer = gpt_replying_buffer + completion.completion
+            history[-1] = gpt_replying_buffer
+            chatbot[-1] = (history[-2], history[-1])
+            yield from update_ui(chatbot=chatbot, history=history, msg='正常') # 刷新界面
+
+        except Exception as e:
+            from toolbox import regular_txt_to_markdown
+            tb_str = '```\n' + trimmed_format_exc() + '```'
+            chatbot[-1] = (chatbot[-1][0], f"[Local Message] 异常 \n\n{tb_str}")
+            yield from update_ui(chatbot=chatbot, history=history, msg="Json异常" + tb_str) # 刷新界面
+            return
+        
+
+
+
+# https://github.com/jtsang4/claude-to-chatgpt/blob/main/claude_to_chatgpt/adapter.py
+def convert_messages_to_prompt(messages):
+    prompt = ""
+    role_map = {
+        "system": "Human",
+        "user": "Human",
+        "assistant": "Assistant",
+    }
+    for message in messages:
+        role = message["role"]
+        content = message["content"]
+        transformed_role = role_map[role]
+        prompt += f"\n\n{transformed_role.capitalize()}: {content}"
+    prompt += "\n\nAssistant: "
+    return prompt
+
+def generate_payload(inputs, llm_kwargs, history, system_prompt, stream):
+    """
+    整合所有信息，选择LLM模型，生成http请求，为发送请求做准备
+    """
+    from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
+
+    conversation_cnt = len(history) // 2
+
+    messages = [{"role": "system", "content": system_prompt}]
+    if conversation_cnt:
+        for index in range(0, 2*conversation_cnt, 2):
+            what_i_have_asked = {}
+            what_i_have_asked["role"] = "user"
+            what_i_have_asked["content"] = history[index]
+            what_gpt_answer = {}
+            what_gpt_answer["role"] = "assistant"
+            what_gpt_answer["content"] = history[index+1]
+            if what_i_have_asked["content"] != "":
+                if what_gpt_answer["content"] == "": continue
+                if what_gpt_answer["content"] == timeout_bot_msg: continue
+                messages.append(what_i_have_asked)
+                messages.append(what_gpt_answer)
+            else:
+                messages[-1]['content'] = what_gpt_answer['content']
+
+    what_i_ask_now = {}
+    what_i_ask_now["role"] = "user"
+    what_i_ask_now["content"] = inputs
+    messages.append(what_i_ask_now)
+    prompt = convert_messages_to_prompt(messages)
+
+    return prompt
+
+

request_llm/bridge_internlm.py

@@ -0,0 +1,315 @@
+
+from transformers import AutoModel, AutoTokenizer
+import time
+import threading
+import importlib
+from toolbox import update_ui, get_conf, Singleton
+from multiprocessing import Process, Pipe
+
+model_name = "InternLM"
+cmd_to_install = "`pip install ???`"
+load_message = f"{model_name}尚未加载，加载需要一段时间。注意，取决于`config.py`的配置，{model_name}消耗大量的内存（CPU）或显存（GPU），也许会导致低配计算机卡死 ……"
+def try_to_import_special_deps():
+    import sentencepiece
+
+user_prompt = "<|User|>:{user}<eoh>\n"
+robot_prompt = "<|Bot|>:{robot}<eoa>\n"
+cur_query_prompt = "<|User|>:{user}<eoh>\n<|Bot|>:"
+
+
+def combine_history(prompt, hist):
+    messages = hist
+    total_prompt = ""
+    for message in messages:
+        cur_content = message
+        cur_prompt = user_prompt.replace("{user}", cur_content[0])
+        total_prompt += cur_prompt
+        cur_prompt = robot_prompt.replace("{robot}", cur_content[1])
+        total_prompt += cur_prompt
+    total_prompt = total_prompt + cur_query_prompt.replace("{user}", prompt)
+    return total_prompt
+
+
+@Singleton
+class GetInternlmHandle(Process):
+    def __init__(self):
+        # ⭐主进程执行
+        super().__init__(daemon=True)
+        self.parent, self.child = Pipe()
+        self._model = None
+        self._tokenizer = None
+        self.info = ""
+        self.success = True
+        self.check_dependency()
+        self.start()
+        self.threadLock = threading.Lock()
+
+    def ready(self):
+        # ⭐主进程执行
+        return self._model is not None
+
+    def load_model_and_tokenizer(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        device, = get_conf('LOCAL_MODEL_DEVICE')
+        if self._model is None:
+            tokenizer = AutoTokenizer.from_pretrained("internlm/internlm-chat-7b", trust_remote_code=True)
+            if device=='cpu':
+                model = AutoModelForCausalLM.from_pretrained("internlm/internlm-chat-7b", trust_remote_code=True).to(torch.bfloat16)
+            else:
+                model = AutoModelForCausalLM.from_pretrained("internlm/internlm-chat-7b", trust_remote_code=True).to(torch.bfloat16).cuda()
+
+            model = model.eval()
+        return model, tokenizer
+
+    def llm_stream_generator(self, **kwargs):
+        import torch
+        import logging
+        import copy
+        import warnings
+        import torch.nn as nn
+        from transformers.generation.utils import LogitsProcessorList, StoppingCriteriaList, GenerationConfig
+
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        def adaptor():
+            model = self._model
+            tokenizer = self._tokenizer
+            prompt = kwargs['query']
+            max_length = kwargs['max_length']
+            top_p = kwargs['top_p']
+            temperature = kwargs['temperature']
+            history = kwargs['history']
+            real_prompt = combine_history(prompt, history)
+            return model, tokenizer, real_prompt, max_length, top_p, temperature
+        
+        model, tokenizer, prompt, max_length, top_p, temperature = adaptor()
+        prefix_allowed_tokens_fn = None
+        logits_processor = None
+        stopping_criteria = None
+        additional_eos_token_id = 103028
+        generation_config = None
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ https://github.com/InternLM/InternLM/blob/efbf5335709a8c8faeac6eaf07193973ff1d56a1/web_demo.py#L25
+
+        inputs = tokenizer([prompt], padding=True, return_tensors="pt")
+        input_length = len(inputs["input_ids"][0])
+        for k, v in inputs.items():
+            inputs[k] = v.cuda()
+        input_ids = inputs["input_ids"]
+        batch_size, input_ids_seq_length = input_ids.shape[0], input_ids.shape[-1]
+        if generation_config is None:
+            generation_config = model.generation_config
+        generation_config = copy.deepcopy(generation_config)
+        model_kwargs = generation_config.update(**kwargs)
+        bos_token_id, eos_token_id = generation_config.bos_token_id, generation_config.eos_token_id
+        if isinstance(eos_token_id, int):
+            eos_token_id = [eos_token_id]
+        if additional_eos_token_id is not None:
+            eos_token_id.append(additional_eos_token_id)
+        has_default_max_length = kwargs.get("max_length") is None and generation_config.max_length is not None
+        if has_default_max_length and generation_config.max_new_tokens is None:
+            warnings.warn(
+                f"Using `max_length`'s default ({generation_config.max_length}) to control the generation length. "
+                "This behaviour is deprecated and will be removed from the config in v5 of Transformers -- we"
+                " recommend using `max_new_tokens` to control the maximum length of the generation.",
+                UserWarning,
+            )
+        elif generation_config.max_new_tokens is not None:
+            generation_config.max_length = generation_config.max_new_tokens + input_ids_seq_length
+            if not has_default_max_length:
+                logging.warn(
+                    f"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(="
+                    f"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. "
+                    "Please refer to the documentation for more information. "
+                    "(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)",
+                    UserWarning,
+                )
+
+        if input_ids_seq_length >= generation_config.max_length:
+            input_ids_string = "input_ids"
+            logging.warning(
+                f"Input length of {input_ids_string} is {input_ids_seq_length}, but `max_length` is set to"
+                f" {generation_config.max_length}. This can lead to unexpected behavior. You should consider"
+                " increasing `max_new_tokens`."
+            )
+
+        # 2. Set generation parameters if not already defined
+        logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
+        stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
+
+        logits_processor = model._get_logits_processor(
+            generation_config=generation_config,
+            input_ids_seq_length=input_ids_seq_length,
+            encoder_input_ids=input_ids,
+            prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,
+            logits_processor=logits_processor,
+        )
+
+        stopping_criteria = model._get_stopping_criteria(
+            generation_config=generation_config, stopping_criteria=stopping_criteria
+        )
+        logits_warper = model._get_logits_warper(generation_config)
+
+        unfinished_sequences = input_ids.new(input_ids.shape[0]).fill_(1)
+        scores = None
+        while True:
+            model_inputs = model.prepare_inputs_for_generation(input_ids, **model_kwargs)
+            # forward pass to get next token
+            outputs = model(
+                **model_inputs,
+                return_dict=True,
+                output_attentions=False,
+                output_hidden_states=False,
+            )
+
+            next_token_logits = outputs.logits[:, -1, :]
+
+            # pre-process distribution
+            next_token_scores = logits_processor(input_ids, next_token_logits)
+            next_token_scores = logits_warper(input_ids, next_token_scores)
+
+            # sample
+            probs = nn.functional.softmax(next_token_scores, dim=-1)
+            if generation_config.do_sample:
+                next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
+            else:
+                next_tokens = torch.argmax(probs, dim=-1)
+
+            # update generated ids, model inputs, and length for next step
+            input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
+            model_kwargs = model._update_model_kwargs_for_generation(
+                outputs, model_kwargs, is_encoder_decoder=False
+            )
+            unfinished_sequences = unfinished_sequences.mul((min(next_tokens != i for i in eos_token_id)).long())
+            
+            output_token_ids = input_ids[0].cpu().tolist()
+            output_token_ids = output_token_ids[input_length:]
+            for each_eos_token_id in eos_token_id:
+                if output_token_ids[-1] == each_eos_token_id:
+                    output_token_ids = output_token_ids[:-1]
+            response = tokenizer.decode(output_token_ids)
+
+            yield response
+            # stop when each sentence is finished, or if we exceed the maximum length
+            if unfinished_sequences.max() == 0 or stopping_criteria(input_ids, scores):
+                return
+
+
+
+    def check_dependency(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        try:
+            try_to_import_special_deps()
+            self.info = "依赖检测通过"
+            self.success = True
+        except:
+            self.info = f"缺少{model_name}的依赖，如果要使用{model_name}，除了基础的pip依赖以外，您还需要运行{cmd_to_install}安装{model_name}的依赖。"
+            self.success = False
+
+    def run(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        # 第一次运行，加载参数
+        try:
+            self._model, self._tokenizer = self.load_model_and_tokenizer()
+        except:
+            from toolbox import trimmed_format_exc
+            self.child.send(f'[Local Message] 不能正常加载{model_name}的参数.' + '\n```\n' + trimmed_format_exc() + '\n```\n')
+            raise RuntimeError(f"不能正常加载{model_name}的参数！")
+
+        while True:
+            # 进入任务等待状态
+            kwargs = self.child.recv()
+            # 收到消息，开始请求
+            try:
+                for response_full in self.llm_stream_generator(**kwargs):
+                    self.child.send(response_full)
+            except:
+                from toolbox import trimmed_format_exc
+                self.child.send(f'[Local Message] 调用{model_name}失败.' + '\n```\n' + trimmed_format_exc() + '\n```\n')
+            # 请求处理结束，开始下一个循环
+            self.child.send('[Finish]')
+
+    def stream_chat(self, **kwargs):
+        # ⭐主进程执行
+        self.threadLock.acquire()
+        self.parent.send(kwargs)
+        while True:
+            res = self.parent.recv()
+            if res != '[Finish]':
+                yield res
+            else:
+                break
+        self.threadLock.release()
+    
+    
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 GPT-Academic
+# ------------------------------------------------------------------------------------------------------------------------
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+    """
+        ⭐多线程方法
+        函数的说明请见 request_llm/bridge_all.py
+    """
+    _llm_handle = GetInternlmHandle()
+    if len(observe_window) >= 1: observe_window[0] = load_message + "\n\n" + _llm_handle.info
+    if not _llm_handle.success: 
+        error = _llm_handle.info
+        _llm_handle = None
+        raise RuntimeError(error)
+
+    # chatglm 没有 sys_prompt 接口，因此把prompt加入 history
+    history_feedin = []
+    history_feedin.append(["What can I do?", sys_prompt])
+    for i in range(len(history)//2):
+        history_feedin.append([history[2*i], history[2*i+1]] )
+
+    watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
+    response = ""
+    for response in _llm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+        if len(observe_window) >= 1:  observe_window[0] = response
+        if len(observe_window) >= 2:  
+            if (time.time()-observe_window[1]) > watch_dog_patience:
+                raise RuntimeError("程序终止。")
+    return response
+
+
+
+def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+    """
+        ⭐单线程方法
+        函数的说明请见 request_llm/bridge_all.py
+    """
+    chatbot.append((inputs, ""))
+
+    _llm_handle = GetInternlmHandle()
+    chatbot[-1] = (inputs, load_message + "\n\n" + _llm_handle.info)
+    yield from update_ui(chatbot=chatbot, history=[])
+    if not _llm_handle.success: 
+        _llm_handle = None
+        return
+
+    if additional_fn is not None:
+        import core_functional
+        importlib.reload(core_functional)    # 热更新prompt
+        core_functional = core_functional.get_core_functions()
+        if "PreProcess" in core_functional[additional_fn]: inputs = core_functional[additional_fn]["PreProcess"](inputs)  # 获取预处理函数（如果有的话）
+        inputs = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"]
+
+    # 处理历史信息
+    history_feedin = []
+    history_feedin.append(["What can I do?", system_prompt] )
+    for i in range(len(history)//2):
+        history_feedin.append([history[2*i], history[2*i+1]] )
+
+    # 开始接收chatglm的回复
+    response = f"[Local Message]: 等待{model_name}响应中 ..."
+    for response in _llm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+        chatbot[-1] = (inputs, response)
+        yield from update_ui(chatbot=chatbot, history=history)
+
+    # 总结输出
+    if response == f"[Local Message]: 等待{model_name}响应中 ...":
+        response = f"[Local Message]: {model_name}响应异常 ..."
+    history.extend([inputs, response])
+    yield from update_ui(chatbot=chatbot, history=history)

request_llm/current_ptune_model.json

@@ -1,5 +0,0 @@
-{
-    "model_name_or_path": "THUDM/chatglm2-6b",
-    "pre_seq_len": "128",
-    "ptuning_checkpoint": "/home/hmp/ChatGLM2-6B/ptuning/output/clothgen-chatglm2-6b-pt-128-2e-2/checkpoint-100"
-}

request_llm/edge_gpt_free.py

@@ -447,6 +447,15 @@ class _ChatHub:
         """
         Ask a question to the bot
         """
+        req_header = HEADERS
+        if self.cookies is not None:
+            ws_cookies = []
+            for cookie in self.cookies:
+                ws_cookies.append(f"{cookie['name']}={cookie['value']}")
+            req_header.update({
+                'Cookie': ';'.join(ws_cookies),
+            })
+            
         timeout = aiohttp.ClientTimeout(total=30)
         self.session = aiohttp.ClientSession(timeout=timeout)
 
@@ -455,7 +464,7 @@ class _ChatHub:
         # Check if websocket is closed
         self.wss = await self.session.ws_connect(
             wss_link,
-            headers=HEADERS,
+            headers=req_header,
             ssl=ssl_context,
             proxy=self.proxy,
             autoping=False,
@@ -1109,4 +1118,4 @@ class ImageQuery(Query):
 
 
 if __name__ == "__main__":
-    main()
+    main()

request_llm/test_llms.py

@@ -10,11 +10,12 @@ def validate_path():
     
 validate_path() # validate path so you can run from base directory
 if __name__ == "__main__":
-    from request_llm.bridge_chatglmft import predict_no_ui_long_connection
     # from request_llm.bridge_newbingfree import predict_no_ui_long_connection
     # from request_llm.bridge_moss import predict_no_ui_long_connection
     # from request_llm.bridge_jittorllms_pangualpha import predict_no_ui_long_connection
     # from request_llm.bridge_jittorllms_llama import predict_no_ui_long_connection
+    # from request_llm.bridge_claude import predict_no_ui_long_connection
+    from request_llm.bridge_internlm import predict_no_ui_long_connection
 
     llm_kwargs = {
         'max_length': 512,
@@ -22,9 +23,8 @@ if __name__ == "__main__":
         'temperature': 1,
     }
 
-    result = predict_no_ui_long_connection(inputs="你好", 
-                                        llm_kwargs=llm_kwargs,
-                                        history=[],
-                                        sys_prompt="")
+    result = predict_no_ui_long_connection( inputs="请问什么是质子？", 
+                                            llm_kwargs=llm_kwargs,
+                                            history=["你好", "我好！"],
+                                            sys_prompt="")
     print('final result:', result)
-

requirements.txt

@@ -9,6 +9,7 @@ prompt_toolkit
 latex2mathml
 python-docx
 mdtex2html
+anthropic
 colorama
 Markdown
 pygments

themes/default.css

@@ -82,12 +82,14 @@
     margin: 1em 2em 1em 0.5em;
 }
 
-.app.svelte-1mya07g.svelte-1mya07g {
-    max-width: 95%;
-    position: relative;
-    padding: var(--size-4);
-    width: 95%;
-    height: 100%;
+/* .mic-wrap.svelte-1thnwz {
+
+} */
+.block.svelte-mppz8v > .mic-wrap.svelte-1thnwz{
+    justify-content: center;
+    display: flex;
+    padding: 0;
+
 }
 
 .codehilite .hll { background-color: #6e7681 }

themes/default.py

@@ -9,9 +9,8 @@ def adjust_theme():
         set_theme = gr.themes.Default(
             primary_hue=gr.themes.utils.colors.orange,
             neutral_hue=gr.themes.utils.colors.gray,
-            font=["sans-serif", "Microsoft YaHei", "ui-sans-serif", "system-ui",
-                  "sans-serif", gr.themes.utils.fonts.GoogleFont("Source Sans Pro")],
-            font_mono=["ui-monospace", "Consolas", "monospace", gr.themes.utils.fonts.GoogleFont("IBM Plex Mono")])
+            font=["sans-serif", "Microsoft YaHei", "ui-sans-serif", "system-ui"],
+            font_mono=["ui-monospace", "Consolas", "monospace"])
         set_theme.set(
             # Colors
             input_background_fill_dark="*neutral_800",
@@ -61,7 +60,7 @@ def adjust_theme():
         if LAYOUT=="TOP-DOWN": 
             js = ""
         else:
-            with open('theme/common.js', 'r', encoding='utf8') as f: 
+            with open('themes/common.js', 'r', encoding='utf8') as f: 
                 js = f"<script>{f.read()}</script>"
             
         # 添加一个萌萌的看板娘
@@ -83,5 +82,5 @@ def adjust_theme():
         print('gradio版本较旧, 不能自定义字体和颜色')
     return set_theme
 
-with open("theme/default.css", "r", encoding="utf-8") as f:
+with open("themes/default.css", "r", encoding="utf-8") as f:
     advanced_css = f.read()

themes/green.py

@@ -77,7 +77,7 @@ def adjust_theme():
         if LAYOUT=="TOP-DOWN":
             js = ""
         else:
-            with open('theme/common.js', 'r', encoding='utf8') as f:
+            with open('themes/common.js', 'r', encoding='utf8') as f:
                 js = f"<script>{f.read()}</script>"
 
         # 添加一个萌萌的看板娘
@@ -100,5 +100,5 @@ def adjust_theme():
     return set_theme
 
 
-with open("theme/green.css", "r", encoding="utf-8") as f:
+with open("themes/green.css", "r", encoding="utf-8") as f:
     advanced_css = f.read()

toolbox.py

@@ -883,4 +883,16 @@ def objload(file='objdump.tmp'):
         return
     with open(file, 'rb') as f:
         return pickle.load(f)
-    
+    
+def Singleton(cls):
+    """
+    一个单实例装饰器
+    """
+    _instance = {}
+ 
+    def _singleton(*args, **kargs):
+        if cls not in _instance:
+            _instance[cls] = cls(*args, **kargs)
+        return _instance[cls]
+ 
+    return _singleton

version

@@ -1,5 +1,5 @@
 {
-  "version": 3.44,
+  "version": 3.46,
   "show_feature": true,
-  "new_feature": "[改善UI] 动态ChatBot窗口高度 <-> 修复Azure接口的BUG <-> 完善多语言模块 <-> 完善本地Latex矫错和翻译功能 <-> 增加gpt-3.5-16k的支持 <-> 新增最强Arxiv论文翻译插件 <-> 修复gradio复制按钮BUG <-> 修复PDF翻译的BUG, 新增HTML中英双栏对照 <-> 添加了OpenAI图片生成插件"
-}
+  "new_feature": "临时修复theme的文件丢失问题 <-> 新增实时语音对话插件（自动断句，脱手对话） <-> 支持加载自定义的ChatGLM2微调模型 <-> 动态ChatBot窗口高度 <-> 修复Azure接口的BUG <-> 完善多语言模块 <-> 完善本地Latex矫错和翻译功能 <-> 增加gpt-3.5-16k的支持 <-> 新增最强Arxiv论文翻译插件 <-> 修复gradio复制按钮BUG <-> 修复PDF翻译的BUG, 新增HTML中英双栏对照 <-> 添加了OpenAI图片生成插件"
+}