| A solution of Text Detection/Recognition + SAM that segments every text character, with striking text removal and text inpainting demos driven by diffusion models and Gradio! |
| [MMEditing-SAM](#-mmediting-sam) | 
| Join SAM and image generation to create awesome images and edit any part of them. |
| [Label-Studio-SAM](#-label-studio-sam) | 
| Combining Label-Studio and SAM to achieve semi-automated annotation. |
+| [InternLM-Langchain](#-internlm-langchain) | 
| OpenMMLab Knowledge Base QA based on [internlm/internlm-chat-7b-v1_1](https://huggingface.co/internlm/internlm-chat-7b-v1_1). |
@@ -145,5 +146,12 @@ The solution provides an integration of SAM with Label Studio. The specific feat
2. Bbox2Label: Supports triggering SAM in Label-Studio to generate object masks and axis-aligned bounding box annotations by annotating the object's bounding box.
3. Refine: Supports refining the annotations generated by SAM within Label-Studio.
-详情见 [README](./label_anything/readme.md)。
+Please see [README](./label_anything/readme.md) for more information.
+## ✨ InternLM-Langchain
+
+
+
+ Use [LangChain-Chatchat](https://github.com/chatchat-space/Langchain-Chatchat) to build an OpenMMLab projects knowledge-based question-answering system based on the LLM internlm/[internlm/internlm-chat-7b-v1_1](https://huggingface.co/internlm/internlm-chat-7b-v1_1). It includes multiple projects under OpenMMLab.
+
+Please see [README](./internlm_langchain/README.md) for more information.
diff --git a/README_zh-CN.md b/README_zh-CN.md
index 7b76949a..42467a91 100644
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -52,7 +52,7 @@
| [MMOCR-SAM](#-mmocr-sam) | 
+
+🎉 langchain-ChatGLM 项目微信交流群，如果你也对本项目感兴趣，欢迎加入群聊参与讨论交流。
diff --git a/internlm_langchain/README.md b/internlm_langchain/README.md
new file mode 100644
index 00000000..cea8b71d
--- /dev/null
+++ b/internlm_langchain/README.md
@@ -0,0 +1,161 @@
+## 介绍
+
+使用 [LangChain-Chatchat](https://github.com/chatchat-space/Langchain-Chatchat) 搭建基于 LLM [internlm/internlm-chat-7b-v1_1](https://huggingface.co/internlm/internlm-chat-7b-v1_1) 的 OpenMMLab 知识库问答。
+
+ 
+
+## 模型支持
+
+本项目中默认使用的 LLM 模型为 [internlm/internlm-chat-7b-v1_1](https://huggingface.co/internlm/internlm-chat-7b-v1_1)，默认使用的 Embedding 模型为 [moka-ai/m3e-base](https://huggingface.co/moka-ai/m3e-base) 。
+
+设置文件 `configs/model_configs.py` 中的 `llm_model_dict` 为 `internlm-chat-7b`。
+
+## 开发部署
+
+### 软件需求
+
+本项目已在 Python 3.8，CUDA 11.7 Ubuntu 环境下完成测试。
+
+### 1. 开发环境准备
+
+参见 [开发环境准备](docs/INSTALL.md)。
+
+### 2. 下载模型至本地
+
+下载 LLM 模型 [internlm/internlm-chat-7b-v1_1](https://huggingface.co/internlm/internlm-chat-7b-v1_1) 与 Embedding 模型 [moka-ai/m3e-base](https://huggingface.co/moka-ai/m3e-base) 为例：
+
+下载模型需要先[安装Git LFS](https://docs.github.com/zh/repositories/working-with-files/managing-large-files/installing-git-large-file-storage)，然后运行
+
+```Shell
+$ git clone https://huggingface.co/internlm/internlm-chat-7b-v1_1
+
+$ git clone https://huggingface.co/moka-ai/m3e-base
+```
+
+### 3. 设置配置项
+
+在开始执行 Web UI 或命令行交互前，请先检查 `configs/model_config.py` 和 `configs/server_config.py` 中的各项模型参数设计是否符合需求：
+
+- 请确认已下载至本地的 LLM 模型本地存储路径写在 `llm_model_dict` 对应模型的 `local_model_path` 属性中，如:
+
+```python
+llm_model_dict={
+ "internlm-chat-7b": {
+ "local_model_path": "/root/huggingface/internlm-chat-7b-v1_1",
+ "api_base_url": "http://localhost:8888/v1", # "name"修改为 FastChat 服务中的"api_base_url"
+ "api_key": "EMPTY"
+ },
+ }
+```
+
+- 请确认已下载至本地的 Embedding 模型本地存储路径写在 `embedding_model_dict` 对应模型位置，如：
+
+```python
+embedding_model_dict = {
+ "m3e-base": "/root/huggingface/m3e-base",
+ }
+```
+
+### 5. 启动 API 服务或 Web UI
+
+#### 5.1 启动 LLM 服务
+
+如需使用开源模型进行本地部署，需首先启动 LLM 服务
+
+在项目根目录下，执行 [server/llm_api.py](server/llm_api.py) 脚本启动 **LLM 模型**服务：
+
+```shell
+$ python server/llm_api.py
+```
+
+项目支持多卡加载，需在 llm_api.py 中修改 create_model_worker_app 函数中，修改如下三个参数:
+
+```python
+gpus=None,
+num_gpus=1,
+max_gpu_memory="20GiB"
+```
+
+其中，`gpus` 控制使用的显卡的ID，如果 "0,1";
+
+`num_gpus` 控制使用的卡数;
+
+`max_gpu_memory` 控制每个卡使用的显存容量。
+
+#### 5.2 启动 API 服务
+
+本地部署情况下，按照 [5.1 节](README.md#5.1-启动-LLM-服务)**启动 LLM 服务后**，再执行 [server/api.py](server/api.py) 脚本启动 **API** 服务；
+
+在线调用API服务的情况下，直接执执行 [server/api.py](server/api.py) 脚本启动 **API** 服务；
+
+调用命令示例：
+
+```shell
+$ python server/api.py
+```
+
+启动 API 服务后，可访问 `localhost:7861` 或 `{API 所在服务器 IP}:7861` FastAPI 自动生成的 docs 进行接口查看与测试。
+
+
+
+#### 5.3 启动 Web UI 服务
+
+按照 [5.2 节](README.md#5.2-启动-API-服务)**启动 API 服务后**，执行 [webui.py](webui.py) 启动 **Web UI** 服务（默认使用端口 `8501`）
+
+```shell
+$ streamlit run webui.py
+```
+
+使用 Langchain-Chatchat 主题色启动 **Web UI** 服务（默认使用端口 `8501`）
+
+```shell
+$ streamlit run webui.py --theme.base "light" --theme.primaryColor "#165dff" --theme.secondaryBackgroundColor "#f5f5f5" --theme.textColor "#000000"
+```
+
+或使用以下命令指定启动 **Web UI** 服务并指定端口号
+
+```shell
+$ streamlit run webui.py --server.port 666
+```
+
+- Web UI 对话界面：
+
+ 
+
+---
+
+### 6. 一键启动
+
+更新一键启动脚本 startup.py,一键启动所有 Fastchat 服务、API 服务、WebUI 服务，示例代码：
+
+```shell
+$ python startup.py -a
+```
+
+并可使用 `Ctrl + C` 直接关闭所有运行服务。如果一次结束不了，可以多按几次。
+
+可选参数包括 `-a (或--all-webui)`, `--all-api`, `--llm-api`, `-c (或--controller)`, `--openai-api`,
+`-m (或--model-worker)`, `--api`, `--webui`，其中：
+
+- `--all-webui` 为一键启动 WebUI 所有依赖服务；
+- `--all-api` 为一键启动 API 所有依赖服务；
+- `--llm-api` 为一键启动 Fastchat 所有依赖的 LLM 服务；
+- `--openai-api` 为仅启动 FastChat 的 controller 和 openai-api-server 服务；
+- 其他为单独服务启动选项。
+
+若想指定非默认模型，需要用 `--model-name` 选项，示例：
+
+```shell
+$ python startup.py --all-webui --model-name Qwen-7B-Chat
+```
+
+更多信息可通过 `python startup.py -h`查看。
+
+**注意：**
+
+**1. startup 脚本用多进程方式启动各模块的服务，可能会导致打印顺序问题，请等待全部服务发起后再调用，并根据默认或指定端口调用服务（默认 LLM API 服务端口：`127.0.0.1:8888`,默认 API 服务端口：`127.0.0.1:7861`,默认 WebUI 服务端口：`本机IP：8501`)**
+
+**2.服务启动时间示设备不同而不同，约 3-10 分钟，如长时间没有启动请前往 `./logs`目录下监控日志，定位问题。**
+
+**3. 在Linux上使用ctrl+C退出可能会由于linux的多进程机制导致multiprocessing遗留孤儿进程，可通过shutdown_all.sh进行退出**
+
diff --git a/internlm_langchain/chains/llmchain_with_history.py b/internlm_langchain/chains/llmchain_with_history.py
new file mode 100644
index 00000000..3d360422
--- /dev/null
+++ b/internlm_langchain/chains/llmchain_with_history.py
@@ -0,0 +1,29 @@
+from langchain.chat_models import ChatOpenAI
+from configs.model_config import llm_model_dict, LLM_MODEL
+from langchain import LLMChain
+from langchain.prompts.chat import (
+ ChatPromptTemplate,
+ HumanMessagePromptTemplate,
+)
+
+model = ChatOpenAI(
+ streaming=True,
+ verbose=True,
+ # callbacks=[callback],
+ openai_api_key=llm_model_dict[LLM_MODEL]["api_key"],
+ openai_api_base=llm_model_dict[LLM_MODEL]["api_base_url"],
+ model_name=LLM_MODEL
+)
+
+
+human_prompt = "{input}"
+human_message_template = HumanMessagePromptTemplate.from_template(human_prompt)
+
+chat_prompt = ChatPromptTemplate.from_messages(
+ [("human", "我们来玩成语接龙，我先来，生龙活虎"),
+ ("ai", "虎头虎脑"),
+ ("human", "{input}")])
+
+
+chain = LLMChain(prompt=chat_prompt, llm=model, verbose=True)
+print(chain({"input": "恼羞成怒"}))
\ No newline at end of file
diff --git a/internlm_langchain/common/__init__.py b/internlm_langchain/common/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/internlm_langchain/configs/__init__.py b/internlm_langchain/configs/__init__.py
new file mode 100644
index 00000000..7c105f4e
--- /dev/null
+++ b/internlm_langchain/configs/__init__.py
@@ -0,0 +1,4 @@
+from .model_config import *
+from .server_config import *
+
+VERSION = "v0.2.2"
diff --git a/internlm_langchain/configs/model_config.py b/internlm_langchain/configs/model_config.py
new file mode 100644
index 00000000..ee970d25
--- /dev/null
+++ b/internlm_langchain/configs/model_config.py
@@ -0,0 +1,173 @@
+import os
+import logging
+import torch
+# 日志格式
+LOG_FORMAT = "%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s"
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+logging.basicConfig(format=LOG_FORMAT)
+
+
+# 在以下字典中修改属性值，以指定本地embedding模型存储位置
+# 如将 "text2vec": "GanymedeNil/text2vec-large-chinese" 修改为 "text2vec": "User/Downloads/text2vec-large-chinese"
+# 此处请写绝对路径
+embedding_model_dict = {
+ "ernie-tiny": "nghuyong/ernie-3.0-nano-zh",
+ "ernie-base": "nghuyong/ernie-3.0-base-zh",
+ "text2vec-base": "shibing624/text2vec-base-chinese",
+ "text2vec": "GanymedeNil/text2vec-large-chinese",
+ "text2vec-paraphrase": "shibing624/text2vec-base-chinese-paraphrase",
+ "text2vec-sentence": "shibing624/text2vec-base-chinese-sentence",
+ "text2vec-multilingual": "shibing624/text2vec-base-multilingual",
+ "m3e-small": "moka-ai/m3e-small",
+ "m3e-base": "/root/huggingface/m3e-base",
+ "m3e-large": "moka-ai/m3e-large",
+ "bge-small-zh": "BAAI/bge-small-zh",
+ "bge-base-zh": "BAAI/bge-base-zh",
+ "bge-large-zh": "BAAI/bge-large-zh",
+ "bge-large-zh-noinstruct": "BAAI/bge-large-zh-noinstruct",
+ "text-embedding-ada-002": os.environ.get("OPENAI_API_KEY")
+}
+
+# 选用的 Embedding 名称
+EMBEDDING_MODEL = "m3e-base"
+
+# Embedding 模型运行设备
+EMBEDDING_DEVICE = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+
+
+llm_model_dict = {
+ "chatglm-6b": {
+ "local_model_path": "THUDM/chatglm-6b",
+ "api_base_url": "http://localhost:8888/v1", # "name"修改为fastchat服务中的"api_base_url"
+ "api_key": "EMPTY"
+ },
+
+ "chatglm2-6b": {
+ "local_model_path": "/root/huggingface/chatglm2-6b",
+ "api_base_url": "http://localhost:8123/v1", # URL需要与运行fastchat服务端的server_config.FSCHAT_OPENAI_API一致
+ "api_key": "EMPTY"
+ },
+ "internlm-chat-7b": {
+ "local_model_path": "/root/huggingface/internlm-chat-7b-v1_1",
+ "api_base_url": "http://localhost:8123/v1", # URL需要与运行fastchat服务端的server_config.FSCHAT_OPENAI_API一致
+ "api_key": "EMPTY"
+ },
+
+ "chatglm2-6b-32k": {
+ "local_model_path": "THUDM/chatglm2-6b-32k", # "THUDM/chatglm2-6b-32k",
+ "api_base_url": "http://localhost:8888/v1", # "URL需要与运行fastchat服务端的server_config.FSCHAT_OPENAI_API一致
+ "api_key": "EMPTY"
+ },
+
+ # 调用chatgpt时如果报出： urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host='api.openai.com', port=443):
+ # Max retries exceeded with url: /v1/chat/completions
+ # 则需要将urllib3版本修改为1.25.11
+ # 如果依然报urllib3.exceptions.MaxRetryError: HTTPSConnectionPool，则将https改为http
+ # 参考https://zhuanlan.zhihu.com/p/350015032
+
+ # 如果报出：raise NewConnectionError(
+ # urllib3.exceptions.NewConnectionError:
+
+
+7B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama2 /path/to/llama-2-7b-chat-hf +bash workspace/service_docker_up.sh +``` + +
+
+
+13B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama2 /path/to/llama-2-13b-chat-hf --tp 2 +bash workspace/service_docker_up.sh +``` + +
+
+
+## 部署 [LLaMA](https://github.com/facebookresearch/llama) 服务
+
+请填写[这张表](https://docs.google.com/forms/d/e/1FAIpQLSfqNECQnMkycAp2jP4Z9TFX0cGR4uf7b_fBxjY_OjhJILlKGA/viewform)，获取 LLaMA 模型权重
+
+70B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama2 /path/to/llama-2-70b-chat-hf --tp 8 +bash workspace/service_docker_up.sh +``` + +
+
+
+7B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama /path/to/llama-7b llama \ + --tokenizer_path /path/to/tokenizer/model +bash workspace/service_docker_up.sh +``` + +
+
+
+13B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama /path/to/llama-13b llama \ + --tokenizer_path /path/to/tokenizer/model --tp 2 +bash workspace/service_docker_up.sh +``` + +
+
+
+30B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama /path/to/llama-30b llama \ + --tokenizer_path /path/to/tokenizer/model --tp 4 +bash workspace/service_docker_up.sh +``` + +
+
+
+### 部署 [Vicuna](https://lmsys.org/blog/2023-03-30-vicuna/) 服务
+
+65B
+ +```shell +python3 -m lmdeploy.serve.turbomind.deploy llama /path/to/llama-65b llama \ + --tokenizer_path /path/to/tokenizer/model --tp 8 +bash workspace/service_docker_up.sh +``` + +
+
+
+7B
+ +```shell +python3 -m pip install fschat +python3 -m fastchat.model.apply_delta \ + --base-model-path /path/to/llama-7b \ + --target-model-path /path/to/vicuna-7b \ + --delta-path lmsys/vicuna-7b-delta-v1.1 + +python3 -m lmdeploy.serve.turbomind.deploy vicuna /path/to/vicuna-7b +bash workspace/service_docker_up.sh +``` + +
+
diff --git a/internlm_langchain/knowledge_base/LMDeploy/content/turbomind.md b/internlm_langchain/knowledge_base/LMDeploy/content/turbomind.md
new file mode 100644
index 00000000..e51a0199
--- /dev/null
+++ b/internlm_langchain/knowledge_base/LMDeploy/content/turbomind.md
@@ -0,0 +1,70 @@
+# TurboMind
+
+TurboMind 是一款关于 LLM 推理的高效推理引擎，基于英伟达的 [FasterTransformer](https://github.com/NVIDIA/FasterTransformer) 研发而成。它的主要功能包括：LLaMa 结构模型的支持，persistent batch 推理模式和可扩展的 KV 缓存管理器。
+
+## TurboMind 结构
+
+```
+ +--------------------+
+ | API |
+ +--------------------+
+ | ^
+ 请 求 | | 流式回调
+ v |
+ +--------------------+ 获取 +-------------------+
+ | Persistent Batch | <-------> | KV Cache 管理器 |
+ +--------------------+ 更新 +-------------------+
+ ^
+ |
+ v
++------------------------+
+| LLaMa推理实现 |
++------------------------+
+| FT kernels & utilities |
++------------------------+
+```
+
+## Persistent Batch
+
+你也许在别的项目中看到这项机制的另一个名字： `continuous batching` 。在开发这个功能时，我们将对话式 LLM 的推理建模为一个持续运行的 batch ，其生命周期跨越整个服务过程，故将其命名为 `persistent batch` 。简单来说是这样实现的：
+
+- 该功能会预先准备好 N 个 batch slots。
+- 当有空闲 slots 时， 请求就会加入到 batch 中。当请求对应的 tokens 都生成完毕后，对应的 batch slot 会立刻被释放，接收新的请求。
+- **当一个 sequence 命中缓存时（见下文），它的历史 token 不必在每轮中都进行解码，所以它的 token 生成过程会即刻开始**。
+- 整个 batch 会自动扩缩容来避免不必要的计算。
+
+## KV 缓存管理器
+
+TurboMind 的 [KV 缓存管理器](https://github.com/InternLM/lmdeploy/blob/main/src/turbomind/models/llama/LlamaCacheManager.h) 是一个内存池类型的对象，并且在其中加入了 LRU 的实现，这样整个管理器可以被看作是一个 **KV 缓存的缓存**。大致工作方式如下：
+
+- KV 缓存由管理器分配。管理器会根据预先配置好的 slot 数量开辟空间。每个 slot 对应于一个 sequence 所需的 KV 缓存。分配的内存块大小可通过配置来实现预分配或者按需分配（或介于两者之间）。
+- 当有新的请求，但是缓存池中没有空闲 slot时，根据 LRU 机制，管理器会踢除最近使用最少的 sequence，把它占据的 slot 分给新的请求。不仅仅如此，
+- sequence获取到了slot，类似缓存命中。它在缓存中的历史KV会被直接返回，而不用在进行context decoding 。
+- 被踢除的 sequences 不会被完全的删除，而是会被转换成最简洁的形式，例如 token IDs 。当之后获取到相同的 sequence id 时 (即 _cache-miss_ 状态)，这些 token IDs 将被 FMHA 的 context decoder 解码并被转回 KV 缓存。
+- 踢除和转换均由 TurboMind 内部自动管理所以对用户来说是透明的。__从用户的使用角度来看，使用了 TurboMind 的系统就像是可以访问无限的设备内存__。
+
+## TurboMind 的 LLaMa 实现
+
+我们对 LLaMa 系列模型的实现是从 FasterTransformer 中的 Gpt-NeX 模型修改而来的。除了对 LLaMa 系列进行基本重构和修改外，我们还做了一些改进以实现会话模型的高性能推理，其中最重要的是：
+
+- 支持多轮对话中的快速文本解码。我们用基于 [cutlass](https://github.com/NVIDIA/cutlass) 的 FMHA 实现替代了 context decoder 中的注意力机制实现，从而支持了 Q/K 长度不匹配的情况。
+- 我们在 context FMHA 和 generation FMHA 中都加入了间接缓冲指针，支持 batch 中不连续的 KV 缓存。
+- 为了支持 persistent batch 的并发推理，我们设计了新的同步机制来协调在张量并型模式下的工作线程。
+- 我们实现了 INT8 KV cache，降低了内存开销，提高了批处理大小和系统吞吐量。这在实际场景中非常有用，因为相比权重和其他激活，KV cache 会消耗更多的内存和内存带宽。
+- 我们解决了单个进程内多个模型实例在 TP 模式下运行时 NCCL 卡住的问题。NCCL APIs 现由 host 端的同步 barriers 保护。
+
+## API
+
+TurboMind 的 Python API 支持流式结果返回和张量并行模式。
+
+同时 TurboMind 也继承了 FasterTransformer 能够注册为 [Triton Inference Server](https://github.com/triton-inference-server/server) 推理后端的能力。但是为了支持 persistent batch 中的并发请求，我们不再像 FasterTransformer 那样使用 sequence batching 或者 dynamic batching 。相反，TurboMind 负责记录和管理请求序列的状态。
+
+## TurboMind 和 FasterTransformer 的区别
+
+除了上文中提到的功能外，TurboMind 相较于 FasterTransformer 还有不少差别。譬如不少 FasterTransformer 的功能在 TurboMind 中都被去掉了，这其中包括前缀提示词、 beam search 、上下文 embedding、稀疏化 GEMM 操作和对应 GPT 或 T5 等结构的模型的支持等等。
+
+## FAQ
+
+### 对 Huggingface 模型的支持
+
+因为历史因素， TurboMind 的权重设计是基于 [LLaMa 的官方实现](https://github.com/facebookresearch/llama) 完成的，两者只相差一个转置操作。但是 Huggingface 版本的实现却是[另一种形式](https://github.com/huggingface/transformers/blob/45025d92f815675e483f32812caa28cce3a960e7/src/transformers/models/llama/convert_llama_weights_to_hf.py#L123C76-L123C76)，两种权重实现方式在 `W_q` 和 `W_k` 上的区别我们在 [deploy.py](https://github.com/InternLM/lmdeploy/blob/ff4648a1d09e5aec74cf70efef35bfaeeac552e0/lmdeploy/serve/turbomind/deploy.py#L398) 进行了适配处理，用户可前往查看。
diff --git a/internlm_langchain/knowledge_base/LMDeploy/content/w4a16.md b/internlm_langchain/knowledge_base/LMDeploy/content/w4a16.md
new file mode 100644
index 00000000..a67304b6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/LMDeploy/content/w4a16.md
@@ -0,0 +1,97 @@
+# W4A16 LLM 模型部署
+
+LMDeploy 支持 4bit 权重模型的推理，**对 NVIDIA 显卡的最低要求是 sm80**，比如A10，A100，Gerforce 30/40系列。
+
+在推理之前，请确保安装了 lmdeploy
+
+```shell
+pip install lmdeploy
+```
+
+## 4bit 权重模型推理
+
+你可以直接从 LMDeploy 的 [model zoo](https://huggingface.co/lmdeploy) 下载已经量化好的 4bit 权重模型，直接使用下面的命令推理。也可以根据["4bit 权重量化"](#4bit-权重量化)章节的内容，把 16bit 权重量化为 4bit 权重，然后再按下述说明推理
+
+以 4bit 的 Llama-2-chat-7B 模型为例，可以从 model zoo 直接下载：
+
+```shell
+git-lfs install
+git clone https://huggingface.co/lmdeploy/llama2-chat-7b-w4
+```
+
+执行以下命令，即可在终端与模型对话：
+
+```shell
+
+## 转换模型的layout，存放在默认路径 ./workspace 下
+python3 -m lmdeploy.serve.turbomind.deploy \
+ --model-name llama2 \
+ --model-path ./llama2-chat-7b-w4 \
+ --model-format awq \
+ --group-size 128
+
+## 推理
+python3 -m lmdeploy.turbomind.chat ./workspace
+```
+
+## 启动 gradio 服务
+
+如果想通过 webui 与模型对话，请执行以下命令启动 gradio 服务
+
+```shell
+python3 -m lmdeploy.serve.turbomind ./workspace --server_name {ip_addr} ----server_port {port}
+```
+
+然后，在浏览器中打开 http://{ip_addr}:{port}，即可在线对话
+
+## 推理速度
+
+我们在 NVIDIA GeForce RTX 4090 上使用 [profile_generation.py](https://github.com/InternLM/lmdeploy/blob/main/benchmark/profile_generation.py)，分别测试了 4-bit Llama-2-7B-chat 和 Llama-2-13B-chat 模型的 token 生成速度。测试配置为 batch size = 1，(prompt_tokens, completion_tokens) = (1, 512)
+
+| model | llm-awq | mlc-llm | turbomind |
+| ---------------- | ------- | ------- | --------- |
+| Llama-2-7B-chat | 112.9 | 159.4 | 206.4 |
+| Llama-2-13B-chat | N/A | 90.7 | 115.8 |
+
+上述两个模型的16bit 和 4bit 权重，分别使用 turbomind 推理时，各自在context size 为 2048 和 4096 配置下，所占的显存对比如下：
+
+| model | 16bit(2048) | 4bit(2048) | 16bit(4096) | 4bit(4096) |
+| ---------------- | ----------- | ---------- | ----------- | ---------- |
+| Llama-2-7B-chat | 15.1 | 6.3 | 16.2 | 7.5 |
+| Llama-2-13B-chat | OOM | 10.3 | OOM | 12.0 |
+
+```shell
+python benchmark/profile_generation.py \
+ ./workspace \
+ --concurrency 1 --input_seqlen 1 --output_seqlen 512
+```
+
+## 4bit 权重量化
+
+4bit 权重量化包括 2 步：
+
+- 生成量化参数
+- 根据量化参数，量化模型权重
+
+### 第一步：生成量化参数
+
+```shell
+python3 -m lmdeploy.lite.apis.calibrate \
+ --model $HF_MODEL \
+ --calib_dataset 'c4' \ # 校准数据集，支持 c4, ptb, wikitext2, pileval
+ --calib_samples 128 \ # 校准集的样本数，如果显存不够，可以适当调小
+ --calib_seqlen 2048 \ # 单条的文本长度，如果显存不够，可以适当调小
+ --work_dir $WORK_DIR \ # 保存 Pytorch 格式量化统计参数和量化后权重的文件夹
+```
+
+### 第二步：量化权重模型
+
+LMDeploy 使用 AWQ 算法对模型权重进行量化。在执行下面的命令时，需要把步骤1的`$WORK_DIR`传入。量化结束后，权重文件也会存放在这个目录中。然后就可以根据 ["4bit权重模型推理"](#4bit-权重模型推理)章节的说明，进行模型推理。
+
+```shell
+python3 -m lmdeploy.lite.apis.auto_awq \
+ --model $HF_MODEL \
+ --w_bits 4 \ # 权重量化的 bit 数
+ --w_group_size 128 \ # 权重量化分组统计尺寸
+ --work_dir $WORK_DIR \ # 步骤 1 保存量化参数的目录
+```
diff --git a/internlm_langchain/knowledge_base/LMDeploy/vector_store/index.faiss b/internlm_langchain/knowledge_base/LMDeploy/vector_store/index.faiss
new file mode 100644
index 00000000..9bcda8dc
Binary files /dev/null and b/internlm_langchain/knowledge_base/LMDeploy/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMAction/content/DATASET.md b/internlm_langchain/knowledge_base/MMAction/content/DATASET.md
new file mode 100644
index 00000000..df8c4e2d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMAction/content/DATASET.md
@@ -0,0 +1,69 @@
+## Dataset Preparation
+
+### Notes on Video Data format
+MMAction supports two types of data format: raw frames and video. The former is widely used in previous projects such as [TSN](https://github.com/yjxiong/temporal-segment-networks).
+This is fast (especially when SSD is available) but fails to scale to the fast-growing datasets.
+(For example, the newest edition of [Kinetics](https://deepmind.com/research/open-source/open-source-datasets/kinetics/) has 650K videos and the total frames will take up several TBs.)
+The latter save much space but is slower due to video decoding at execution time.
+To alleviate such issue, we use [decord](https://github.com/zhreshold/decord) for efficient video loading.
+
+For action recognition, both formats are supported.
+For temporal action detection and spatial-temporal action detection, we still recommend the format of raw frames.
+
+
+### Supported datasets
+The supported datasets are listed below.
+We provide shell scripts for data preparation under the path `$MMACTION/data_tools/`.
+To ease usage, we provide tutorials of data deployment for each dataset.
+
+- [HMDB51](http://serre-lab.clps.brown.edu/resource/hmdb-a-large-human-motion-database/): See [PREPARING_HMDB51.md](https://github.com/open-mmlab/mmaction/tree/master/data_tools/hmdb51/PREPARING_HMDB51.md)
+- [UCF101](https://www.crcv.ucf.edu/data/UCF101.php): See [PREPARING_UCF101.md](https://github.com/open-mmlab/mmaction/tree/master/data_tools/ucf101/PREPARING_UCF101.md)
+- [Kinetics400](https://deepmind.com/research/open-source/open-source-datasets/kinetics/): See [PREPARING_KINETICS400.md](https://github.com/open-mmlab/mmaction/tree/master/data_tools/kinetics400/PREPARING_KINETICS400.md)
+- [THUMOS14](https://www.crcv.ucf.edu/THUMOS14/download.html): See [PREPARING_TH14.md](https://github.com/open-mmlab/mmaction/tree/master/data_tools/thumos14/PREPARING_TH14.md)
+- [AVA](https://research.google.com/ava/): See [PREPARING_AVA.md](https://github.com/open-mmlab/mmaction/tree/master/data_tools/ava/PREPARING_AVA.md)
+
+
+Now, you can switch to [GETTING_STARTED.md](https://github.com/open-mmlab/mmaction/tree/master/GETTING_STARTED.md) to train and test the model.
+
+
+**TL;DR** The following guide is helpful when you want to experiment with custom dataset.
+Similar to the datasets stated above, it is recommended organizing in `$MMACTION/data/$DATASET`.
+
+### Prepare annotations
+
+### Prepare videos
+Please refer to the official website and/or the official script to prepare the videos.
+Note that the videos should be arranged in either (1) a two-level directory organized by `${CLASS_NAME}/${VIDEO_ID}` or (2) a single-level directory.
+It is recommended using (1) for action recognition datasets (such as UCF101 and Kinetics) and using (2) for action detection datasets or those with multiple annotations per video (such as THUMOS14 and AVA).
+
+
+### Extract frames
+To extract frames (optical flow, to be specific), [dense_flow](https://github.com/yjxiong/dense_flow) is needed.
+(**TODO**: This will be merged into MMAction in the next version in a smoother way).
+For the time being, please use the following command:
+
+```shell
+python build_rawframes.py $SRC_FOLDER $OUT_FOLDER --df_path $PATH_OF_DENSE_FLOW --level {1, 2}
+```
+- `$SRC_FOLDER` points to the folder of the original video (for example)
+- `$OUT_FOLDER` points to the root folder where the extracted frames and optical flow store
+- `$PATH_OF_DENSE_FLOW` points to the root folder where dense_flow is installed.
+- `--level` is either 1 for the single-level directory or 2 for the two-level directory
+
+The recommended practice is
+
+1. set `$OUT_FOLDER` to be an folder located in SSD
+2. symlink the link `$OUT_FOLDER` to `$MMACTION/data/$DATASET/rawframes`.
+
+```shell
+ln -s ${OUT_FOLDER} $MMACTION/data/$DATASET/rawframes
+```
+
+### Generate filelist
+```shell
+cd $MMACTION
+python data_tools/build_file_list.py ${DATASET} ${SRC_FOLDER} --level {1, 2} --format {rawframes, videos}
+```
+- `${SRC_FOLDER}` should point to the folder of the corresponding to the data format:
+ - "$MMACTION/data/$DATASET/rawframes" if `--format rawframes`
+ - "$MMACTION/data/$DATASET/videos" if `--format videos`
diff --git a/internlm_langchain/knowledge_base/MMAction/content/DOCKER.md b/internlm_langchain/knowledge_base/MMAction/content/DOCKER.md
new file mode 100644
index 00000000..9ce308bf
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMAction/content/DOCKER.md
@@ -0,0 +1,40 @@
+# using Docker to set environment of mmaction
+
+## Requirements
+
+We've been testing/build from ubuntu 18.04 LTS & docker version 19.03.1 (with docker API version 1.40). If you want to building docker images, you could have
+
+- Docker Engine
+- nvidia-docker (to start container with GPUs)
+- Disk space (a lot)
+
+## Install Docker Engine (Ubuntu version)
+
+```
+$ curl -fsSL https://get.docker.com -o get-docker.sh
+$ sh get-docker.sh
+```
+
+## Install Nvidia-Docker
+
+You could update from [nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+
+## Build the images
+
+You could see the ```Dockerfile``` on [this](https://github.com/open-mmlab/mmaction) repository. So you can copy this file and build as manually or clone this repository.
+
+```
+$ git clone --recursive https://github.com/open-mmlab/mmaction
+$ cd mmaction
+$ docker build -t mmaction .
+```
+
+So when you building this image. The image will not successfully because we want to modified in this code. So you can clone repository in container manually from next step below.
+
+## Run container from images
+
+```
+$ docker run --name mmaction --gpus all -it -v /path/to/your/data:/root mmaction
+```
+
+When run the container, Please follow step [GETTING_STARTED.md](https://github.com/open-mmlab/mmaction/blob/master/GETTING_STARTED.md) to use mmaction.
\ No newline at end of file
diff --git a/internlm_langchain/knowledge_base/MMAction/content/GETTING_STARTED.md b/internlm_langchain/knowledge_base/MMAction/content/GETTING_STARTED.md
new file mode 100644
index 00000000..7c7ca8f9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMAction/content/GETTING_STARTED.md
@@ -0,0 +1,96 @@
+# Getting Started
+
+This document provides basic tutorials for the usage of MMAction.
+For installation, please refer to [INSTALL.md](https://github.com/open-mmlab/mmaction/blob/master/INSTALL.md).
+For data deployment, please refer to [DATASET.md](https://github.com/open-mmlab/mmaction/blob/master/DATASET.md).
+
+
+## An example on UCF-101
+We first give an example of testing and training action recognition models on UCF101.
+### Prepare data
+First of all, please follow [PREPARING_UCF101.md](https://github.com/open-mmlab/mmaction/blob/master/data_tools/ucf101/PREPARING_UCF101.md) for data preparation.
+
+### Test a reference model
+Reference models are stored in [MODEL_ZOO.md](https://github.com/open-mmlab/mmaction/blob/master/MODEL_ZOO.md).
+We download a reference model spatial stream BN-Inception at `$MMACTION/modelzoo` using:
+```shell
+wget -c https://open-mmlab.s3.ap-northeast-2.amazonaws.com/mmaction/models/ucf101/tsn_2d_rgb_bninception_seg3_f1s1_b32_g8-98160339.pth -P ./modelzoo/
+```
+Then, together with provided configs files, we run the following code to test with multiple GPUs:
+```shell
+./tools/dist_test_recognizer.sh test_configs/TSN/ucf101/tsn_rgb_bninception.py tsn_2d_rgb_bninception_seg3_f1s1_b32_g8-98160339.pth 8
+```
+
+When testing 3D ConvNets, the oversample we used is 10 clips x 3 crops by default. For some extremely large models, it might be difficult for so many samples to fit on 1 GPU. When it happens, you can use commands for heavy test instead:
+```shell
+./tools/dist_test_recognizer_heavy.sh test_configs/CSN\ircsn_kinetics400_se_rgb_r152_seg1_32x2.py ircsn_kinetics400_se_rgb_r152_f32s2_ig65m_fbai-9d6ed879.pth 8 --batch_size=5
+```
+
+
+### Train a model with multiple GPUs
+
+To reproduce the model, we provide training scripts as follows:
+```shell
+./tools/dist_train_recognizer.sh configs/TSN/ucf101/tsn_rgb_bninception.py 8 --validate
+```
+- `--validate`: performs evaluation every k (default=1) epochs during the training, which help diagnose training process.
+
+
+## More examples
+The procedure is not limited to action recognition in UCF101.
+To perform spatial-temporal detection on AVA, we can train a baseline model by running
+```shell
+./tools/dist_train_detector.sh configs/ava/ava_fast_rcnn_nl_r50_c4_1x_kinetics_pretrain_crop.py 8 --validate
+```
+and evaluate a reference model by running
+```shell
+wget -c wget -c https://open-mmlab.s3.ap-northeast-2.amazonaws.com/mmaction/models/ava/fast_rcnn_ava2.1_nl_r50_c4_1x_f32s2_kin-e2495b48.pth -P modelzoo/
+python tools/test_detector.py ava_fast_rcnn_nl_r50_c4_1x_kinetics_pretrain_crop.py modelzoo/fast_rcnn_ava2.1_nl_r50_c4_1x_f32s2_kin-e2495b48.pth --out ava_fast_rcnn_nl_r50_multiscale.pkl --gpus 8 --eval bbox
+```
+
+To perform temporal action detection on THUMOS14, we can training a baseline model by running
+```shell
+./tools/dist_train_localizer.sh configs/thumos14/ssn_thumos14_rgb_bn_inception.py 8
+```
+and evaluate a reference model by running
+```shell
+wget -c wget -c https://open-mmlab.s3.ap-northeast-2.amazonaws.com/mmaction/models/thumos14/ssn_thumos14_rgb_bn_inception_tag-dac9ddb0.pth -P modelzoo/
+python tools/test_detector.py configs/thumos14/ssn_thumos14_rgb_bn_inception.py modelzoo/ssn_thumos14_rgb_bn_inception_tag-dac9ddb0.pth --gpus 8 --out ssn_thumos14_rgb_bn_inception.pkl --eval thumos14
+```
+
+
+## More Abstract Usage
+
+## Inference with pretrained models
+We provide testing scripts to evaluate a whole dataset.
+
+### Test a dataset
+```shell
+python tools/test_${ARCH}.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [other task-specific arguments]
+```
+Arguments:
+- `${ARCH}` could be
+ - "recognizer" for action recognition (TSN, I3D, SlowFast, R(2+1)D, CSN, ...)
+ - "localizer" for temporal action detection/localization (SSN)
+ - "detector" for spatial-temporal action detection (a re-implmented Fast-RCNN baseline)
+- `${CONFIG_FILE}` is the config file stored in `$MMACTION/test_configs`.
+- `${CHECKPOINT_FILE}` is the checkpoint file.
+ Please refer to [MODEL_ZOO.md](https://github.com/open-mmlab/mmaction/blob/master/MODEL_ZOO.md) for more details.
+
+
+## Train a model
+MMAction implements distributed training and non-distributed training, powered by the same engine of [mmdetection](https://github.com/open-mmlab/mmdetection).
+
+
+### Train with multiple GPUs (Recommended)
+Training with multiple GPUs follows the rules below:
+
+```shell
+./tools/dist_train_${ARCH}.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+- ${ARCH} could be
+ - "recognizer" for action recognition (TSN, I3D, ...)
+ - "localizer" for temporal action detection/localization (SSN)
+ - "detector" for spatial-temporal action detection (a re-implmented Fast-RCNN baseline)
+- ${CONFIG_FILE} is the config file stored in `$MMACTION/configs`.
+- ${GPU_NUM} is the number of GPU (default: 8). If you are using number other than 8, please adjust the learning rate in the config file linearly.
diff --git a/internlm_langchain/knowledge_base/MMAction/content/INSTALL.md b/internlm_langchain/knowledge_base/MMAction/content/INSTALL.md
new file mode 100644
index 00000000..9052d1a1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMAction/content/INSTALL.md
@@ -0,0 +1,159 @@
+# Installation
+
+```shell
+git clone --recursive https://github.com/open-mmlab/mmaction.git
+```
+
+## Requirements
+
+- Linux
+- Python 3.5+
+- PyTorch 1.0+
+- CUDA 9.0+
+- NVCC 2+
+- GCC 4.9+
+- ffmpeg 4.0+
+- [mmcv](https://github.com/open-mmlab/mmcv).
+ Note that you are strongly recommended to clone the master branch and build from scratch since some of the features have not been added in the latest release.
+- [Decord](https://github.com/zhreshold/decord)
+- [dense_flow](https://github.com/yjxiong/dense_flow)
+
+Note that the last two will be contained in this codebase as a submodule.
+
+## Install Pre-requisites
+### Install Decord (Optional)
+[Decord](https://github.com/zhreshold/decord) is an efficient video loader with smart shuffling.
+This is required when you want to use videos as the input format for training and is more efficient than OpenCV, useds by [mmcv](https://github.com/open-mmlab/mmcv).
+If you just want to have a quick experience with MMAction, you can simply skip this step.
+The installation steps follow decord's documentation.
+
+(a) install the required packages by running:
+
+```shell
+# official PPA comes with ffmpeg 2.8, which lacks tons of features, we use ffmpeg 4.0 here
+sudo apt-get install -y software-properties-common
+sudo add-apt-repository ppa:jonathonf/ffmpeg-4
+sudo apt-get update
+sudo apt-get install -y build-essential python3-dev python3-setuptools make cmake
+libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev
+# note: make sure you have cmake 3.8 or later, you can install from cmake official website if it's too old
+sudo apt-get install ffmpeg
+```
+
+(b) Build the library from source
+
+```shell
+cd third_party/decord
+mkdir build && cd build
+cmake .. -DUSE_CUDA=0
+make
+```
+
+(c) Install python binding
+
+```shell
+cd ../python
+python setup.py install --user
+cd ../../
+```
+
+### Install dense_flow (Optional)
+[Dense_flow](https://github.com/yjxiong/dense_flow) is used to calculate the optical flow of videos.
+If you just want to have a quick experience with MMAction without taking pain of installing opencv, you can skip this step.
+
+Note that Dense_flow now supports OpenCV 4.1.0, 3.1.0 and 2.4.13.
+The master branch is for 4.1.0. For those with 2.4.13, please refer to the lines with strikethrough.
+
+13B
+ +```shell +python3 -m pip install fschat +python3 -m fastchat.model.apply_delta \ + --base-model-path /path/to/llama-13b \ + --target-model-path /path/to/vicuna-13b \ + --delta-path lmsys/vicuna-13b-delta-v1.1 + +python3 -m lmdeploy.serve.turbomind.deploy vicuna /path/to/vicuna-13b +bash workspace/service_docker_up.sh +``` + +从注释文件中构建数据列表。 | +| `MMAction2::BaseActionDataset` | `get_data_info(self, idx)`
给定 `idx`，从数据列表中返回相应的数据样本。 | +| `MMEngine::BaseDataset` | `__getitem__(self, idx)`
给定 `idx`，调用 `get_data_info` 获取数据样本，然后调用 `pipeline` 在 `train_pipeline` 或 `val_pipeline` 中执行数据变换和增强。 | + +## 定制新的数据集类 + +大多数情况下，把你的数据集离线转换成指定格式是首选方法，但 MMAction2 提供了一个方便的过程来创建一个定制的 `Dataset` 类。如前所述，任务特定的数据集只需要实现 `load_data_list(self)` 来从注释文件生成数据列表。请注意，`data_list` 中的元素是包含后续流程中必要字段的 `dict`。 + +以 `VideoDataset` 为例，`train_pipeline`/`val_pipeline` 在 `DecordInit` 中需要 `'filename'`，在 `PackActionInputs` 中需要 `'label'`。因此，`data_list` 中的数据样本必须包含2个字段：`'filename'`和`'label'`。 +请参考[定制数据流水线](customize_pipeline.md)以获取有关 `pipeline` 的更多详细信息。 + +``` +data_list.append(dict(filename=filename, label=label)) +``` + +`AVADataset` 会更加复杂，`data_list` 中的数据样本包含有关视频数据的几个字段。此外，它重写了 `get_data_info(self, idx)` 以转换在时空动作检测数据流水线中需要用的字段。 + +```python + +class AVADataset(BaseActionDataset): + ... + + def load_data_list(self) -> List[dict]: + ... + video_info = dict( + frame_dir=frame_dir, + video_id=video_id, + timestamp=int(timestamp), + img_key=img_key, + shot_info=shot_info, + fps=self._FPS, + ann=ann) + data_list.append(video_info) + data_list.append(video_info) + return data_list + + def get_data_info(self, idx: int) -> dict: + ... + ann = data_info.pop('ann') + data_info['gt_bboxes'] = ann['gt_bboxes'] + data_info['gt_labels'] = ann['gt_labels'] + data_info['entity_ids'] = ann['entity_ids'] + return data_info +``` + +## 为 PoseDataset 自定义关键点格式 + +MMAction2 目前支持三种关键点格式：`coco`，`nturgb+d` 和 `openpose`。如果你使用其中一种格式，你可以简单地在以下模块中指定相应的格式： + +对于图卷积网络，如 AAGCN，STGCN，... + +- `pipeline`：在 `JointToBone` 中的参数 `dataset`。 +- `backbone`：在图卷积网络中的参数 `graph_cfg`。 + +对于 PoseC3D： + +- `pipeline`：在 `Flip` 中，根据关键点的对称关系指定 `left_kp` 和 `right_kp`。 +- `pipeline`：在 `GeneratePoseTarget` 中，如果 `with_limb` 为 `True`，指定`skeletons`，`left_limb`，`right_limb`，如果 `with_kp` 为 `True`，指定`left_kp` 和 `right_kp`。 + +如果使用自定义关键点格式，需要在 `backbone` 和 `pipeline` 中都包含一个新的图布局。这个布局将定义关键点及其连接关系。 + +以 `coco` 数据集为例，我们在 `Graph` 中定义了一个名为 `coco` 的布局。这个布局的 `inward` 连接包括所有节点连接，每个**向心**连接由一个节点元组组成。`coco`的额外设置包括将节点数指定为 `17`，将 `node 0` 设为中心节点。 + +```python + +self.num_node = 17 +self.inward = [(15, 13), (13, 11), (16, 14), (14, 12), (11, 5), + (12, 6), (9, 7), (7, 5), (10, 8), (8, 6), (5, 0), + (6, 0), (1, 0), (3, 1), (2, 0), (4, 2)] +self.center = 0 +``` + +同样，我们在 `JointToBone` 中定义了 `pairs`，添加了一个 bone `(0, 0)` 以使 bone 的数量对齐到 joint。coco数据集的 `pairs` 如下所示，`JointToBone` 中的 `pairs` 的顺序无关紧要。 + +```python + +self.pairs = ((0, 0), (1, 0), (2, 0), (3, 1), (4, 2), + (5, 0), (6, 0), (7, 5), (8, 6), (9, 7), + (10, 8), (11, 0), (12, 0), (13, 11), (14, 12), + (15, 13), (16, 14)) +``` + +要使用你的自定义关键点格式，只需定义上述设置为你的图结构，并在你的配置文件中指定它们，如下所示。在这个例子中，我们将使用 `STGCN`，其中 `n` 表示类别的数量，`custom_dataset` 在 `Graph` 和 `JointToBone` 中定义。 + +```python +model = dict( + type='RecognizerGCN', + backbone=dict( + type='STGCN', graph_cfg=dict(layout='custom_dataset', mode='stgcn_spatial')), + cls_head=dict(type='GCNHead', num_classes=n, in_channels=256)) + +train_pipeline = [ + ... + dict(type='GenSkeFeat', dataset='custom_dataset'), + ...] + +val_pipeline = [ + ... + dict(type='GenSkeFeat', dataset='custom_dataset'), + ...] + +test_pipeline = [ + ... + dict(type='GenSkeFeat', dataset='custom_dataset'), + ...] + +``` + +只需简单地指定自定义布局，你就可以使用你自己的关键点格式进行训练和测试了。通过这种方式，MMAction2 为用户提供了很大的灵活性，允许用户自定义他们的数据集和关键点格式，以满足他们特定的需求。 + +以上就是关于如何自定义你的数据集的一些方法。希望这个教程能帮助你理解MMAction2的数据集结构，并教给你如何根据自己的需求创建新的数据集。虽然这可能需要一些编程知识，但是 MMAction2 试图使这个过程尽可能简单。通过了解这些基本概念，你将能够更好地控制你的数据，从而改进你的模型性能。 diff --git a/internlm_langchain/knowledge_base/MMAction2/content/customize_logging.md b/internlm_langchain/knowledge_base/MMAction2/content/customize_logging.md new file mode 100644 index 00000000..badb315c --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/customize_logging.md @@ -0,0 +1,163 @@ +# 自定义日志 + +MMAction2 在运行过程中会产生大量的日志，如损失、迭代时间、学习率等。在这一部分，我们将向你介绍如何输出自定义日志。有关日志系统的更多详细信息，请参考 [MMEngine 教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/logging.html)。 + +- [自定义日志](#自定义日志) + - [灵活的日志系统](#灵活的日志系统) + - [定制日志](#定制日志) + - [导出调试日志](#导出调试日志) + +## 灵活的日志系统 + +默认情况下，MMAction2 的日志系统由 [default_runtime](/configs/_base_/default_runtime.py) 中的 `LogProcessor` 配置： + +```python +log_processor = dict(type='LogProcessor', window_size=20, by_epoch=True) +``` + +默认情况下，`LogProcessor` 捕获 `model.forward` 返回的所有以 `loss` 开头的字段。例如，在以下模型中，`loss1` 和 `loss2` 将在没有任何额外配置的情况下自动记录到日志。 + +```python +from mmengine.model import BaseModel + +class ToyModel(BaseModel): + def __init__(self) -> None: + super().__init__() + self.linear = nn.Linear(1, 1) + + def forward(self, img, label, mode): + feat = self.linear(img) + loss1 = (feat - label).pow(2) + loss2 = (feat - label).abs() + return dict(loss1=loss1, loss2=loss2) +``` + +输出日志遵循以下格式： + +``` +08/21 02:58:41 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0019 data_time: 0.0004 loss1: 0.8381 loss2: 0.9007 loss: 1.7388 +08/21 02:58:41 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0029 data_time: 0.0010 loss1: 0.1978 loss2: 0.4312 loss: 0.6290 +``` + +`LogProcessor` 将按以下格式输出日志： + +- 日志的前缀： + - epoch 模式(`by_epoch=True`)：`Epoch(train) [{current_epoch}/{current_iteration}]/{dataloader_length}` + - iteration 模式(`by_epoch=False`)：`Iter(train) [{current_iteration}/{max_iteration}]` +- 学习率 (`lr`)：最后一次迭代的学习率。 +- 时间： + - `time`：过去 `window_size` 次迭代的推理平均时间。 + - `data_time`：过去 `window_size` 次迭代的数据加载平均时间。 + - `eta`：完成训练的预计到达时间。 +- 损失：过去 `window_size` 次迭代中模型输出的平均损失。 + +```{warning} +默认情况下，log_processor 输出基于 epoch 的日志(`by_epoch=True`)。要得到与 `train_cfg` 匹配的预期日志，我们应在 `train_cfg` 和 `log_processor` 中设置相同的 `by_epoch` 值。 +``` + +根据以上规则，代码片段将每20次迭代计算 loss1 和 loss2 的平均值。更多类型的统计方法，请参考 [mmengine.runner.LogProcessor](mmengine.runner.LogProcessor)。 + +## 定制日志 + +日志系统不仅可以记录 `loss`，`lr` 等，还可以收集和输出自定义日志。例如，如果我们想要统计中间损失： + +`ToyModel` 在 forward 中计算 `loss_tmp`，但不将其保存到返回字典中。 + +```python +from mmengine.logging import MessageHub + +class ToyModel(BaseModel): + + def __init__(self) -> None: + super().__init__() + self.linear = nn.Linear(1, 1) + + def forward(self, img, label, mode): + feat = self.linear(img) + loss_tmp = (feat - label).abs() + loss = loss_tmp.pow(2) + + message_hub = MessageHub.get_current_instance() + # 在消息中心更新中间的 `loss_tmp` + message_hub.update_scalar('train/loss_tmp', loss_tmp.sum()) + return dict(loss=loss) +``` + +将 `loss_tmp` 添加到配置中： + +```python +log_processor = dict( + type='LogProcessor', + window_size=20, + by_epoch=True, + custom_cfg=[ + # 使用平均值统计 loss_tmp + dict( + data_src='loss_tmp', + window_size=20, + method_name='mean') + ]) +``` + +`loss_tmp` 将被添加到输出日志中： + +``` +08/21 03:40:31 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0026 data_time: 0.0008 loss_tmp: 0.0097 loss: 0.0000 +08/21 03:40:31 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0028 data_time: 0.0013 loss_tmp: 0.0065 loss: 0.0000 +``` + +## 导出调试日志 + +要将调试日志导出到 `work_dir`，你可以在配置文件中设置日志级别如下： + +``` +log_level='DEBUG' +``` + +``` +08/21 18:16:22 - mmengine - DEBUG - Get class `LocalVisBackend` from "vis_backend" registry in "mmengine" +08/21 18:16:22 - mmengine - DEBUG - An `LocalVisBackend` instance is built from registry, its implementation can be found in mmengine.visualization.vis_backend +08/21 18:16:22 - mmengine - DEBUG - Get class `RuntimeInfoHook` from "hook" registry in "mmengine" +08/21 18:16:22 - mmengine - DEBUG - An `RuntimeInfoHook` instance is built from registry, its implementation can be found in mmengine.hooks.runtime_info_hook +08/21 18:16:22 - mmengine - DEBUG - Get class `IterTimerHook` from "hook" registry in "mmengine" +... +``` + +此外，如果你正在使用共享存储训练你的模型，那么在 `debug` 模式下，不同排名的日志将被保存。日志的层级结构如下： + +```text +./tmp +├── tmp.log +├── tmp_rank1.log +├── tmp_rank2.log +├── tmp_rank3.log +├── tmp_rank4.log +├── tmp_rank5.log +├── tmp_rank6.log +└── tmp_rank7.log +... +└── tmp_rank63.log +``` + +在具有独立存储的多台机器上的日志： + +```text +# 设备：0： +work_dir/ +└── exp_name_logs + ├── exp_name.log + ├── exp_name_rank1.log + ├── exp_name_rank2.log + ├── exp_name_rank3.log + ... + └── exp_name_rank7.log + +# 设备：7： +work_dir/ +└── exp_name_logs + ├── exp_name_rank56.log + ├── exp_name_rank57.log + ├── exp_name_rank58.log + ... + └── exp_name_rank63.log +``` diff --git a/internlm_langchain/knowledge_base/MMAction2/content/customize_models.md b/internlm_langchain/knowledge_base/MMAction2/content/customize_models.md new file mode 100644 index 00000000..c64a6bb3 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/customize_models.md @@ -0,0 +1,3 @@ +# 自定义模型 + +内容建设中... diff --git a/internlm_langchain/knowledge_base/MMAction2/content/customize_optimizer.md b/internlm_langchain/knowledge_base/MMAction2/content/customize_optimizer.md new file mode 100644 index 00000000..5e4279d4 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/customize_optimizer.md @@ -0,0 +1,332 @@ +# 自定义优化器 + +在本教程中，我们将介绍一些构建优化器和学习率策略的方法，以用于你的任务。 + +- [自定义优化器](#自定义优化器) + - [使用 optim_wrapper 构建优化器](#使用-optim_wrapper-构建优化器) + - [使用 PyTorch 支持的优化器](#使用-pytorch-支持的优化器) + - [参数化精细配置](#参数化精细配置) + - [梯度裁剪](#梯度裁剪) + - [梯度累积](#梯度累积) + - [自定义参数策略](#自定义参数策略) + - [自定义学习率策略](#自定义学习率策略) + - [自定义动量策略](#自定义动量策略) + - [添加新的优化器或构造器](#添加新的优化器或构造器) + - [添加新的优化器](#添加新的优化器) + - [1. 实现一个新的优化器](#1-实现一个新的优化器) + - [2. 导入优化器](#2-导入优化器) + - [3. 在配置文件中指定优化器](#3-在配置文件中指定优化器) + - [添加新的优化器构造器](#添加新的优化器构造器) + +## 使用 optim_wrapper 构建优化器 + +我们使用 `optim_wrapper` 字段来配置优化策略，其中包括选择优化器、参数逐个配置、梯度裁剪和梯度累积。一个简单的示例可以是： + +```python +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.0003, weight_decay=0.0001) +) +``` + +在上面的示例中，我们构建了一个学习率为 0.0003，权重衰减为 0.0001 的 SGD 优化器。 + +### 使用 PyTorch 支持的优化器 + +我们支持 PyTorch 实现的所有优化器。要使用不同的优化器，只需更改配置文件中的 `optimizer` 字段。例如，如果想使用 `torch.optim.Adam`，可以在配置文件中进行如下修改。 + +```python +optim_wrapper = dict( + type='OptimWrapper', + optimizer = dict( + type='Adam', + lr=0.001, + betas=(0.9, 0.999), + eps=1e-08, + weight_decay=0, + amsgrad=False), +) +``` + +首先，我们需要将 `type` 的值更改为 `torch.optim` 支持的期望优化器名称。然后，将该优化器的必要参数添加到 `optimizer` 字段中。上述配置将构建以下优化器： + +```python +torch.optim.Adam(lr=0.001, + betas=(0.9, 0.999), + eps=1e-08, + weight_decay=0, + amsgrad=False) +``` + +### 参数化精细配置 + +一些模型可能对优化有特定的参数设置，例如对于 BatchNorm 层不使用权重衰减，或者对不同网络层使用不同的学习率。为了对其进行细致配置，我们可以使用 `optim_wrapper` 中的 `paramwise_cfg` 参数。 + +- **为不同类型的参数设置不同的超参数倍数。** + + 例如，我们可以在 `paramwise_cfg` 中设置 `norm_decay_mult=0.`，将归一化层的权重衰减设置为零。 + + ```python + optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.8, weight_decay=1e-4), + paramwise_cfg=dict(norm_decay_mult=0.)) + ``` + + 还支持设置其他类型的参数，包括： + + - `lr_mult`：所有参数的学习率乘数。 + - `decay_mult`：所有参数的权重衰减乘数。 + - `bias_lr_mult`：偏置项的学习率乘数（不包括归一化层的偏置项和可变形卷积层的偏移量）。默认为 1。 + - `bias_decay_mult`：偏置项的权重衰减乘数（不包括归一化层的偏置项和可变形卷积层的偏移量）。默认为 1。 + - `norm_decay_mult`：归一化层权重和偏置项的权重衰减乘数。默认为 1。 + - `dwconv_decay_mult`：深度卷积层的权重衰减乘数。默认为 1。 + - `bypass_duplicate`：是否跳过重复的参数。默认为 `False`。 + - `dcn_offset_lr_mult`：可变形卷积层的学习率乘数。默认为 1。 + +- **为特定参数设置不同的超参数倍数。** + + MMAction2 可以使用 `paramwise_cfg` 中的 `custom_keys` 来指定不同的参数使用不同的学习率或权重衰减。 + + 例如，要将 `backbone.layer0` 的所有学习率和权重衰减设置为 0，而保持 `backbone` 的其余部分与优化器相同，并将 `head` 的学习率设置为 0.001，可以使用以下配置： + + ```python + optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001), + paramwise_cfg=dict( + custom_keys={ + 'backbone.layer0': dict(lr_mult=0, decay_mult=0), + 'backbone': dict(lr_mult=1), + 'head': dict(lr_mult=0.1) + })) + ``` + +### 梯度裁剪 + +在训练过程中，损失函数可能接近悬崖区域，导致梯度爆炸。梯度裁剪有助于稳定训练过程。梯度裁剪的更多介绍可以在[这个页面](https://paperswithcode.com/method/gradient-clipping)找到。 + +目前，我们支持 `optim_wrapper` 中的 `clip_grad` 选项进行梯度裁剪，参考[PyTorch 文档](torch.nn.utils.clip_grad_norm_)。 + +以下是一个示例： + +```python +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001), + # norm_type: 使用的 p-范数的类型，这里 norm_type 为 2。 + clip_grad=dict(max_norm=35, norm_type=2)) +``` + +### 梯度累积 + +当计算资源有限时，批量大小只能设置为较小的值，这可能会影响模型的性能。可以使用梯度累积来解决这个问题。我们支持 `optim_wrapper` 中的 `accumulative_counts` 选项进行梯度累积。 + +以下是一个示例： + +```python +train_dataloader = dict(batch_size=64) +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001), + accumulative_counts=4) +``` + +表示在训练过程中，每 4 个迭代执行一次反向传播。上述示例等价于： + +```python +train_dataloader = dict(batch_size=256) +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001)) +``` + +## 新增优化器或者优化器构造器 + +在训练中，优化参数（如学习率、动量等）通常不是固定的，而是随着迭代或周期的变化而变化。PyTorch 支持几种学习率策略，但对于复杂的策略可能不足够。在 MMAction2 中，我们提供 `param_scheduler` 来更好地控制不同参数的学习率策略。 + +### 配置学习率调整策略 + +调整学习率策略被广泛用于提高性能。我们支持大多数 PyTorch 学习率策略，包括 `ExponentialLR`、`LinearLR`、`StepLR`、`MultiStepLR` 等。 + +所有可用的学习率策略可以在[这里](https://mmaction2.readthedocs.io/en/latest/schedulers.html)找到，学习率策略的名称以 `LR` 结尾。 + +- **单一学习率策略** + + 在大多数情况下，我们只使用一个学习策略以简化问题。例如，`MultiStepLR` 被用作 ResNet 的默认学习率策略。在这里，`param_scheduler` 是一个字典。 + + ```python + param_scheduler = dict( + type='MultiStepLR', + by_epoch=True, + milestones=[100, 150], + gamma=0.1) + ``` + + 或者，我们想使用 `CosineAnnealingLR` 策略来衰减学习率： + + ```python + param_scheduler = dict( + type='CosineAnnealingLR', + by_epoch=True, + T_max=num_epochs) + ``` + +- **多个学习率策略** + + 在某些训练案例中，为了提高准确性，会应用多个学习率策略。例如，在早期阶段，训练容易不稳定，预热是一种减少不稳定性的技术。学习率将从一个较小的值逐渐增加到预期值，通过预热进行衰减和其他策略进行衰减。 + + 在 MMAction2 中，通过将所需的策略组合成 `param_scheduler` 的列表即可实现预热策略。 + + 以下是一些示例： + + 1. 在前 50 个迭代中进行线性预热。 + + ```python + param_scheduler = [ + # 线性预热 + dict(type='LinearLR', + start_factor=0.001, + by_epoch=False, # 按迭代 + end=50), # 仅在前 50 个迭代中进行预热 + # 主要的学习率策略 + dict(type='MultiStepLR', + by_epoch=True, + milestones=[8, 11], + gamma=0.1) + ] + ``` + + 2. 在前 10 个周期中进行线性预热，并在每个周期内按迭代更新学习率。 + + ```python + param_scheduler = [ + # 线性预热 [0, 10) 个周期 + dict(type='LinearLR', + start_factor=0.001, + by_epoch=True, + end=10, + convert_to_iter_based=True, # 按迭代更新学习率 + ), + # 在 10 个周期后使用 CosineAnnealing 策略 + dict(type='CosineAnnealingLR', by_epoch=True, begin=10) + ] + ``` + + 注意，我们在这里使用 `begin` 和 `end` 参数来指定有效范围，该范围为 \[`begin`, `end`)。范围的单位由 `by_epoch` 参数定义。如果未指定，则 `begin` 为 0，`end` 为最大周期或迭代次数。 + + 如果所有策略的范围都不连续，则学习率将在忽略的范围内保持不变，否则所有有效的策略将按特定阶段的顺序执行，这与 PyTorch [`ChainedScheduler`](torch.optim.lr_scheduler.ChainedScheduler) 的行为相同。 + +### 自定义动量策略 + +我们支持使用动量策略根据学习率修改优化器的动量，这可以使损失以更快的方式收敛。使用方法与学习率策略相同。 + +所有可用的学习率策略可以在[这里](https://mmaction2.readthedocs.io/en/latest/schedulers.html)找到，动量策略的名称以 `Momentum` 结尾。 + +以下是一个示例： + +```python +param_scheduler = [ + # 学习率策略 + dict(type='LinearLR', ...), + # 动量策略 + dict(type='LinearMomentum', + start_factor=0.001, + by_epoch=False, + begin=0, + end=1000) +] +``` + +## 添加新的优化器或构造器 + +本部分将修改 MMAction2 源代码或向 MMAction2 框架中添加代码，初学者可以跳过此部分。 + +### 添加新的优化器 + +在学术研究和工业实践中，可能需要使用 MMAction2 未实现的优化方法，可以通过以下方法进行添加。 + +#### 1. 实现一个新的优化器 + +假设要添加一个名为 `MyOptimizer` 的优化器，它具有参数 `a`、`b` 和 `c`。需要在 `mmaction/engine/optimizers` 下创建一个新文件，并在文件中实现新的优化器，例如在 `mmaction/engine/optimizers/my_optimizer.py` 中： + +```python +from torch.optim import Optimizer +from mmaction.registry import OPTIMIZERS + + +@OPTIMIZERS.register_module() +class MyOptimizer(Optimizer): + + def __init__(self, a, b, c): + ... + + def step(self, closure=None): + ... +``` + +#### 2. 导入优化器 + +为了找到上述定义的模块，需要在运行时导入该模块。首先，在 `mmaction/engine/optimizers/__init__.py` 中导入该模块，将其添加到 `mmaction.engine` 包中。 + +```python +# In mmaction/engine/optimizers/__init__.py +... +from .my_optimizer import MyOptimizer # MyOptimizer 可能是其他类名 + +__all__ = [..., 'MyOptimizer'] +``` + +在运行时，我们将自动导入 `mmaction.engine` 包，并同时注册 `MyOptimizer`。 + +#### 3. 在配置文件中指定优化器 + +然后，可以在配置文件的 `optim_wrapper.optimizer` 字段中使用 `MyOptimizer`。 + +```python +optim_wrapper = dict( + optimizer=dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value)) +``` + +### 添加新的优化器构造器 + +一些模型可能对优化有一些特定的参数设置，例如所有 `BatchNorm` 层的不同权重衰减率。 + +尽管我们已经可以使用[优化器教程](#参数化精细配置)中的 `optim_wrapper.paramwise_cfg` 字段来配置各种特定参数的优化器设置，但可能仍无法满足需求。 + +当然，你可以修改它。默认情况下，我们使用 [`DefaultOptimWrapperConstructor`](mmengine.optim.DefaultOptimWrapperConstructor) 类来处理优化器的构造。在构造过程中，它根据 `paramwise_cfg` 对不同参数的优化器设置进行细致配置，这也可以作为新优化器构造器的模板。 + +你可以通过添加新的优化器构造器来覆盖这些行为。 + +```python +# In mmaction/engine/optimizers/my_optim_constructor.py +from mmengine.optim import DefaultOptimWrapperConstructor +from mmaction.registry import OPTIM_WRAPPER_CONSTRUCTORS + + +@OPTIM_WRAPPER_CONSTRUCTORS.register_module() +class MyOptimWrapperConstructor: + + def __init__(self, optim_wrapper_cfg, paramwise_cfg=None): + ... + + def __call__(self, model): + ... +``` + +然后，导入它并几乎像[优化器教程](#添加新的优化器)中那样使用它。 + +1. 在 `mmaction/engine/optimizers/__init__.py` 中导入它，将其添加到 `mmaction.engine` 包中。 + + ```python + # In mmaction/engine/optimizers/__init__.py + ... + from .my_optim_constructor import MyOptimWrapperConstructor + + __all__ = [..., 'MyOptimWrapperConstructor'] + ``` + +2. 在配置文件的 `optim_wrapper.constructor` 字段中使用 `MyOptimWrapperConstructor`。 + + ```python + optim_wrapper = dict( + constructor=dict(type='MyOptimWrapperConstructor'), + optimizer=..., + paramwise_cfg=..., + ) + ``` diff --git a/internlm_langchain/knowledge_base/MMAction2/content/customize_pipeline.md b/internlm_langchain/knowledge_base/MMAction2/content/customize_pipeline.md new file mode 100644 index 00000000..4327f96d --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/customize_pipeline.md @@ -0,0 +1,144 @@ +# 自定义数据流水线 + +在本教程中，我们将介绍如何为你的任务构建数据流水线（即，数据转换）的一些方法。 + +- [自定义数据流水线](#自定义数据流水线) + - [数据流水线设计](#数据流水线设计) + - [修改训练/测试数据流水线](#修改训练/测试数据流水线) + - [加载](#加载) + - [采样帧和其他处理](#采样帧和其他处理) + - [格式化](#格式化) + - [添加新的数据转换](#添加新的数据转换) + +## 数据流水线设计 + +数据流水线指的是从数据集索引样本时处理数据样本字典的过程，它包括一系列的数据转换。每个数据转换接受一个 `dict` 作为输入，对其进行处理，并产生一个 `dict` 作为输出，供序列中的后续数据转换使用。 + +以下是一个例子，用于使用 `VideoDataset` 在 Kinetics 上训练 SlowFast 的数据流水线。这个数据流水线首先使用 [`decord`](https://github.com/dmlc/decord) 读取原始视频并随机采样一个视频剪辑，该剪辑包含 `32` 帧，帧间隔为 `2`。然后，它对所有帧应用随机大小调整的裁剪和随机水平翻转，然后将数据形状格式化为 `NCTHW`，在这个例子中，它是 `(1, 3, 32, 224, 224)`。 + +```python +train_pipeline = [ + dict(type='DecordInit',), + dict(type='SampleFrames', clip_len=32, frame_interval=2, num_clips=1), + dict(type='DecordDecode'), + dict(type='Resize', scale=(-1, 256)), + dict(type='RandomResizedCrop'), + dict(type='Resize', scale=(224, 224), keep_ratio=False), + dict(type='Flip', flip_ratio=0.5), + dict(type='FormatShape', input_format='NCTHW'), + dict(type='PackActionInputs') +] +``` + +MMAction2 中所有可用的数据转换的详细列表可以在 [mmaction.datasets.transforms](mmaction.datasets.transforms) 中找到。 + +## 修改训练/测试数据流水线 + +MMAction2 的数据流水线非常灵活，因为几乎每一步的数据预处理都可以从配置文件中进行配置。然而，对于一些用户来说，这种多样性可能会让人感到不知所措。 + +以下是一些用于构建动作识别任务数据流水线的一般实践和指南。 + +### 加载 + +在数据流水线的开始，通常是加载视频。然而，如果帧已经被提取出来，你应该使用 `RawFrameDecode` 并修改数据集类型为 `RawframeDataset`。 + +```python +train_pipeline = [ + dict(type='SampleFrames', clip_len=32, frame_interval=2, num_clips=1), + dict(type='RawFrameDecode'), + dict(type='Resize', scale=(-1, 256)), + dict(type='RandomResizedCrop'), + dict(type='Resize', scale=(224, 224), keep_ratio=False), + dict(type='Flip', flip_ratio=0.5), + dict(type='FormatShape', input_format='NCTHW'), + dict(type='PackActionInputs') +] +``` + +如果你需要从具有不同格式（例如，`pkl`，`bin`等）的文件或从特定位置加载数据，你可以创建一个新的加载转换并将其包含在数据流水线的开始。有关更多详细信息，请参阅[添加新的数据转换](#添加新的数据转换)。 + +### 采样帧和其他处理 + +在训练和测试过程中，我们可能会有从视频中采样帧的不同策略。 + +例如，当测试 SlowFast 时，我们会均匀地采样多个剪辑，如下所示： + +```python +test_pipeline = [ + ... + dict( + type='SampleFrames', + clip_len=32, + frame_interval=2, + num_clips=10, + test_mode=True), + ... +] +``` + +在上述例子中，每个视频将均匀地采样10个视频剪辑，每个剪辑包含32帧。 `test_mode=True` 用于实现这一点，与训练期间的随机采样相反。 + +另一个例子涉及 `TSN/TSM` 模型，它们从视频中采样多个片段： + +```python +train_pipeline = [ + ... + dict(type='SampleFrames', clip_len=1, frame_interval=1, num_clips=8), + ... +] +``` + +通常，数据流水线中的数据增强只处理视频级的转换，例如调整大小或裁剪，而不处理像视频标准化或 mixup/cutmix 这样的转换。这是因为我们可以在批量视频数据上进行视频标准化和 mixup/cutmix，以使用 GPU 加速处理。要配置视频标准化和 mixup/cutmix，请使用 [mmaction.models.utils.data_preprocessor](mmaction.models.utils.data_preprocessor)。 + +### 格式化 + +格式化涉及从数据信息字典中收集训练数据，并将其转换为与模型兼容的格式。 + +在大多数情况下，你可以简单地使用 [`PackActionInputs`](mmaction.datasets.transforms.PackActionInputs)，它将以 `NumPy Array` 格式的图像转换为 `PyTorch Tensor`，并将地面真实类别信息和其他元信息打包为一个类似字典的对象 [`ActionDataSample`](mmaction.structures.ActionDataSample)。 + +```python +train_pipeline = [ + ... + dict(type='PackActionInputs'), +] +``` + +## 添加新的数据转换 + +1. 要创建一个新的数据转换，编写一个新的转换类在一个 Python 文件中，例如，名为 `my_transforms.py`。数据转换类必须继承 [`mmcv.transforms.BaseTransform`](mmcv.transforms.BaseTransform) 类，并重写 `transform` 方法，该方法接受一个 `dict` 作为输入并返回一个 `dict`。最后，将 `my_transforms.py` 放在 `mmaction/datasets/transforms/` 文件夹中。 + + ```python + from mmcv.transforms import BaseTransform + from mmaction.datasets import TRANSFORMS + + @TRANSFORMS.register_module() + class MyTransform(BaseTransform): + def __init__(self, msg): + self.msg = msg + + def transform(self, results): + # 修改数据信息字典 `results`。 + print(msg, 'MMAction2.') + return results + ``` + +2. 在 `mmaction/datasets/transforms/__init__.py` 中导入新类。 + + ```python + ... + from .my_transform import MyTransform + + __all__ = [ + ..., 'MyTransform' + ] + ``` + +3. 在配置文件中使用它。 + + ```python + train_pipeline = [ + ... + dict(type='MyTransform', msg='Hello!'), + ... + ] + ``` diff --git a/internlm_langchain/knowledge_base/MMAction2/content/dataflow.md b/internlm_langchain/knowledge_base/MMAction2/content/dataflow.md new file mode 100644 index 00000000..29db77f9 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/dataflow.md @@ -0,0 +1,3 @@ +# MMAction2 的数据流 + +内容建设中... diff --git a/internlm_langchain/knowledge_base/MMAction2/content/depoly.md b/internlm_langchain/knowledge_base/MMAction2/content/depoly.md new file mode 100644 index 00000000..58e9f58e --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/depoly.md @@ -0,0 +1,3 @@ +# How to deploy MMAction2 models + +coming soon... diff --git a/internlm_langchain/knowledge_base/MMAction2/content/ecosystem.md b/internlm_langchain/knowledge_base/MMAction2/content/ecosystem.md new file mode 100644 index 00000000..2aafe731 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/ecosystem.md @@ -0,0 +1,23 @@ +# 基于 MMAction2 的生态项目 + +有许多研究工作和项目是基于 MMAction2 构建的。 +我们列举了一些例子，展示了如何扩展 MMAction2 来适用于您自己的项目。 +由于页面可能尚未完成，所以请随时通过提交PR来更新此页面。 + +## 作为扩展的项目 + +- [OTEAction2](https://github.com/openvinotoolkit/mmaction2)：用于动作识别的 OpenVINO 训练扩展。 +- [PYSKL](https://github.com/kennymckormick/pyskl)：一个专注于基于骨骼点动作识别的工具箱。 + +## 论文相关的项目 + +还有一些与论文一起发布的项目。 +其中一些论文发表在顶级会议（CVPR、ICCV 和 ECCV）上，其他一些也具有很高的影响力。 +我们按照会议时间列出它们，方便社区参考。 + +- Video Swin Transformer，CVPR 2022 [\[论文\]](https://arxiv.org/abs/2106.13230)[\[github\]](https://github.com/SwinTransformer/Video-Swin-Transformer) +- Evidential Deep Learning for Open Set Action Recognition，ICCV 2021 Oral [\[论文\]](https://arxiv.org/abs/2107.10161)[\[github\]](https://github.com/Cogito2012/DEAR) +- Rethinking Self-supervised Correspondence Learning: A Video Frame-level Similarity Perspective，ICCV 2021 Oral [\[论文\]](https://arxiv.org/abs/2103.17263)[\[github\]](https://github.com/xvjiarui/VFS) +- MGSampler: An Explainable Sampling Strategy for Video Action Recognition，ICCV 2021 [\[论文\]](https://arxiv.org/abs/2104.09952)[\[github\]](https://github.com/MCG-NJU/MGSampler) +- MultiSports: A Multi-Person Video Dataset of Spatio-Temporally Localized Sports Actions，ICCV 2021 [\[论文\]](https://arxiv.org/abs/2105.07404) +- Long Short-Term Transformer for Online Action Detection，NeurIPS 2021 [\[论文\]](https://arxiv.org/abs/2107.03377)[\[github\]](https://github.com/amazon-research/long-short-term-transformer) diff --git a/internlm_langchain/knowledge_base/MMAction2/content/faq.md b/internlm_langchain/knowledge_base/MMAction2/content/faq.md new file mode 100644 index 00000000..6c785f11 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMAction2/content/faq.md @@ -0,0 +1,125 @@ +# 常见问题解答 + +## 概述 + +我们在这里列出了许多用户常遇到的问题以及相应的解决方案。 + +- [常见问题解答](#常见问题解答) + - [概述](#概述) + - [安装](#安装) + - [数据](#数据) + - [训练](#训练) + - [测试](#测试) + +如果您发现任何频繁出现的问题并且有解决方法，欢迎在列表中补充。如果这里的内容没有涵盖您的问题，请使用[提供的模板](https://github.com/open-mmlab/mmaction2/tree/main/.github/ISSUE_TEMPLATE/error-report.md)创建一个问题，并确保在模板中填写所有必要的信息。 + +## 安装 + +- **"No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'"** + + 1. 使用 `pip uninstall mmcv` 命令卸载环境中的现有 mmcv。 + 2. 参照[安装说明](https://mmcv.readthedocs.io/en/2.x/get_started/installation.html#install-mmcv)安装 mmcv。 + +- **"OSError: MoviePy Error: creation of None failed because of the following error"** + + 使用 `pip install moviepy` 安装。更多信息可以参考[官方安装文档](https://zulko.github.io/moviepy/install.html), 请注意（根据这个 [issue](https://github.com/Zulko/moviepy/issues/693)）： + + 1. 对于 Windows 用户，[ImageMagick](https://www.imagemagick.org/script/index.php) 不会自动被 MoviePy 检测到，需要修改 `moviepy/config_defaults.py` 文件，提供 ImageMagick 二进制文件 `magick` 的路径，例如 `IMAGEMAGICK_BINARY = "C:\\Program Files\\ImageMagick_VERSION\\magick.exe"` + 2. 对于 Linux 用户，如果 MoviePy 没有检测到 ImageMagick，需要修改 `/etc/ImageMagick-6/policy.xml` 文件，将 `
+ 行为识别 |
+  + 基于骨架的行为识别 |
+
+ 时空动作检测 |
+  + 时空动作检测 |
+
+
+
+MMAction2 的基础用法
+ +- [安装](installation.md) +- [快速运行](quick_run.md) +- [利用现有模型进行推理](../user_guides/inference.md) + +
+
+
+关于在已支持的数据集上进行训练
+ +- [了解配置文件](../user_guides/config.md) +- [准备数据集](../user_guides/prepare_dataset.md) +- [训练与测试](../user_guides/train_test.md) + +
+
+
+关于使用过程中的常见问题
+ +- [常见问题解答](faq.md) +- [有用的工具](../useful_tools.md) + +
+
+
+关于 MMAction2 的框架设计
+ +- [20分钟 MMAction2 框架指南](guide_to_framework.md) +- [MMAction2 中的数据流](../advanced_guides/dataflow.md) + +
+
+
+关于自定义训练的高级用法
+ +- [自定义模型](../advanced_guides/customize_models.md) +- [自定义数据集](../advanced_guides/customize_dataset.md) +- [自定义数据管道](../advanced_guides/customize_pipeline.md) +- [自定义优化器](../advanced_guides/customize_optimizer.md) +- [自定义日志记录](../advanced_guides/customize_logging.md) + +
+
+
+关于支持的模型库和数据集
+ +- [模型库](../modelzoo_statistics.md) +- [数据集](../datasetzoo_statistics.md) + +
+
+
+关于从 MMAction2 0.x 迁移
+ +- [从 MMAction2 0.x 迁移](../migration.md) + +
+
diff --git a/internlm_langchain/knowledge_base/MMAction2/content/prepare_dataset.md b/internlm_langchain/knowledge_base/MMAction2/content/prepare_dataset.md
new file mode 100644
index 00000000..b8cdfee6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMAction2/content/prepare_dataset.md
@@ -0,0 +1,253 @@
+# 准备数据集
+
+MMAction2 支持许多现有的数据集。在本章中，我们将引导您准备 MMAction2 的数据集。
+
+- [准备数据集](#准备数据集)
+ - [关于视频数据格式的说明](#关于视频数据格式的说明)
+ - [使用内置数据集](#使用内置数据集)
+ - [使用自定义数据集](#使用自定义数据集)
+ - [动作识别](#动作识别)
+ - [基于骨骼的动作识别](#基于骨骼的动作识别)
+ - [时空动作检测](#时空动作检测)
+ - [时序动作定位](#时序动作定位)
+ - [使用混合数据集进行训练](#使用混合数据集进行训练)
+ - [重复数据集](#重复数据集)
+ - [浏览数据集](#浏览数据集)
+
+## 关于视频数据格式的说明
+
+MMAction2 支持两种类型的数据格式：原始帧和视频。前者在之前的项目（如 [TSN](https://github.com/yjxiong/temporal-segment-networks)）中被广泛使用。当 SSD 可用时，这种方法运行速度很快，但无法满足日益增长的数据集需求（例如，最新的 [Kinetics](https://www.deepmind.com/open-source/kinetics) 数据集有 65 万个视频，总帧数将占用几 TB 的空间）。后者可以节省空间，但必须在执行时进行计算密集型的视频解码。为了加快视频解码速度，我们支持几种高效的视频加载库，如 [decord](https://github.com/zhreshold/decord)、[PyAV](https://github.com/PyAV-Org/PyAV) 等。
+
+## 使用内置数据集
+
+MMAction2 已经支持许多数据集，我们在路径 `$MMACTION2/tools/data/` 下提供了用于数据准备的 shell 脚本，请参考[支持的数据集](../datasetzoo_satatistics.md)以获取准备特定数据集的详细信息。
+
+## 使用自定义数据集
+
+最简单的方法是将您的数据集转换为现有的数据集格式：
+
+- `RawFrameDataset` 和 `VideoDataset` 用于[动作识别](#动作识别)
+- `PoseDataset` 用于[基于骨骼的动作识别](#基于骨骼的动作识别)
+- `AVADataset` 用于[时空动作检测](#时空动作检测)
+- `ActivityNetDataset` 用于[时序动作定位](#时序动作定位)
+
+在数据预处理之后，用户需要进一步修改配置文件以使用数据集。以下是在原始帧格式中使用自定义数据集的示例。
+
+在 `configs/task/method/my_custom_config.py` 中：
+
+```python
+...
+# 数据集设置
+dataset_type = 'RawframeDataset'
+data_root = 'path/to/your/root'
+data_root_val = 'path/to/your/root_val'
+ann_file_train = 'data/custom/custom_train_list.txt'
+ann_file_val = 'data/custom/custom_val_list.txt'
+ann_file_test = 'data/custom/custom_val_list.txt'
+...
+data = dict(
+ videos_per_gpu=32,
+ workers_per_gpu=2,
+ train=dict(
+ type=dataset_type,
+ ann_file=ann_file_train,
+ ...),
+ val=dict(
+ type=dataset_type,
+ ann_file=ann_file_val,
+ ...),
+ test=dict(
+ type=dataset_type,
+ ann_file=ann_file_test,
+ ...))
+...
+```
+
+### 动作识别
+
+动作识别有两种类型的注释文件。
+
+- `RawFrameDataset` 的原始帧注释
+
+ 原始帧数据集的注释是一个包含多行的文本文件，每一行表示一个视频的 `frame_directory`（相对路径）、视频的 `total_frames` 和视频的 `label`，用空格分隔。
+
+ 以下是一个示例。
+
+ ```
+ some/directory-1 163 1
+ some/directory-2 122 1
+ some/directory-3 258 2
+ some/directory-4 234 2
+ some/directory-5 295 3
+ some/directory-6 121 3
+ ```
+
+- `VideoDataset` 的视频注释
+
+ 视频数据集的注释是一个包含多行的文本文件，每一行表示一个样本视频，包括 `filepath`（相对路径）和 `label`，用空格分隔。
+
+ 以下是一个示例。
+
+ ```
+ some/path/000.mp4 1
+ some/path/001.mp4 1
+ some/path/002.mp4 2
+ some/path/003.mp4 2
+ some/path/004.mp4 3
+ some/path/005.mp4 3
+ ```
+
+### 基于骨骼点的动作识别
+
+该任务基于骨骼序列（关键点的时间序列）识别动作类别。我们提供了一些方法来构建自定义的骨骼数据集。
+
+- 从 RGB 视频数据构建
+
+ 您需要从视频中提取关键点数据，并将其转换为支持的格式。我们提供了一个[教程](https://github.com/open-mmlab/mmaction2/tree/main/configs/skeleton/posec3d/custom_dataset_training.md)，详细介绍了如何执行。
+
+- 从现有关键点数据构建
+
+ 假设您已经有了 coco 格式的关键点数据，您可以将它们收集到一个 pickle 文件中。
+
+ 每个 pickle 文件对应一个动作识别数据集。pickle 文件的内容是一个字典，包含两个字段：`split` 和 `annotations`
+
+ 1. Split：`split` 字段的值是一个字典：键是拆分名称，值是属于特定剪辑的视频标识符列表。
+ 2. Annotations：`annotations` 字段的值是一个骨骼注释列表，每个骨骼注释是一个字典，包含以下字段：
+ - `frame_dir`（str）：对应视频的标识符。
+ - `total_frames`（int）：此视频中的帧数。
+ - `img_shape`（tuple\[int\]）：视频帧的形状，一个包含两个元素的元组，格式为 `(height, width)`。仅对 2D 骨骼需要。
+ - `original_shape`（tuple\[int\]）：与 `img_shape` 相同。
+ - `label`（int）：动作标签。
+ - `keypoint`（np.ndarray，形状为 `[M x T x V x C]`）：关键点注释。
+ - M：人数；
+ - T：帧数（与 `total_frames` 相同）；
+ - V：关键点数量（NTURGB+D 3D 骨骼为 25，Coco 为 17，OpenPose 为 18 等）；
+ - C：关键点坐标的维数（2D 关键点为 C=2，3D 关键点为 C=3）。
+ - `keypoint_score`（np.ndarray，形状为 `[M x T x V]`）：关键点的置信度分数。仅对 2D 骨骼需要。
+
+ 以下是一个示例：
+
+ ```
+ {
+ "split":
+ {
+ 'xsub_train':
+ ['S001C001P001R001A001', ...],
+ 'xsub_val':
+ ['S001C001P003R001A001', ...],
+ ...
+ }
+
+ "annotations:
+ [
+ {
+ {
+ 'frame_dir': 'S001C001P001R001A001',
+ 'label': 0,
+ 'img_shape': (1080, 1920),
+ 'original_shape': (1080, 1920),
+ 'total_frames': 103,
+ 'keypoint': array([[[[1032. , 334.8], ...]]])
+ 'keypoint_score': array([[[0.934 , 0.9766, ...]]])
+ },
+ {
+ 'frame_dir': 'S001C001P003R001A001',
+ ...
+ },
+ ...
+
+ }
+ ]
+ }
+ ```
+
+ 支持其他关键点格式需要进行进一步修改，请参考[自定义数据集](../advanced_guides/customize_dataset.md)。
+
+### 时空动作检测
+
+MMAction2 支持基于 `AVADataset` 的时空动作检测任务。注释包含真实边界框和提议边界框。
+
+- 真实边界框
+ 真实边界框是一个包含多行的 csv 文件，每一行是一个帧的检测样本，格式如下：
+
+ video_identifier, time_stamp, lt_x, lt_y, rb_x, rb_y, label, entity_id
+ 每个字段的含义如下：
+ `video_identifier`：对应视频的标识符
+ `time_stamp`：当前帧的时间戳
+ `lt_x`：左上角点的规范化 x 坐标
+ `lt_y`：左上角点的规范化 y 坐标
+ `rb_y`：右下角点的规范化 x 坐标
+ `rb_y`：右下角点的规范化 y 坐标
+ `label`：动作标签
+ `entity_id`：一个唯一的整数，允许将此框与该视频相邻帧中描绘同一个人的其他框连接起来
+
+ 以下是一个示例：
+
+ ```
+ _-Z6wFjXtGQ,0902,0.063,0.049,0.524,0.996,12,0
+ _-Z6wFjXtGQ,0902,0.063,0.049,0.524,0.996,74,0
+ ...
+ ```
+
+- 提议边界框
+ 提议边界框是由一个人体检测器生成的 pickle 文件，通常需要在目标数据集上进行微调。pickle 文件包含一个带有以下数据结构的字典：
+
+ `{'video_identifier,time_stamp': bbox_info}`
+
+ video_identifier（str）：对应视频的标识符
+ time_stamp（int）：当前帧的时间戳
+ bbox_info（np.ndarray，形状为`[n, 5]`）：检测到的边界框，\对于希望加入开源社区，向 MMAction2 贡献代码的研究者和开发者
+ +- [如何为 MMAction2 做出贡献](contribution_guide.md) + +
+ 
+
+
++ +```bash +# 推理结果 +{'predictions': [{'rec_labels': [[6]], 'rec_scores': [[...]]}]} +``` + +```{note} +如果您在没有 GUI 的服务器上运行 MMAction2，或者通过禁用 X11 转发的 SSH 隧道运行 MMAction2，则可能不会看到弹出窗口。 +``` + +关于 MMAction2 推理接口的详细描述可以在[这里](/demo/README.md#inferencer)找到. + +除了使用我们提供的预训练模型，您还可以在自己的数据集上训练模型。在下一节中，我们将通过在精简版 [Kinetics](https://download.openmmlab.com/mmaction/kinetics400_tiny.zip) 数据集上训练 TSN 为例，带您了解 MMAction2 的基本功能。 + +## 准备数据集 + +由于视频数据集格式的多样性不利于数据集的切换，MMAction2 提出了统一的[数据格式](../user_guides/prepare_dataset.md) ，并为常用的视频数据集提供了[数据集准备指南](../user_guides/data_prepare/dataset_prepare.md)。通常，要在 MMAction2 中使用这些数据集，你只需要按照步骤进行准备。 + +```{笔记} +但在这里，效率意味着一切。 +``` + +首先，请下载我们预先准备好的 [kinetics400_tiny.zip](https://download.openmmlab.com/mmaction/kinetics400_tiny.zip) ，并将其解压到 MMAction2 根目录下的 `data/` 目录。这将为您提供必要的视频和注释文件。 + +```Bash +wget https://download.openmmlab.com/mmaction/kinetics400_tiny.zip +mkdir -p data/ +unzip kinetics400_tiny.zip -d data/ +``` + +## 修改配置 + +准备好数据集之后，下一步是修改配置文件，以指定训练集和训练参数的位置。 + +在本例中，我们将使用 resnet50 作为主干网络来训练 TSN。由于 MMAction2 已经有了完整的 Kinetics400 数据集的配置文件 (`configs/recognition/tsn/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb.py`)，我们只需要在其基础上进行一些修改。 + +### 修改数据集 + +我们首先需要修改数据集的路径。打开 `configs/recognition/tsn/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb.py` ，按如下替换关键字: + +```Python +data_root = 'data/kinetics400_tiny/train' +data_root_val = 'data/kinetics400_tiny/val' +ann_file_train = 'data/kinetics400_tiny/kinetics_tiny_train_video.txt' +ann_file_val = 'data/kinetics400_tiny/kinetics_tiny_val_video.txt' +``` + +### 修改运行配置 + +此外，由于数据集的大小减少，我们建议将训练批大小减少到4个，训练epoch的数量相应减少到10个。此外，我们建议将验证和权值存储间隔缩短为1轮，并修改学习率衰减策略。修改 `configs/recognition/tsn/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb.py` 中对应的关键字，如下所示生效。 + +```python +# 设置训练批大小为 4 +train_dataloader['batch_size'] = 4 + +# 每轮都保存权重，并且只保留最新的权重 +default_hooks = dict( + checkpoint=dict(type='CheckpointHook', interval=1, max_keep_ckpts=1)) +# 将最大 epoch 数设置为 10，并每 1 个 epoch验证模型 +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=10, val_interval=1) +#根据 10 个 epoch调整学习率调度 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=10, + by_epoch=True, + milestones=[4, 8], + gamma=0.1) +] +``` + +### 修改模型配置 + +此外，由于精简版 Kinetics 数据集规模较小，建议加载原始 Kinetics 数据集上的预训练模型。此外，模型需要根据实际类别数进行修改。请直接将以下代码添加到 `configs/recognition/tsn/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb.py` 中。 + +```python +model = dict( + cls_head=dict(num_classes=2)) +load_from = 'https://download.openmmlab.com/mmaction/v1.0/recognition/tsn/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb_20220906-cd10898e.pth' +``` + +在这里，我们直接通过继承 ({external+mmengine:doc} `MMEngine: Config
+
+| MMCV < 2.0 | +MMCV >= 2.0 | +
|---|---|
| + +```bash +# 包含算子，因为 mmcv-full 的最高版本小于 2.0.0，所以无需加版本限制 +pip install openmim +mim install mmcv-full + +# 不包含算子 +pip install openmim +mim install "mmcv < 2.0.0" +``` + + | ++ +```bash +# 包含算子 +pip install openmim +mim install mmcv + +# 不包含算子，因为 mmcv-lite 的起始版本为 2.0.0，所以无需加版本限制 +pip install openmim +mim install mmcv-lite +``` + + | +
+
+将代码克隆到本地
+
+```shell
+git clone git@github.com:{username}/mmcv.git
+```
+
+添加原代码库为上游代码库
+
+```bash
+git remote add upstream git@github.com:open-mmlab/mmcv
+```
+
+检查 remote 是否添加成功，在终端输入 `git remote -v`
+
+```bash
+origin git@github.com:{username}/mmcv.git (fetch)
+origin git@github.com:{username}/mmcv.git (push)
+upstream git@github.com:open-mmlab/mmcv (fetch)
+upstream git@github.com:open-mmlab/mmcv (push)
+```
+
+```{note}
+这里对 origin 和 upstream 进行一个简单的介绍，当我们使用 git clone 来克隆代码时，会默认创建一个 origin 的 remote，它指向我们克隆的代码库地址，而 upstream 则是我们自己添加的，用来指向原始代码库地址。当然如果你不喜欢他叫 upstream，也可以自己修改，比如叫 open-mmlab。我们通常向 origin 提交代码（即 fork 下来的远程仓库），然后向 upstream 提交一个 pull request。如果提交的代码和最新的代码发生冲突，再从 upstream 拉取最新的代码，和本地分支解决冲突，再提交到 origin。
+```
+
+#### 2. 配置 pre-commit
+
+在本地开发环境中，我们使用 [pre-commit](https://pre-commit.com/#intro) 来检查代码风格，以确保代码风格的统一。在提交代码，需要先安装 pre-commit（需要在 MMCV 目录下执行）:
+
+```shell
+pip install -U pre-commit
+pre-commit install
+```
+
+检查 pre-commit 是否配置成功，并安装 `.pre-commit-config.yaml` 中的钩子：
+
+```shell
+pre-commit run --all-files
+```
+
+
+
+
+
+```{note}
+如果你是中国用户，由于网络原因，可能会出现安装失败的情况，这时可以使用国内源
+
+pre-commit install -c .pre-commit-config-zh-cn.yaml
+
+pre-commit run --all-files -c .pre-commit-config-zh-cn.yaml
+```
+
+如果安装过程被中断，可以重复执行 `pre-commit run ...` 继续安装。
+
+如果提交的代码不符合代码风格规范，pre-commit 会发出警告，并自动修复部分错误。
+
+
+
+如果我们想临时绕开 pre-commit 的检查提交一次代码，可以在 `git commit` 时加上 `--no-verify`（需要保证最后推送至远程仓库的代码能够通过 pre-commit 检查）。
+
+```shell
+git commit -m "xxx" --no-verify
+```
+
+#### 3. 创建开发分支
+
+安装完 pre-commit 之后，我们需要基于 main 创建开发分支，建议的分支命名规则为 `username/pr_name`。
+
+```shell
+git checkout -b yhc/refactor_contributing_doc
+```
+
+在后续的开发中，如果本地仓库的 main 分支落后于 upstream 的 main 分支，我们需要先拉取 upstream 的代码进行同步，再执行上面的命令
+
+```shell
+git pull upstream main
+```
+
+#### 4. 提交代码并在本地通过单元测试
+
+- MMCV 引入了 mypy 来做静态类型检查，以增加代码的鲁棒性。因此我们在提交代码时，需要补充 Type Hints。具体规则可以参考[教程](https://zhuanlan.zhihu.com/p/519335398)。
+
+- 提交的代码同样需要通过单元测试
+
+ ```shell
+ # 通过全量单元测试
+ pytest tests
+
+ # 我们需要保证提交的代码能够通过修改模块的单元测试，以 runner 为例
+ pytest tests/test_runner/test_runner.py
+ ```
+
+ 如果你由于缺少依赖无法运行修改模块的单元测试，可以参考[指引-单元测试](#单元测试)
+
+- 如果修改/添加了文档，参考[指引](#文档渲染)确认文档渲染正常。
+
+#### 5. 推送代码到远程
+
+代码通过单元测试和 pre-commit 检查后，将代码推送到远程仓库，如果是第一次推送，可以在 `git push` 后加上 `-u` 参数以关联远程分支
+
+```shell
+git push -u origin {branch_name}
+```
+
+这样下次就可以直接使用 `git push` 命令推送代码了，而无需指定分支和远程仓库。
+
+#### 6. 提交拉取请求（PR）
+
+(1) 在 GitHub 的 Pull request 界面创建拉取请求
+
+
+(2) 根据指引修改 PR 描述，以便于其他开发者更好地理解你的修改
+
+
+
+描述规范详见[拉取请求规范](#拉取请求规范)
+
+
+
+**注意事项**
+
+(a) PR 描述应该包含修改理由、修改内容以及修改后带来的影响，并关联相关 Issue（具体方式见[文档](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)）
+
+(b) 如果是第一次为 OpenMMLab 做贡献，需要签署 CLA
+
+
+
+(c) 检查提交的 PR 是否通过 CI（集成测试）
+
+
+
+MMCV 会在不同的平台（Linux、Window、Mac），基于不同版本的 Python、PyTorch、CUDA 对提交的代码进行单元测试，以保证代码的正确性，如果有任何一个没有通过，我们可点击上图中的 `Details` 来查看具体的测试信息，以便于我们修改代码。
+
+(3) 如果 PR 通过了 CI，那么就可以等待其他开发者的 review，并根据 reviewer 的意见，修改代码，并重复 [4](#4-提交代码并本地通过单元测试)-[5](#5-推送代码到远程) 步骤，直到 reviewer 同意合入 PR。
+
+
+
+所有 reviewer 同意合入 PR 后，我们会尽快将 PR 合并到主分支。
+
+#### 7. 解决冲突
+
+随着时间的推移，我们的代码库会不断更新，这时候，如果你的 PR 与主分支存在冲突，你需要解决冲突，解决冲突的方式有两种：
+
+```shell
+git fetch --all --prune
+git rebase upstream/main
+```
+
+或者
+
+```shell
+git fetch --all --prune
+git merge upstream/main
+```
+
+如果你非常善于处理冲突，那么可以使用 rebase 的方式来解决冲突，因为这能够保证你的 commit log 的整洁。如果你不太熟悉 `rebase` 的使用，那么可以使用 `merge` 的方式来解决冲突。
+
+### 指引
+
+#### 单元测试
+
+如果你无法正常执行部分模块的单元测试，例如 [video](https://github.com/open-mmlab/mmcv/tree/main/mmcv/video) 模块，可能是你的当前环境没有安装以下依赖
+
+```shell
+# Linux
+sudo apt-get update -y
+sudo apt-get install -y libturbojpeg
+sudo apt-get install -y ffmpeg
+
+# Windows
+conda install ffmpeg
+```
+
+在提交修复代码错误或新增特性的拉取请求时，我们应该尽可能的让单元测试覆盖所有提交的代码，计算单元测试覆盖率的方法如下
+
+```shell
+python -m coverage run -m pytest /path/to/test_file
+python -m coverage html
+# check file in htmlcov/index.html
+```
+
+#### 文档渲染
+
+在提交修复代码错误或新增特性的拉取请求时，可能会需要修改/新增模块的 docstring。我们需要确认渲染后的文档样式是正确的。
+本地生成渲染后的文档的方法如下
+
+```shell
+pip install -r requirements/docs.txt
+cd docs/zh_cn/
+# or docs/en
+make html
+# check file in ./docs/zh_cn/_build/html/index.html
+```
+
+### 代码风格
+
+#### Python
+
+[PEP8](https://www.python.org/dev/peps/pep-0008/) 作为 OpenMMLab 算法库首选的代码规范，我们使用以下工具检查和格式化代码
+
+- [flake8](https://github.com/PyCQA/flake8): Python 官方发布的代码规范检查工具，是多个检查工具的封装
+- [isort](https://github.com/timothycrosley/isort): 自动调整模块导入顺序的工具
+- [yapf](https://github.com/google/yapf): Google 发布的代码规范检查工具
+- [codespell](https://github.com/codespell-project/codespell): 检查单词拼写是否有误
+- [mdformat](https://github.com/executablebooks/mdformat): 检查 markdown 文件的工具
+- [docformatter](https://github.com/myint/docformatter): 格式化 docstring 的工具
+
+yapf 和 isort 的配置可以在 [setup.cfg](./setup.cfg) 找到
+
+通过配置 [pre-commit hook](https://pre-commit.com/) ，我们可以在提交代码时自动检查和格式化 `flake8`、`yapf`、`isort`、`trailing whitespaces`、`markdown files`，
+修复 `end-of-files`、`double-quoted-strings`、`python-encoding-pragma`、`mixed-line-ending`，调整 `requirments.txt` 的包顺序。
+pre-commit 钩子的配置可以在 [.pre-commit-config](./.pre-commit-config.yaml) 找到。
+
+pre-commit 具体的安装使用方式见[拉取请求](#2-配置-pre-commit)。
+
+更具体的规范请参考 [OpenMMLab 代码规范](code_style.md)。
+
+#### C++ and CUDA
+
+C++ 和 CUDA 的代码规范遵从 [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html)
+
+### 拉取请求规范
+
+1. 使用 [pre-commit hook](https://pre-commit.com)，尽量减少代码风格相关问题
+
+2. 一个`拉取请求`对应一个短期分支
+
+3. 粒度要细，一个`拉取请求`只做一件事情，避免超大的`拉取请求`
+
+ - Bad：实现 Faster R-CNN
+ - Acceptable：给 Faster R-CNN 添加一个 box head
+ - Good：给 box head 增加一个参数来支持自定义的 conv 层数
+
+4. 每次 Commit 时需要提供清晰且有意义 commit 信息
+
+5. 提供清晰且有意义的`拉取请求`描述
+
+ - 标题写明白任务名称，一般格式:\[Prefix\] Short description of the pull request (Suffix)
+ - prefix: 新增功能 \[Feature\], 修 bug \[Fix\], 文档相关 \[Docs\], 开发中 \[WIP\] (暂时不会被review)
+ - 描述里介绍`拉取请求`的主要修改内容，结果，以及对其他部分的影响, 参考`拉取请求`模板
+ - 关联相关的`议题` (issue) 和其他`拉取请求`
+
+6. 如果引入了其他三方库，或借鉴了三方库的代码，请确认他们的许可证和 mmcv 兼容，并在借鉴的代码上补充 `This code is inspired from http://`
diff --git a/internlm_langchain/knowledge_base/MMCV/content/data_process.md b/internlm_langchain/knowledge_base/MMCV/content/data_process.md
new file mode 100644
index 00000000..7e0afd1e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/data_process.md
@@ -0,0 +1,275 @@
+## 数据处理
+
+### 图像
+
+图像模块提供了一些图像预处理的函数，该模块依赖 `opencv` 。
+
+#### 读取/保存/显示
+
+使用 `imread` 和 `imwrite` 函数可以读取和保存图像。
+
+```python
+import mmcv
+
+img = mmcv.imread('test.jpg')
+img = mmcv.imread('test.jpg', flag='grayscale')
+img_ = mmcv.imread(img) # 相当于什么也没做
+mmcv.imwrite(img, 'out.jpg')
+```
+
+从二进制中读取图像
+
+```python
+with open('test.jpg', 'rb') as f:
+ data = f.read()
+img = mmcv.imfrombytes(data)
+```
+
+显示图像文件或已读取的图像
+
+```python
+mmcv.imshow('tests/data/color.jpg')
+
+for i in range(10):
+ img = np.random.randint(256, size=(100, 100, 3), dtype=np.uint8)
+ mmcv.imshow(img, win_name='test image', wait_time=200)
+```
+
+#### 色彩空间转换
+
+支持的转换函数：
+
+- bgr2gray
+- gray2bgr
+- bgr2rgb
+- rgb2bgr
+- bgr2hsv
+- hsv2bgr
+
+```python
+img = mmcv.imread('tests/data/color.jpg')
+img1 = mmcv.bgr2rgb(img)
+img2 = mmcv.rgb2gray(img1)
+img3 = mmcv.bgr2hsv(img)
+```
+
+#### 缩放
+
+有三种缩放图像的方法。所有以 `imresize_*` 开头的函数都有一个 `return_scale` 参数，如果
+该参数为 `False` ，函数的返回值只有调整之后的图像，否则是一个元组 `(resized_img, scale)` 。
+
+```python
+# 缩放图像至给定的尺寸
+mmcv.imresize(img, (1000, 600), return_scale=True)
+
+# 缩放图像至与给定的图像同样的尺寸
+mmcv.imresize_like(img, dst_img, return_scale=False)
+
+# 以一定的比例缩放图像
+mmcv.imrescale(img, 0.5)
+
+# 缩放图像至最长的边不大于1000、最短的边不大于800并且没有改变图像的长宽比
+mmcv.imrescale(img, (1000, 800))
+```
+
+#### 旋转
+
+我们可以使用 `imrotate` 旋转图像一定的角度。旋转的中心需要指定，默认值是原始图像的中心。有
+两种旋转的模式，一种保持图像的尺寸不变，因此旋转后原始图像中的某些部分会被裁剪，另一种是扩大
+图像的尺寸进而保留完整的原始图像。
+
+```python
+img = mmcv.imread('tests/data/color.jpg')
+
+# 顺时针旋转图像30度
+img_ = mmcv.imrotate(img, 30)
+
+# 逆时针旋转图像90度
+img_ = mmcv.imrotate(img, -90)
+
+# 顺时针旋转图像30度并且缩放图像为原始图像的1.5倍
+img_ = mmcv.imrotate(img, 30, scale=1.5)
+
+# 以坐标(100, 100)为中心顺时针旋转图像30度
+img_ = mmcv.imrotate(img, 30, center=(100, 100))
+
+# 顺时针旋转图像30度并扩大图像的尺寸
+img_ = mmcv.imrotate(img, 30, auto_bound=True)
+```
+
+#### 翻转
+
+我们可以使用 `imflip` 翻转图像。
+
+```python
+img = mmcv.imread('tests/data/color.jpg')
+
+# 水平翻转图像
+mmcv.imflip(img)
+
+# 垂直翻转图像
+mmcv.imflip(img, direction='vertical')
+```
+
+#### 裁剪
+
+`imcrop` 可以裁剪图像的一个或多个区域，每个区域用左上角和右下角坐标表示，形如(x1, y1, x2, y2)
+
+```python
+import mmcv
+import numpy as np
+
+img = mmcv.imread('tests/data/color.jpg')
+
+# 裁剪区域 (10, 10, 100, 120)
+bboxes = np.array([10, 10, 100, 120])
+patch = mmcv.imcrop(img, bboxes)
+
+# 裁剪两个区域，分别是 (10, 10, 100, 120) 和 (0, 0, 50, 50)
+bboxes = np.array([[10, 10, 100, 120], [0, 0, 50, 50]])
+patches = mmcv.imcrop(img, bboxes)
+
+# 裁剪两个区域并且缩放区域1.2倍
+patches = mmcv.imcrop(img, bboxes, scale=1.2)
+```
+
+#### 填充
+
+`impad` and `impad_to_multiple` 可以用给定的值将图像填充至给定的尺寸。
+
+```python
+img = mmcv.imread('tests/data/color.jpg')
+
+# 用给定值将图像填充至 (1000, 1200)
+img_ = mmcv.impad(img, shape=(1000, 1200), pad_val=0)
+
+# 用给定值分别填充图像的3个通道至 (1000, 1200)
+img_ = mmcv.impad(img, shape=(1000, 1200), pad_val=(100, 50, 200))
+
+# 用给定值填充图像的左、右、上、下四条边
+img_ = mmcv.impad(img, padding=(10, 20, 30, 40), pad_val=0)
+
+# 用3个值分别填充图像的左、右、上、下四条边的3个通道
+img_ = mmcv.impad(img, padding=(10, 20, 30, 40), pad_val=(100, 50, 200))
+
+# 将图像的四条边填充至能够被给定值整除
+img_ = mmcv.impad_to_multiple(img, 32)
+```
+
+### 视频
+
+视频模块提供了以下的功能：
+
+- 一个 `VideoReader` 类，具有友好的 API 接口可以读取和转换视频
+- 一些编辑视频的方法，包括 `cut` ， `concat` ， `resize`
+- 光流的读取/保存/变换
+
+#### VideoReader
+
+`VideoReader` 类提供了和序列一样的接口去获取视频帧。该类会缓存所有被访问过的帧。
+
+```python
+video = mmcv.VideoReader('test.mp4')
+
+# 获取基本的信息
+print(len(video))
+print(video.width, video.height, video.resolution, video.fps)
+
+# 遍历所有的帧
+for frame in video:
+ print(frame.shape)
+
+# 读取下一帧
+img = video.read()
+
+# 使用索引获取帧
+img = video[100]
+
+# 获取指定范围的帧
+img = video[5:10]
+```
+
+将视频切成帧并保存至给定目录或者从给定目录中生成视频。
+
+```python
+# 将视频切成帧并保存至目录
+video = mmcv.VideoReader('test.mp4')
+video.cvt2frames('out_dir')
+
+# 从给定目录中生成视频
+mmcv.frames2video('out_dir', 'test.avi')
+```
+
+#### 编辑函数
+
+有几个用于编辑视频的函数，这些函数是对 `ffmpeg` 的封装。
+
+```python
+# 裁剪视频
+mmcv.cut_video('test.mp4', 'clip1.mp4', start=3, end=10, vcodec='h264')
+
+# 将多个视频拼接成一个视频
+mmcv.concat_video(['clip1.mp4', 'clip2.mp4'], 'joined.mp4', log_level='quiet')
+
+# 将视频缩放至给定的尺寸
+mmcv.resize_video('test.mp4', 'resized1.mp4', (360, 240))
+
+# 将视频缩放至给定的倍率
+mmcv.resize_video('test.mp4', 'resized2.mp4', ratio=2)
+```
+
+#### 光流
+
+`mmcv` 提供了以下用于操作光流的函数：
+
+- 读取/保存
+- 可视化
+- 流变换
+
+我们提供了两种将光流dump到文件的方法，分别是非压缩和压缩的方法。非压缩的方法直接将浮点数值的光流
+保存至二进制文件，虽然光流无损但文件会比较大。而压缩的方法先量化光流至 0-255 整形数值再保存为
+jpeg图像。光流的x维度和y维度会被拼接到图像中。
+
+1. 读取/保存
+
+```python
+flow = np.random.rand(800, 600, 2).astype(np.float32)
+# 保存光流到flo文件 (~3.7M)
+mmcv.flowwrite(flow, 'uncompressed.flo')
+# 保存光流为jpeg图像 (~230K)，图像的尺寸为 (800, 1200)
+mmcv.flowwrite(flow, 'compressed.jpg', quantize=True, concat_axis=1)
+
+# 读取光流文件，以下两种方式读取的光流尺寸均为 (800, 600, 2)
+flow = mmcv.flowread('uncompressed.flo')
+flow = mmcv.flowread('compressed.jpg', quantize=True, concat_axis=1)
+```
+
+2. 可视化
+
+使用 `mmcv.flowshow()` 可视化光流
+
+```python
+mmcv.flowshow(flow)
+```
+
+
+
+1. 流变换
+
+```python
+img1 = mmcv.imread('img1.jpg')
+flow = mmcv.flowread('flow.flo')
+warped_img2 = mmcv.flow_warp(img1, flow)
+```
+
+img1 (左) and img2 (右)
+
+
+
+光流 (img2 -> img1)
+
+
+
+变换后的图像和真实图像的差异
+
+
diff --git a/internlm_langchain/knowledge_base/MMCV/content/data_transform.md b/internlm_langchain/knowledge_base/MMCV/content/data_transform.md
new file mode 100644
index 00000000..47d16e1b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/data_transform.md
@@ -0,0 +1,341 @@
+# 数据变换
+
+在 OpenMMLab 算法库中，数据集的构建和数据的准备是相互解耦的。通常，数据集的构建只对数据集进行解析，记录每个样本的基本信息；而数据的准备则是通过一系列的数据变换，根据样本的基本信息进行数据加载、预处理、格式化等操作。
+
+## 数据变换的设计
+
+在 MMCV 中，我们使用各种可调用的数据变换类来进行数据的操作。这些数据变换类可以接受若干配置参数进行实例化，之后通过调用的方式对输入的数据字典进行处理。同时，我们约定所有数据变换都接受一个字典作为输入，并将处理后的数据输出为一个字典。一个简单的例子如下：
+
+```python
+>>> import numpy as np
+>>> from mmcv.transforms import Resize
+>>>
+>>> transform = Resize(scale=(224, 224))
+>>> data_dict = {'img': np.random.rand(256, 256, 3)}
+>>> data_dict = transform(data_dict)
+>>> print(data_dict['img'].shape)
+(224, 224, 3)
+```
+
+数据变换类会读取输入字典的某些字段，并且可能添加、或者更新某些字段。这些字段的键大部分情况下是固定的，如 `Resize` 会固定地读取输入字典中的 `"img"` 等字段。我们可以在对应类的文档中了解对输入输出字段的约定。
+
+```{note}
+默认情况下，在需要图像尺寸作为**初始化参数**的数据变换 (如Resize, Pad) 中，图像尺寸的顺序均为 (width, height)。在数据变换**返回的字典**中，图像相关的尺寸， 如 `img_shape`、`ori_shape`、`pad_shape` 等，均为 (height, width)。
+```
+
+MMCV 为所有的数据变换类提供了一个统一的基类 (`BaseTransform`)：
+
+```python
+class BaseTransform(metaclass=ABCMeta):
+
+ def __call__(self, results: dict) -> dict:
+
+ return self.transform(results)
+
+ @abstractmethod
+ def transform(self, results: dict) -> dict:
+ pass
+```
+
+所有的数据变换类都需要继承 `BaseTransform`，并实现 `transform` 方法。`transform` 方法的输入和输出均为一个字典。在**自定义数据变换类**一节中，我们会更详细地介绍如何实现一个数据变换类。
+
+## 数据流水线
+
+如上所述，所有数据变换的输入和输出都是一个字典，而且根据 OpenMMLab 中 [有关数据集的约定](TODO)，数据集中每个样本的基本信息都是一个字典。这样一来，我们可以将所有的数据变换操作首尾相接，组合成为一条数据流水线（data pipeline），输入数据集中样本的信息字典，输出完成一系列处理后的信息字典。
+
+以分类任务为例，我们在下图展示了一个典型的数据流水线。对每个样本，数据集中保存的基本信息是一个如图中最左侧所示的字典，之后每经过一个由蓝色块代表的数据变换操作，数据字典中都会加入新的字段（标记为绿色）或更新现有的字段（标记为橙色）。
+
+
+
+
+
+在配置文件中，数据流水线是一个若干数据变换配置字典组成的列表，每个数据集都需要设置参数 `pipeline` 来定义该数据集需要进行的数据准备操作。如上数据流水线在配置文件中的配置如下：
+
+```python
+pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize', size=256, keep_ratio=True),
+ dict(type='CenterCrop', crop_size=224),
+ dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+ dict(type='ClsFormatBundle')
+]
+
+dataset = dict(
+ ...
+ pipeline=pipeline,
+ ...
+)
+```
+
+## 常用的数据变换类
+
+按照功能，常用的数据变换类可以大致分为数据加载、数据预处理与增强、数据格式化。在 MMCV 中，我们提供了一些常用的数据变换类如下：
+
+### 数据加载
+
+为了支持大规模数据集的加载，通常在 `Dataset` 初始化时不加载数据，只加载相应的路径。因此需要在数据流水线中进行具体数据的加载。
+
+| class | 功能 |
+| :-------------------------: | :---------------------------------------: |
+| [`LoadImageFromFile`](TODO) | 根据路径加载图像 |
+| [`LoadAnnotations`](TODO) | 加载和组织标注信息，如 bbox、语义分割图等 |
+
+### 数据预处理及增强
+
+数据预处理和增强通常是对图像本身进行变换，如裁剪、填充、缩放等。
+
+| class | 功能 |
+| :------------------------------: | :--------------------------------: |
+| [`Pad`](TODO) | 填充图像边缘 |
+| [`CenterCrop`](TODO) | 居中裁剪 |
+| [`Normalize`](TODO) | 对图像进行归一化 |
+| [`Resize`](TODO) | 按照指定尺寸或比例缩放图像 |
+| [`RandomResize`](TODO) | 缩放图像至指定范围的随机尺寸 |
+| [`RandomMultiscaleResize`](TODO) | 缩放图像至多个尺寸中的随机一个尺寸 |
+| [`RandomGrayscale`](TODO) | 随机灰度化 |
+| [`RandomFlip`](TODO) | 图像随机翻转 |
+| [`MultiScaleFlipAug`](TODO) | 支持缩放和翻转的测试时数据增强 |
+
+### 数据格式化
+
+数据格式化操作通常是对数据进行的类型转换。
+
+| class | 功能 |
+| :---------------------: | :-------------------------------: |
+| [`ToTensor`](TODO) | 将指定的数据转换为 `torch.Tensor` |
+| [`ImageToTensor`](TODO) | 将图像转换为 `torch.Tensor` |
+
+## 自定义数据变换类
+
+要实现一个新的数据变换类，需要继承 `BaseTransform`，并实现 `transform` 方法。这里，我们使用一个简单的翻转变换（`MyFlip`）作为示例：
+
+```python
+import random
+import mmcv
+from mmcv.transforms import BaseTransform, TRANSFORMS
+
+@TRANSFORMS.register_module()
+class MyFlip(BaseTransform):
+ def __init__(self, direction: str):
+ super().__init__()
+ self.direction = direction
+
+ def transform(self, results: dict) -> dict:
+ img = results['img']
+ results['img'] = mmcv.imflip(img, direction=self.direction)
+ return results
+```
+
+从而，我们可以实例化一个 `MyFlip` 对象，并将之作为一个可调用对象，来处理我们的数据字典。
+
+```python
+import numpy as np
+
+transform = MyFlip(direction='horizontal')
+data_dict = {'img': np.random.rand(224, 224, 3)}
+data_dict = transform(data_dict)
+processed_img = data_dict['img']
+```
+
+又或者，在配置文件的 pipeline 中使用 `MyFlip` 变换
+
+```python
+pipeline = [
+ ...
+ dict(type='MyFlip', direction='horizontal'),
+ ...
+]
+```
+
+需要注意的是，如需在配置文件中使用，需要保证 `MyFlip` 类所在的文件在运行时能够被导入。
+
+## 变换包装
+
+变换包装是一种特殊的数据变换类，他们本身并不操作数据字典中的图像、标签等信息，而是对其中定义的数据变换的行为进行增强。
+
+### 字段映射（KeyMapper）
+
+字段映射包装（`KeyMapper`）用于对数据字典中的字段进行映射。例如，一般的图像处理变换都从数据字典中的 `"img"` 字段获得值。但有些时候，我们希望这些变换处理数据字典中其他字段中的图像，比如 `"gt_img"` 字段。
+
+如果配合注册器和配置文件使用的话，在配置文件中数据集的 `pipeline` 中如下例使用字段映射包装：
+
+```python
+pipeline = [
+ ...
+ dict(type='KeyMapper',
+ mapping={
+ 'img': 'gt_img', # 将 "gt_img" 字段映射至 "img" 字段
+ 'mask': ..., # 不使用原始数据中的 "mask" 字段。即对于被包装的数据变换，数据中不包含 "mask" 字段
+ },
+ auto_remap=True, # 在完成变换后，将 "img" 重映射回 "gt_img" 字段
+ transforms=[
+ # 在 `RandomFlip` 变换类中，我们只需要操作 "img" 字段即可
+ dict(type='RandomFlip'),
+ ])
+ ...
+]
+```
+
+利用字段映射包装，我们在实现数据变换类时，不需要考虑在 `transform` 方法中考虑各种可能的输入字段名，只需要处理默认的字段即可。
+
+### 随机选择（RandomChoice）和随机执行（RandomApply）
+
+随机选择包装（`RandomChoice`）用于从一系列数据变换组合中随机应用一个数据变换组合。利用这一包装，我们可以简单地实现一些数据增强功能，比如 AutoAugment。
+
+如果配合注册器和配置文件使用的话，在配置文件中数据集的 `pipeline` 中如下例使用随机选择包装：
+
+```python
+pipeline = [
+ ...
+ dict(type='RandomChoice',
+ transforms=[
+ [
+ dict(type='Posterize', bits=4),
+ dict(type='Rotate', angle=30.)
+ ], # 第一种随机变化组合
+ [
+ dict(type='Equalize'),
+ dict(type='Rotate', angle=30)
+ ], # 第二种随机变换组合
+ ],
+ prob=[0.4, 0.6] # 两种随机变换组合各自的选用概率
+ )
+ ...
+]
+```
+
+随机执行包装（`RandomApply`）用于以指定概率随机执行数据变换组合。例如：
+
+```python
+pipeline = [
+ ...
+ dict(type='RandomApply',
+ transforms=[dict(type='Rotate', angle=30.)],
+ prob=0.3) # 以 0.3 的概率执行被包装的数据变换
+ ...
+]
+```
+
+### 多目标扩展（TransformBroadcaster）
+
+通常，一个数据变换类只会从一个固定的字段读取操作目标。虽然我们也可以使用 `KeyMapper` 来改变读取的字段，但无法将变换一次性应用于多个字段的数据。为了实现这一功能，我们需要借助多目标扩展包装（`TransformBroadcaster`）。
+
+多目标扩展包装（`TransformBroadcaster`）有两个用法，一是将数据变换作用于指定的多个字段，二是将数据变换作用于某个字段下的一组目标中。
+
+1. 应用于多个字段
+
+ 假设我们需要将数据变换应用于 `"lq"` (low-quality) 和 `"gt"` (ground-truth) 两个字段中的图像上。
+
+ ```python
+ pipeline = [
+ dict(type='TransformBroadcaster',
+ # 分别应用于 "lq" 和 "gt" 两个字段，并将二者应设置 "img" 字段
+ mapping={'img': ['lq', 'gt']},
+ # 在完成变换后，将 "img" 字段重映射回原先的字段
+ auto_remap=True,
+ # 是否在对各目标的变换中共享随机变量
+ # 更多介绍参加后续章节（随机变量共享）
+ share_random_params=True,
+ transforms=[
+ # 在 `RandomFlip` 变换类中，我们只需要操作 "img" 字段即可
+ dict(type='RandomFlip'),
+ ])
+ ]
+ ```
+
+ 在多目标扩展的 `mapping` 设置中，我们同样可以使用 `...` 来忽略指定的原始字段。如以下例子中，被包裹的 `RandomCrop` 会对字段 `"img"` 中的图像进行裁剪，并且在字段 `"img_shape"` 存在时更新剪裁后的图像大小。如果我们希望同时对两个图像字段 `"lq"` 和 `"gt"` 进行相同的随机裁剪，但只更新一次 `"img_shape"` 字段，可以通过例子中的方式实现：
+
+ ```python
+ pipeline = [
+ dict(type='TransformBroadcaster',
+ mapping={
+ 'img': ['lq', 'gt'],
+ 'img_shape': ['img_shape', ...],
+ },
+ # 在完成变换后，将 "img" 和 "img_shape" 字段重映射回原先的字段
+ auto_remap=True,
+ # 是否在对各目标的变换中共享随机变量
+ # 更多介绍参加后续章节（随机变量共享）
+ share_random_params=True,
+ transforms=[
+ # `RandomCrop` 类中会操作 "img" 和 "img_shape" 字段。若 "img_shape" 空缺，
+ # 则只操作 "img"
+ dict(type='RandomCrop'),
+ ])
+ ]
+ ```
+
+2. 应用于一个字段的一组目标
+
+ 假设我们需要将数据变换应用于 `"images"` 字段，该字段为一个图像组成的 list。
+
+ ```python
+ pipeline = [
+ dict(type='TransformBroadcaster',
+ # 将 "images" 字段下的每张图片映射至 "img" 字段
+ mapping={'img': 'images'},
+ # 在完成变换后，将 "img" 字段下的图片重映射回 "images" 字段的列表中
+ auto_remap=True,
+ # 是否在对各目标的变换中共享随机变量
+ share_random_params=True,
+ transforms=[
+ # 在 `RandomFlip` 变换类中，我们只需要操作 "img" 字段即可
+ dict(type='RandomFlip'),
+ ])
+ ]
+ ```
+
+#### 装饰器 `cache_randomness`
+
+在 `TransformBroadcaster` 中，我们提供了 `share_random_params` 选项来支持在多次数据变换中共享随机状态。例如，在超分辨率任务中，我们希望将随机变换**同步**作用于低分辨率图像和原始图像。如果我们希望在自定义的数据变换类中使用这一功能，需要在类中标注哪些随机变量是支持共享的。这可以通过装饰器 `cache_randomness` 来实现。
+
+以上文中的 `MyFlip` 为例，我们希望以一定的概率随机执行翻转：
+
+```python
+from mmcv.transforms.utils import cache_randomness
+
+@TRANSFORMS.register_module()
+class MyRandomFlip(BaseTransform):
+ def __init__(self, prob: float, direction: str):
+ super().__init__()
+ self.prob = prob
+ self.direction = direction
+
+ @cache_randomness # 标注该方法的输出为可共享的随机变量
+ def do_flip(self):
+ flip = True if random.random() > self.prob else False
+ return flip
+
+ def transform(self, results: dict) -> dict:
+ img = results['img']
+ if self.do_flip():
+ results['img'] = mmcv.imflip(img, direction=self.direction)
+ return results
+```
+
+在上面的例子中，我们用`cache_randomness` 装饰 `do_flip`方法，即将该方法返回值 `flip` 标注为一个支持共享的随机变量。进而，在 `TransformBroadcaster` 对多个目标的变换中，这一变量的值都会保持一致。
+
+#### 装饰器 `avoid_cache_randomness`
+
+在一些情况下，我们无法将数据变换中产生随机变量的过程单独放在类方法中。例如数据变换中使用的来自第三方库的模块，这些模块将随机变量相关的部分封装在了内部，导致无法将其抽出为数据变换的类方法。这样的数据变换无法通过装饰器 `cache_randomness` 标注支持共享的随机变量，进而无法在多目标扩展时共享随机变量。
+
+为了避免在多目标扩展中误用此类数据变换，我们提供了另一个装饰器 `avoid_cache_randomness`，用来对此类数据变换进行标记：
+
+```python
+from mmcv.transforms.utils import avoid_cache_randomness
+
+@TRANSFORMS.register_module()
+@avoid_cache_randomness
+class MyRandomTransform(BaseTransform):
+
+ def transform(self, results: dict) -> dict:
+ ...
+```
+
+用 `avoid_cache_randomness` 标记的数据变换类，当其实例被 `TransformBroadcaster` 包装且将参数 `share_random_params` 设置为 True 时，会抛出异常，以此提醒用户不能这样使用。
+
+在使用 `avoid_cache_randomness` 时需要注意以下几点：
+
+1. `avoid_cache_randomness` 只用于装饰数据变换类（BaseTransfrom 的子类），而不能用与装饰其他一般的类、类方法或函数
+2. 被 `avoid_cache_randomness` 修饰的数据变换作为基类时，其子类将**不会继承**这一特性。如果子类仍无法共享随机变量，则应再次使用 `avoid_cache_randomness` 修饰
+3. 只有当一个数据变换具有随机性，且无法共享随机参数时，才需要以 `avoid_cache_randomness` 修饰。无随机性的数据变换不需要修饰
diff --git a/internlm_langchain/knowledge_base/MMCV/content/faq.md b/internlm_langchain/knowledge_base/MMCV/content/faq.md
new file mode 100644
index 00000000..6cfb100c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/faq.md
@@ -0,0 +1,91 @@
+## 常见问题
+
+在这里我们列出了用户经常遇到的问题以及对应的解决方法。如果您遇到了其他常见的问题，并且知道可以帮到大家的解决办法，
+欢迎随时丰富这个列表。
+
+### 安装问题
+
+- KeyError: "xxx: 'yyy is not in the zzz registry'"
+
+ 只有模块所在的文件被导入时，注册机制才会被触发，所以您需要在某处导入该文件，更多详情请查看 [KeyError: "MaskRCNN: 'RefineRoIHead is not in the models registry'"](https://github.com/open-mmlab/mmdetection/issues/5974)。
+
+- "No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'"
+
+ 1. 使用 `pip uninstall mmcv` 卸载您环境中的 mmcv
+ 2. 参考 [installation instruction](https://mmcv.readthedocs.io/en/latest/get_started/installation.html) 或者 [Build MMCV from source](https://mmcv.readthedocs.io/en/latest/get_started/build.html) 安装 mmcv-full
+
+- "invalid device function" 或者 "no kernel image is available for execution"
+
+ 1. 检查 GPU 的 CUDA 计算能力
+ 2. 运行 `python mmdet/utils/collect_env.py` 来检查 PyTorch、torchvision 和 MMCV 是否是针对正确的 GPU 架构构建的，您可能需要去设置 `TORCH_CUDA_ARCH_LIST` 来重新安装 MMCV。兼容性问题可能会出现在使用旧版的 GPUs，如：colab 上的 Tesla K80 (3.7)
+ 3. 检查运行环境是否和 mmcv/mmdet 编译时的环境相同。例如，您可能使用 CUDA 10.0 编译 mmcv，但在 CUDA 9.0 的环境中运行它
+
+- "undefined symbol" 或者 "cannot open xxx.so"
+
+ 1. 如果符号和 CUDA/C++ 相关（例如：libcudart.so 或者 GLIBCXX），请检查 CUDA/GCC 运行时的版本是否和编译 mmcv 的一致
+ 2. 如果符号和 PyTorch 相关（例如：符号包含 caffe、aten 和 TH），请检查 PyTorch 运行时的版本是否和编译 mmcv 的一致
+ 3. 运行 `python mmdet/utils/collect_env.py` 以检查 PyTorch、torchvision 和 MMCV 构建和运行的环境是否相同
+
+- "RuntimeError: CUDA error: invalid configuration argument"
+
+ 这个错误可能是由于您的 GPU 性能不佳造成的。尝试降低 [THREADS_PER_BLOCK](https://github.com/open-mmlab/mmcv/blob/cac22f8cf5a904477e3b5461b1cc36856c2793da/mmcv/ops/csrc/common_cuda_helper.hpp#L10)
+ 的值并重新编译 mmcv。
+
+- "RuntimeError: nms is not compiled with GPU support"
+
+ 这个错误是由于您的 CUDA 环境没有正确安装。
+ 您可以尝试重新安装您的 CUDA 环境，然后删除 mmcv/build 文件夹并重新编译 mmcv。
+
+- "Segmentation fault"
+
+ 1. 检查 GCC 的版本，通常是因为 PyTorch 版本与 GCC 版本不匹配 （例如 GCC \< 4.9 )，我们推荐用户使用 GCC 5.4，我们也不推荐使用 GCC 5.5， 因为有反馈 GCC 5.5 会导致 "segmentation fault" 并且切换到 GCC 5.4 就可以解决问题
+ 2. 检查是否正确安装 CUDA 版本的 PyTorc。输入以下命令并检查是否返回 True
+ ```shell
+ python -c 'import torch; print(torch.cuda.is_available())'
+ ```
+ 3. 如果 `torch` 安装成功，那么检查 MMCV 是否安装成功。输入以下命令，如果没有报错说明 mmcv-full 安装成。
+ ```shell
+ python -c 'import mmcv; import mmcv.ops'
+ ```
+ 4. 如果 MMCV 与 PyTorch 都安装成功了，则可以使用 `ipdb` 设置断点或者使用 `print` 函数，分析是哪一部分的代码导致了 `segmentation fault`
+
+- "libtorch_cuda_cu.so: cannot open shared object file"
+
+ `mmcv-full` 依赖 `libtorch_cuda_cu.so` 文件，但程序运行时没能找到该文件。我们可以检查该文件是否存在 `~/miniconda3/envs/{environment-name}/lib/python3.7/site-packages/torch/lib` 也可以尝试重装 PyTorch。
+
+- "fatal error C1189: #error: -- unsupported Microsoft Visual Studio version!"
+
+ 如果您在 Windows 上编译 mmcv-full 并且 CUDA 的版本是 9.2，您很可能会遇到这个问题 `"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.2\include\crt/host_config.h(133): fatal error C1189: #error: -- unsupported Microsoft Visual Studio version! Only the versions 2012, 2013, 2015 and 2017 are supported!"`，您可以尝试使用低版本的 Microsoft Visual Studio，例如 vs2017。
+
+- "error: member "torch::jit::detail::ModulePolicy::all_slots" may not be initialized"
+
+ 如果您在 Windows 上编译 mmcv-full 并且 PyTorch 的版本是 1.5.0，您很可能会遇到这个问题 `- torch/csrc/jit/api/module.h(474): error: member "torch::jit::detail::ModulePolicy::all_slots" may not be initialized`。解决这个问题的方法是将 `torch/csrc/jit/api/module.h` 文件中所有 `static constexpr bool all_slots = false;` 替换为 `static bool all_slots = false;`。更多细节可以查看 [member "torch::jit::detail::AttributePolicy::all_slots" may not be initialized](https://github.com/pytorch/pytorch/issues/39394)。
+
+- "error: a member with an in-class initializer must be const"
+
+ 如果您在 Windows 上编译 mmcv-full 并且 PyTorch 的版本是 1.6.0，您很可能会遇到这个问题 `"- torch/include\torch/csrc/jit/api/module.h(483): error: a member with an in-class initializer must be const"`. 解决这个问题的方法是将 `torch/include\torch/csrc/jit/api/module.h` 文件中的所有 `CONSTEXPR_EXCEPT_WIN_CUDA ` 替换为 `const`。更多细节可以查看 [Ninja: build stopped: subcommand failed](https://github.com/open-mmlab/mmcv/issues/575)。
+
+- "error: member "torch::jit::ProfileOptionalOp::Kind" may not be initialized"
+
+ 如果您在 Windows 上编译 mmcv-full 并且 PyTorch 的版本是 1.7.0，您很可能会遇到这个问题 `torch/include\torch/csrc/jit/ir/ir.h(1347): error: member "torch::jit::ProfileOptionalOp::Kind" may not be initialized`. 解决这个问题的方法是修改 PyTorch 中的几个文件：
+
+ - 删除 `torch/include\torch/csrc/jit/ir/ir.h` 文件中的 `static constexpr Symbol Kind = ::c10::prim::profile;` 和 `tatic constexpr Symbol Kind = ::c10::prim::profile_optional;`
+ - 将 `torch\include\pybind11\cast.h` 文件中的 `explicit operator type&() { return *(this->value); }` 替换为 `explicit operator type&() { return *((type*)this->value); }`
+ - 将 `torch/include\torch/csrc/jit/api/module.h` 文件中的 所有 `CONSTEXPR_EXCEPT_WIN_CUDA` 替换为 `const`
+
+ 更多细节可以查看 [Ensure default extra_compile_args](https://github.com/pytorch/pytorch/pull/45956)。
+
+- MMCV 和 MMDetection 的兼容性问题；"ConvWS is already registered in conv layer"
+
+ 请参考 [installation instruction](https://mmdetection.readthedocs.io/en/latest/get_started.html#installation) 为您的 MMDetection 版本安装正确版本的 MMCV。
+
+### 使用问题
+
+- "RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one"
+
+ 1. 这个错误是因为有些参数没有参与 loss 的计算，可能是代码中存在多个分支，导致有些分支没有参与 loss 的计算。更多细节见 [Expected to have finished reduction in the prior iteration before starting a new one](https://github.com/pytorch/pytorch/issues/55582)。
+ 2. 你可以设置 DDP 中的 `find_unused_parameters` 为 `True`，或者手动查找哪些参数没有用到。
+
+- "RuntimeError: Trying to backward through the graph a second time"
+
+ 不能同时设置 `GradientCumulativeOptimizerHook` 和 `OptimizerHook`，这会导致 `loss.backward()` 被调用两次，于是程序抛出 `RuntimeError`。我们只需设置其中的一个。更多细节见 [Trying to backward through the graph a second time](https://github.com/open-mmlab/mmcv/issues/1379)。
diff --git a/internlm_langchain/knowledge_base/MMCV/content/installation.md b/internlm_langchain/knowledge_base/MMCV/content/installation.md
new file mode 100644
index 00000000..16cb0076
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/installation.md
@@ -0,0 +1,369 @@
+## 安装 MMCV
+
+MMCV 有两个版本：
+
+- **mmcv**: 完整版，包含所有的特性以及丰富的开箱即用的 CPU 和 CUDA 算子。注意，完整版本可能需要更长时间来编译。
+- **mmcv-lite**: 精简版，不包含 CPU 和 CUDA 算子但包含其余所有特性和功能，类似 MMCV 1.0 之前的版本。如果你不需要使用算子的话，精简版可以作为一个考虑选项。
+
+```{warning}
+请不要在同一个环境中安装两个版本，否则可能会遇到类似 `ModuleNotFound` 的错误。在安装一个版本之前，需要先卸载另一个。`如果 CUDA 可用，强烈推荐安装 mmcv`。
+```
+
+### 安装 mmcv
+
+在安装 mmcv 之前，请确保 PyTorch 已经成功安装在环境中，可以参考 [PyTorch 官方安装文档](https://pytorch.org/get-started/locally/#start-locally)。可使用以下命令验证
+
+```bash
+python -c 'import torch;print(torch.__version__)'
+```
+
+如果输出版本信息，则表示 PyTorch 已安装。
+
+#### 使用 mim 安装（推荐）
+
+[mim](https://github.com/open-mmlab/mim) 是 OpenMMLab 项目的包管理工具，使用它可以很方便地安装 mmcv。
+
+```bash
+pip install -U openmim
+mim install mmcv
+```
+
+如果发现上述的安装命令没有使用预编译包（以 `.whl` 结尾）而是使用源码包（以 `.tar.gz` 结尾）安装，则有可能是我们没有提供和当前环境的 PyTorch 版本、CUDA 版本相匹配的 mmcv 预编译包，此时，你可以[源码安装 mmcv](build.md)。
+
+
+
+
+Collecting mmcv
+Downloading https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/mmcv-2.0.0-cp38-cp38-manylinux1_x86_64.whl + +
+
+使用预编译包的安装日志
+ +Looking in links: https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html+Collecting mmcv
+Downloading https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/mmcv-2.0.0-cp38-cp38-manylinux1_x86_64.whl + +
+
+Collecting mmcv==2.0.0
+Downloading mmcv-2.0.0.tar.gz + +
+
+如需安装指定版本的 mmcv，例如安装 2.0.0 版本的 mmcv，可使用以下命令
+
+```bash
+mim install mmcv==2.0.0
+```
+
+:::{note}
+如果你打算使用 `opencv-python-headless` 而不是 `opencv-python`，例如在一个很小的容器环境或者没有图形用户界面的服务器中，你可以先安装 `opencv-python-headless`，这样在安装 mmcv 依赖的过程中会跳过 `opencv-python`。
+
+另外，如果安装依赖库的时间过长，可以指定 pypi 源
+
+```bash
+mim install "mmcv>=2.0.0rc1" -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+:::
+
+安装完成后可以运行 [check_installation.py](https://github.com/open-mmlab/mmcv/blob/main/.dev_scripts/check_installation.py) 脚本检查 mmcv 是否安装成功。
+
+#### 使用 pip 安装
+
+使用以下命令查看 CUDA 和 PyTorch 的版本
+
+```bash
+python -c 'import torch;print(torch.__version__);print(torch.version.cuda)'
+```
+
+根据系统的类型、CUDA 版本、PyTorch 版本以及 MMCV 版本选择相应的安装命令
+
+
+
+
+ 使用源码包的安装日志
+ +Looking in links: https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html+Collecting mmcv==2.0.0
+Downloading mmcv-2.0.0.tar.gz + +
+
+
+
+
+
+
+
+
+
+
+如果在上面的下拉框中没有找到对应的版本，则可能是没有对应 PyTorch 或者 CUDA 或者 mmcv 版本的预编译包，此时，你可以[源码安装 mmcv](build.md)。
+
+:::{note}
+PyTorch 在 1.x.0 和 1.x.1 之间通常是兼容的，故 mmcv 只提供 1.x.0 的编译包。如果你
+的 PyTorch 版本是 1.x.1，你可以放心地安装在 1.x.0 版本编译的 mmcv。例如，如果你的
+PyTorch 版本是 1.8.1，你可以放心选择 1.8.x。
+:::
+
+:::{note}
+如果你打算使用 `opencv-python-headless` 而不是 `opencv-python`，例如在一个很小的容器环境或者没有图形用户界面的服务器中，你可以先安装 `opencv-python-headless`，这样在安装 mmcv 依赖的过程中会跳过 `opencv-python`。
+
+另外，如果安装依赖库的时间过长，可以指定 pypi 源
+
+```bash
+pip install mmcv -f https://download.openmmlab.com/mmcv/dist/cu111/torch1.9.0/index.html -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+:::
+
+安装完成后可以运行 [check_installation.py](https://github.com/open-mmlab/mmcv/blob/main/.dev_scripts/check_installation.py) 脚本检查 mmcv 是否安装成功。
+
+#### 使用 docker 镜像
+
+先将算法库克隆到本地再构建镜像
+
+```bash
+git clone https://github.com/open-mmlab/mmcv.git && cd mmcv
+docker build -t mmcv -f docker/release/Dockerfile .
+```
+
+也可以直接使用下面的命令构建镜像
+
+```bash
+docker build -t mmcv https://github.com/open-mmlab/mmcv.git#main:docker/release
+```
+
+[Dockerfile](release/Dockerfile) 默认安装最新的 mmcv，如果你想要指定版本，可以使用下面的命令
+
+```bash
+docker image build -t mmcv -f docker/release/Dockerfile --build-arg MMCV=2.0.0 .
+```
+
+如果你想要使用其他版本的 PyTorch 和 CUDA，你可以在构建镜像时指定它们的版本。
+
+例如指定 PyTorch 的版本是 1.11，CUDA 的版本是 11.3
+
+```bash
+docker build -t mmcv -f docker/release/Dockerfile \
+ --build-arg PYTORCH=1.11.0 \
+ --build-arg CUDA=11.3 \
+ --build-arg CUDNN=8 \
+ --build-arg MMCV=2.0.0 .
+```
+
+更多 PyTorch 和 CUDA 镜像可以点击 [dockerhub/pytorch](https://hub.docker.com/r/pytorch/pytorch/tags) 查看。
+
+### 安装 mmcv-lite
+
+如果你需要使用和 PyTorch 相关的模块，请确保 PyTorch 已经成功安装在环境中，可以参考 [PyTorch 官方安装文档](https://pytorch.org/get-started/locally/#start-locally)。
+
+```python
+pip install mmcv-lite
+```
diff --git a/internlm_langchain/knowledge_base/MMCV/content/introduction.md b/internlm_langchain/knowledge_base/MMCV/content/introduction.md
new file mode 100644
index 00000000..4c735b94
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/introduction.md
@@ -0,0 +1,36 @@
+## 介绍 MMCV
+
+MMCV 是一个面向计算机视觉的基础库，它提供了以下功能：
+
+- [图像和视频处理](../understand_mmcv/data_process.md)
+- [图像和标注结果可视化](../understand_mmcv/visualization.md)
+- [图像变换](../understand_mmcv/data_transform.md)
+- [多种 CNN 网络结构](../understand_mmcv/cnn.md)
+- [高质量实现的常见 CUDA 算子](../understand_mmcv/ops.md)
+
+MMCV 支持多种平台，包括：
+
+- Linux
+- Windows
+- macOS
+
+它支持的 OpenMMLab 项目：
+
+- [MMClassification](https://github.com/open-mmlab/mmclassification): OpenMMLab 图像分类工具箱
+- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab 目标检测工具箱
+- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab 新一代通用 3D 目标检测平台
+- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab 旋转框检测工具箱与测试基准
+- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO 系列工具箱与测试基准
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab 语义分割工具箱
+- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab 全流程文字检测识别理解工具箱
+- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab 姿态估计工具箱
+- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 人体参数化模型工具箱与测试基准
+- [MMSelfSup](https://github.com/open-mmlab/mmselfsup): OpenMMLab 自监督学习工具箱与测试基准
+- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab 模型压缩工具箱与测试基准
+- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab 少样本学习工具箱与测试基准
+- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab 新一代视频理解工具箱
+- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab 一体化视频目标感知平台
+- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab 光流估计工具箱与测试基准
+- [MMEditing](https://github.com/open-mmlab/mmediting): OpenMMLab 图像视频编辑工具箱
+- [MMGeneration](https://github.com/open-mmlab/mmgeneration): OpenMMLab 图片视频生成模型工具箱
+- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab 模型部署框架
diff --git a/internlm_langchain/knowledge_base/MMCV/content/ops.md b/internlm_langchain/knowledge_base/MMCV/content/ops.md
new file mode 100644
index 00000000..ba744daf
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/ops.md
@@ -0,0 +1,66 @@
+## 算子
+
+MMCV 提供了检测、分割等任务中常用的算子
+
+| Device | CPU | CUDA | MLU | MPS | Ascend |
+| ---------------------------- | --- | ---- | --- | --- | ------ |
+| ActiveRotatedFilter | √ | √ | | | √ |
+| AssignScoreWithK | | √ | | | |
+| BallQuery | | √ | √ | | |
+| BBoxOverlaps | | √ | √ | √ | √ |
+| BorderAlign | | √ | | | |
+| BoxIouRotated | √ | √ | √ | | √ |
+| BoxIouQuadri | √ | √ | | | |
+| CARAFE | | √ | √ | | |
+| ChamferDistance | | √ | | | |
+| CrissCrossAttention | | √ | | | |
+| ContourExpand | √ | | | | |
+| ConvexIoU | | √ | | | |
+| CornerPool | | √ | | | |
+| Correlation | | √ | | | |
+| Deformable Convolution v1/v2 | √ | √ | √ | | √ |
+| Deformable RoIPool | | √ | √ | | √ |
+| DiffIoURotated | | √ | √ | | |
+| DynamicScatter | | √ | √ | | |
+| FurthestPointSample | | √ | | | |
+| FurthestPointSampleWithDist | | √ | | | |
+| FusedBiasLeakyrelu | | √ | | | √ |
+| GatherPoints | | √ | | | √ |
+| GroupPoints | | √ | | | |
+| Iou3d | | √ | √ | | |
+| KNN | | √ | | | |
+| MaskedConv | | √ | √ | | √ |
+| MergeCells | | √ | | | |
+| MinAreaPolygon | | √ | | | |
+| ModulatedDeformConv2d | √ | √ | √ | | √ |
+| MultiScaleDeformableAttn | | √ | √ | | |
+| NMS | √ | √ | √ | | √ |
+| NMSRotated | √ | √ | √ | | √ |
+| NMSQuadri | √ | √ | | | |
+| PixelGroup | √ | | | | |
+| PointsInBoxes | √ | √ | | | |
+| PointsInPolygons | | √ | | | |
+| PSAMask | √ | √ | √ | | √ |
+| RotatedFeatureAlign | √ | √ | √ | | |
+| RoIPointPool3d | | √ | √ | | |
+| RoIPool | | √ | √ | | √ |
+| RoIAlignRotated | √ | √ | √ | | |
+| RiRoIAlignRotated | | √ | | | |
+| RoIAlign | √ | √ | √ | | √ |
+| RoIAwarePool3d | | √ | √ | | |
+| SAConv2d | | √ | | | |
+| SigmoidFocalLoss | | √ | √ | | √ |
+| SoftmaxFocalLoss | | √ | | | √ |
+| SoftNMS | | √ | | | |
+| Sparse Convolution | | √ | √ | | |
+| Synchronized BatchNorm | | √ | | | |
+| ThreeInterpolate | | √ | | | |
+| ThreeNN | | √ | √ | | |
+| TINShift | | √ | √ | | |
+| UpFirDn2d | | √ | | | |
+| Voxelization | √ | √ | √ | | √ |
+| PrRoIPool | | √ | | | |
+| BezierAlign | √ | √ | | | |
+| BiasAct | | √ | | | |
+| FilteredLrelu | | √ | | | |
+| Conv2dGradfix | | √ | | | |
diff --git a/internlm_langchain/knowledge_base/MMCV/content/pr.md b/internlm_langchain/knowledge_base/MMCV/content/pr.md
new file mode 100644
index 00000000..427fdf9e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/pr.md
@@ -0,0 +1,3 @@
+## 拉取请求
+
+本文档的内容已迁移到[贡献指南](contributing.md)。
diff --git a/internlm_langchain/knowledge_base/MMCV/content/previous_versions.md b/internlm_langchain/knowledge_base/MMCV/content/previous_versions.md
new file mode 100644
index 00000000..d5438187
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/previous_versions.md
@@ -0,0 +1,47 @@
+## 其他版本的 PyTorch
+
+我们不再提供在较低的 `PyTorch` 版本下编译的 `mmcv-full` 包，但为了您的方便，您可以在下面找到它们。
+
+### PyTorch 1.4
+
+| 1.0.0 \<= mmcv_version \<= 1.2.1
+
+#### CUDA 10.1
+
+```bash
+pip install mmcv-full=={mmcv_version} -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.4.0/index.html
+```
+
+#### CUDA 9.2
+
+```bash
+pip install mmcv-full=={mmcv_version} -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.4.0/index.html
+```
+
+#### CPU
+
+```bash
+pip install mmcv-full=={mmcv_version} -f https://download.openmmlab.com/mmcv/dist/cpu/torch1.4.0/index.html
+```
+
+### PyTorch v1.3
+
+| 1.0.0 \<= mmcv_version \<= 1.3.16
+
+#### CUDA 10.1
+
+```bash
+pip install mmcv-full=={mmcv_version} -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.3.0/index.html
+```
+
+#### CUDA 9.2
+
+```bash
+pip install mmcv-full=={mmcv_version} -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.3.0/index.html
+```
+
+#### CPU
+
+```bash
+pip install mmcv-full=={mmcv_version} -f https://download.openmmlab.com/mmcv/dist/cpu/torch1.3.0/index.html
+```
diff --git a/internlm_langchain/knowledge_base/MMCV/content/visualization.md b/internlm_langchain/knowledge_base/MMCV/content/visualization.md
new file mode 100644
index 00000000..9ad26c6a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMCV/content/visualization.md
@@ -0,0 +1,24 @@
+## 可视化
+
+`mmcv` 可以展示图像以及标注（目前只支持标注框）
+
+```python
+# 展示图像文件
+mmcv.imshow('a.jpg')
+
+# 展示已加载的图像
+img = np.random.rand(100, 100, 3)
+mmcv.imshow(img)
+
+# 展示带有标注框的图像
+img = np.random.rand(100, 100, 3)
+bboxes = np.array([[0, 0, 50, 50], [20, 20, 60, 60]])
+mmcv.imshow_bboxes(img, bboxes)
+```
+
+`mmcv` 也可以展示特殊的图像，例如光流
+
+```python
+flow = mmcv.flowread('test.flo')
+mmcv.flowshow(flow)
+```
diff --git a/internlm_langchain/knowledge_base/MMCV/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMCV/vector_store/index.faiss
new file mode 100644
index 00000000..c98ec505
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMCV/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/01_introduction_to_model_deployment.md b/internlm_langchain/knowledge_base/MMDeploy/content/01_introduction_to_model_deployment.md
new file mode 100644
index 00000000..8ec39adc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/01_introduction_to_model_deployment.md
@@ -0,0 +1,253 @@
+# 第一章：模型部署简介
+
+OpenMMLab 的算法如何部署？这是很多社区用户的困惑。而[模型部署工具箱 MMDeploy](https://zhuanlan.zhihu.com/p/450342651) 的开源，强势打通了从算法模型到应用程序这“最后一公里”！今天我们将开启模型部署入门系列教程，在模型部署开源库 MMDeploy 的辅助下，介绍以下内容：
+
+- 中间表示 ONNX 的定义标准。
+- PyTorch 模型转换到 ONNX 模型的方法。
+- 推理引擎 ONNX Runtime、TensorRT 的使用方法。
+- 部署流水线 PyTorch - ONNX - ONNX Runtime/TensorRT 的示例及常见部署问题的解决方法。
+- MMDeploy C/C++ 推理 SDK。
+
+希望通过本系列教程，带领大家学会如何把自己的 PyTorch 模型部署到 ONNX Runtime/TensorRT 上，并学会如何把 OpenMMLab 开源体系中各个计算机视觉任务的模型用 MMDeploy 部署到各个推理引擎上。
+
+我们默认大家熟悉 Python 语言，并对 PyTorch 框架有基本的认识，除此之外不需要了解任何模型部署的知识。
+
+在第一篇文章中，我们将部署一个简单的超分辨率模型，认识中间表示、推理引擎等模型部署中的概念。
+
+## 初识模型部署
+
+在软件工程中，部署指把开发完毕的软件投入使用的过程，包括环境配置、软件安装等步骤。类似地，对于深度学习模型来说，模型部署指让训练好的模型在特定环境中运行的过程。相比于软件部署，模型部署会面临更多的难题：
+
+1. 运行模型所需的环境难以配置。深度学习模型通常是由一些框架编写，比如 PyTorch、TensorFlow。由于框架规模、依赖环境的限制，这些框架不适合在手机、开发板等生产环境中安装。
+2. 深度学习模型的结构通常比较庞大，需要大量的算力才能满足实时运行的需求。模型的运行效率需要优化。
+
+因为这些难题的存在，模型部署不能靠简单的环境配置与安装完成。经过工业界和学术界数年的探索，模型部署有了一条流行的流水线：
+
+
+
+为了让模型最终能够部署到某一环境上，开发者们可以使用任意一种深度学习框架来定义网络结构，并通过训练确定网络中的参数。之后，模型的结构和参数会被转换成一种只描述网络结构的中间表示，一些针对网络结构的优化会在中间表示上进行。最后，用面向硬件的高性能编程框架（如 CUDA，OpenCL）编写，能高效执行深度学习网络中算子的推理引擎会把中间表示转换成特定的文件格式，并在对应硬件平台上高效运行模型。
+
+这一条流水线解决了模型部署中的两大问题：使用对接深度学习框架和推理引擎的中间表示，开发者不必担心如何在新环境中运行各个复杂的框架；通过中间表示的网络结构优化和推理引擎对运算的底层优化，模型的运算效率大幅提升。
+
+现在，让我们从一个模型部署的“Hello World”项目入手，见识一下模型部署各方面的知识吧！
+
+## 部署第一个模型
+
+### 创建 PyTorch 模型
+
+仿照 PyTorch 的官方[部署教程](https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html)，让我们用 PyTorch 实现一个超分辨率模型，并把模型部署到 ONNX Runtime 这个推理引擎上。
+
+首先，我们需要创建一个有 PyTorch 库的 Python 编程环境。如果你的 PyTorch 环境还没有装好，可以参考官方的[入门教程](https://pytorch.org/get-started/locally/)。我们强烈推荐使用 conda 来管理 Python 库。使用 conda 可以靠如下的命令初始化一个 PyTorch 环境：
+
+```bash
+# 创建预安装 Python 3.7 的名叫 deploy 虚拟环境
+conda create -n deploy python=3.7 -y
+# 进入虚拟环境
+conda activate deploy
+# 安装 cpu 版本的 PyTorch
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+如果你的设备支持 cuda 编程，我们建议你在配置 cuda 环境后使用 gpu 上的 PyTorch。比如将上面安装 PyTorch 的命令改成：
+
+```bash
+# 安装 cuda 11.3 的 PyTorch
+# 如果你用的是其他版本的 cuda，请参考上面 PyTorch 的官方安装教程选择安装命令
+conda install pytorch torchvision cudatoolkit=11.3 -c pytorch
+```
+
+本教程会用到其他一些第三方库。你可以用以下命令来安装这些库：
+
+```bash
+# 安装 ONNX Runtime, ONNX, OpenCV
+pip install onnxruntime onnx opencv-python
+```
+
+在一切都配置完毕后，用下面的代码来创建一个超分辨率模型。
+
+```python
+import os
+
+import cv2
+import numpy as np
+import requests
+import torch
+import torch.onnx
+from torch import nn
+
+class SuperResolutionNet(nn.Module):
+ def __init__(self, upscale_factor):
+ super().__init__()
+ self.upscale_factor = upscale_factor
+ self.img_upsampler = nn.Upsample(
+ scale_factor=self.upscale_factor,
+ mode='bicubic',
+ align_corners=False)
+
+ self.conv1 = nn.Conv2d(3,64,kernel_size=9,padding=4)
+ self.conv2 = nn.Conv2d(64,32,kernel_size=1,padding=0)
+ self.conv3 = nn.Conv2d(32,3,kernel_size=5,padding=2)
+
+ self.relu = nn.ReLU()
+
+ def forward(self, x):
+ x = self.img_upsampler(x)
+ out = self.relu(self.conv1(x))
+ out = self.relu(self.conv2(out))
+ out = self.conv3(out)
+ return out
+
+# Download checkpoint and test image
+urls = ['https://download.openmmlab.com/mmediting/restorers/srcnn/srcnn_x4k915_1x16_1000k_div2k_20200608-4186f232.pth',
+ 'https://raw.githubusercontent.com/open-mmlab/mmagic/master/tests/data/face/000001.png']
+names = ['srcnn.pth', 'face.png']
+for url, name in zip(urls, names):
+ if not os.path.exists(name):
+ open(name, 'wb').write(requests.get(url).content)
+
+def init_torch_model():
+ torch_model = SuperResolutionNet(upscale_factor=3)
+
+ state_dict = torch.load('srcnn.pth')['state_dict']
+
+ # Adapt the checkpoint
+ for old_key in list(state_dict.keys()):
+ new_key = '.'.join(old_key.split('.')[1:])
+ state_dict[new_key] = state_dict.pop(old_key)
+
+ torch_model.load_state_dict(state_dict)
+ torch_model.eval()
+ return torch_model
+
+model = init_torch_model()
+input_img = cv2.imread('face.png').astype(np.float32)
+
+# HWC to NCHW
+input_img = np.transpose(input_img, [2, 0, 1])
+input_img = np.expand_dims(input_img, 0)
+
+# Inference
+torch_output = model(torch.from_numpy(input_img)).detach().numpy()
+
+# NCHW to HWC
+torch_output = np.squeeze(torch_output, 0)
+torch_output = np.clip(torch_output, 0, 255)
+torch_output = np.transpose(torch_output, [1, 2, 0]).astype(np.uint8)
+
+# Show image
+cv2.imwrite("face_torch.png", torch_output)
+```
+
+在这份代码中，我们创建了一个经典的超分辨率网络 [SRCNN](https://arxiv.org/abs/1501.00092)。SRCNN 先把图像上采样到对应分辨率，再用 3 个卷积层处理图像。为了方便起见，我们跳过训练网络的步骤，直接下载模型权重（由于 MMagic 中 SRCNN 的权重结构和我们定义的模型不太一样，我们修改了权重字典的 key 来适配我们定义的模型），同时下载好输入图片。为了让模型输出成正确的图片格式，我们把模型的输出转换成 HWC 格式，并保证每一通道的颜色值都在 0~255 之间。如果脚本正常运行的话，一幅超分辨率的人脸照片会保存在 `face_torch.png` 中。
+
+在 PyTorch 模型测试正确后，我们来正式开始部署这个模型。我们下一步的任务是把 PyTorch 模型转换成用中间表示 ONNX 描述的模型。
+
+
+
+### 中间表示 —— ONNX
+
+在介绍 ONNX 之前，我们先从本质上来认识一下神经网络的结构。神经网络实际上只是描述了数据计算的过程，其结构可以用计算图表示。比如 `a+b` 可以用下面的计算图来表示：
+
+
+
+为了加速计算，一些框架会使用对神经网络“先编译，后执行”的静态图来描述网络。静态图的缺点是难以描述控制流（比如 if-else 分支语句和 for 循环语句），直接对其引入控制语句会导致产生不同的计算图。比如循环执行 n 次 `a=a+b`，对于不同的 n，会生成不同的计算图：
+
+
+
+ONNX（Open Neural Network Exchange）是 Facebook 和微软在 2017 年共同发布的，用于标准描述计算图的一种格式。目前，在数家机构的共同维护下，ONNX 已经对接了多种深度学习框架和多种推理引擎。因此，ONNX 被当成了深度学习框架到推理引擎的桥梁，就像编译器的中间语言一样。由于各框架兼容性不一，我们通常只用 ONNX 表示更容易部署的静态图。
+
+让我们用下面的代码来把 PyTorch 的模型转换成 ONNX 格式的模型：
+
+```python
+x = torch.randn(1, 3, 256, 256)
+
+with torch.no_grad():
+ torch.onnx.export(
+ model,
+ x,
+ "srcnn.onnx",
+ opset_version=11,
+ input_names=['input'],
+ output_names=['output'])
+```
+
+其中，**torch.onnx.export** 是 PyTorch 自带的把模型转换成 ONNX 格式的函数。让我们先看一下前三个必选参数：前三个参数分别是要转换的模型、模型的任意一组输入、导出的 ONNX 文件的文件名。转换模型时，需要原模型和输出文件名是很容易理解的，但为什么需要为模型提供一组输入呢？这就涉及到 ONNX 转换的原理了。从 PyTorch 的模型到 ONNX 的模型，本质上是一种语言上的翻译。直觉上的想法是像编译器一样彻底解析原模型的代码，记录所有控制流。但前面也讲到，我们通常只用 ONNX 记录不考虑控制流的静态图。因此，PyTorch 提供了一种叫做追踪（trace）的模型转换方法：给定一组输入，再实际执行一遍模型，即把这组输入对应的计算图记录下来，保存为 ONNX 格式。**export** 函数用的就是追踪导出方法，需要给任意一组输入，让模型跑起来。我们的测试图片是三通道，256x256 大小的，这里也构造一个同样形状的随机张量。
+
+剩下的参数中，`opset_version` 表示 ONNX 算子集的版本。深度学习的发展会不断诞生新算子，为了支持这些新增的算子，ONNX 会经常发布新的算子集，目前已经更新 15 个版本。 我们令 `opset_version=11`，即使用第 11 个 ONNX 算子集，是因为 SRCNN 中的 bicubic（双三次插值）在 opset11 中才得到支持。剩下的两个参数 `input_names`, `output_names` 是输入、输出 tensor 的名称，我们稍后会用到这些名称。
+
+如果上述代码运行成功，目录下会新增一个 `srcnn.onnx` 的 ONNX 模型文件。我们可以用下面的脚本来验证一下模型文件是否正确。
+
+```python
+import onnx
+
+onnx_model = onnx.load("srcnn.onnx")
+try:
+ onnx.checker.check_model(onnx_model)
+except Exception:
+ print("Model incorrect")
+else:
+ print("Model correct")
+```
+
+其中，**onnx.load** 函数用于读取一个 ONNX 模型。**onnx.checker.check_model** 用于检查模型格式是否正确，如果有错误的话该函数会直接报错。我们的模型是正确的，控制台中应该会打印出 "Model correct"。
+
+接下来，让我们来看一看 ONNX 模型具体的结构是怎么样的。我们可以使用 Netron（开源的模型可视化工具）来可视化 ONNX 模型。把 `srcnn.onnx` 文件从本地的文件系统拖入网站，即可看到如下的可视化结果：
+
+
+
+点击 input 或者 output，可以查看 ONNX 模型的基本信息，包括模型的版本信息，以及模型输入、输出的名称和数据类型。
+
+
+
+点击某一个算子节点，可以看到算子的具体信息。比如点击第一个 Conv 可以看到：
+
+
+
+每个算子记录了算子属性、图结构、权重三类信息。
+
+- 算子属性信息即图中 attributes 里的信息，对于卷积来说，算子属性包括了卷积核大小（kernel_shape）、卷积步长（strides）等内容。这些算子属性最终会用来生成一个具体的算子。
+- 图结构信息指算子节点在计算图中的名称、邻边的信息。对于图中的卷积来说，该算子节点叫做 Conv_2，输入数据叫做 11，输出数据叫做 12。根据每个算子节点的图结构信息，就能完整地复原出网络的计算图。
+- 权重信息指的是网络经过训练后，算子存储的权重信息。对于卷积来说，权重信息包括卷积核的权重值和卷积后的偏差值。点击图中 conv1.weight, conv1.bias 后面的加号即可看到权重信息的具体内容。
+
+现在，我们有了 SRCNN 的 ONNX 模型。让我们看看最后该如何把这个模型运行起来。
+
+### 推理引擎 —— ONNX Runtime
+
+**ONNX Runtime** 是由微软维护的一个跨平台机器学习推理加速器，也就是我们前面提到的“推理引擎”。ONNX Runtime 是直接对接 ONNX 的，即 ONNX Runtime 可以直接读取并运行 `.onnx` 文件，而不需要再把 `.onnx` 格式的文件转换成其他格式的文件。也就是说，对于 `PyTorch - ONNX - ONNX Runtime` 这条部署流水线，只要在目标设备中得到 `.onnx` 文件，并在 ONNX Runtime 上运行模型，模型部署就算大功告成了。
+
+通过刚刚的操作，我们把 PyTorch 编写的模型转换成了 ONNX 模型，并通过可视化检查了模型的正确性。最后，让我们用 ONNX Runtime 运行一下模型，完成模型部署的最后一步。
+
+ONNX Runtime 提供了 Python 接口。接着刚才的脚本，我们可以添加如下代码运行模型：
+
+```python
+import onnxruntime
+
+ort_session = onnxruntime.InferenceSession("srcnn.onnx")
+ort_inputs = {'input': input_img}
+ort_output = ort_session.run(['output'], ort_inputs)[0]
+
+ort_output = np.squeeze(ort_output, 0)
+ort_output = np.clip(ort_output, 0, 255)
+ort_output = np.transpose(ort_output, [1, 2, 0]).astype(np.uint8)
+cv2.imwrite("face_ort.png", ort_output)
+```
+
+这段代码中，除去后处理操作外，和 ONNX Runtime 相关的代码只有三行。让我们简单解析一下这三行代码。**onnxruntime.InferenceSession** 用于获取一个 ONNX Runtime 推理器，其参数是用于推理的 ONNX 模型文件。推理器的 run 方法用于模型推理，其第一个参数为输出张量名的列表，第二个参数为输入值的字典。其中输入值字典的 key 为张量名，value 为 numpy 类型的张量值。输入输出张量的名称需要和 **torch.onnx.export** 中设置的输入输出名对应。
+
+如果代码正常运行的话，另一幅超分辨率照片会保存在 `face_ort.png` 中。这幅图片和刚刚得到的 `face_torch.png` 是一模一样的。这说明 ONNX Runtime 成功运行了 SRCNN 模型，模型部署完成了！以后有用户想实现超分辨率的操作，我们只需要提供一个 `srcnn.onnx` 文件，并帮助用户配置好 ONNX Runtime 的 Python 环境，用几行代码就可以运行模型了。或者还有更简便的方法，我们可以利用 ONNX Runtime 编译出一个可以直接执行模型的应用程序。我们只需要给用户提供 ONNX 模型文件，并让用户在应用程序选择要执行的 ONNX 模型文件名就可以运行模型了。
+
+## 总结
+
+在这篇教程里，我们利用成熟的模型部署工具，轻松部署了一个初始版本的超分辨率模型 SRCNN。但在实际应用场景中，随着模型结构的复杂度不断加深，碰到的困难的也会越来越多。在下一篇教程里，我们将“升级”一下这个超分辨率模型，让它支持动态的输入。
+
+看完这篇教程，是不是感觉知识太多一下消化不过来？没关系，模型部署本身有非常多的东西要学。为了举例的方便，这篇教程包含了许多未来才会讲到的知识点。事实上，读完这篇教程后，记下以下知识点就够了：
+
+- 模型部署，指把训练好的模型在特定环境中运行的过程。模型部署要解决模型框架兼容性差和模型运行速度慢这两大问题。
+- 模型部署的常见流水线是“深度学习框架-中间表示-推理引擎”。其中比较常用的一个中间表示是 ONNX。
+- 深度学习模型实际上就是一个计算图。模型部署时通常把模型转换成静态的计算图，即没有控制流（分支语句、循环语句）的计算图。
+- PyTorch 框架自带对 ONNX 的支持，只需要构造一组随机的输入，并对模型调用 **torch.onnx.export** 即可完成 PyTorch 到 ONNX 的转换。
+- 推理引擎 ONNX Runtime 对 ONNX 模型有原生的支持。给定一个 `.onnx` 文件，只需要简单使用 ONNX Runtime 的 Python API 就可以完成模型推理。
+
+为了实现深度学习算法的落地，充满挑战的模型部署是一个逃不开的步骤。MMDeploy 实现了 OpenMMLab 中目标检测、图像分割、超分辨率等多个视觉任务模型的部署，支持 ONNX Runtime，TensorRT，ncnn，openppl，OpenVINO 等多个推理引擎。
+
+在后续的模型部署教程中，我们将在介绍模型部署技术的同时，介绍这些技术是如何运用在 MMDeploy 中的。
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/02_challenges.md b/internlm_langchain/knowledge_base/MMDeploy/content/02_challenges.md
new file mode 100644
index 00000000..85e4b0c2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/02_challenges.md
@@ -0,0 +1,356 @@
+# 第二章：解决模型部署中的难题
+
+在[第一章](https://mmdeploy.readthedocs.io/zh_CN/latest/tutorial/01_introduction_to_model_deployment.html)中，我们部署了一个简单的超分辨率模型，一切都十分顺利。但是，上一个模型还有一些缺陷——图片的放大倍数固定是 4，我们无法让图片放大任意的倍数。现在，我们来尝试部署一个支持动态放大倍数的模型，体验一下在模型部署中可能会碰到的困难。
+
+## 模型部署中常见的难题
+
+在之前的学习中，我们在模型部署上顺风顺水，没有碰到任何问题。这是因为 SRCNN 模型只包含几个简单的算子，而这些卷积、插值算子已经在各个中间表示和推理引擎上得到了完美支持。如果模型的操作稍微复杂一点，我们可能就要为兼容模型而付出大量的功夫了。实际上，模型部署时一般会碰到以下几类困难：
+
+- 模型的动态化。出于性能的考虑，各推理框架都默认模型的输入形状、输出形状、结构是静态的。而为了让模型的泛用性更强，部署时需要在尽可能不影响原有逻辑的前提下，让模型的输入输出或是结构动态化。
+- 新算子的实现。深度学习技术日新月异，提出新算子的速度往往快于 ONNX 维护者支持的速度。为了部署最新的模型，部署工程师往往需要自己在 ONNX 和推理引擎中支持新算子。
+- 中间表示与推理引擎的兼容问题。由于各推理引擎的实现不同，对 ONNX 难以形成统一的支持。为了确保模型在不同的推理引擎中有同样的运行效果，部署工程师往往得为某个推理引擎定制模型代码，这为模型部署引入了许多工作量。
+
+我们会在后续教程详细讲述解决这些问题的方法。如果对前文中 ONNX、推理引擎、中间表示、算子等名词感觉陌生，不用担心，可以阅读[第一章](https://mmdeploy.readthedocs.io/zh_CN/latest/tutorial/01_introduction_to_model_deployment.html)，了解有关概念。
+
+现在，让我们对原来的 SRCNN 模型做一些小的修改，体验一下模型动态化对模型部署造成的困难，并学习解决该问题的一种方法。
+
+## 问题：实现动态放大的超分辨率模型
+
+在原来的 SRCNN 中，图片的放大比例是写死在模型里的：
+
+```python
+class SuperResolutionNet(nn.Module):
+ def __init__(self, upscale_factor):
+ super().__init__()
+ self.upscale_factor = upscale_factor
+ self.img_upsampler = nn.Upsample(
+ scale_factor=self.upscale_factor,
+ mode='bicubic',
+ align_corners=False)
+
+...
+
+def init_torch_model():
+ torch_model = SuperResolutionNet(upscale_factor=3)
+```
+
+我们使用 upscale_factor 来控制模型的放大比例。初始化模型的时候，我们默认令 upscale_factor 为 3，生成了一个放大 3 倍的 PyTorch 模型。这个 PyTorch 模型最终被转换成了 ONNX 格式的模型。如果我们需要一个放大 4 倍的模型，需要重新生成一遍模型，再做一次到 ONNX 的转换。
+
+现在，假设我们要做一个超分辨率的应用。我们的用户希望图片的放大倍数能够自由设置。而我们交给用户的，只有一个 .onnx 文件和运行超分辨率模型的应用程序。我们在不修改 .onnx 文件的前提下改变放大倍数。
+
+因此，我们必须修改原来的模型，令模型的放大倍数变成推理时的输入。在[第一章](https://mmdeploy.readthedocs.io/zh_CN/latest/tutorial/01_introduction_to_model_deployment.html)中的 Python 脚本的基础上，我们做一些修改，得到这样的脚本：
+
+```python
+import torch
+from torch import nn
+from torch.nn.functional import interpolate
+import torch.onnx
+import cv2
+import numpy as np
+
+
+class SuperResolutionNet(nn.Module):
+
+ def __init__(self):
+ super().__init__()
+
+ self.conv1 = nn.Conv2d(3, 64, kernel_size=9, padding=4)
+ self.conv2 = nn.Conv2d(64, 32, kernel_size=1, padding=0)
+ self.conv3 = nn.Conv2d(32, 3, kernel_size=5, padding=2)
+
+ self.relu = nn.ReLU()
+
+ def forward(self, x, upscale_factor):
+ x = interpolate(x,
+ scale_factor=upscale_factor,
+ mode='bicubic',
+ align_corners=False)
+ out = self.relu(self.conv1(x))
+ out = self.relu(self.conv2(out))
+ out = self.conv3(out)
+ return out
+
+
+def init_torch_model():
+ torch_model = SuperResolutionNet()
+
+ # Please read the code about downloading 'srcnn.pth' and 'face.png' in
+ # https://mmdeploy.readthedocs.io/zh_CN/latest/tutorial/01_introduction_to_model_deployment.html#pytorch
+ state_dict = torch.load('srcnn.pth')['state_dict']
+
+ # Adapt the checkpoint
+ for old_key in list(state_dict.keys()):
+ new_key = '.'.join(old_key.split('.')[1:])
+ state_dict[new_key] = state_dict.pop(old_key)
+
+ torch_model.load_state_dict(state_dict)
+ torch_model.eval()
+ return torch_model
+
+
+model = init_torch_model()
+
+input_img = cv2.imread('face.png').astype(np.float32)
+
+# HWC to NCHW
+input_img = np.transpose(input_img, [2, 0, 1])
+input_img = np.expand_dims(input_img, 0)
+
+# Inference
+torch_output = model(torch.from_numpy(input_img), 3).detach().numpy()
+
+# NCHW to HWC
+torch_output = np.squeeze(torch_output, 0)
+torch_output = np.clip(torch_output, 0, 255)
+torch_output = np.transpose(torch_output, [1, 2, 0]).astype(np.uint8)
+
+# Show image
+cv2.imwrite("face_torch_2.png", torch_output)
+```
+
+SuperResolutionNet 未修改之前，nn.Upsample 在初始化阶段固化了放大倍数，而 PyTorch 的 interpolate 插值算子可以在运行阶段选择放大倍数。因此，我们在新脚本中使用 interpolate 代替 nn.Upsample，从而让模型支持动态放大倍数的超分。 在第 55 行使用模型推理时，我们把放大倍数设置为 3。最后，图片保存在文件 "face_torch_2.png" 中。一切正常的话，"face_torch_2.png" 和 "face_torch.png" 的内容一模一样。
+
+通过简单的修改，PyTorch 模型已经支持了动态分辨率。现在我们来一下尝试导出模型：
+
+```python
+x = torch.randn(1, 3, 256, 256)
+
+with torch.no_grad():
+ torch.onnx.export(model, (x, 3),
+ "srcnn2.onnx",
+ opset_version=11,
+ input_names=['input', 'factor'],
+ output_names=['output'])
+```
+
+运行这些脚本时，会报一长串错误。没办法，我们碰到了模型部署中的兼容性问题。
+
+## 解决方法：自定义算子
+
+直接使用 PyTorch 模型的话，我们修改几行代码就能实现模型输入的动态化。但在模型部署中，我们要花数倍的时间来设法解决这一问题。现在，让我们顺着解决问题的思路，体验一下模型部署的困难，并学习使用自定义算子的方式，解决超分辨率模型的动态化问题。
+
+刚刚的报错是因为 PyTorch 模型在导出到 ONNX 模型时，模型的输入参数的类型必须全部是 torch.Tensor。而实际上我们传入的第二个参数" 3 "是一个整形变量。这不符合 PyTorch 转 ONNX 的规定。我们必须要修改一下原来的模型的输入。为了保证输入的所有参数都是 torch.Tensor 类型的，我们做如下修改：
+
+```python
+...
+
+class SuperResolutionNet(nn.Module):
+
+ def forward(self, x, upscale_factor):
+ x = interpolate(x,
+ scale_factor=upscale_factor.item(),
+ mode='bicubic',
+ align_corners=False)
+
+...
+
+# Inference
+# Note that the second input is torch.tensor(3)
+torch_output = model(torch.from_numpy(input_img), torch.tensor(3)).detach().numpy()
+
+...
+
+with torch.no_grad():
+ torch.onnx.export(model, (x, torch.tensor(3)),
+ "srcnn2.onnx",
+ opset_version=11,
+ input_names=['input', 'factor'],
+ output_names=['output'])
+```
+
+由于 PyTorch 中 interpolate 的 scale_factor 参数必须是一个数值，我们使用 torch.Tensor.item() 来把只有一个元素的 torch.Tensor 转换成数值。之后，在模型推理时，我们使用 torch.tensor(3) 代替 3，以使得我们的所有输入都满足要求。现在运行脚本的话，无论是直接运行模型，还是导出 ONNX 模型，都不会报错了。
+
+但是，导出 ONNX 时却报了一条 TraceWarning 的警告。这条警告说有一些量可能会追踪失败。这是怎么回事呢？让我们把生成的 srcnn2.onnx 用 Netron 可视化一下：
+
+
+可以发现，虽然我们把模型推理的输入设置为了两个，但 ONNX 模型还是长得和原来一模一样，只有一个叫 " input " 的输入。这是由于我们使用了 torch.Tensor.item() 把数据从 Tensor 里取出来，而导出 ONNX 模型时这个操作是无法被记录的，只好报了一条 TraceWarning。这导致 interpolate 插值函数的放大倍数还是被设置成了" 3 "这个固定值，我们导出的" srcnn2.onnx "和最开始的" srcnn.onnx "完全相同。
+
+直接修改原来的模型似乎行不通，我们得从 PyTorch 转 ONNX 的原理入手，强行令 ONNX 模型明白我们的想法了。
+
+仔细观察 Netron 上可视化出的 ONNX 模型，可以发现在 PyTorch 中无论是使用最早的 nn.Upsample，还是后来的 interpolate，PyTorch 里的插值操作最后都会转换成 ONNX 定义的 Resize 操作。也就是说，所谓 PyTorch 转 ONNX，实际上就是把每个 PyTorch 的操作映射成了 ONNX 定义的算子。
+
+点击该算子，可以看到它的详细参数如下：
+
+
+
+其中，展开 scales，可以看到 scales 是一个长度为 4 的一维张量，其内容为 [1, 1, 3, 3], 表示 Resize 操作每一个维度的缩放系数；其类型为 Initializer，表示这个值是根据常量直接初始化出来的。如果我们能够自己生成一个 ONNX 的 Resize 算子，让 scales 成为一个可变量而不是常量，就像它上面的 X 一样，那这个超分辨率模型就能动态缩放了。
+
+现有实现插值的 PyTorch 算子有一套规定好的映射到 ONNX Resize 算子的方法，这些映射出的 Resize 算子的 scales 只能是常量，无法满足我们的需求。我们得自己定义一个实现插值的 PyTorch 算子，然后让它映射到一个我们期望的 ONNX Resize 算子上。
+
+下面的脚本定义了一个 PyTorch 插值算子，并在模型里使用了它。我们先通过运行模型来验证该算子的正确性：
+
+```python
+import torch
+from torch import nn
+from torch.nn.functional import interpolate
+import torch.onnx
+import cv2
+import numpy as np
+
+
+class NewInterpolate(torch.autograd.Function):
+
+ @staticmethod
+ def symbolic(g, input, scales):
+ return g.op("Resize",
+ input,
+ g.op("Constant",
+ value_t=torch.tensor([], dtype=torch.float32)),
+ scales,
+ coordinate_transformation_mode_s="pytorch_half_pixel",
+ cubic_coeff_a_f=-0.75,
+ mode_s='cubic',
+ nearest_mode_s="floor")
+
+ @staticmethod
+ def forward(ctx, input, scales):
+ scales = scales.tolist()[-2:]
+ return interpolate(input,
+ scale_factor=scales,
+ mode='bicubic',
+ align_corners=False)
+
+
+class StrangeSuperResolutionNet(nn.Module):
+
+ def __init__(self):
+ super().__init__()
+
+ self.conv1 = nn.Conv2d(3, 64, kernel_size=9, padding=4)
+ self.conv2 = nn.Conv2d(64, 32, kernel_size=1, padding=0)
+ self.conv3 = nn.Conv2d(32, 3, kernel_size=5, padding=2)
+
+ self.relu = nn.ReLU()
+
+ def forward(self, x, upscale_factor):
+ x = NewInterpolate.apply(x, upscale_factor)
+ out = self.relu(self.conv1(x))
+ out = self.relu(self.conv2(out))
+ out = self.conv3(out)
+ return out
+
+
+def init_torch_model():
+ torch_model = StrangeSuperResolutionNet()
+
+ state_dict = torch.load('srcnn.pth')['state_dict']
+
+ # Adapt the checkpoint
+ for old_key in list(state_dict.keys()):
+ new_key = '.'.join(old_key.split('.')[1:])
+ state_dict[new_key] = state_dict.pop(old_key)
+
+ torch_model.load_state_dict(state_dict)
+ torch_model.eval()
+ return torch_model
+
+
+model = init_torch_model()
+factor = torch.tensor([1, 1, 3, 3], dtype=torch.float)
+
+input_img = cv2.imread('face.png').astype(np.float32)
+
+# HWC to NCHW
+input_img = np.transpose(input_img, [2, 0, 1])
+input_img = np.expand_dims(input_img, 0)
+
+# Inference
+torch_output = model(torch.from_numpy(input_img), factor).detach().numpy()
+
+# NCHW to HWC
+torch_output = np.squeeze(torch_output, 0)
+torch_output = np.clip(torch_output, 0, 255)
+torch_output = np.transpose(torch_output, [1, 2, 0]).astype(np.uint8)
+
+# Show image
+cv2.imwrite("face_torch_3.png", torch_output)
+```
+
+模型运行正常的话，一幅放大3倍的超分辨率图片会保存在"face_torch_3.png"中，其内容和"face_torch.png"完全相同。
+
+在刚刚那个脚本中，我们定义 PyTorch 插值算子的代码如下：
+
+```python
+class NewInterpolate(torch.autograd.Function):
+
+ @staticmethod
+ def symbolic(g, input, scales):
+ return g.op("Resize",
+ input,
+ g.op("Constant",
+ value_t=torch.tensor([], dtype=torch.float32)),
+ scales,
+ coordinate_transformation_mode_s="pytorch_half_pixel",
+ cubic_coeff_a_f=-0.75,
+ mode_s='cubic',
+ nearest_mode_s="floor")
+
+ @staticmethod
+ def forward(ctx, input, scales):
+ scales = scales.tolist()[-2:]
+ return interpolate(input,
+ scale_factor=scales,
+ mode='bicubic',
+ align_corners=False)
+```
+
+在具体介绍这个算子的实现前，让我们先理清一下思路。我们希望新的插值算子有两个输入，一个是被用于操作的图像，一个是图像的放缩比例。前面讲到，为了对接 ONNX 中 Resize 算子的 scales 参数，这个放缩比例是一个 [1, 1, x, x] 的张量，其中 x 为放大倍数。在之前放大3倍的模型中，这个参数被固定成了[1, 1, 3, 3]。因此，在插值算子中，我们希望模型的第二个输入是一个 [1, 1, w, h] 的张量，其中 w 和 h 分别是图片宽和高的放大倍数。
+
+搞清楚了插值算子的输入，再看一看算子的具体实现。算子的推理行为由算子的 forward 方法决定。该方法的第一个参数必须为 ctx，后面的参数为算子的自定义输入，我们设置两个输入，分别为被操作的图像和放缩比例。为保证推理正确，需要把 [1, 1, w, h] 格式的输入对接到原来的 interpolate 函数上。我们的做法是截取输入张量的后两个元素，把这两个元素以 list 的格式传入 interpolate 的 scale_factor 参数。
+
+接下来，我们要决定新算子映射到 ONNX 算子的方法。映射到 ONNX 的方法由一个算子的 symbolic 方法决定。symbolic 方法第一个参数必须是g，之后的参数是算子的自定义输入，和 forward 函数一样。ONNX 算子的具体定义由 g.op 实现。g.op 的每个参数都可以映射到 ONNX 中的算子属性：
+
+
+
+对于其他参数，我们可以照着现在的 [Resize](https://github.com/onnx/onnx/blob/main/docs/Operators.md#Resize) 算子填。而要注意的是，我们现在希望 scales 参数是由输入动态决定的。因此，在填入 ONNX 的 scales 时，我们要把 symbolic 方法的输入参数中的 scales 填入。
+
+接着，让我们把新模型导出成 ONNX 模型：
+
+```python
+x = torch.randn(1, 3, 256, 256)
+
+with torch.no_grad():
+ torch.onnx.export(model, (x, factor),
+ "srcnn3.onnx",
+ opset_version=11,
+ input_names=['input', 'factor'],
+ output_names=['output'])
+```
+
+把导出的 " srcnn3.onnx " 进行可视化：
+
+
+
+可以看到，正如我们所期望的，导出的 ONNX 模型有了两个输入！第二个输入表示图像的放缩比例。
+
+之前在验证 PyTorch 模型和导出 ONNX 模型时，我们宽高的缩放比例设置成了 3x3。现在，在用 ONNX Runtime 推理时，我们尝试使用 4x4 的缩放比例：
+
+```python
+import onnxruntime
+
+input_factor = np.array([1, 1, 4, 4], dtype=np.float32)
+ort_session = onnxruntime.InferenceSession("srcnn3.onnx")
+ort_inputs = {'input': input_img, 'factor': input_factor}
+ort_output = ort_session.run(None, ort_inputs)[0]
+
+ort_output = np.squeeze(ort_output, 0)
+ort_output = np.clip(ort_output, 0, 255)
+ort_output = np.transpose(ort_output, [1, 2, 0]).astype(np.uint8)
+cv2.imwrite("face_ort_3.png", ort_output)
+```
+
+运行上面的代码，可以得到一个边长放大4倍的超分辨率图片 "face_ort_3.png"。动态的超分辨率模型生成成功了！只要修改 input_factor，我们就可以自由地控制图片的缩放比例。
+
+我们刚刚的工作，实际上是绕过 PyTorch 本身的限制，凭空“捏”出了一个 ONNX 算子。事实上，我们不仅可以创建现有的 ONNX 算子，还可以定义新的 ONNX 算子以拓展 ONNX 的表达能力。后续教程中我们将介绍自定义新 ONNX 算子的方法。
+
+## 总结
+
+通过学习前两篇教程，我们走完了整个部署流水线，成功部署了支持动态放大倍数的超分辨率模型。在这个过程中，我们既学会了如何简单地调用各框架的API实现模型部署，又学到了如何分析并尝试解决模型部署时碰到的难题。
+
+同样，让我们总结一下本篇教程的知识点：
+
+- 模型部署中常见的几类困难有：模型的动态化；新算子的实现；框架间的兼容。
+- PyTorch 转 ONNX，实际上就是把每一个操作转化成 ONNX 定义的某一个算子。比如对于 PyTorch 中的 Upsample 和 interpolate，在转 ONNX 后最终都会成为 ONNX 的 Resize 算子。
+- 通过修改继承自 torch.autograd.Function 的算子的 symbolic 方法，可以改变该算子映射到 ONNX 算子的行为。
+
+至此，"部署第一个模型“的教程算是告一段落了。是不是觉得学到的知识还不够多？没关系，在接下来的几篇教程中，我们将结合 MMDeploy ，重点介绍 ONNX 中间表示和 ONNX Runtime/TensorRT 推理引擎的知识，让大家学会如何部署更复杂的模型。
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/03_pytorch2onnx.md b/internlm_langchain/knowledge_base/MMDeploy/content/03_pytorch2onnx.md
new file mode 100644
index 00000000..680b7d97
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/03_pytorch2onnx.md
@@ -0,0 +1,347 @@
+# 第三章：PyTorch 转 ONNX 详解
+
+ONNX 是目前模型部署中最重要的中间表示之一。学懂了 ONNX 的技术细节，就能规避大量的模型部署问题。从这篇文章开始，在接下来的三篇文章里，我们将由浅入深地介绍 ONNX 相关的知识。在第一篇文章里，我们会介绍更多 PyTorch 转 ONNX 的细节，让大家完全掌握把简单的 PyTorch 模型转成 ONNX 模型的方法；在第二篇文章里，我们将介绍如何在 PyTorch 中支持更多的 ONNX 算子，让大家能彻底走通 PyTorch 到 ONNX 这条部署路线；第三篇文章里，我们讲介绍 ONNX 本身的知识，以及修改、调试 ONNX 模型的常用方法，使大家能自行解决大部分和 ONNX 有关的部署问题。
+
+在把 PyTorch 模型转换成 ONNX 模型时，我们往往只需要轻松地调用一句`torch.onnx.export`就行了。这个函数的接口看上去简单，但它在使用上还有着诸多的“潜规则”。在这篇教程中，我们会详细介绍 PyTorch 模型转 ONNX 模型的原理及注意事项。除此之外，我们还会介绍 PyTorch 与 ONNX 的算子对应关系，以教会大家如何处理 PyTorch 模型转换时可能会遇到的算子支持问题。
+
+## `torch.onnx.export` 细解
+
+在这一节里，我们将详细介绍 PyTorch 到 ONNX 的转换函数—— torch.onnx.export。我们希望大家能够更加灵活地使用这个模型转换接口，并通过了解它的实现原理来更好地应对该函数的报错（由于模型部署的兼容性问题，部署复杂模型时该函数时常会报错）。
+
+### 计算图导出方法
+
+[TorchScript](https://pytorch.org/docs/stable/jit.html) 是一种序列化和优化 PyTorch 模型的格式，在优化过程中，一个`torch.nn.Module`模型会被转换成 TorchScript 的`torch.jit.ScriptModule`模型。现在， TorchScript 也被常当成一种中间表示使用。我们在[其他文章](https://zhuanlan.zhihu.com/p/486914187)中对 TorchScript 有详细的介绍，这里介绍 TorchScript 仅用于说明 PyTorch 模型转 ONNX的原理。
+`torch.onnx.export`中需要的模型实际上是一个`torch.jit.ScriptModule`。而要把普通 PyTorch 模型转一个这样的 TorchScript 模型，有跟踪（trace）和脚本化（script）两种导出计算图的方法。如果给`torch.onnx.export`传入了一个普通 PyTorch 模型（`torch.nn.Module`)，那么这个模型会默认使用跟踪的方法导出。这一过程如下图所示：
+
+
+
+回忆一下我们[第一篇教程](01_introduction_to_model_deployment.md) 知识：跟踪法只能通过实际运行一遍模型的方法导出模型的静态图，即无法识别出模型中的控制流（如循环）；脚本化则能通过解析模型来正确记录所有的控制流。我们以下面这段代码为例来看一看这两种转换方法的区别：
+
+```python
+import torch
+
+class Model(torch.nn.Module):
+ def __init__(self, n):
+ super().__init__()
+ self.n = n
+ self.conv = torch.nn.Conv2d(3, 3, 3)
+
+ def forward(self, x):
+ for i in range(self.n):
+ x = self.conv(x)
+ return x
+
+
+
+models = [Model(2), Model(3)]
+model_names = ['model_2', 'model_3']
+
+for model, model_name in zip(models, model_names):
+ dummy_input = torch.rand(1, 3, 10, 10)
+ dummy_output = model(dummy_input)
+ model_trace = torch.jit.trace(model, dummy_input)
+ model_script = torch.jit.script(model)
+
+ # 跟踪法与直接 torch.onnx.export(model, ...)等价
+ torch.onnx.export(model_trace, dummy_input, f'{model_name}_trace.onnx', example_outputs=dummy_output)
+ # 脚本化必须先调用 torch.jit.sciprt
+ torch.onnx.export(model_script, dummy_input, f'{model_name}_script.onnx', example_outputs=dummy_output)
+```
+
+在这段代码里，我们定义了一个带循环的模型，模型通过参数`n`来控制输入张量被卷积的次数。之后，我们各创建了一个`n=2`和`n=3`的模型。我们把这两个模型分别用跟踪和脚本化的方法进行导出。
+值得一提的是，由于这里的两个模型（`model_trace`, `model_script`)是 TorchScript 模型，`export`函数已经不需要再运行一遍模型了。（如果模型是用跟踪法得到的，那么在执行`torch.jit.trace`的时候就运行过一遍了；而用脚本化导出时，模型不需要实际运行）参数中的`dummy_input`和`dummy_output`仅仅是为了获取输入和输出张量的类型和形状。
+运行上面的代码，我们把得到的4个 onnx 文件用 Netron 可视化：
+
+
+
+首先看跟踪法得到的 ONNX 模型结构。可以看出来，对于不同的 `n`,ONNX 模型的结构是不一样的。
+
+
+
+而用脚本化的话，最终的 ONNX 模型用 `Loop` 节点来表示循环。这样哪怕对于不同的 `n`，ONNX 模型也有同样的结构。
+由于推理引擎对静态图的支持更好，通常我们在模型部署时不需要显式地把 PyTorch 模型转成 TorchScript 模型，直接把 PyTorch 模型用 `torch.onnx.export` 跟踪导出即可。了解这部分的知识主要是为了在模型转换报错时能够更好地定位问题是否发生在 PyTorch 转 TorchScript 阶段。
+
+### 参数讲解
+
+了解完转换函数的原理后，我们来详细介绍一下该函数的主要参数的作用。我们主要会从应用的角度来介绍每个参数在不同的模型部署场景中应该如何设置，而不会去列出每个参数的所有设置方法。该函数详细的 API 文档可参考 [torch.onnx ‒ PyTorch 1.11.0 documentation](https://pytorch.org/docs/stable/onnx.html#functions)
+
+`torch.onnx.export` 在 `torch.onnx.__init__.py`文件中的定义如下：
+
+```python
+def export(model, args, f, export_params=True, verbose=False, training=TrainingMode.EVAL,
+ input_names=None, output_names=None, aten=False, export_raw_ir=False,
+ operator_export_type=None, opset_version=None, _retain_param_name=True,
+ do_constant_folding=True, example_outputs=None, strip_doc_string=True,
+ dynamic_axes=None, keep_initializers_as_inputs=None, custom_opsets=None,
+ enable_onnx_checker=True, use_external_data_format=False):
+```
+
+前三个必选参数为模型、模型输入、导出的 onnx 文件名，我们对这几个参数已经很熟悉了。我们来着重看一下后面的一些常用可选参数。
+
+#### export_params
+
+模型中是否存储模型权重。一般中间表示包含两大类信息：模型结构和模型权重，这两类信息可以在同一个文件里存储，也可以分文件存储。ONNX 是用同一个文件表示记录模型的结构和权重的。
+我们部署时一般都默认这个参数为 True。如果 onnx 文件是用来在不同框架间传递模型（比如 PyTorch 到 Tensorflow）而不是用于部署，则可以令这个参数为 False。
+
+#### input_names, output_names
+
+设置输入和输出张量的名称。如果不设置的话，会自动分配一些简单的名字（如数字）。
+ONNX 模型的每个输入和输出张量都有一个名字。很多推理引擎在运行 ONNX 文件时，都需要以“名称-张量值”的数据对来输入数据，并根据输出张量的名称来获取输出数据。在进行跟张量有关的设置（比如添加动态维度）时，也需要知道张量的名字。
+在实际的部署流水线中，我们都需要设置输入和输出张量的名称，并保证 ONNX 和推理引擎中使用同一套名称。
+
+#### opset_version
+
+转换时参考哪个 ONNX 算子集版本，默认为9。后文会详细介绍 PyTorch 与 ONNX 的算子对应关系。
+
+#### dynamic_axes
+
+指定输入输出张量的哪些维度是动态的。
+为了追求效率，ONNX 默认所有参与运算的张量都是静态的（张量的形状不发生改变）。但在实际应用中，我们又希望模型的输入张量是动态的，尤其是本来就没有形状限制的全卷积模型。因此，我们需要显式地指明输入输出张量的哪几个维度的大小是可变的。
+我们来看一个`dynamic_axes`的设置例子：
+
+```python
+import torch
+
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv = torch.nn.Conv2d(3, 3, 3)
+
+ def forward(self, x):
+ x = self.conv(x)
+ return x
+
+
+model = Model()
+dummy_input = torch.rand(1, 3, 10, 10)
+model_names = ['model_static.onnx',
+'model_dynamic_0.onnx',
+'model_dynamic_23.onnx']
+
+dynamic_axes_0 = {
+ 'in' : [0],
+ 'out' : [0]
+}
+dynamic_axes_23 = {
+ 'in' : [2, 3],
+ 'out' : [2, 3]
+}
+
+torch.onnx.export(model, dummy_input, model_names[0],
+input_names=['in'], output_names=['out'])
+torch.onnx.export(model, dummy_input, model_names[1],
+input_names=['in'], output_names=['out'], dynamic_axes=dynamic_axes_0)
+torch.onnx.export(model, dummy_input, model_names[2],
+input_names=['in'], output_names=['out'], dynamic_axes=dynamic_axes_23)
+```
+
+首先，我们导出3个 ONNX 模型，分别为没有动态维度、第0维动态、第2第3维动态的模型。
+在这份代码里，我们是用列表的方式表示动态维度，例如：
+
+````python
+dynamic_axes_0 = {
+ 'in' : [0],
+ 'out' : [0]
+}
+```
+
+由于 ONNX 要求每个动态维度都有一个名字，这样写的话会引出一条 UserWarning，警告我们通过列表的方式设置动态维度的话系统会自动为它们分配名字。一种显式添加动态维度名字的方法如下：
+```python
+dynamic_axes_0 = {
+ 'in' : {0: 'batch'},
+ 'out' : {0: 'batch'}
+}
+````
+
+由于在这份代码里我们没有更多的对动态维度的操作，因此简单地用列表指定动态维度即可。
+之后，我们用下面的代码来看一看动态维度的作用：
+
+```python
+import onnxruntime
+import numpy as np
+
+origin_tensor = np.random.rand(1, 3, 10, 10).astype(np.float32)
+mult_batch_tensor = np.random.rand(2, 3, 10, 10).astype(np.float32)
+big_tensor = np.random.rand(1, 3, 20, 20).astype(np.float32)
+
+inputs = [origin_tensor, mult_batch_tensor, big_tensor]
+exceptions = dict()
+
+for model_name in model_names:
+ for i, input in enumerate(inputs):
+ try:
+ ort_session = onnxruntime.InferenceSession(model_name)
+ ort_inputs = {'in': input}
+ ort_session.run(['out'], ort_inputs)
+ except Exception as e:
+ exceptions[(i, model_name)] = e
+ print(f'Input[{i}] on model {model_name} error.')
+ else:
+ print(f'Input[{i}] on model {model_name} succeed.')
+```
+
+我们在模型导出计算图时用的是一个形状为`(1, 3, 10, 10)`的张量。现在，我们来尝试以形状分别是`(1, 3, 10, 10), (2, 3, 10, 10), (1, 3, 20, 20)`为输入，用ONNX Runtime运行一下这几个模型，看看哪些情况下会报错，并保存对应的报错信息。得到的输出信息应该如下：
+
+```python
+Input[0] on model model_static.onnx succeed.
+Input[1] on model model_static.onnx error.
+Input[2] on model model_static.onnx error.
+Input[0] on model model_dynamic_0.onnx succeed.
+Input[1] on model model_dynamic_0.onnx succeed.
+Input[2] on model model_dynamic_0.onnx error.
+Input[0] on model model_dynamic_23.onnx succeed.
+Input[1] on model model_dynamic_23.onnx error.
+Input[2] on model model_dynamic_23.onnx succeed.
+```
+
+可以看出，形状相同的`(1, 3, 10, 10)`的输入在所有模型上都没有出错。而对于batch（第0维）或者长宽（第2、3维）不同的输入，只有在设置了对应的动态维度后才不会出错。我们可以错误信息中找出是哪些维度出了问题。比如我们可以用以下代码查看`input[1]`在`model_static.onnx`中的报错信息：
+
+```python
+print(exceptions[(1, 'model_static.onnx')])
+
+# output
+# [ONNXRuntimeError] : 2 : INVALID_ARGUMENT : Got invalid dimensions for input: in for the following indices index: 0 Got: 2 Expected: 1 Please fix either the inputs or the model.
+```
+
+这段报错告诉我们名字叫`in`的输入的第0维不匹配。本来该维的长度应该为1，但我们的输入是2。实际部署中，如果我们碰到了类似的报错，就可以通过设置动态维度来解决问题。
+
+### 使用技巧
+
+通过学习之前的知识，我们基本掌握了 `torch.onnx.export` 函数的部分实现原理和参数设置方法，足以完成简单模型的转换了。但在实际应用中，使用该函数还会踩很多坑。这里我们模型部署团队把在实战中积累的一些经验分享给大家。
+
+#### 使模型在 ONNX 转换时有不同的行为
+
+有些时候，我们希望模型在直接用 PyTorch 推理时有一套逻辑，而在导出的ONNX模型中有另一套逻辑。比如，我们可以把一些后处理的逻辑放在模型里，以简化除运行模型之外的其他代码。`torch.onnx.is_in_onnx_export()`可以实现这一任务，该函数仅在执行 `torch.onnx.export()`时为真。以下是一个例子：
+
+```python
+import torch
+
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv = torch.nn.Conv2d(3, 3, 3)
+
+ def forward(self, x):
+ x = self.conv(x)
+ if torch.onnx.is_in_onnx_export():
+ x = torch.clip(x, 0, 1)
+ return x
+```
+
+这里，我们仅在模型导出时把输出张量的数值限制在[0, 1]之间。使用 `is_in_onnx_export` 确实能让我们方便地在代码中添加和模型部署相关的逻辑。但是，这些代码对只关心模型训练的开发者和用户来说很不友好，突兀的部署逻辑会降低代码整体的可读性。同时，`is_in_onnx_export` 只能在每个需要添加部署逻辑的地方都“打补丁”，难以进行统一的管理。我们之后会介绍如何使用 MMDeploy 的重写机制来规避这些问题。
+
+#### 利用中断张量跟踪的操作
+
+PyTorch 转 ONNX 的跟踪导出法是不是万能的。如果我们在模型中做了一些很“出格”的操作，跟踪法会把某些取决于输入的中间结果变成常量，从而使导出的ONNX模型和原来的模型有出入。以下是一个会造成这种“跟踪中断”的例子：
+
+```python
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ x = x * x[0].item()
+ return x, torch.Tensor([i for i in x])
+
+model = Model()
+dummy_input = torch.rand(10)
+torch.onnx.export(model, dummy_input, 'a.onnx')
+```
+
+如果你尝试去导出这个模型，会得到一大堆 warning，告诉你转换出来的模型可能不正确。这也难怪，我们在这个模型里使用了`.item()`把 torch 中的张量转换成了普通的 Python 变量，还尝试遍历 torch 张量，并用一个列表新建一个 torch 张量。这些涉及张量与普通变量转换的逻辑都会导致最终的 ONNX 模型不太正确。
+另一方面，我们也可以利用这个性质，在保证正确性的前提下令模型的中间结果变成常量。这个技巧常常用于模型的静态化上，即令模型中所有的张量形状都变成常量。在未来的教程中，我们会在部署实例中详细介绍这些“高级”操作。
+
+#### 使用张量为输入（PyTorch版本 \< 1.9.0）
+
+正如我们第一篇教程所展示的，在较旧(\< 1.9.0)的 PyTorch 中把 Python 数值作为 `torch.onnx.export()`的模型输入时会报错。出于兼容性的考虑，我们还是推荐以张量为模型转换时的模型输入。
+
+## PyTorch 对 ONNX 的算子支持
+
+在确保`torch.onnx.export()`的调用方法无误后，PyTorch 转 ONNX 时最容易出现的问题就是算子不兼容了。这里我们会介绍如何判断某个 PyTorch 算子在 ONNX 中是否兼容，以助大家在碰到报错时能更好地把错误归类。而具体添加算子的方法我们会在之后的文章里介绍。
+在转换普通的`torch.nn.Module`模型时，PyTorch 一方面会用跟踪法执行前向推理，把遇到的算子整合成计算图；另一方面，PyTorch 还会把遇到的每个算子翻译成 ONNX 中定义的算子。在这个翻译过程中，可能会碰到以下情况：
+
+- 该算子可以一对一地翻译成一个 ONNX 算子。
+- 该算子在 ONNX 中没有直接对应的算子，会翻译成一至多个 ONNX 算子。
+- 该算子没有定义翻译成 ONNX 的规则，报错。
+
+那么，该如何查看 PyTorch 算子与 ONNX 算子的对应情况呢？由于 PyTorch 算子是向 ONNX 对齐的，这里我们先看一下 ONNX 算子的定义情况，再看一下 PyTorch 定义的算子映射关系。
+
+### ONNX 算子文档
+
+ONNX 算子的定义情况，都可以在官方的[算子文档](https://github.com/onnx/onnx/blob/main/docs/Operators.md)中查看。这份文档十分重要，我们碰到任何和 ONNX 算子有关的问题都得来”请教“这份文档。
+
+
+
+这份文档中最重要的开头的这个算子变更表格。表格的第一列是算子名，第二列是该算子发生变动的算子集版本号，也就是我们之前在`torch.onnx.export`中提到的`opset_version`表示的算子集版本号。通过查看算子第一次发生变动的版本号，我们可以知道某个算子是从哪个版本开始支持的；通过查看某算子小于等于`opset_version`的第一个改动记录，我们可以知道当前算子集版本中该算子的定义规则。
+
+
+
+通过点击表格中的链接，我们可以查看某个算子的输入、输出参数规定及使用示例。比如上图是Relu在 ONNX 中的定义规则，这份定义表明 Relu 应该有一个输入和一个输入，输入输出的类型相同，均为 tensor。
+
+### PyTorch 对 ONNX 算子的映射
+
+在 PyTorch 中，和 ONNX 有关的定义全部放在 [torch.onnx 目录](https://github.com/pytorch/pytorch/tree/main/torch/onnx)中，如下图所示：
+
+
+
+其中，`symbloic_opset{n}.py`（符号表文件）即表示 PyTorch 在支持第 n 版 ONNX 算子集时新加入的内容。我们之前讲过， bicubic 插值是在第 11 个版本开始支持的。我们以它为例来看看如何查找算子的映射情况。
+首先，使用搜索功能，在`torch/onnx`文件夹搜索"bicubic"，可以发现这个这个插值在第 11 个版本的定义文件中：
+
+
+
+之后，我们按照代码的调用逻辑，逐步跳转直到最底层的 ONNX 映射函数：
+
+```python
+upsample_bicubic2d = _interpolate("upsample_bicubic2d", 4, "cubic")
+
+->
+
+def _interpolate(name, dim, interpolate_mode):
+ return sym_help._interpolate_helper(name, dim, interpolate_mode)
+
+->
+
+def _interpolate_helper(name, dim, interpolate_mode):
+ def symbolic_fn(g, input, output_size, *args):
+ ...
+
+ return symbolic_fn
+```
+
+最后，在`symbolic_fn`中，我们可以看到插值算子是怎么样被映射成多个 ONNX 算子的。其中，每一个`g.op`就是一个 ONNX 的定义。比如其中的 `Resize` 算子就是这样写的：
+
+```python
+ return g.op("Resize",
+ input,
+ empty_roi,
+ empty_scales,
+ output_size,
+ coordinate_transformation_mode_s=coordinate_transformation_mode,
+ cubic_coeff_a_f=-0.75, # only valid when mode="cubic"
+ mode_s=interpolate_mode, # nearest, linear, or cubic
+ nearest_mode_s="floor") # only valid when mode="nearest"
+```
+
+通过在前面提到的 ONNX 算子文档中查找 [Resize 算子的定义](https://github.com/onnx/onnx/blob/main/docs/Operators.md#resize)，我们就可以知道这每一个参数的含义了。用类似的方法，我们可以去查询其他 ONNX 算子的参数含义，进而知道 PyTorch 中的参数是怎样一步一步传入到每个 ONNX 算子中的。
+掌握了如何查询 PyTorch 映射到 ONNX 的关系后，我们在实际应用时就可以在 `torch.onnx.export()`的`opset_version`中先预设一个版本号，碰到了问题就去对应的 PyTorch 符号表文件里去查。如果某算子确实不存在，或者算子的映射关系不满足我们的要求，我们就可能得用其他的算子绕过去，或者自定义算子了。
+
+## 总结
+
+在这篇教程中，我们系统地介绍了 PyTorch 转 ONNX 的原理。我们先是着重讲解了使用最频繁的 `torch.onnx.export`函数，又给出了查询 PyTorch 对 ONNX 算子支持情况的方法。通过本文，我们希望大家能够成功转换出大部分不需要添加新算子的 ONNX 模型，并在碰到算子问题时能够有效定位问题原因。具体而言，大家读完本文后应该了解以下的知识：
+
+- 跟踪法和脚本化在导出带控制语句的计算图时有什么区别。
+- `torch.onnx.export()`中该如何设置 `input_names, output_names, dynamic_axes`。
+- 使用 `torch.onnx.is_in_onnx_export()`来使模型在转换到 ONNX 时有不同的行为。
+- 如何查询 [ONNX 算子文档](https://github.com/onnx/onnx/blob/main/docs/Operators.md)。
+- 如何查询 PyTorch 对某个 ONNX 版本的新特性支持情况。
+- 如何判断 PyTorch 对某个 ONNX 算子是否支持，支持的方法是怎样的。
+
+这期介绍的知识比较抽象，大家会不会觉得有点“水”？没关系，下一篇教程中，我们将以给出代码实例的形式，介绍多种为 PyTorch 转 ONNX 添加算子支持的方法，为大家在 PyTorch 转 ONNX 这条路上扫除更多的障碍。
+
+## 练习
+
+1. Asinh 算子出现于第 9 个 ONNX 算子集。PyTorch 在 9 号版本的符号表文件中是怎样支持这个算子的？
+2. BitShift 算子出现于第11个 ONNX 算子集。PyTorch 在 11 号版本的符号表文件中是怎样支持这个算子的？
+3. 在 [第一篇教程](01_introduction_to_model_deployment.md) 中，我们讲过 PyTorch （截至第 11 号算子集）不支持在插值中设置动态的放缩系数。这个系数对应 `torch.onnx.symbolic_helper._interpolate_helper`的symbolic_fn的Resize算子映射关系中的哪个参数？我们是如何修改这一参数的？
+
+练习的答案会在下期教程中揭晓。
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/04_onnx_custom_op.md b/internlm_langchain/knowledge_base/MMDeploy/content/04_onnx_custom_op.md
new file mode 100644
index 00000000..54ebe9e7
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/04_onnx_custom_op.md
@@ -0,0 +1,473 @@
+# 第四章：在 PyTorch 中支持更多 ONNX 算子
+
+在[上一篇教程](03_pytorch2onnx.md)中，我们系统地学习了 PyTorch 转 ONNX 的方法，可以发现 PyTorch 对 ONNX 的支持还不错。但在实际的部署过程中，难免碰到模型无法用原生 PyTorch 算子表示的情况。这个时候，我们就得考虑扩充 PyTorch，即在 PyTorch 中支持更多 ONNX 算子。
+
+而要使 PyTorch 算子顺利转换到 ONNX ，我们需要保证以下三个环节都不出错：
+
+- 算子在 PyTorch 中有实现
+- 有把该 PyTorch 算子映射成一个或多个 ONNX 算子的方法
+- ONNX 有相应的算子
+
+可在实际部署中，这三部分的内容都可能有所缺失。其中最坏的情况是：我们定义了一个全新的算子，它不仅缺少 PyTorch 实现，还缺少 PyTorch 到 ONNX 的映射关系。但所谓车到山前必有路，对于这三个环节，我们也分别都有以下的添加支持的方法：
+
+- PyTorch 算子
+ - 组合现有算子
+ - 添加 TorchScript 算子
+ - 添加普通 C++ 拓展算子
+- 映射方法
+ - 为 ATen 算子添加符号函数
+ - 为 TorchScript 算子添加符号函数
+ - 封装成 torch.autograd.Function 并添加符号函数
+- ONNX 算子
+ - 使用现有 ONNX 算子
+ - 定义新 ONNX 算子
+
+那么，面对不同的情况时，就需要我们灵活地选用和组合这些方法。听起来是不是很复杂？别担心，本篇文章中，我们将围绕着三种算子映射方法，学习三个添加算子支持的实例，来理清如何为 PyTorch 算子转 ONNX 算子的三个环节添加支持。
+
+## 支持 ATen 算子
+
+实际的部署过程中，我们都有可能会碰到一个最简单的算子缺失问题： 算子在 ATen 中已经实现了，ONNX 中也有相关算子的定义，但是相关算子映射成 ONNX 的规则没有写。在这种情况下，我们只需要**为 ATen 算子补充描述映射规则的符号函数**就行了。
+
+> [ATen](https://pytorch.org/cppdocs/#aten) 是 PyTorch 内置的 C++ 张量计算库，PyTorch 算子在底层绝大多数计算都是用 ATen 实现的。
+
+上期习题中，我们曾经提到了 ONNX 的 `Asinh` 算子。这个算子在 ATen 中有实现，却缺少了映射到 ONNX 算子的符号函数。在这里，我们来尝试为它补充符号函数，并导出一个包含这个算子的 ONNX 模型。
+
+### 获取 ATen 中算子接口定义
+
+为了编写符号函数，我们需要获得 `asinh` 推理接口的输入参数定义。这时，我们要去 `torch/_C/_VariableFunctions.pyi` 和 `torch/nn/functional.pyi` 这两个文件中搜索我们刚刚得到的这个算子名。这两个文件是编译 PyTorch 时本地自动生成的文件，里面包含了 ATen 算子的 PyTorch 调用接口。通过搜索，我们可以知道 `asinh` 在文件 `torch/_C/_VariableFunctions.pyi` 中，其接口定义为:
+
+```python
+def asinh(input: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+```
+
+经过这些步骤，我们确认了缺失的算子名为 `asinh`，它是一个有实现的 ATen 算子。我们还记下了 `asinh` 的调用接口。接下来，我们要为它补充符号函数，使它在转换成 ONNX 模型时不再报错。
+
+### 添加符号函数
+
+到目前为止，我们已经多次接触了定义 PyTorch 到 ONNX 映射规则的符号函数了。现在，我们向大家正式介绍一下符号函数。
+
+符号函数，可以看成是 PyTorch 算子类的一个静态方法。在把 PyTorch 模型转换成 ONNX 模型时，各个 PyTorch 算子的符号函数会被依次调用，以完成 PyTorch 算子到 ONNX 算子的转换。符号函数的定义一般如下：
+
+```python
+def symbolic(g: torch._C.Graph, input_0: torch._C.Value, input_1: torch._C.Value, ...):
+```
+
+其中，`torch._C.Graph` 和 `torch._C.Value` 都对应 PyTorch 的 C++ 实现里的一些类。我们在这篇文章不深究它们的细节，只需要知道第一个参数就固定叫 `g`，它表示和计算图相关的内容；后面的每个参数都表示算子的输入，需要和算子的前向推理接口的输入相同。对于 ATen 算子来说，它们的前向推理接口就是上述两个 `.pyi` 文件里的函数接口。
+
+`g` 有一个方法 `op`。在把 PyTorch 算子转换成 ONNX 算子时，需要在符号函数中调用此方法来为最终的计算图添加一个 ONNX 算子。其定义如下：
+
+```python
+def op(name: str, input_0: torch._C.Value, input_1: torch._C.Value, ...)
+```
+
+其中，第一个参数是算子名称。如果该算子是普通的 ONNX 算子，只需要把它在 ONNX 官方文档里的名称填进去即可（我们稍后再讲其他情况）。
+
+在最简单的情况下，我们只要把 PyTorch 算子的输入用`g.op()`一一对应到 ONNX 算子上即可，并把`g.op()`的返回值作为符号函数的返回值。在情况更复杂时，我们转换一个 PyTorch 算子可能要新建若干个 ONNX 算子。
+
+补充完了背景知识，让我们回到 `asinh` 算子上，来为它编写符号函数。我们先去翻阅一下 ONNX 算子文档，学习一下我们在符号函数里的映射关系 `g.op()` 里应该怎么写。[`Asinh` 的文档](https://github.com/onnx/onnx/blob/main/docs/Operators.md#asinh)写道：该算子有一个输入 `input`，一个输出 `output`，二者的类型都为张量。
+
+到这里，我们已经完成了信息收集环节。我们在上一小节得知了 `asinh` 的推理接口定义，在这一小节里收集了 ONNX 算子 `Asinh` 的定义。现在，我们可以用代码来补充这二者的映射关系了。在刚刚导出 `asinh` 算子的代码中，我们添加以下内容：
+
+```python
+from torch.onnx.symbolic_registry import register_op
+
+def asinh_symbolic(g, input, *, out=None):
+ return g.op("Asinh", input)
+
+register_op('asinh', asinh_symbolic, '', 9)
+```
+
+这里的`asinh_symbolic`就是`asinh`的符号函数。从除`g`以外的第二个输入参数开始，其输入参数应该严格对应它在 ATen 中的定义：
+
+```python
+def asinh(input: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+```
+
+在符号函数的函数体中，`g.op("Asinh", input)`则完成了 ONNX 算子的定义。其中，第一个参数`"Asinh"`是算子在 ONNX 中的名称。至于第二个参数 `input`，如我们刚刚在文档里所见，这个算子只有一个输入，因此我们只要把符号函数的输入参数 `input` 对应过去就行。ONNX 的 `Asinh` 的输出和 ATen 的 `asinh` 的输出是一致的，因此我们直接把 `g.op()` 的结果返回即可。
+
+定义完符号函数后，我们要把这个符号函数和原来的 ATen 算子“绑定”起来。这里，我们要用到 `register_op` 这个 PyTorch API 来完成绑定。如示例所示，只需要一行简单的代码即可把符号函数 `asinh_symbolic` 绑定到算子 `asinh` 上：
+
+```python
+register_op('asinh', asinh_symbolic, '', 9)
+```
+
+`register_op`的第一个参数是目标 ATen 算子名，第二个是要注册的符号函数，这两个参数很好理解。第三个参数是算子的“域”，对于普通 ONNX 算子，直接填空字符串即可。第四个参数表示向哪个算子集版本注册。我们遵照 ONNX 标准，向第 9 号算子集注册。值得注意的是，这里向第 9 号算子集注册，不代表较新的算子集（第 10 号、第 11 号……）都得到了注册。在示例中，我们先只向第 9 号算子集注册。
+
+整理一下，我们最终的代码如下：
+
+```python
+import torch
+
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ return torch.asinh(x)
+
+from torch.onnx.symbolic_registry import register_op
+
+def asinh_symbolic(g, input, *, out=None):
+ return g.op("Asinh", input)
+
+register_op('asinh', asinh_symbolic, '', 9)
+
+model = Model()
+input = torch.rand(1, 3, 10, 10)
+torch.onnx.export(model, input, 'asinh.onnx')
+```
+
+成功导出的话，`asinh.onnx` 应该长这个样子：
+
+
+
+### 测试算子
+
+在完成了一份自定义算子后，我们一定要测试一下算子的正确性。一般我们要用 PyTorch 运行一遍原算子，再用推理引擎（比如 ONNX Runtime）运行一下 ONNX 算子，最后比对两次的运行结果。对于我们刚刚得到的 `asinh.onnx`，可以用如下代码来验证：
+
+```python
+import onnxruntime
+import torch
+import numpy as np
+
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ return torch.asinh(x)
+
+model = Model()
+input = torch.rand(1, 3, 10, 10)
+torch_output = model(input).detach().numpy()
+
+sess = onnxruntime.InferenceSession('asinh.onnx')
+ort_output = sess.run(None, {'0': input.numpy()})[0]
+
+assert np.allclose(torch_output, ort_output)
+```
+
+在这份代码里，我们用 PyTorch 做了一遍推理，并把结果转成了 numpy 格式。之后，我们又用 ONNX Runtime 对 onnx 文件做了一次推理。最后，我们使用 `np.allclose` 来保证两个结果张量的误差在一个可以允许的范围内。一切正常的话，运行这段代码后，`assert` 所在行不会报错，程序应该没有任何输出。
+
+## 支持 TorchScript 算子
+
+对于一些比较复杂的运算，仅使用 PyTorch 原生算子是无法实现的。这个时候，就要考虑自定义一个 PyTorch 算子，再把它转换到 ONNX 中了。新增 PyTorch 算子的方法有很多，PyTorch 官方比较推荐的一种做法是[添加 TorchScript 算子](https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html) 。
+
+由于添加算子的方法较繁琐，我们今天跳过新增 TorchScript 算子的内容，以可变形卷积（Deformable Convolution）算子为例，介绍为现有 TorchScript 算子添加 ONNX 支持的方法。
+
+> 可变形卷积（Deformable Convolution）是在 Torchvision 中实现的 TorchScript 算子，虽然尚未得到广泛支持，但是出现在许多模型中。
+
+有了支持 ATen 算子的经验之后，我们可以知道为算子添加符号函数一般要经过以下几步：
+
+1. 获取原算子的前向推理接口。
+2. 获取目标 ONNX 算子的定义。
+3. 编写符号函数并绑定。
+
+在为可变形卷积添加符号函数时，我们也可以尝试走一遍这个流程。
+
+### 使用 TorchScript 算子
+
+和之前一样，我们首先定义一个包含了算子的模型，为之后转换 ONNX 模型做准备。
+
+```python
+import torch
+import torchvision
+
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = torch.nn.Conv2d(3, 18, 3)
+ self.conv2 = torchvision.ops.DeformConv2d(3, 3, 3)
+
+ def forward(self, x):
+ return self.conv2(x, self.conv1(x))
+```
+
+其中，`torchvision.ops.DeformConv2d` 就是 Torchvision 中的可变形卷积层。相比于普通卷积，可变形卷积的其他参数都大致相同，唯一的区别就是在推理时需要多输入一个表示偏移量的张量。
+
+然后，我们查询算子的前向推理接口。`DeformConv2d` 层最终会调用 `deform_conv2d` 这个算子。我们可以在 `torchvision/csrc/ops/deform_conv2d.cpp` 中查到该算子的调用接口：
+
+```python
+m.def(TORCH_SELECTIVE_SCHEMA(
+ "torchvision::deform_conv2d(Tensor input,
+ Tensor weight,
+ Tensor offset,
+ ......
+ bool use_mask) -> Tensor"));
+```
+
+那么接下来，根据之前的经验，我们就是要去 ONNX 官方文档中查找算子的定义了。
+
+### 自定义 ONNX 算子
+
+很遗憾的是，如果我们去 ONNX 的官方算子页面搜索 "deform"，将搜不出任何内容。目前，ONNX 还没有提供可变形卷积的算子，我们要自己定义一个 ONNX 算子了。
+
+我们在前面讲过，`g.op()` 是用来定义 ONNX 算子的函数。对于 ONNX 官方定义的算子，`g.op()` 的第一个参数就是该算子的名称。而对于一个自定义算子，`g.op()` 的第一个参数是一个带命名空间的算子名，比如：
+
+```python
+g.op("custom::deform_conv2d, ...)
+```
+
+其中，"::"前面的内容就是我们的命名空间。该概念和 C++ 的命名空间类似，是为了防止命名冲突而设定的。如果在 `g.op()` 里不加前面的命名空间，则算子会被默认成 ONNX 的官方算子。
+
+PyTorch 在运行 `g.op()` 时会对官方的算子做检查，如果算子名有误，或者算子的输入类型不正确， `g.op()` 就会报错。为了让我们随心所欲地定义新 ONNX 算子，我们必须设定一个命名空间，给算子取个名，再定义自己的算子。
+
+我们在[第一篇教程](01_introduction_to_model_deployment.md)学过：ONNX 是一套标准，本身并不包括实现。在这里，我们就简略地定义一个 ONNX 可变形卷积算子，而不去写它在某个推理引擎上的实现。在之后的教程中，我们再学习在各个推理引擎中添加新 ONNX 算子支持的方法。此处，我们只关心如何导出一个包含新 ONNX 算子节点的 onnx 文件。因此，我们可以为新算子编写如下简单的符号函数：
+
+```python
+@parse_args("v", "v", "v", "v", "v", "i", "i", "i", "i", "i", "i", "i", "i", "none")
+def symbolic(g,
+ input,
+ weight,
+ offset,
+ mask,
+ bias,
+ stride_h, stride_w,
+ pad_h, pad_w,
+ dil_h, dil_w,
+ n_weight_grps,
+ n_offset_grps,
+ use_mask):
+ return g.op("custom::deform_conv2d", input, offset)
+```
+
+在这个符号函数中，我们以刚刚搜索到的算子输入参数作为符号函数的输入参数，并只用 `input` 和 `offset` 来构造一个简单的 ONNX 算子。
+
+这段代码中，最令人疑惑的就是装饰器 `@parse_args` 了。简单来说，TorchScript 算子的符号函数要求标注出每一个输入参数的类型。比如"v"表示 Torch 库里的 `value` 类型，一般用于标注张量，而"i"表示 int 类型，"f"表示 float 类型，"none"表示该参数为空。具体的类型含义可以在 [torch.onnx.symbolic_helper.py](https://github.com/pytorch/pytorch/blob/main/torch/onnx/symbolic_helper.py)中查看。这里输入参数中的 `input, weight, offset, mask, bias` 都是张量，所以用"v"表示。后面的其他参数同理。我们不必纠结于 `@parse_args`的原理，根据实际情况对符号函数的参数标注类型即可。
+
+有了符号函数后，我们通过如下的方式注册符号函数：
+
+```python
+register_custom_op_symbolic("torchvision::deform_conv2d", symbolic, 9)
+```
+
+和前面的 `register_op` 类似，注册符号函数时，我们要输入算子名、符号函数、算子集版本。与前面不同的是，这里的算子集版本是最早生效版本，在这里设定版本 9，意味着之后的第 10 号、第 11 号……版本集都能使用这个新算子。
+
+最后，我们完整的模型导出代码如下：
+
+```python
+import torch
+import torchvision
+
+class Model(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = torch.nn.Conv2d(3, 18, 3)
+ self.conv2 = torchvision.ops.DeformConv2d(3, 3, 3)
+
+ def forward(self, x):
+ return self.conv2(x, self.conv1(x))
+
+from torch.onnx import register_custom_op_symbolic
+from torch.onnx.symbolic_helper import parse_args
+
+@parse_args("v", "v", "v", "v", "v", "i", "i", "i", "i", "i", "i", "i", "i", "none")
+def symbolic(g,
+ input,
+ weight,
+ offset,
+ mask,
+ bias,
+ stride_h, stride_w,
+ pad_h, pad_w,
+ dil_h, dil_w,
+ n_weight_grps,
+ n_offset_grps,
+ use_mask):
+ return g.op("custom::deform_conv2d", input, offset)
+
+register_custom_op_symbolic("torchvision::deform_conv2d", symbolic, 9)
+
+model = Model()
+input = torch.rand(1, 3, 10, 10)
+torch.onnx.export(model, input, 'dcn.onnx')
+```
+
+代码成功运行的话，我们应该能得到如下的 ONNX 模型：
+
+
+
+可以看到，我们自定义的 ONNX 算子 `deform_conv2d` 包含了两个输入，一个输出，和我们预想得一样。
+
+## 使用 torch.autograd.Function
+
+最后，我们来学习一种简单的为 PyTorch 添加 C++ 算子实现的方法，来代替较为复杂的新增 TorchScript 算子。同时，我们会用 torch.autograd.Function 封装这个新算子。torch.autograd.Function 能完成算子实现和算子调用的隔离。不管算子是怎么实现的，它封装后的使用体验以及 ONNX 导出方法会和原生的 PyTorch 算子一样。这是我们比较推荐的为算子添加 ONNX 支持的方法。
+
+为了应对更复杂的情况，我们来自定义一个奇怪的 `my_add` 算子。这个算子的输入张量 a, b ，输出 `2a + b` 的值。我们会先把它在 PyTorch 中实现，再把它导出到 ONNX 中。
+
+### 为 PyTorch 添加 C++ 拓展
+
+为 PyTorch 添加简单的 C++ 拓展还是很方便的。对于我们定义的 my_add 算子，可以用以下的 C++ 源文件来实现。我们把该文件命名为 "my_add.cpp"：
+
+```C++
+// my_add.cpp
+
+#include
+ 
+
+
+直接将该模型转换成TensorRT模型也是不可行的，这是因为TensorRT还无法解析 `DynamicTRTResize` 节点。而想要解析该节点，我们必须为TensorRT添加c++代码，实现该插件。
+
+### C++实现
+
+因为MMDeploy中已经实现了Bicubic Interpolate算子，所以我们可以复用其中的CUDA部分代码，只针对TensorRT实现支持动态scale的插件即可。对CUDA编程感兴趣的小伙伴可以参考CUDA的[官方教程](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html)。因为 `csrc/backend_ops/tensorrt/bicubic_interpolate` 中有我们需要的CUDA代码，所以我们可以直接在该文件夹加添加TensorRT相关的trt_dynamic_resize.hpp和trt_dynamic_resize.cpp文件，在这两个文件中分别声明和实现插件就可以了。我们也可以新建文件夹 `csrc/backend_ops/tensorrt/dynamic_resize`，将这两个文件直接放到这个文件夹下。
+
+对TensorRT 7+，要实现这样一个自定义插件，我们需要写两个类。
+
+- `DynamicTRTResize`，继承自[nvinfer1::IPluginV2DynamicExt](https://docs.nvidia.com/deeplearning/tensorrt/api/c_api/classnvinfer1_1_1_i_plugin_v2_dynamic_ext.html)，完成插件的具体实现
+- `DynamicTRTResizeCreator`，继承自[nvinfer1::IPluginCreator](https://docs.nvidia.com/deeplearning/tensorrt/api/c_api/classnvinfer1_1_1_i_plugin_creator.html)，是插件的工厂类，用于创建`DynamicTRTResize`插件的实例。
+
+在MMDeploy中，由于有若干插件需要实现，所以我们在`mmdeploy/csrc/backend_ops/tensorrt/common/trt_plugin_base.hpp`中实现了`TRTPluginBase`和`TRTPluginCreatorBase`两个类，用于管理一些所有插件共有的属性方法。其中，`TRTPluginBase`是继承自`nvinfer1::IPluginV2DynamicExt`，而`TRTPluginCreatorBase`是继承自`nvinfer1::IPluginCreator`。这样，用户实现插件时只需继承这两个新的类即可。所以我们只需在`dynamic_resize`文件夹下.hpp文件中，引用`trt_plugin_base.hpp`头文件，然后实现类如下：
+
+```cpp
+class DynamicTRTResize : public TRTPluginBase{}
+class DynamicTRTResizeCreator : public TRTPluginCreatorBase{}
+```
+
+在trt_dynamic_resize.hpp中，我们声明如下内容：
+
+```cpp
+#ifndef TRT_DYNAMIC_RESIZE_HPP
+#define TRT_DYNAMIC_RESIZE_HPP
+#include
+
+ 
+
+
+从上面的图片和代码中我们发现，插件类`DynamicTRTResize`中我们定义了私有变量`mAlignCorners`，该变量表示是否`align corners`。此外只要实现构造析构函数和TensoRT中三个基类的方法即可。其中构造函数有二，分别用于创建插件和反序列化插件。而基类方法中：
+
+1. 基类`IPluginV2DynamicExt`的方法较为值得关注，`getOutputDimensions`获取输出张量的形状，`enqueue`真正负责执行我们的算法，内部一般会调用CUDA核函数。本文实现的插件直接调用MMDeploy已定义在`csrc/backend_ops/tensorrt/bicubic_interpolate`的核函数`bicubic_interpolate`。
+2. 基类`IPluginV2Ext`的方法，我们只要实现获取输出数据类型的`getOutputDataType`即可。
+3. 基类`IPluginV2`则是些获取插件类型和版本号的方法，此外则是序列化输入插件的参数的函数`serialize`和计算该参数的序列化后`buffer`大小的函数`getSerializationSize`，以及获取输出张量个数的方法`getNbOutputs`。还有部分公共方法被定义在`TRTPluginBase`类内了。
+
+在插件工厂类 `DynamicTRTResizeCreator` 中，我们需要声明获取插件名称和版本的方法 `getPluginName` 和 `getPluginVersion`。同时我们还需要声明创建插件和反序列化插件的方法 `createPlugin` 和 `deserializePlugin`，前者调用 `DynamicTRTResize` 中创建插件的方法，后者调用反序列化插件的方法。
+
+接下来，我们就实现上述声明吧。在.cpp文件中我们实现代码如下：
+
+```cpp
+// Copyright (c) OpenMMLab. All rights reserved
+#include "trt_dynamic_resize.hpp"
+
+#include
+| 名称 | +安装方式 | +
|---|---|
| OpenCV (>=3.0) |
+
+ |
+
+
| ncnn | +ncnn 是支持 android 平台的高效神经网络推理计算框架
+ 目前, MMDeploy 支持 ncnn 的 20220721 版本, 且必须使用git clone 下载源码的方式安装。请到 这里 查询 ncnn 支持的 android ABI。+ + |
+
| OpenJDK | +编译Java API之前需要先准备OpenJDK开发环境 + 请参考 Java API 编译 进行构建. + | +
+
+
+
+
+
+
+
+
+| mmpretrain | +TensorRT(ms) | +PPLNN(ms) | +ncnn(ms) | +Ascend(ms) | +|||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| model | +spatial | +T4 | +JetsonNano2GB | +Jetson TX2 | +T4 | +SnapDragon888 | +Adreno660 | +Ascend310 | +|||
| fp32 | +fp16 | +int8 | +fp32 | +fp16 | +fp32 | +fp16 | +fp32 | +fp32 | +fp32 | +||
| ResNet | +224x224 | +2.97 | +1.26 | +1.21 | +59.32 | +30.54 | +24.13 | +1.30 | +33.91 | +25.93 | +2.49 | +
| ResNeXt | +224x224 | +4.31 | +1.42 | +1.37 | +88.10 | +49.18 | +37.45 | +1.36 | +133.44 | +69.38 | +- | +
| SE-ResNet | +224x224 | +3.41 | +1.66 | +1.51 | +74.59 | +48.78 | +29.62 | +1.91 | +107.84 | +80.85 | +- | +
| ShuffleNetV2 | +224x224 | +1.37 | +1.19 | +1.13 | +15.26 | +10.23 | +7.37 | +4.69 | +9.55 | +10.66 | +- | +
| mmdet part1 | +TensorRT(ms) | +PPLNN(ms) | +||||
|---|---|---|---|---|---|---|
| model | +spatial | +T4 | +Jetson TX2 | +T4 | +||
| fp32 | +fp16 | +int8 | +fp32 | +fp16 | +||
| YOLOv3 | +320x320 | +14.76 | +24.92 | +24.92 | +- | +18.07 | +
| SSD-Lite | +320x320 | +8.84 | +9.21 | +8.04 | +1.28 | +19.72 | +
| RetinaNet | +800x1344 | +97.09 | +25.79 | +16.88 | +780.48 | +38.34 | +
| FCOS | +800x1344 | +84.06 | +23.15 | +17.68 | +- | +- | +
| FSAF | +800x1344 | +82.96 | +21.02 | +13.50 | +- | +30.41 | +
| Faster R-CNN | +800x1344 | +88.08 | +26.52 | +19.14 | +733.81 | +65.40 | +
| Mask R-CNN | +800x1344 | +104.83 | +58.27 | +- | +- | +86.80 | +
+
+
+
+
+
+| mmdet part2 | +ncnn | +||
|---|---|---|---|
| model | +spatial | +SnapDragon888 | +Adreno660 | +
| fp32 | +fp32 | +||
| MobileNetv2-YOLOv3 | +320x320 | +48.57 | +66.55 | +
| SSD-Lite | +320x320 | +44.91 | +66.19 | +
| YOLOX | +416x416 | +111.60 | +134.50 | +
+
+
+
+
+
+| mmagic | +TensorRT(ms) | +PPLNN(ms) | +||||
|---|---|---|---|---|---|---|
| model | +spatial | +T4 | +Jetson TX2 | +T4 | +||
| fp32 | +fp16 | +int8 | +fp32 | +fp16 | +||
| ESRGAN | +32x32 | +12.64 | +12.42 | +12.45 | +- | +7.67 | +
| SRCNN | +32x32 | +0.70 | +0.35 | +0.26 | +58.86 | +0.56 | +
+
+
+
+
+
+| mmocr | +TensorRT(ms) | +PPLNN(ms) | +ncnn(ms) | +||||
|---|---|---|---|---|---|---|---|
| model | +spatial | +T4 | +T4 | +SnapDragon888 | +Adreno660 | +||
| fp32 | +fp16 | +int8 | +fp16 | +fp32 | +fp32 | +||
| DBNet | +640x640 | +10.70 | +5.62 | +5.00 | +34.84 | +- | +- | +
| CRNN | +32x32 | +1.93 | +1.40 | +1.36 | +- | +10.57 | +20.00 | +
+
+
+
+
+
+## 精度测试
+
+| mmseg | +TensorRT(ms) | +PPLNN(ms) | +||||
|---|---|---|---|---|---|---|
| model | +spatial | +T4 | +Jetson TX2 | +T4 | +||
| fp32 | +fp16 | +int8 | +fp32 | +fp16 | +||
| FCN | +512x1024 | +128.42 | +23.97 | +18.13 | +1682.54 | +27.00 | +
| PSPNet | +1x3x512x1024 | +119.77 | +24.10 | +16.33 | +1586.19 | +27.26 | +
| DeepLabV3 | +512x1024 | +226.75 | +31.80 | +19.85 | +- | +36.01 | +
| DeepLabV3+ | +512x1024 | +151.25 | +47.03 | +50.38 | +2534.96 | +34.80 | +
+
+
+
+
+| mmpretrain | +PyTorch | +TorchScript | +ONNX Runtime | +TensorRT | +PPLNN | +Ascend | +|||
|---|---|---|---|---|---|---|---|---|---|
| model | +metric | +fp32 | +fp32 | +fp32 | +fp32 | +fp16 | +int8 | +fp16 | +fp32 | +
| ResNet-18 | +top-1 | +69.90 | +69.90 | +69.88 | +69.88 | +69.86 | +69.86 | +69.86 | +69.91 | +
| top-5 | +89.43 | +89.43 | +89.34 | +89.34 | +89.33 | +89.38 | +89.34 | +89.43 | +|
| ResNeXt-50 | +top-1 | +77.90 | +77.90 | +77.90 | +77.90 | +- | +77.78 | +77.89 | +- | +
| top-5 | +93.66 | +93.66 | +93.66 | +93.66 | +- | +93.64 | +93.65 | +- | +|
| SE-ResNet-50 | +top-1 | +77.74 | +77.74 | +77.74 | +77.74 | +77.75 | +77.63 | +77.73 | +- | +
| top-5 | +93.84 | +93.84 | +93.84 | +93.84 | +93.83 | +93.72 | +93.84 | +- | +|
| ShuffleNetV1 1.0x | +top-1 | +68.13 | +68.13 | +68.13 | +68.13 | +68.13 | +67.71 | +68.11 | +- | +
| top-5 | +87.81 | +87.81 | +87.81 | +87.81 | +87.81 | +87.58 | +87.80 | +- | +|
| ShuffleNetV2 1.0x | +top-1 | +69.55 | +69.55 | +69.55 | +69.55 | +69.54 | +69.10 | +69.54 | +- | +
| top-5 | +88.92 | +88.92 | +88.92 | +88.92 | +88.91 | +88.58 | +88.92 | +- | +|
| MobileNet V2 | +top-1 | +71.86 | +71.86 | +71.86 | +71.86 | +71.87 | +70.91 | +71.84 | +71.87 | +
| top-5 | +90.42 | +90.42 | +90.42 | +90.42 | +90.40 | +89.85 | +90.41 | +90.42 | +|
| Vision Transformer | +top-1 | +85.43 | +85.43 | +- | +85.43 | +85.42 | +- | +- | +85.43 | +
| top-5 | +97.77 | +97.77 | +- | +97.77 | +97.76 | +- | +- | +97.77 | +|
| Swin Transformer | +top-1 | +81.18 | +81.18 | +81.18 | +81.18 | +81.18 | +- | +- | +- | +
| top-5 | +95.61 | +95.61 | +95.61 | +95.61 | +95.61 | +- | +- | +- | +|
| EfficientFormer | +top-1 | +80.46 | +80.45 | +80.46 | +80.46 | +- | +- | +- | +- | +
| top-5 | +94.99 | +94.98 | +94.99 | +94.99 | +- | +- | +- | +- | +|
+
+
+
+
+| mmdet | +Pytorch | +TorchScript | +ONNXRuntime | +TensorRT | +PPLNN | +Ascend | +OpenVINO | +|||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| model | +task | +dataset | +metric | +fp32 | +fp32 | +fp32 | +fp32 | +fp16 | +int8 | +fp16 | +fp32 | +fp32 | +
| YOLOV3 | +Object Detection | +COCO2017 | +box AP | +33.7 | +33.7 | +- | +33.5 | +33.5 | +33.5 | +- | +- | +- | +
| SSD | +Object Detection | +COCO2017 | +box AP | +25.5 | +25.5 | +- | +25.5 | +25.5 | +- | +- | +- | +- | +
| RetinaNet | +Object Detection | +COCO2017 | +box AP | +36.5 | +36.4 | +- | +36.4 | +36.4 | +36.3 | +36.5 | +36.4 | +- | +
| FCOS | +Object Detection | +COCO2017 | +box AP | +36.6 | +- | +- | +36.6 | +36.5 | +- | +- | +- | +- | +
| FSAF | +Object Detection | +COCO2017 | +box AP | +37.4 | +37.4 | +- | +37.4 | +37.4 | +37.2 | +37.4 | +- | +- | +
| CenterNet | +Object Detection | +COCO2017 | +box AP | +25.9 | +26.0 | +26.0 | +26.0 | +25.8 | +- | +- | +- | +- | +
| YOLOX | +Object Detection | +COCO2017 | +box AP | +40.5 | +40.3 | +- | +40.3 | +40.3 | +29.3 | +- | +- | +- | +
| Faster R-CNN | +Object Detection | +COCO2017 | +box AP | +37.4 | +37.3 | +- | +37.3 | +37.3 | +37.1 | +37.3 | +37.2 | +- | +
| ATSS | +Object Detection | +COCO2017 | +box AP | +39.4 | +- | +- | +39.4 | +39.4 | +- | +- | +- | +- | +
| Cascade R-CNN | +Object Detection | +COCO2017 | +box AP | +40.4 | +- | +- | +40.4 | +40.4 | +- | +40.4 | +- | +- | +
| GFL | +Object Detection | +COCO2017 | +box AP | +40.2 | +- | +40.2 | +40.2 | +40.0 | +- | +- | +- | +- | +
| RepPoints | +Object Detection | +COCO2017 | +box AP | +37.0 | +- | +- | +36.9 | +- | +- | +- | +- | +- | +
| DETR | +Object Detection | +COCO2017 | +box AP | +40.1 | +40.1 | +- | +40.1 | +40.1 | +- | +- | +- | +- | +
| Mask R-CNN | +Instance Segmentation | +COCO2017 | +box AP | +38.2 | +38.1 | +- | +38.1 | +38.1 | +- | +38.0 | +- | +- | +
| mask AP | +34.7 | +34.7 | +- | +33.7 | +33.7 | +- | +- | +- | +- | +|||
| Swin-Transformer | +Instance Segmentation | +COCO2017 | +box AP | +42.7 | +- | +42.7 | +42.5 | +37.7 | +- | +- | +- | +- | +
| mask AP | +39.3 | +- | +39.3 | +39.3 | +35.4 | +- | +- | +- | +- | +|||
| SOLO | +Instance Segmentation | +COCO2017 | +mask AP | +33.1 | +- | +32.7 | +- | +- | +- | +- | +- | +32.7 | +
| SOLOv2 | +Instance Segmentation | +COCO2017 | +mask AP | +34.8 | +- | +34.5 | +- | +- | +- | +- | +- | +34.5 | +
+
+
+
+
+| mmagic | +Pytorch | +TorchScript | +ONNX Runtime | +TensorRT | +PPLNN | +|||||
|---|---|---|---|---|---|---|---|---|---|---|
| model | +task | +dataset | +metric | +fp32 | +fp32 | +fp32 | +fp32 | +fp16 | +int8 | +fp16 | +
| SRCNN | +Super Resolution | +Set5 | +PSNR | +28.4316 | +28.4120 | +28.4323 | +28.4323 | +28.4286 | +28.1995 | +28.4311 | +
| SSIM | +0.8099 | +0.8106 | +0.8097 | +0.8097 | +0.8096 | +0.7934 | +0.8096 | +|||
| ESRGAN | +Super Resolution | +Set5 | +PSNR | +28.2700 | +28.2619 | +28.2592 | +28.2592 | +- | +- | +28.2624 | +
| SSIM | +0.7778 | +0.7784 | +0.7764 | +0.7774 | +- | +- | +0.7765 | +|||
| ESRGAN-PSNR | +Super Resolution | +Set5 | +PSNR | +30.6428 | +30.6306 | +30.6444 | +30.6430 | +- | +- | +27.0426 | +
| SSIM | +0.8559 | +0.8565 | +0.8558 | +0.8558 | +- | +- | +0.8557 | +|||
| SRGAN | +Super Resolution | +Set5 | +PSNR | +27.9499 | +27.9252 | +27.9408 | +27.9408 | +- | +- | +27.9388 | +
| SSIM | +0.7846 | +0.7851 | +0.7839 | +0.7839 | +- | +- | +0.7839 | +|||
| SRResNet | +Super Resolution | +Set5 | +PSNR | +30.2252 | +30.2069 | +30.2300 | +30.2300 | +- | +- | +30.2294 | +
| SSIM | +0.8491 | +0.8497 | +0.8488 | +0.8488 | +- | +- | +0.8488 | +|||
| Real-ESRNet | +Super Resolution | +Set5 | +PSNR | +28.0297 | +- | +27.7016 | +27.7016 | +- | +- | +27.7049 | +
| SSIM | +0.8236 | +- | +0.8122 | +0.8122 | +- | +- | +0.8123 | +|||
| EDSR | +Super Resolution | +Set5 | +PSNR | +30.2223 | +30.2192 | +30.2214 | +30.2214 | +30.2211 | +30.1383 | +- | +
| SSIM | +0.8500 | +0.8507 | +0.8497 | +0.8497 | +0.8497 | +0.8469 | +- | +|||
+
+
+
+
+| mmocr | +Pytorch | +TorchScript | +ONNXRuntime | +TensorRT | +PPLNN | +OpenVINO | +|||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| model | +task | +dataset | +metric | +fp32 | +fp32 | +fp32 | +fp32 | +fp16 | +int8 | +fp16 | +fp32 | +
| DBNet* | +TextDetection | +ICDAR2015 | +recall | +0.7310 | +0.7308 | +0.7304 | +0.7198 | +0.7179 | +0.7111 | +0.7304 | +0.7309 | +
| precision | +0.8714 | +0.8718 | +0.8714 | +0.8677 | +0.8674 | +0.8688 | +0.8718 | +0.8714 | +|||
| hmean | +0.7950 | +0.7949 | +0.7950 | +0.7868 | +0.7856 | +0.7821 | +0.7949 | +0.7950 | +|||
| DBNetpp | +TextDetection | +ICDAR2015 | +recall | +0.8209 | +0.8209 | +0.8209 | +0.8199 | +0.8204 | +0.8204 | +- | +0.8209 | +
| precision | +0.9079 | +0.9079 | +0.9079 | +0.9117 | +0.9117 | +0.9142 | +- | +0.9079 | +|||
| hmean | +0.8622 | +0.8622 | +0.8622 | +0.8634 | +0.8637 | +0.8648 | +- | +0.8622 | +|||
| PSENet | +TextDetection | +ICDAR2015 | +recall | +0.7526 | +0.7526 | +0.7526 | +0.7526 | +0.7520 | +0.7496 | +- | +0.7526 | +
| precision | +0.8669 | +0.8669 | +0.8669 | +0.8669 | +0.8668 | +0.8550 | +- | +0.8669 | +|||
| hmean | +0.8057 | +0.8057 | +0.8057 | +0.8057 | +0.8054 | +0.7989 | +- | +0.8057 | +|||
| PANet | +TextDetection | +ICDAR2015 | +recall | +0.7401 | +0.7401 | +0.7401 | +0.7357 | +0.7366 | +- | +- | +0.7401 | +
| precision | +0.8601 | +0.8601 | +0.8601 | +0.8570 | +0.8586 | +- | +- | +0.8601 | +|||
| hmean | +0.7955 | +0.7955 | +0.7955 | +0.7917 | +0.7930 | +- | +- | +0.7955 | +|||
| TextSnake | +TextDetection | +CTW1500 | +recall | +0.8052 | +0.8052 | +0.8052 | +0.8055 | +- | +- | +- | +- | +
| precision | +0.8535 | +0.8535 | +0.8535 | +0.8538 | +- | +- | +- | +- | +|||
| hmean | +0.8286 | +0.8286 | +0.8286 | +0.8290 | +- | +- | +- | +- | +|||
| MaskRCNN | +TextDetection | +ICDAR2015 | +recall | +0.7766 | +0.7766 | +0.7766 | +0.7766 | +0.7761 | +0.7670 | +- | +- | +
| precision | +0.8644 | +0.8644 | +0.8644 | +0.8644 | +0.8630 | +0.8705 | +- | +- | +|||
| hmean | +0.8182 | +0.8182 | +0.8182 | +0.8182 | +0.8172 | +0.8155 | +- | +- | +|||
| CRNN | +TextRecognition | +IIIT5K | +acc | +0.8067 | +0.8067 | +0.8067 | +0.8067 | +0.8063 | +0.8067 | +0.8067 | +- | +
| SAR | +TextRecognition | +IIIT5K | +acc | +0.9517 | +- | +0.9287 | +- | +- | +- | +- | +- | +
| SATRN | +TextRecognition | +IIIT5K | +acc | +0.9470 | +0.9487 | +0.9487 | +0.9487 | +0.9483 | +0.9483 | +- | +- | +
| ABINet | +TextRecognition | +IIIT5K | +acc | +0.9603 | +0.9563 | +0.9563 | +0.9573 | +0.9507 | +0.9510 | +- | +- | +
+
+
+
+
+| mmseg | +Pytorch | +TorchScript | +ONNXRuntime | +TensorRT | +PPLNN | +Ascend | +||||
|---|---|---|---|---|---|---|---|---|---|---|
| model | +dataset | +metric | +fp32 | +fp32 | +fp32 | +fp32 | +fp16 | +int8 | +fp16 | +fp32 | +
| FCN | +Cityscapes | +mIoU | +72.25 | +72.36 | +- | +72.36 | +72.35 | +74.19 | +72.35 | +72.35 | +
| PSPNet | +Cityscapes | +mIoU | +78.55 | +78.66 | +- | +78.26 | +78.24 | +77.97 | +78.09 | +78.67 | +
| deeplabv3 | +Cityscapes | +mIoU | +79.09 | +79.12 | +- | +79.12 | +79.12 | +78.96 | +79.12 | +79.06 | +
| deeplabv3+ | +Cityscapes | +mIoU | +79.61 | +79.60 | +- | +79.60 | +79.60 | +79.43 | +79.60 | +79.51 | +
| Fast-SCNN | +Cityscapes | +mIoU | +70.96 | +70.96 | +- | +70.93 | +70.92 | +66.00 | +70.92 | +- | +
| UNet | +Cityscapes | +mIoU | +69.10 | +- | +- | +69.10 | +69.10 | +68.95 | +- | +- | +
| ANN | +Cityscapes | +mIoU | +77.40 | +- | +- | +77.32 | +77.32 | +- | +- | +- | +
| APCNet | +Cityscapes | +mIoU | +77.40 | +- | +- | +77.32 | +77.32 | +- | +- | +- | +
| BiSeNetV1 | +Cityscapes | +mIoU | +74.44 | +- | +- | +74.44 | +74.43 | +- | +- | +- | +
| BiSeNetV2 | +Cityscapes | +mIoU | +73.21 | +- | +- | +73.21 | +73.21 | +- | +- | +- | +
| CGNet | +Cityscapes | +mIoU | +68.25 | +- | +- | +68.27 | +68.27 | +- | +- | +- | +
| EMANet | +Cityscapes | +mIoU | +77.59 | +- | +- | +77.59 | +77.6 | +- | +- | +- | +
| EncNet | +Cityscapes | +mIoU | +75.67 | +- | +- | +75.66 | +75.66 | +- | +- | +- | +
| ERFNet | +Cityscapes | +mIoU | +71.08 | +- | +- | +71.08 | +71.07 | +- | +- | +- | +
| FastFCN | +Cityscapes | +mIoU | +79.12 | +- | +- | +79.12 | +79.12 | +- | +- | +- | +
| GCNet | +Cityscapes | +mIoU | +77.69 | +- | +- | +77.69 | +77.69 | +- | +- | +- | +
| ICNet | +Cityscapes | +mIoU | +76.29 | +- | +- | +76.36 | +76.36 | +- | +- | +- | +
| ISANet | +Cityscapes | +mIoU | +78.49 | +- | +- | +78.49 | +78.49 | +- | +- | +- | +
| OCRNet | +Cityscapes | +mIoU | +74.30 | +- | +- | +73.66 | +73.67 | +- | +- | +- | +
| PointRend | +Cityscapes | +mIoU | +76.47 | +76.47 | +- | +76.41 | +76.42 | +- | +- | +- | +
| Semantic FPN | +Cityscapes | +mIoU | +74.52 | +- | +- | +74.52 | +74.52 | +- | +- | +- | +
| STDC | +Cityscapes | +mIoU | +75.10 | +- | +- | +75.10 | +75.10 | +- | +- | +- | +
| STDC | +Cityscapes | +mIoU | +77.17 | +- | +- | +77.17 | +77.17 | +- | +- | +- | +
| UPerNet | +Cityscapes | +mIoU | +77.10 | +- | +- | +77.19 | +77.18 | +- | +- | +- | +
| Segmenter | +ADE20K | +mIoU | +44.32 | +44.29 | +44.29 | +44.29 | +43.34 | +43.35 | +- | +- | +
+
+
+
+
+
+| mmpose | +Pytorch | +ONNXRuntime | +TensorRT | +PPLNN | +OpenVINO | +||||
|---|---|---|---|---|---|---|---|---|---|
| model | +task | +dataset | +metric | +fp32 | +fp32 | +fp32 | +fp16 | +fp16 | +fp32 | +
| HRNet | +Pose Detection | +COCO | +AP | +0.748 | +0.748 | +0.748 | +0.748 | +- | +0.748 | +
| AR | +0.802 | +0.802 | +0.802 | +0.802 | +- | +0.802 | +|||
| LiteHRNet | +Pose Detection | +COCO | +AP | +0.663 | +0.663 | +0.663 | +- | +- | +0.663 | +
| AR | +0.728 | +0.728 | +0.728 | +- | +- | +0.728 | +|||
| MSPN | +Pose Detection | +COCO | +AP | +0.762 | +0.762 | +0.762 | +0.762 | +- | +0.762 | +
| AR | +0.825 | +0.825 | +0.825 | +0.825 | +- | +0.825 | +|||
| Hourglass | +Pose Detection | +COCO | +AP | +0.717 | +0.717 | +0.717 | +0.717 | +- | +0.717 | +
| AR | +0.774 | +0.774 | +0.774 | +0.774 | +- | +0.774 | +|||
| SimCC | +Pose Detection | +COCO | +AP | +0.607 | +- | +0.608 | +- | +- | +- | +
| AR | +0.668 | +- | +0.672 | +- | +- | +- | +|||
+
+
+
+
+
+| mmrotate | +Pytorch | +ONNXRuntime | +TensorRT | +PPLNN | +OpenVINO | +||||
|---|---|---|---|---|---|---|---|---|---|
| model | +task | +dataset | +metrics | +fp32 | +fp32 | +fp32 | +fp16 | +fp16 | +fp32 | +
| RotatedRetinaNet | +Rotated Detection | +DOTA-v1.0 | +mAP | +0.698 | +0.698 | +0.698 | +0.697 | +- | +- | +
| Oriented RCNN | +Rotated Detection | +DOTA-v1.0 | +mAP | +0.756 | +0.756 | +0.758 | +0.730 | +- | +- | +
| GlidingVertex | +Rotated Detection | +DOTA-v1.0 | +mAP | +0.732 | +- | +0.733 | +0.731 | +- | +- | +
| RoI Transformer | +Rotated Detection | +DOTA-v1.0 | +mAP | +0.761 | +- | +0.758 | +- | +- | +- | +
+
+
+
+
+## 备注
+
+- 由于某些数据集在代码库中包含各种分辨率的图像，例如 MMDet，速度基准是通过 MMDeploy 中的静态配置获得的，而性能基准是通过动态配置获得的
+- TensorRT 的一些 int8 性能基准测试需要有 tensor core 的 Nvidia 卡，否则性能会大幅下降
+- DBNet 在模型 `neck` 使用了`nearest` 插值，TensorRT-7 用了与 Pytorch 完全不同的策略。为了使与 TensorRT-7 兼容，我们重写了`neck`以使用`bilinear`插值，这提高了检测性能。为了获得与 Pytorch 匹配的性能，推荐使用 TensorRT-8+，其插值方法与 Pytorch 相同。
+- 对于 mmpose 模型，在模型配置文件中 `flip_test` 需设置为 `False`
+- 部分模型在 fp16 模式下可能存在较大的精度损失，请根据具体情况对模型进行调整。
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/benchmark_edge.md b/internlm_langchain/knowledge_base/MMDeploy/content/benchmark_edge.md
new file mode 100644
index 00000000..1a539273
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/benchmark_edge.md
@@ -0,0 +1,58 @@
+# 边、端设备测试结果
+
+这里给出我们边、端设备的测试结论，用户可以直接通过 [model profiling](../02-how-to-run/profile_model.md) 获得自己环境的结果。
+
+## 软硬件环境
+
+- host OS ubuntu 18.04
+- backend SNPE-1.59
+- device Mi11 (qcom 888)
+
+## mmpretrain 模型
+
+| model | dataset | spatial | fp32 top-1 (%) | snpe gpu hybrid fp32 top-1 (%) | latency (ms) |
+| :----------------------------------------------------------------------------------------------------------------------: | :---------: | :-----: | :------------: | :----------------------------: | :----------: |
+| [ShuffleNetV2](https://github.com/open-mmlab/mmpretrain/blob/main/configs/shufflenet_v2/shufflenet-v2-1x_16xb64_in1k.py) | ImageNet-1k | 224x224 | 69.55 | 69.83\* | 20±7 |
+| [MobilenetV2](https://github.com/open-mmlab/mmpretrain/blob/main/configs/mobilenet_v2/mobilenet-v2_8xb32_in1k.py) | ImageNet-1k | 224x224 | 71.86 | 72.14\* | 15±6 |
+
+tips:
+
+1. ImageNet-1k 数据集较大，仅使用一部分测试（8000/50000）
+2. 边、端设备发热会降频，因此耗时实际上会波动。这里给出运行一段时间后、稳定的数值。这个结果更贴近实际需求
+
+## mmocr 检测
+
+| model | dataset | spatial | fp32 hmean | snpe gpu hybrid hmean | latency(ms) |
+| :--------------------------------------------------------------------------------------------------------------------: | :-------: | :------: | :--------: | :-------------------: | :---------: |
+| [PANet](https://github.com/open-mmlab/mmocr/blob/main/configs/textdet/panet/panet_resnet18_fpem-ffm_600e_icdar2015.py) | ICDAR2015 | 1312x736 | 0.795 | 0.785 @thr=0.9 | 3100±100 |
+
+## mmpose 模型
+
+| model | dataset | spatial | snpe hybrid AR@IoU=0.50 | snpe hybrid AP@IoU=0.50 | latency(ms) |
+| :---------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------: | :-----: | :---------------------: | :---------------------: | :---------: |
+| [pose_hrnet_w32](https://github.com/open-mmlab/mmpose/blob/main/configs/animal_2d_keypoint/topdown_heatmap/animalpose/td-hm_hrnet-w32_8xb64-210e_animalpose-256x256.py) | Animalpose | 256x256 | 0.997 | 0.989 | 630±50 |
+
+tips:
+
+- 测试 pose_hrnet 用的是 AnimalPose 的 test dataset，而非 val dataset
+
+## mmseg
+
+| model | dataset | spatial | mIoU | latency(ms) |
+| :------------------------------------------------------------------------------------------------------------------: | :--------: | :------: | :---: | :---------: |
+| [fcn](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py) | Cityscapes | 512x1024 | 71.11 | 4915±500 |
+
+tips:
+
+- fcn 用 512x1024 尺寸运行正常。Cityscapes 数据集 1024x2048 分辨率会导致设备重启
+
+## 其他模型
+
+- mmdet 需要手动把模型拆成两部分。因为
+ - snpe 源码中 `onnx_to_ir.py` 仅能解析输入，`ir_to_dlc.py` 还不支持 topk
+ - UDO （用户自定义算子）无法和 `snpe-onnx-to-dlc` 配合使用
+- mmagic 模型
+ - srcnn 需要 cubic resize，snpe 不支持
+ - esrgan 可正常转换，但加载模型会导致设备重启
+- mmrotate 依赖 [e2cnn](https://pypi.org/project/e2cnn/) ，需要手动安装 [其 Python3.6
+ 兼容分支](https://github.com/QUVA-Lab/e2cnn)
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/benchmark_tvm.md b/internlm_langchain/knowledge_base/MMDeploy/content/benchmark_tvm.md
new file mode 100644
index 00000000..d58c9c9b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/benchmark_tvm.md
@@ -0,0 +1,51 @@
+# TVM 测试
+
+## 支持模型列表
+
+| Model | Codebase | Model config |
+| :---------------- | :------------- | :-------------------------------------------------------------------------------------: |
+| RetinaNet | MMDetection | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/retinanet) |
+| Faster R-CNN | MMDetection | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/faster_rcnn) |
+| YOLOv3 | MMDetection | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/yolo) |
+| YOLOX | MMDetection | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/yolox) |
+| Mask R-CNN | MMDetection | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/mask_rcnn) |
+| SSD | MMDetection | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/ssd) |
+| ResNet | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/resnet) |
+| ResNeXt | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/resnext) |
+| SE-ResNet | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/seresnet) |
+| MobileNetV2 | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/mobilenet_v2) |
+| ShuffleNetV1 | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/shufflenet_v1) |
+| ShuffleNetV2 | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/shufflenet_v2) |
+| VisionTransformer | MMPretrain | [config](https://github.com/open-mmlab/mmpretrain/tree/main/configs/vision_transformer) |
+| FCN | MMSegmentation | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn) |
+| PSPNet | MMSegmentation | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/pspnet) |
+| DeepLabV3 | MMSegmentation | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3) |
+| DeepLabV3+ | MMSegmentation | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus) |
+| UNet | MMSegmentation | [config](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/unet) |
+
+表中仅列出已测试模型，未列出的模型可能同样支持，可以自行尝试转换。
+
+## Test
+
+- Ubuntu 20.04
+- tvm 0.9.0
+
+| mmpretrain | metric | PyTorch | TVM |
+| :-----------------------------------------------------------------------------------------------------------------------: | :----: | :-----: | :---: |
+| [ResNet-18](https://github.com/open-mmlab/mmpretrain/blob/main/configs/resnet/resnet18_8xb32_in1k.py) | top-1 | 69.90 | 69.90 |
+| [ResNeXt-50](https://github.com/open-mmlab/mmpretrain/blob/main/configs/resnext/resnext50-32x4d_8xb32_in1k.py) | top-1 | 77.90 | 77.90 |
+| [ShuffleNet V2](https://github.com/open-mmlab/mmpretrain/blob/main/configs/shufflenet_v2/shufflenet-v2-1x_16xb64_in1k.py) | top-1 | 69.55 | 69.55 |
+| [MobileNet V2](https://github.com/open-mmlab/mmpretrain/tree/main/configs/mobilenet_v2/mobilenet-v2_8xb32_in1k.py) | top-1 | 71.86 | 71.86 |
+
+
+
+| mmdet(\*) | metric | PyTorch | TVM |
+| :-----------------------------------------------------------------------------------: | :----: | :-----: | :--: |
+| [SSD](https://github.com/open-mmlab/mmdetection/tree/main/configs/ssd/ssd300_coco.py) | box AP | 25.5 | 25.5 |
+
+\*: 由于暂时不支持动态转换，因此仅提供 SSD 的精度测试结果。
+
+| mmseg | metric | PyTorch | TVM |
+| :---------------------------------------------------------------------------------------------------------------------------: | :----: | :-----: | :---: |
+| [FCN](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py) | mIoU | 72.25 | 72.36 |
+| [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/pspnet/pspnet_r50-d8_4xb2-80k_cityscapes-512x1024.py) | mIoU | 78.55 | 77.90 |
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/build_from_docker.md b/internlm_langchain/knowledge_base/MMDeploy/content/build_from_docker.md
new file mode 100644
index 00000000..4813dad1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/build_from_docker.md
@@ -0,0 +1,68 @@
+# 使用 Docker 镜像
+
+本文简述如何使用[Docker](https://docs.docker.com/get-docker/)安装mmdeploy
+
+## 获取镜像
+
+为了方便用户，mmdeploy在[Docker Hub](https://hub.docker.com/r/openmmlab/mmdeploy)上提供了多个版本的镜像，例如对于`mmdeploy==1.2.0`，
+其镜像标签为`openmmlab/mmdeploy:ubuntu20.04-cuda11.3-mmdeploy1.2.0`，而最新的镜像标签为`openmmlab/mmdeploy:ubuntu20.04-cuda11.3-mmdeploy`。
+镜像相关规格信息如下表所示：
+
+| Item | Version |
+| :---------: | :---------: |
+| OS | Ubuntu20.04 |
+| CUDA | 11.3 |
+| CUDNN | 8.2 |
+| Python | 3.8.10 |
+| Torch | 1.10.0 |
+| TorchVision | 0.11.0 |
+| TorchScript | 1.10.0 |
+| TensorRT | 8.2.3.0 |
+| ONNXRuntime | 1.8.1 |
+| OpenVINO | 2022.3.0 |
+| ncnn | 20221128 |
+| openppl | 0.8.1 |
+
+用户可选择一个[镜像](https://hub.docker.com/r/openmmlab/mmdeploy/tags)并运行`docker pull`拉取镜像到本地：
+
+```shell
+export TAG=openmmlab/mmdeploy:ubuntu20.04-cuda11.3-mmdeploy
+docker pull $TAG
+```
+
+## 构建镜像(可选)
+
+如果已提供的镜像无法满足要求，用户可修改`docker/Release/Dockerfile`并在本地构建镜像。其中，构建参数`MMDEPLOY_VERSION`可以是[mmdeploy](https://github.com/open-mmlab/mmdeploy)项目的一个[标签](https://github.com/open-mmlab/mmdeploy/tags)或者分支。
+
+```shell
+export MMDEPLOY_VERSION=main
+export TAG=mmdeploy-${MMDEPLOY_VERSION}
+docker build docker/Release/ -t ${TAG} --build-arg MMDEPLOY_VERSION=${MMDEPLOY_VERSION}
+```
+
+## 运行 docker 容器
+
+当拉取或构建 docker 镜像后，用户可使用 `docker run` 启动 docker 服务：
+
+```shell
+export TAG=openmmlab/mmdeploy:ubuntu20.04-cuda11.3-mmdeploy
+docker run --gpus=all -it --rm $TAG
+```
+
+## 常见问答
+
+1. CUDA error: the provided PTX was compiled with an unsupported toolchain:
+
+ 如 [这里](https://forums.developer.nvidia.com/t/cuda-error-the-provided-ptx-was-compiled-with-an-unsupported-toolchain/185754)所说，更新 GPU 的驱动到您的GPU能使用的最新版本。
+
+2. docker: Error response from daemon: could not select device driver "" with capabilities: [gpu].
+
+ ```shell
+ # Add the package repositories
+ distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+ curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+ curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+
+ sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
+ sudo systemctl restart docker
+ ```
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/build_from_script.md b/internlm_langchain/knowledge_base/MMDeploy/content/build_from_script.md
new file mode 100644
index 00000000..3d563649
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/build_from_script.md
@@ -0,0 +1,53 @@
+# 一键式脚本安装
+
+通过用户调研，我们得知多数使用者在了解 mmdeploy 前，已经熟知 python 和 torch 用法。因此我们提供脚本简化 mmdeploy 安装。
+
+假设您已经准备好
+
+- python3 -m pip（必须，conda 或 pyenv 皆可）
+- nvcc（取决于推理后端）
+- torch（非必须，可延后安装）
+
+运行这个脚本来安装 mmdeploy + ncnn backend，`nproc` 可以不指定。
+
+```bash
+$ cd /path/to/mmdeploy
+$ python3 tools/scripts/build_ubuntu_x64_ncnn.py
+..
+```
+
+期间可能需要 sudo 密码，脚本会尽最大努力完成 mmdeploy SDK 和 demo：
+
+- 检测系统版本、make 使用的 job 个数、是否 root 用户，也会自动修复 pip 问题
+- 寻找必须的基础工具，如 g++-7、cmake、wget 等
+- 编译必须的依赖，如 pyncnn、 protobuf
+
+脚本也会尽量避免影响 host 环境：
+
+- 源码编译的依赖，都放在与 mmdeploy 同级的 `mmdeploy-dep` 目录中
+- 不会主动修改 PATH、LD_LIBRARY_PATH、PYTHONPATH 等变量
+- 会打印需要修改的环境变量，**需要注意最终的输出信息**
+
+脚本最终会执行 `python3 tools/check_env.py`，安装成功应显示对应 backend 的版本号和 `ops_is_available: True`，例如：
+
+```bash
+$ python3 tools/check_env.py
+..
+2022-09-13 14:49:13,767 - mmdeploy - INFO - **********Backend information**********
+2022-09-13 14:49:14,116 - mmdeploy - INFO - onnxruntime: 1.8.0 ops_is_avaliable : True
+2022-09-13 14:49:14,131 - mmdeploy - INFO - tensorrt: 8.4.1.5 ops_is_avaliable : True
+2022-09-13 14:49:14,139 - mmdeploy - INFO - ncnn: 1.0.20220901 ops_is_avaliable : True
+2022-09-13 14:49:14,150 - mmdeploy - INFO - pplnn_is_avaliable: True
+..
+```
+
+这是已验证的安装脚本。如果想让 mmdeploy 同时支持多种 backend，每个脚本执行一次即可：
+
+| script | OS version |
+| :-----------------------------: | :-----------------: |
+| build_ubuntu_x64_ncnn.py | 18.04/20.04 |
+| build_ubuntu_x64_ort.py | 18.04/20.04 |
+| build_ubuntu_x64_pplnn.py | 18.04/20.04 |
+| build_ubuntu_x64_torchscript.py | 18.04/20.04 |
+| build_ubuntu_x64_tvm.py | 18.04/20.04 |
+| build_jetson_orin_python38.sh | JetPack5.0 L4T 34.1 |
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/build_from_source.md b/internlm_langchain/knowledge_base/MMDeploy/content/build_from_source.md
new file mode 100644
index 00000000..04c85655
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/build_from_source.md
@@ -0,0 +1,51 @@
+# 源码手动安装
+
+如果网络良好，我们建议使用 [docker](build_from_docker.md) 或 [一键式脚本](build_from_script.md) 方式。
+
+## 下载
+
+```bash
+git clone -b main git@github.com:open-mmlab/mmdeploy.git --recursive
+```
+
+### FAQ
+
+- 如果由于网络等原因导致拉取仓库子模块失败，可以尝试通过如下指令手动再次安装子模块:
+
+ ```bash
+ git clone git@github.com:NVIDIA/cub.git third_party/cub
+ cd third_party/cub
+ git checkout c3cceac115
+
+ # 返回至 third_party 目录, 克隆 pybind11
+ cd ..
+ git clone git@github.com:pybind/pybind11.git pybind11
+ cd pybind11
+ git checkout 70a58c5
+
+ cd ..
+ git clone git@github.com:gabime/spdlog.git spdlog
+ cd spdlog
+ git checkout 9e8e52c048
+ ```
+
+- 如果以 `SSH` 方式 `git clone` 代码失败，您可以尝试使用 `HTTPS` 协议下载代码：
+
+ ```bash
+ git clone -b main https://github.com/open-mmlab/mmdeploy.git MMDeploy
+ cd MMDeploy
+ git submodule update --init --recursive
+ ```
+
+## 编译
+
+根据您的目标平台，点击如下对应的链接，按照说明编译 MMDeploy
+
+- [Linux-x86_64](linux-x86_64.md)
+- [Windows](windows.md)
+- [MacOS](macos-arm64.md)
+- [Android-aarch64](android.md)
+- [NVIDIA Jetson](jetsons.md)
+- [Qcom SNPE](snpe.md)
+- [RISC-V](riscv.md)
+- [Rockchip](rockchip.md)
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/cmake_option.md b/internlm_langchain/knowledge_base/MMDeploy/content/cmake_option.md
new file mode 100644
index 00000000..7c10bb20
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/cmake_option.md
@@ -0,0 +1,129 @@
+# cmake 编译选项说明
+
+| mmaction2 | +Pytorch | +ONNXRuntime | +TensorRT | +PPLNN | +OpenVINO | +||||
|---|---|---|---|---|---|---|---|---|---|
| model | +task | +dataset | +metrics | +fp32 | +fp32 | +fp32 | +fp16 | +fp16 | +fp32 | +
| TSN | +Recognition | +Kinetics-400 | +top-1 | +69.71 | +- | +69.71 | +- | +- | +- | +
| top-5 | +88.75 | +- | +88.75 | +- | +- | +- | +|||
| SlowFast | +Recognition | +Kinetics-400 | +top-1 | +74.45 | +- | +75.62 | +- | +- | +- | +
| top-5 | +91.55 | +- | +92.10 | +- | +- | +- | +|||
| 选项 | +取值范围 | +缺省值 | +说明 | +
|---|---|---|---|
| MMDEPLOY_SHARED_LIBS | +{ON, OFF} | +ON | +动态库的编译开关。设置OFF时，编译静态库 | +
| MMDEPLOY_BUILD_SDK | +{ON, OFF} | +OFF | +MMDeploy SDK 编译开关 | +
| MMDEPLOY_BUILD_SDK_MONOLITHIC | +{ON, OFF} | +OFF | +编译生成单个 lib 文件 | +
| MMDEPLOY_BUILD_TEST | +{ON, OFF} | +OFF | +MMDeploy SDK 的单元测试程序编译开关 | +
| MMDEPLOY_BUILD_SDK_PYTHON_API | +{ON, OFF} | +OFF | +SDK python package的编译开关 | +
| MMDEPLOY_BUILD_SDK_CSHARP_API | +{ON, OFF} | +OFF | +SDK C# package的编译开关 | +
| MMDEPLOY_BUILD_SDK_JAVA_API | +{ON, OFF} | +OFF | +SDK Java package的编译开关 | +
| MMDEPLOY_BUILD_EXAMPLES | +{ON, OFF} | +OFF | +是否编译 demo | +
| MMDEPLOY_SPDLOG_EXTERNAL | +{ON, OFF} | +OFF | +是否使用系统自带的 spdlog 安装包 | +
| MMDEPLOY_ZIP_MODEL | +{ON, OFF} | +OFF | +是否使用 zip 格式的 sdk 目录 | +
| MMDEPLOY_COVERAGE | +{ON, OFF} | +OFF | +额外增加编译选项，以生成代码覆盖率报表 | +
| MMDEPLOY_TARGET_DEVICES | +{"cpu", "cuda"} | +cpu | +设置目标设备。当有多个设备时，设备名称之间使用分号隔开。 比如，-DMMDEPLOY_TARGET_DEVICES="cpu;cuda" | +
| MMDEPLOY_TARGET_BACKENDS | +{"trt", "ort", "pplnn", "ncnn", "openvino", "torchscript", "snpe", "coreml", "tvm"} | +N/A | + 默认情况下，SDK不设置任何后端, 因为它与应用场景高度相关。 当选择多个后端时， 中间使用分号隔开。比如，+ 1. trt: 表示 TensorRT。需要设置 TENSORRT_DIR 和 CUDNN_DIR。
+ONNXRUNTIME_DIR。
+pplnn_DIR。+ 4. ncnn：表示 ncnn。需要设置 ncnn_DIR。 + 5. openvino: 表示 OpenVINO。需要设置 InferenceEngine_DIR。+ 6. torchscript: 表示 TorchScript。需要设置 Torch_DIR。+ 7. snpe: 表示 qcom snpe。需要环境变量设置 SNPE_ROOT。 + 8. coreml: 表示 Core ML。目前在进行模型转换时需要设置 Torch_DIR。 + 9. tvm: 表示 TVM。需要设置 TVM_DIR。+ |
+
| MMDEPLOY_CODEBASES | +{"mmpretrain", "mmdet", "mmseg", "mmagic", "mmocr", "all"} | +all | +用来设置SDK后处理组件，加载 OpenMMLab 算法仓库的后处理功能。如果选择多个 codebase，中间使用分号隔开。比如，-DMMDEPLOY_CODEBASES="mmcls;mmdet"。也可以通过 -DMMDEPLOY_CODEBASES=all 方式，加载所有 codebase。 |
+
| OS-Arch | +Device | +ONNX Runtime | +TensorRT | +
|---|---|---|---|
| Linux-x86_64 | +CPU | +Y | +N/A | +
| CUDA | +Y | +Y | +|
| Windows-x86_64 | +CPU | +Y | +N/A | +
| CUDA | +Y | +Y | +
+
+
+Linux-x86_64
+ +```shell +# 1. 安装 MMDeploy 模型转换工具（含trt/ort自定义算子） +pip install mmdeploy==1.2.0 + +# 2. 安装 MMDeploy SDK推理工具 +# 根据是否需要GPU推理可任选其一进行下载安装 +# 2.1 支持 onnxruntime 推理 +pip install mmdeploy-runtime==1.2.0 +# 2.2 支持 onnxruntime-gpu tensorrt 推理 +pip install mmdeploy-runtime-gpu==1.2.0 + +# 3. 安装推理引擎 +# 3.1 安装推理引擎 TensorRT +# !!! 若要进行 TensorRT 模型的转换以及推理，从 NVIDIA 官网下载 TensorRT-8.2.3.0 CUDA 11.x 安装包并解压到当前目录。 +pip install TensorRT-8.2.3.0/python/tensorrt-8.2.3.0-cp38-none-linux_x86_64.whl +pip install pycuda +export TENSORRT_DIR=$(pwd)/TensorRT-8.2.3.0 +export LD_LIBRARY_PATH=${TENSORRT_DIR}/lib:$LD_LIBRARY_PATH +# !!! 另外还需要从 NVIDIA 官网下载 cuDNN 8.2.1 CUDA 11.x 安装包并解压到当前目录 +export CUDNN_DIR=$(pwd)/cuda +export LD_LIBRARY_PATH=$CUDNN_DIR/lib64:$LD_LIBRARY_PATH + +# 3.2 安装推理引擎 ONNX Runtime +# 根据是否需要GPU推理可任选其一进行下载安装 +# 3.2.1 onnxruntime +wget https://github.com/microsoft/onnxruntime/releases/download/v1.8.1/onnxruntime-linux-x64-1.8.1.tgz +tar -zxvf onnxruntime-linux-x64-1.8.1.tgz +export ONNXRUNTIME_DIR=$(pwd)/onnxruntime-linux-x64-1.8.1 +export LD_LIBRARY_PATH=$ONNXRUNTIME_DIR/lib:$LD_LIBRARY_PATH +# 3.2.2 onnxruntime-gpu +pip install onnxruntime-gpu==1.8.1 +wget https://github.com/microsoft/onnxruntime/releases/download/v1.8.1/onnxruntime-linux-x64-gpu-1.8.1.tgz +tar -zxvf onnxruntime-linux-x64-gpu-1.8.1.tgz +export ONNXRUNTIME_DIR=$(pwd)/onnxruntime-linux-x64-gpu-1.8.1 +export LD_LIBRARY_PATH=$ONNXRUNTIME_DIR/lib:$LD_LIBRARY_PATH +``` + +
+
+
+请阅读 [这里](02-how-to-run/prebuilt_package_windows.md)，了解 MMDeploy 预编译包在 Windows 平台下的使用方法。
+
+## 模型转换
+
+在准备工作就绪后，我们可以使用 MMDeploy 中的工具 `tools/deploy.py`，将 OpenMMLab 的 PyTorch 模型转换成推理后端支持的格式。
+对于`tools/deploy.py` 的使用细节，请参考 [如何转换模型](02-how-to-run/convert_model.md)。
+
+以 [MMDetection](https://github.com/open-mmlab/mmdetection) 中的 `Faster R-CNN` 为例，我们可以使用如下命令，将 PyTorch 模型转换为 TenorRT 模型，从而部署到 NVIDIA GPU 上.
+
+```shell
+# 克隆 mmdeploy 仓库。转换时，需要使用 mmdeploy 仓库中的配置文件，建立转换流水线, `--recursive` 不是必须的
+git clone -b main --recursive https://github.com/open-mmlab/mmdeploy.git
+
+# 安装 mmdetection。转换时，需要使用 mmdetection 仓库中的模型配置文件，构建 PyTorch nn module
+git clone -b 3.x https://github.com/open-mmlab/mmdetection.git
+cd mmdetection
+mim install -v -e .
+cd ..
+
+# 下载 Faster R-CNN 模型权重
+wget -P checkpoints https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
+
+# 执行转换命令，实现端到端的转换
+python mmdeploy/tools/deploy.py \
+ mmdeploy/configs/mmdet/detection/detection_tensorrt_dynamic-320x320-1344x1344.py \
+ mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+ checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
+ mmdetection/demo/demo.jpg \
+ --work-dir mmdeploy_model/faster-rcnn \
+ --device cuda \
+ --dump-info
+```
+
+转换结果被保存在 `--work-dir` 指向的文件夹中。**该文件夹中不仅包含推理后端模型，还包括推理元信息。这些内容的整体被定义为 SDK Model。推理 SDK 将用它进行模型推理。**
+
+```{tip}
+把上述转换命令中的detection_tensorrt_dynamic-320x320-1344x1344.py 换成 detection_onnxruntime_dynamic.py，并修改 --device 为 cpu，
+即可以转出 onnx 模型，并用 ONNXRuntime 进行推理
+```
+
+## 模型推理
+
+在转换完成后，你既可以使用 Model Converter 进行推理，也可以使用 Inference SDK。
+
+### 使用 Model Converter 的推理 API
+
+Model Converter 屏蔽了推理后端接口的差异，对其推理 API 进行了统一封装，接口名称为 `inference_model`。
+
+以上文中 Faster R-CNN 的 TensorRT 模型为例，你可以使用如下方式进行模型推理工作：
+
+```python
+from mmdeploy.apis import inference_model
+result = inference_model(
+ model_cfg='mmdetection/configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py',
+ deploy_cfg='mmdeploy/configs/mmdet/detection/detection_tensorrt_dynamic-320x320-1344x1344.py',
+ backend_files=['mmdeploy_model/faster-rcnn/end2end.engine'],
+ img='mmdetection/demo/demo.jpg',
+ device='cuda:0')
+```
+
+```{note}
+接口中的 model_path 指的是推理引擎文件的路径，比如例子当中end2end.engine文件的路径。路径必须放在 list 中，因为有的推理引擎模型结构和权重是分开存储的。
+```
+
+### 使用推理 SDK
+
+你可以直接运行预编译包中的 demo 程序，输入 SDK Model 和图像，进行推理，并查看推理结果。
+
+```shell
+wget https://github.com/open-mmlab/mmdeploy/releases/download/v1.2.0/mmdeploy-1.2.0-linux-x86_64-cuda11.3.tar.gz
+tar xf mmdeploy-1.2.0-linux-x86_64-cuda11.3
+
+cd mmdeploy-1.2.0-linux-x86_64-cuda11.3
+# 运行 python demo
+python example/python/object_detection.py cuda ../mmdeploy_model/faster-rcnn ../mmdetection/demo/demo.jpg
+# 运行 C/C++ demo
+# 根据文件夹内的 README.md 进行编译
+./bin/object_detection cuda ../mmdeploy_model/faster-rcnn ../mmdetection/demo/demo.jpg
+```
+
+```{note}
+以上述命令中，输入模型是 SDK Model 的路径（也就是 Model Converter 中 --work-dir 参数），而不是推理引擎文件的路径。
+因为 SDK 不仅要获取推理引擎文件，还需要推理元信息（deploy.json, pipeline.json）。它们合在一起，构成 SDK Model，存储在 --work-dir 下
+```
+
+除了 demo 程序，预编译包还提供了 SDK 多语言接口。你可以根据自己的项目需求，选择合适的语言接口，
+把 MMDeploy SDK 集成到自己的项目中，进行二次开发。
+
+#### Python API
+
+对于检测功能，你也可以参考如下代码，集成 MMDeploy SDK Python API 到自己的项目中：
+
+```python
+from mmdeploy_runtime import Detector
+import cv2
+
+# 读取图片
+img = cv2.imread('mmdetection/demo/demo.jpg')
+
+# 创建检测器
+detector = Detector(model_path='mmdeploy_models/faster-rcnn', device_name='cuda', device_id=0)
+# 执行推理
+bboxes, labels, _ = detector(img)
+# 使用阈值过滤推理结果，并绘制到原图中
+indices = [i for i in range(len(bboxes))]
+for index, bbox, label_id in zip(indices, bboxes, labels):
+ [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4]
+ if score < 0.3:
+ continue
+ cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0))
+
+cv2.imwrite('output_detection.png', img)
+```
+
+更多示例，请查阅[这里](https://github.com/open-mmlab/mmdeploy/tree/main/demo/python)。
+
+#### C++ API
+
+使用 C++ API 进行模型推理的流程符合下面的模式：
+
+
+以下是具体过程：
+
+```C++
+#include Windows-x86_64
+| 名称 | +安装说明 | +
|---|---|
| conda | +请参考官方说明安装 conda。 通过 conda 创建并激活 Python 环境。 + |
+
| PyTorch (>=1.8.0) |
+ 安装 PyTorch，要求版本是 torch>=1.8.0。可查看官网获取更多详细的安装教程。请确保 PyTorch 要求的 CUDA 版本和您主机的 CUDA 版本是一致 + |
+
| mmcv | +参考如下命令安装 mmcv。更多安装方式，可查看 mmcv 官网 + |
+
| 名称 | +安装说明 | +
|---|---|
| OpenCV (>=3.0) |
+
+ 在 Ubuntu 18.04 及以上版本
+ |
+
+
| pplcv | +pplcv 是 openPPL 开发的高性能图像处理库。 此依赖项为可选项，只有在 cuda 平台下，才需安装。 + |
+
| 名称 | +安装包 | +安装说明 | +
|---|---|---|
| ONNXRuntime | +onnxruntime (>=1.8.1) |
+
+ 1. 安装 onnxruntime 的 python 包
+ |
+
| TensorRT |
+ TensorRT |
+
+ 1. 登录 NVIDIA 官网，从这里选取并下载 TensorRT tar 包。要保证它和您机器的 CPU 架构以及 CUDA 版本是匹配的。 + 您可以参考这份指南安装 TensorRT。 + 1. 这里也有一份 TensorRT 8.2 GA Update 2 在 Linux x86_64 和 CUDA 11.x 下的安装示例，供您参考。首先，点击此处下载 CUDA 11.x TensorRT 8.2.3.0。然后，根据如下命令，安装并配置 TensorRT 以及相关依赖。 + |
+
| cuDNN | +
+ 1. 从 cuDNN Archive 选择和您环境中 CPU 架构、CUDA 版本以及 TensorRT 版本配套的 cuDNN。以前文 TensorRT 安装说明为例，它需要 cudnn8.2。因此，可以下载 CUDA 11.x cuDNN 8.2 + 2. 解压压缩包，并设置环境变量 + |
+ |
| PPL.NN | +ppl.nn | +
+ 1. 请参考 ppl.nn 的 安装文档 编译 ppl.nn，并安装 pyppl + 2. 将 pplnn 的根目录写入环境变量 + |
+
| OpenVINO | +openvino | +1. 安装 OpenVINO
+ |
+
| ncnn | +ncnn | +1. 请参考 ncnn的 wiki 编译 ncnn。
+编译时，请打开-DNCNN_PYTHON=ON+2. 将 ncnn 的根目录写入环境变量 + |
+
| TorchScript | +libtorch | +
+ 1. Download libtorch from here. Please note that only Pre-cxx11 ABI and version 1.8.1+ on Linux platform are supported by now. For previous versions of libtorch, you can find them in the issue comment. + 2. Take Libtorch1.8.1+cu111 as an example. You can install it like this: + |
+
| Ascend | +CANN | +
+ 1. 按照 官方指引 安装 CANN 工具集. + 2. 配置环境 + |
+
| TVM | +TVM | +
+ 1. 按照 官方指引安装 TVM. + 2. 配置环境 + |
+
+如果您想使上述环境变量永久有效，可以把它们加入
~/.bashrc。以 ONNXRuntime 的环境变量为例，
+
+```bash
+echo '# set env for onnxruntime' >> ~/.bashrc
+echo "export ONNXRUNTIME_DIR=${ONNXRUNTIME_DIR}" >> ~/.bashrc
+echo "export LD_LIBRARY_PATH=$ONNXRUNTIME_DIR/lib:$LD_LIBRARY_PATH" >> ~/.bashrc
+source ~/.bashrc
+```
+
+### 编译 MMDeploy
+
+```bash
+cd /the/root/path/of/MMDeploy
+export MMDEPLOY_DIR=$(pwd)
+```
+
+#### 编译 Model Converter
+
+如果您选择了ONNXRuntime，TensorRT，ncnn 和 torchscript 任一种推理后端，您需要编译对应的自定义算子库。
+
+- **ONNXRuntime** 自定义算子
+
+ ```bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake -DCMAKE_CXX_COMPILER=g++-7 -DMMDEPLOY_TARGET_BACKENDS=ort -DONNXRUNTIME_DIR=${ONNXRUNTIME_DIR} ..
+ make -j$(nproc) && make install
+ ```
+
+- **TensorRT** 自定义算子
+
+ ```bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake -DCMAKE_CXX_COMPILER=g++-7 -DMMDEPLOY_TARGET_BACKENDS=trt -DTENSORRT_DIR=${TENSORRT_DIR} -DCUDNN_DIR=${CUDNN_DIR} ..
+ make -j$(nproc) && make install
+ ```
+
+- **ncnn** 自定义算子
+
+ ```bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake -DCMAKE_CXX_COMPILER=g++-7 -DMMDEPLOY_TARGET_BACKENDS=ncnn -Dncnn_DIR=${NCNN_DIR}/build/install/lib/cmake/ncnn ..
+ make -j$(nproc) && make install
+ ```
+
+- **torchscript** 自定义算子
+
+ ```bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake -DMMDEPLOY_TARGET_BACKENDS=torchscript -DTorch_DIR=${Torch_DIR} ..
+ make -j$(nproc) && make install
+ ```
+
+参考 [cmake 选项说明](cmake_option.md)
+
+#### 安装 Model Converter
+
+```bash
+cd ${MMDEPLOY_DIR}
+mim install -e .
+```
+
+**注意**
+
+- 有些依赖项是可选的。运行 `pip install -e .` 将进行最小化依赖安装。 如果需安装其他可选依赖项，请执行`pip install -r requirements/optional.txt`，
+ 或者 `pip install -e .[optional]`。其中，`[optional]`可以替换为：`all`、`tests`、`build` 或 `optional`。
+- cuda10 建议安装[补丁包](https://developer.nvidia.com/cuda-10.2-download-archive?target_os=Linux&target_arch=x86_64&target_distro=Ubuntu&target_version=1804&target_type=runfilelocal)，否则模型运行可能出现 GEMM 相关错误
+
+#### 编译 SDK 和 Demos
+
+下文展示2个构建SDK的样例，分别用 ONNXRuntime 和 TensorRT 作为推理引擎。您可以参考它们，激活其他的推理引擎。
+
+- cpu + ONNXRuntime
+
+ ```Bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake .. \
+ -DCMAKE_CXX_COMPILER=g++-7 \
+ -DMMDEPLOY_BUILD_SDK=ON \
+ -DMMDEPLOY_BUILD_EXAMPLES=ON \
+ -DMMDEPLOY_BUILD_SDK_PYTHON_API=ON \
+ -DMMDEPLOY_TARGET_DEVICES=cpu \
+ -DMMDEPLOY_TARGET_BACKENDS=ort \
+ -DONNXRUNTIME_DIR=${ONNXRUNTIME_DIR}
+
+ make -j$(nproc) && make install
+ ```
+
+- cuda + TensorRT
+
+ ```Bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake .. \
+ -DCMAKE_CXX_COMPILER=g++-7 \
+ -DMMDEPLOY_BUILD_SDK=ON \
+ -DMMDEPLOY_BUILD_EXAMPLES=ON \
+ -DMMDEPLOY_BUILD_SDK_PYTHON_API=ON \
+ -DMMDEPLOY_TARGET_DEVICES="cuda;cpu" \
+ -DMMDEPLOY_TARGET_BACKENDS=trt \
+ -Dpplcv_DIR=${PPLCV_DIR}/cuda-build/install/lib/cmake/ppl \
+ -DTENSORRT_DIR=${TENSORRT_DIR} \
+ -DCUDNN_DIR=${CUDNN_DIR}
+
+ make -j$(nproc) && make install
+ ```
+
+- pplnn
+
+ ```Bash
+ cd ${MMDEPLOY_DIR}
+ mkdir -p build && cd build
+ cmake .. \
+ -DCMAKE_CXX_COMPILER=g++-7 \
+ -DMMDEPLOY_BUILD_SDK=ON \
+ -DMMDEPLOY_BUILD_EXAMPLES=ON \
+ -DMMDEPLOY_BUILD_SDK_PYTHON_API=ON \
+ -DMMDEPLOY_TARGET_DEVICES="cuda;cpu" \
+ -DMMDEPLOY_TARGET_BACKENDS=pplnn \
+ -Dpplcv_DIR=${PPLCV_DIR}/cuda-build/install/lib/cmake/ppl \
+ -Dpplnn_DIR=${PPLNN_DIR}/pplnn-build/install/lib/cmake/ppl
+
+ make -j$(nproc) && make install
+ ```
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/macos-arm64.md b/internlm_langchain/knowledge_base/MMDeploy/content/macos-arm64.md
new file mode 100644
index 00000000..8aa162db
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/macos-arm64.md
@@ -0,0 +1,177 @@
+# macOS-arm64 下构建方式
+
+- [macOS-arm64 下构建方式](#macos-arm64-下构建方式)
+ - [源码安装](#源码安装)
+ - [安装构建和编译工具链](#安装构建和编译工具链)
+ - [安装依赖包](#安装依赖包)
+ - [安装 MMDeploy Converter 依赖](#安装-mmdeploy-converter-依赖)
+ - [安装 MMDeploy SDK 依赖](#安装-mmdeploy-sdk-依赖)
+ - [安装推理引擎](#安装推理引擎)
+ - [编译 MMDeploy](#编译-mmdeploy)
+ - [编译 Model Converter](#编译-model-converter)
+ - [安装 Model Converter](#安装-model-converter)
+ - [编译 SDK 和 Demos](#编译-sdk-和-demos)
+
+## 源码安装
+
+### 安装构建和编译工具链
+
+- cmake
+
+ ```
+ brew install cmake
+ ```
+
+- clang
+
+ 安装 Xcode 或者通过如下命令安装 Command Line Tools
+
+ ```
+ xcode-select --install
+ ```
+
+### 安装依赖包
+
+#### 安装 MMDeploy Converter 依赖
+
+参考[get_started](../get_started.md)文档，安装conda。
+
+```bash
+# install pytoch & mmcv
+conda install pytorch==1.9.0 torchvision==0.10.0 -c pytorch
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0rc2"
+```
+
+#### 安装 MMDeploy SDK 依赖
+
+如果您只对模型转换感兴趣，那么可以跳过本章节。
+
+| 名称 | +安装说明 | +
|---|---|
| OpenCV (>=3.0) |
+
+ |
+
| 名称 | +安装包 | +安装说明 | +
|---|---|---|
| Core ML | +coremltools | +
+ |
+
| TorchScript | +libtorch | +
+ 1. libtorch暂不提供arm版本的library，故需要自行编译。编译时注意libtorch要和pytorch的版本保持一致，这样编译出的自定义算子才可以加载成功。 + 2. 以libtorch 1.9.0为例，可通过如下命令安装: + |
+
+ 
+
+
+mmdeploy 基于静态图（onnx）生成推理框架所需的量化表，再用后端工具把浮点模型转为定点。
+
+目前 mmdeploy 支持 ncnn PTQ。
+
+## 模型怎么转定点
+
+[mmdeploy 安装](../01-how-to-build/build_from_source.md)完成后，加载 ppq 并安装
+
+```bash
+git clone https://github.com/openppl-public/ppq.git
+cd ppq
+pip install -r requirements.txt
+python3 setup.py install
+```
+
+回到 mmdeploy, 使用 `tools/deploy.py --quant` 选项开启量化。
+
+```bash
+cd /path/to/mmdeploy
+export MODEL_CONFIG=/path/to/mmpretrain/configs/resnet/resnet18_8xb16_cifar10.py
+export MODEL_PATH=https://download.openmmlab.com/mmclassification/v0/resnet/resnet18_b16x8_cifar10_20210528-bd6371c8.pth
+
+# 找一些 imagenet 样例图
+git clone https://github.com/nihui/imagenet-sample-images --depth=1
+
+# 量化模型
+python3 tools/deploy.py configs/mmpretrain/classification_ncnn-int8_static.py ${MODEL_CONFIG} ${MODEL_PATH} /path/to/self-test.png --work-dir work_dir --device cpu --quant --quant-image-dir /path/to/imagenet-sample-images
+...
+```
+
+参数说明
+
+| 参数 | 含义 |
+| :---------------: | :----------------------------------------------: |
+| --quant | 是否开启量化，默认为 False |
+| --quant-image-dir | 校准数据集，默认使用 MODEL_CONFIG 中的**验证集** |
+
+## 自建校准数据集
+
+校准集是用来计算量化层参数的，某些 DFQ（Data Free Quantization）方法甚至不需要校准集
+
+- 新建文件夹，直接放入图片即可（不需要目录结构、不要负例、没有命名要求）
+- 图片需为真实业务场景中的数据，相差过远会导致精度下降
+- 不能直接拿测试集做量化，否则是过拟合
+ | 类型 | 训练集 | 验证集 | 测试集 | 校准集 |
+ | ---- | ------ | ------ | -------- | ------ |
+ | 用法 | QAT | PTQ | 测试精度 | PTQ |
+
+**强烈建议**量化结束后，[按此文档](profile_model.md) 验证模型精度。[这里](../03-benchmark/quantization.md) 是一些量化模型测试结果。
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/quick_start.md b/internlm_langchain/knowledge_base/MMDeploy/content/quick_start.md
new file mode 100644
index 00000000..f19df4cf
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/quick_start.md
@@ -0,0 +1,83 @@
+# 快速开始
+
+大多数 ML 模型除了推理外，需要对输入数据进行一些预处理，并对输出进行一些后处理步骤，以获得结构化输出。 MMDeploy sdk 提供了常见的预处理和后处理步骤。 当您使用 MMDeploy 进行模型转换后，您可以直接使用mmdeploy sdk 进行推理。
+
+## 模型转换
+
+可参考 [convert model](../02-how-to-run/convert_model.md) 获得更多信息.
+
+转模型时通过增加 `--dump-info` 参数得到如下的目录结构(tensorrt)。 如果转换为其他后端，结构会略有不同。其中两个图片为不同后端推理结果
+
+```bash
+├── deploy.json
+├── detail.json
+├── pipeline.json
+├── end2end.onnx
+├── end2end.engine
+├── output_pytorch.jpg
+└── output_tensorrt.jpg
+```
+
+和SDK相关的文件有：
+
+- deploy.json // 模型信息.
+- pipeline.json // pipeline信息，包括前处理、模型以及后处理.
+- end2end.engine // 模型文件
+
+SDK 可以直接读取模型目录，也可以读取相关文件打包成 zip 压缩包。 要读取 zip 文件，sdk 在编译时要设置 `-DMMDEPLOY_ZIP_MODEL=ON`
+
+## SDK 推理
+
+一般来讲，模型推理包含以下三个部分。
+
+- 创建 pipeline
+- 读取数据
+- 模型推理
+
+以下使用 `classifier` 作为例子来展示三个步骤.
+
+### 创建 pipeline
+
+#### 从硬盘中加载模型
+
+```cpp
+
+std::string model_path = "/data/resnet"; // or "/data/resnet.zip" if build with `-DMMDEPLOY_ZIP_MODEL=ON`
+mmdeploy_model_t model;
+mmdeploy_model_create_by_path(model_path, &model);
+
+mmdeploy_classifier_t classifier{};
+mmdeploy_classifier_create(model, "cpu", 0, &classifier);
+```
+
+#### 从内存中加载模型
+
+```cpp
+std::string model_path = "/data/resnet.zip"
+std::ifstream ifs(model_path, std::ios::binary); // /path/to/zipmodel
+ifs.seekg(0, std::ios::end);
+auto size = ifs.tellg();
+ifs.seekg(0, std::ios::beg);
+std::string str(size, '\0'); // binary data, should decrypt if it's encrypted
+ifs.read(str.data(), size);
+
+mmdeploy_model_t model;
+mmdeploy_model_create(str.data(), size, &model);
+
+mmdeploy_classifier_t classifier{};
+mmdeploy_classifier_create(model, "cpu", 0, &classifier);
+```
+
+### 读取数据
+
+```cpp
+cv::Mat img = cv::imread(image_path);
+```
+
+### 模型推理
+
+```cpp
+mmdeploy_classification_t* res{};
+int* res_count{};
+mmdeploy_classifier_apply(classifier, &mat, 1, &res, &res_count);
+```
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/regression_test.md b/internlm_langchain/knowledge_base/MMDeploy/content/regression_test.md
new file mode 100644
index 00000000..cc7150f7
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/regression_test.md
@@ -0,0 +1,285 @@
+# 如何进行回归测试
+
+
+
+这篇教程介绍了如何进行回归测试。部署配置文件由`每个codebase的回归配置文件`，`推理框架配置信息`组成。
+
+
+
+- [如何进行回归测试](#如何进行回归测试)
+ - [1. 环境搭建](#1-环境搭建)
+ - [MMDeploy的安装及配置](#mmdeploy的安装及配置)
+ - [Python环境依赖](#python环境依赖)
+ - [2. 用法](#2-用法)
+ - [参数解析](#参数解析)
+ - [注意事项](#注意事项)
+ - [例子](#例子)
+ - [3. 回归测试配置文件](#3-回归测试配置文件)
+ - [示例及参数解析](#示例及参数解析)
+ - [4. 生成的报告](#4-生成的报告)
+ - [模板](#模板)
+ - [示例](#示例)
+ - [5. 支持的后端](#5-支持的后端)
+ - [6. 支持的Codebase及其Metric](#6-支持的codebase及其metric)
+ - [7. 注意事项](#7-注意事项)
+ - [8. 常见问题](#8-常见问题)
+
+
+
+## 1. 环境搭建
+
+### MMDeploy的安装及配置
+
+本章节的内容，需要提前根据[build 文档](../01-how-to-build/build_from_source.md)将 MMDeploy 安装配置好之后，才能进行。
+
+### Python环境依赖
+
+需要安装 test 的环境
+
+```shell
+pip install -r requirements/tests.txt
+```
+
+如果在使用过程是 numpy 报错，则更新一下 numpy
+
+```shell
+pip install -U numpy
+```
+
+## 2. 用法
+
+```shell
+python ./tools/regression_test.py \
+ --codebase "${CODEBASE_NAME}" \
+ --backends "${BACKEND}" \
+ [--models "${MODELS}"] \
+ --work-dir "${WORK_DIR}" \
+ --device "${DEVICE}" \
+ --log-level INFO \
+ [--performance 或 -p] \
+ [--checkpoint-dir "$CHECKPOINT_DIR"]
+```
+
+### 参数解析
+
+- `--codebase` : 需要测试的 codebase，eg.`mmdet`, 测试多个 `mmpretrain mmdet ...`
+- `--backends` : 筛选测试的后端, 默认测全部`backend`, 也可传入若干个后端，例如 `onnxruntime tesnsorrt`。如果需要一同进行 SDK 的测试，需要在 `tests/regression/${codebase}.yml` 里面的 `sdk_config` 进行配置。
+- `--models` : 指定测试的模型, 默认测试 `yml` 中所有模型, 也可传入若干个模型名称，模型名称可参考相关yml配置文件。例如 `ResNet SE-ResNet "Mask R-CNN"`。注意的是，可传入只有字母和数字组成模型名称，例如 `resnet seresnet maskrcnn`。
+- `--work-dir` : 模型转换、报告生成的路径，默认是`../mmdeploy_regression_working_dir`，注意路径中不要含空格等特殊字符。
+- `--checkpoint-dir`: PyTorch 模型文件下载保存路径，默认是`../mmdeploy_checkpoints`，注意路径中不要含空格等特殊字符。
+- `--device` : 使用的设备，默认 `cuda`。
+- `--log-level` : 设置日记的等级，选项包括`'CRITICAL'， 'FATAL'， 'ERROR'， 'WARN'， 'WARNING'， 'INFO'， 'DEBUG'， 'NOTSET'`。默认是`INFO`。
+- `-p` 或 `--performance` : 是否测试精度，加上则测试转换+精度，不加上则只测试转换
+
+### 注意事项
+
+对于 Windows 用户：
+
+1. 要在 shell 命令中使用 `&&` 连接符，需要下载并使用 `PowerShell 7 Preview 5+`。
+2. 如果您使用 conda env，可能需要在 regression_test.py 中将 `python3` 更改为 `python`，因为 `%USERPROFILE%\AppData\Local\Microsoft\WindowsApps` 目录中有 `python3.exe`。
+
+## 例子
+
+1. 测试 mmdet 和 mmpose 的所有 backend 的 **转换+精度**
+
+```shell
+python ./tools/regression_test.py \
+ --codebase mmdet mmpose \
+ --work-dir "../mmdeploy_regression_working_dir" \
+ --device "cuda" \
+ --log-level INFO \
+ --performance
+```
+
+2. 测试 mmdet 和 mmpose 的某几个 backend 的 **转换+精度**
+
+```shell
+python ./tools/regression_test.py \
+ --codebase mmdet mmpose \
+ --backends onnxruntime tensorrt \
+ --work-dir "../mmdeploy_regression_working_dir" \
+ --device "cuda" \
+ --log-level INFO \
+ -p
+```
+
+3. 测试 mmdet 和 mmpose 的某几个 backend，**只测试转换**
+
+```shell
+python ./tools/regression_test.py \
+ --codebase mmdet mmpose \
+ --backends onnxruntime tensorrt \
+ --work-dir "../mmdeploy_regression_working_dir" \
+ --device "cuda" \
+ --log-level INFO
+```
+
+4. 测试 mmdet 和 mmpretrain 的某几个 models，**只测试转换**
+
+```shell
+python ./tools/regression_test.py \
+ --codebase mmdet mmpose \
+ --models ResNet SE-ResNet "Mask R-CNN" \
+ --work-dir "../mmdeploy_regression_working_dir" \
+ --device "cuda" \
+ --log-level INFO
+```
+
+## 3. 回归测试配置文件
+
+### 示例及参数解析
+
+```yaml
+globals:
+ codebase_dir: ../mmocr # 回归测试的 codebase 路径
+ checkpoint_force_download: False # 回归测试是否重新下载模型即使其已经存在
+ images: # 测试使用图片
+ img_densetext_det: &img_densetext_det ../mmocr/demo/demo_densetext_det.jpg
+ img_demo_text_det: &img_demo_text_det ../mmocr/demo/demo_text_det.jpg
+ img_demo_text_ocr: &img_demo_text_ocr ../mmocr/demo/demo_text_ocr.jpg
+ img_demo_text_recog: &img_demo_text_recog ../mmocr/demo/demo_text_recog.jpg
+ metric_info: &metric_info # 指标参数
+ hmean-iou: # 命名根据 metafile.Results.Metrics
+ eval_name: hmean-iou # 命名根据 test.py --metrics args 入参名称
+ metric_key: 0_hmean-iou:hmean # 命名根据 eval 写入 log 的 key name
+ tolerance: 0.1 # 容忍的阈值区间
+ task_name: Text Detection # 命名根据模型 metafile.Results.Task
+ dataset: ICDAR2015 #命名根据模型 metafile.Results.Dataset
+ word_acc: # 同上
+ eval_name: acc
+ metric_key: 0_word_acc_ignore_case
+ tolerance: 0.2
+ task_name: Text Recognition
+ dataset: IIIT5K
+ convert_image_det: &convert_image_det # det转换会使用到的图片
+ input_img: *img_densetext_det
+ test_img: *img_demo_text_det
+ convert_image_rec: &convert_image_rec
+ input_img: *img_demo_text_recog
+ test_img: *img_demo_text_recog
+ backend_test: &default_backend_test True # 是否对 backend 进行精度测试
+ sdk: # SDK 配置文件
+ sdk_detection_dynamic: &sdk_detection_dynamic configs/mmocr/text-detection/text-detection_sdk_dynamic.py
+ sdk_recognition_dynamic: &sdk_recognition_dynamic configs/mmocr/text-recognition/text-recognition_sdk_dynamic.py
+
+onnxruntime:
+ pipeline_ort_recognition_static_fp32: &pipeline_ort_recognition_static_fp32
+ convert_image: *convert_image_rec # 转换过程中使用的图片
+ backend_test: *default_backend_test # 是否进行后端测试，存在则判断，不存在则视为 False
+ sdk_config: *sdk_recognition_dynamic # 是否进行SDK测试，存在则使用特定的 SDK config 进行测试，不存在则视为不进行 SDK 测试
+ deploy_config: configs/mmocr/text-recognition/text-recognition_onnxruntime_static.py # 使用的 deploy cfg 路径，基于 mmdeploy 的路径
+
+ pipeline_ort_recognition_dynamic_fp32: &pipeline_ort_recognition_dynamic_fp32
+ convert_image: *convert_image_rec
+ backend_test: *default_backend_test
+ sdk_config: *sdk_recognition_dynamic
+ deploy_config: configs/mmocr/text-recognition/text-recognition_onnxruntime_dynamic.py
+
+ pipeline_ort_detection_dynamic_fp32: &pipeline_ort_detection_dynamic_fp32
+ convert_image: *convert_image_det
+ deploy_config: configs/mmocr/text-detection/text-detection_onnxruntime_dynamic.py
+
+tensorrt:
+ pipeline_trt_recognition_dynamic_fp16: &pipeline_trt_recognition_dynamic_fp16
+ convert_image: *convert_image_rec
+ backend_test: *default_backend_test
+ sdk_config: *sdk_recognition_dynamic
+ deploy_config: configs/mmocr/text-recognition/text-recognition_tensorrt-fp16_dynamic-1x32x32-1x32x640.py
+
+ pipeline_trt_detection_dynamic_fp16: &pipeline_trt_detection_dynamic_fp16
+ convert_image: *convert_image_det
+ backend_test: *default_backend_test
+ sdk_config: *sdk_detection_dynamic
+ deploy_config: configs/mmocr/text-detection/text-detection_tensorrt-fp16_dynamic-320x320-2240x2240.py
+
+openvino:
+ # 此处省略，内容同上
+ncnn:
+ # 此处省略，内容同上
+pplnn:
+ # 此处省略，内容同上
+torchscript:
+ # 此处省略，内容同上
+
+
+models:
+ - name: crnn # 模型名称
+ metafile: configs/textrecog/crnn/metafile.yml # 模型对应的 metafile 的路径，相对于 codebase 的路径
+ codebase_model_config_dir: configs/textrecog/crnn # `model_configs` 的父文件夹路径，相对于 codebase 的路径
+ model_configs: # 需要测试的 config 名称
+ - crnn_academic_dataset.py
+ pipelines: # 使用的 pipeline
+ - *pipeline_ort_recognition_dynamic_fp32
+
+ - name: dbnet
+ metafile: configs/textdet/dbnet/metafile.yml
+ codebase_model_config_dir: configs/textdet/dbnet
+ model_configs:
+ - dbnet_r18_fpnc_1200e_icdar2015.py
+ pipelines:
+ - *pipeline_ort_detection_dynamic_fp32
+ - *pipeline_trt_detection_dynamic_fp16
+
+ # 特殊的 pipeline 可以这样加入
+ - convert_image: xxx
+ backend_test: xxx
+ sdk_config: xxx
+ deploy_config: configs/mmocr/text-detection/xxx
+```
+
+## 4. 生成的报告
+
+### 模板
+
+| | Model | Model Config | Task | Checkpoint | Dataset | Backend | Deploy Config | Static or Dynamic | Precision Type | Conversion Result | metric_1 | metric_2 | metric_n | Test Pass |
+| ---- | -------- | ----------------- | ---------------- | -------------- | ---------- | -------- | --------------- | ----------------- | -------------- | ----------------- | ----------- | ----------- | ----------- | ------------ |
+| 序号 | 模型名称 | model config 路径 | 执行的 task name | `.pth`模型路径 | 数据集名称 | 后端名称 | deploy cfg 路径 | 动态 or 静态 | 测试精度 | 模型转换结果 | 指标 1 数值 | 指标 2 数值 | 指标 n 数值 | 后端测试结果 |
+
+### 示例
+
+这是 MMOCR 生成的报告
+
+| | Model | Model Config | Task | Checkpoint | Dataset | Backend | Deploy Config | Static or Dynamic | Precision Type | Conversion Result | hmean-iou | word_acc | Test Pass |
+| --- | ----- | ---------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------ | --------- | --------------- | -------------------------------------------------------------------------------------- | ----------------- | -------------- | ----------------- | --------- | -------- | --------- |
+| 0 | crnn | ../mmocr/configs/textrecog/crnn/crnn_academic_dataset.py | Text Recognition | ../mmdeploy_checkpoints/mmocr/crnn/crnn_academic-a723a1c5.pth | IIIT5K | Pytorch | - | - | - | - | - | 80.5 | - |
+| 1 | crnn | ../mmocr/configs/textrecog/crnn/crnn_academic_dataset.py | Text Recognition | ${WORK_DIR}/mmocr/crnn/onnxruntime/static/crnn_academic-a723a1c5/end2end.onnx | x | onnxruntime | configs/mmocr/text-recognition/text-recognition_onnxruntime_dynamic.py | static | fp32 | True | - | 80.67 | True |
+| 2 | crnn | ../mmocr/configs/textrecog/crnn/crnn_academic_dataset.py | Text Recognition | ${WORK_DIR}/mmocr/crnn/onnxruntime/static/crnn_academic-a723a1c5 | x | SDK-onnxruntime | configs/mmocr/text-recognition/text-recognition_sdk_dynamic.py | static | fp32 | True | - | x | False |
+| 3 | dbnet | ../mmocr/configs/textdet/dbnet/dbnet_r18_fpnc_1200e_icdar2015.py | Text Detection | ../mmdeploy_checkpoints/mmocr/dbnet/dbnet_r18_fpnc_sbn_1200e_icdar2015_20210329-ba3ab597.pth | ICDAR2015 | Pytorch | - | - | - | - | 0.795 | - | - |
+| 4 | dbnet | ../mmocr/configs/textdet/dbnet/dbnet_r18_fpnc_1200e_icdar2015.py | Text Detection | ../mmdeploy_checkpoints/mmocr/dbnet/dbnet_r18_fpnc_sbn_1200e_icdar2015_20210329-ba3ab597.pth | ICDAR | onnxruntime | configs/mmocr/text-detection/text-detection_onnxruntime_dynamic.py | dynamic | fp32 | True | - | - | True |
+| 5 | dbnet | ../mmocr/configs/textdet/dbnet/dbnet_r18_fpnc_1200e_icdar2015.py | Text Detection | ${WORK_DIR}/mmocr/dbnet/tensorrt/dynamic/dbnet_r18_fpnc_sbn_1200e_icdar2015_20210329-ba3ab597/end2end.engine | ICDAR | tensorrt | configs/mmocr/text-detection/text-detection_tensorrt-fp16_dynamic-320x320-2240x2240.py | dynamic | fp16 | True | 0.793302 | - | True |
+| 6 | dbnet | ../mmocr/configs/textdet/dbnet/dbnet_r18_fpnc_1200e_icdar2015.py | Text Detection | ${WORK_DIR}/mmocr/dbnet/tensorrt/dynamic/dbnet_r18_fpnc_sbn_1200e_icdar2015_20210329-ba3ab597 | ICDAR | SDK-tensorrt | configs/mmocr/text-detection/text-detection_sdk_dynamic.py | dynamic | fp16 | True | 0.795073 | - | True |
+
+## 5. 支持的后端
+
+- [x] ONNX Runtime
+- [x] TensorRT
+- [x] PPLNN
+- [x] ncnn
+- [x] OpenVINO
+- [x] TorchScript
+- [x] SNPE
+- [x] MMDeploy SDK
+
+## 6. 支持的Codebase及其Metric
+
+| Codebase | Metric | Support |
+| ---------- | -------- | ------------------ |
+| mmdet | bbox | :heavy_check_mark: |
+| | segm | :heavy_check_mark: |
+| | PQ | :x: |
+| mmpretrain | accuracy | :heavy_check_mark: |
+| mmseg | mIoU | :heavy_check_mark: |
+| mmpose | AR | :heavy_check_mark: |
+| | AP | :heavy_check_mark: |
+| mmocr | hmean | :heavy_check_mark: |
+| | acc | :heavy_check_mark: |
+| mmagic | PSNR | :heavy_check_mark: |
+| | SSIM | :heavy_check_mark: |
+
+## 7. 注意事项
+
+暂无
+
+## 8. 常见问题
+
+暂无
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/riscv.md b/internlm_langchain/knowledge_base/MMDeploy/content/riscv.md
new file mode 100644
index 00000000..b1af8dff
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/riscv.md
@@ -0,0 +1,107 @@
+# 支持 RISC-V
+
+MMDeploy 选择 ncnn 作为 RISC-V 平台下的推理后端。完整的部署过程包含两个步骤：
+
+模型转换：在 Host 端将 PyTorch 模型转为 ncnn 模型。并将转换后的模型传到 device。
+
+模型部署：在 Host 端以交叉编译方式编译 ncnn 和 MMDeploy。传到 Device 端进行推理。
+
+## 1. 模型转换
+
+a) 安装 MMDeploy
+
+可参考 [BUILD 文档](./linux-x86_64.md)，安装 ncnn 推理引擎以及 MMDeploy。
+
+b) 模型转换
+
+以 Resnet-18 为例。先参照[文档](https://github.com/open-mmlab/mmpretrain)安装 mmpretrain，然后使用 `tools/deploy.py` 转换模型。
+
+```bash
+export MODEL_CONFIG=/path/to/mmpretrain/configs/resnet/resnet18_8xb32_in1k.py
+export MODEL_PATH=https://download.openmmlab.com/mmclassification/v0/resnet/resnet18_8xb32_in1k_20210831-fbbb1da6.pth
+
+# 模型转换
+cd /path/to/mmdeploy
+python tools/deploy.py \
+ configs/mmpretrain/classification_ncnn_static.py \
+ $MODEL_CONFIG \
+ $MODEL_PATH \
+ tests/data/tiger.jpeg \
+ --work-dir resnet18 \
+ --device cpu \
+ --dump-info
+```
+
+## 2. 模型部署
+
+a) 下载交叉编译工具链，设置环境变量
+
+```bash
+# 下载 Xuantie-900-gcc-linux-5.10.4-glibc-x86_64-V2.2.6-20220516.tar.gz
+# https://occ.t-head.cn/community/download?id=4046947553902661632
+tar xf Xuantie-900-gcc-linux-5.10.4-glibc-x86_64-V2.2.6-20220516.tar.gz
+export RISCV_ROOT_PATH=`realpath Xuantie-900-gcc-linux-5.10.4-glibc-x86_64-V2.2.6`
+```
+
+b) 编译 ncnn & opencv
+
+```bash
+# ncnn
+# 可参考 https://github.com/Tencent/ncnn/wiki/how-to-build#build-for-allwinner-d1
+
+# opencv
+git clone https://github.com/opencv/opencv.git
+mkdir build_riscv && cd build_riscv
+cmake .. \
+ -DCMAKE_TOOLCHAIN_FILE=/path/to/mmdeploy/cmake/toolchains/riscv64-unknown-linux-gnu.cmake \
+ -DCMAKE_INSTALL_PREFIX=install \
+ -DBUILD_PERF_TESTS=OFF \
+ -DBUILD_SHARED_LIBS=OFF \
+ -DBUILD_TESTS=OFF \
+ -DCMAKE_BUILD_TYPE=Release
+
+make -j$(nproc) && make install
+```
+
+c) 编译 mmdeploy SDK & demo
+
+```bash
+cd /path/to/mmdeploy
+mkdir build_riscv && cd build_riscv
+cmake .. \
+ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/riscv64-unknown-linux-gnu.cmake \
+ -DMMDEPLOY_BUILD_SDK=ON \
+ -DMMDEPLOY_SHARED_LIBS=OFF \
+ -DMMDEPLOY_BUILD_EXAMPLES=ON \
+ -DMMDEPLOY_TARGET_DEVICES="cpu" \
+ -DMMDEPLOY_TARGET_BACKENDS="ncnn" \
+ -Dncnn_DIR=${ncnn_DIR}/build-c906/install/lib/cmake/ncnn/ \
+ -DMMDEPLOY_CODEBASES=all \
+ -DOpenCV_DIR=${OpenCV_DIR}/build_riscv/install/lib/cmake/opencv4
+
+make -j$(nproc) && make install
+```
+
+执行 `make install` 之后, examples的可执行文件会保存在 `install/bin`
+
+```
+tree -L 1 install/bin/
+.
+├── image_classification
+├── image_restorer
+├── image_segmentation
+├── object_detection
+├── ocr
+├── pose_detection
+└── rotated_object_detection
+```
+
+d) 运行 demo
+
+先确认测试模型用了 `--dump-info`，这样 `resnet18` 目录才有 `pipeline.json` 等 SDK 所需文件。
+
+把 dump 好的模型目录(resnet18)、可执行文件(image_classification)、测试图片(tests/data/tiger.jpeg)拷贝到设备中
+
+```bash
+./image_classification cpu ./resnet18 tiger.jpeg
+```
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/rknn.md b/internlm_langchain/knowledge_base/MMDeploy/content/rknn.md
new file mode 100644
index 00000000..159d8718
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/rknn.md
@@ -0,0 +1,9 @@
+# 支持的 RKNN 特征
+
+目前, MMDeploy 只在 rk3588 和 rv1126 的 linux 平台上测试过.
+
+以下特性需要手动在 MMDeploy 自行配置，如[这里](https://github.com/open-mmlab/mmdeploy/tree/main/configs/_base_/backends/rknn.py).
+
+- target_platform ！= default
+- quantization settings
+- optimization level ！= 1
diff --git a/internlm_langchain/knowledge_base/MMDeploy/content/rockchip.md b/internlm_langchain/knowledge_base/MMDeploy/content/rockchip.md
new file mode 100644
index 00000000..b44e10b8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDeploy/content/rockchip.md
@@ -0,0 +1,342 @@
+# 瑞芯微 NPU 部署
+
+- [瑞芯微 NPU 部署](#瑞芯微-npu-部署)
+ - [模型转换](#模型转换)
+ - [安装环境](#安装环境)
+ - [分类模型转换](#分类模型转换)
+ - [检测模型转换](#检测模型转换)
+ - [部署 config 说明](#部署-config-说明)
+ - [问题说明](#问题说明)
+ - [模型推理](#模型推理)
+ - [Host 交叉编译](#host-交叉编译)
+ - [Device 执行推理](#device-执行推理)
+
+______________________________________________________________________
+
+MMDeploy 支持把模型部署到瑞芯微设备上。已支持的芯片：RV1126、RK3588。
+
+完整的部署过程包含两个步骤：
+
+1. 模型转换
+
+ - 在主机上，将 PyTorch 模型转换为 RKNN 模型
+
+2. 模型推理
+
+ - 在主机上， 使用交叉编译工具得到设备所需的 SDK 和 bin
+ - 把转好的模型和编好的 SDK、bin，传到设备，进行推理
+
+## 模型转换
+
+### 安装环境
+
+1. 请参考[快速入门](../get_started.md)，创建 conda 虚拟环境，并安装 PyTorch、mmcv-full
+
+2. 安装 RKNN Toolkit
+
+ 如下表所示，瑞芯微提供了 2 套 RKNN Toolkit，对应于不同的芯片型号
+
+
+| Device | +RKNN-Toolkit | +Installation Guide | +
|---|---|---|
| RK1808 / RK1806 / RV1109 / RV1126 | +git clone https://github.com/rockchip-linux/rknn-toolkit |
+ 安装指南 | +
| RK3566 / RK3568 / RK3588 / RV1103 / RV1106 | +git clone https://github.com/rockchip-linux/rknn-toolkit2 |
+ 安装指南 | +
+2. 把 cmake 路径加入到环境变量 PATH 中, "C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin"
+3. 如果系统中配置了 NVIDIA 显卡，根据[官网教程](https://developer.nvidia.com\/cuda-downloads)，下载并安装 cuda toolkit。
+ +### 安装依赖包 + +#### 安装 MMDeploy Converter 依赖 + +
| 名称 | +安装方法 | +
|---|---|
| conda | +请参考 这里 安装 conda。安装完毕后，打开系统开始菜单，以管理员的身份打开 anaconda powershell prompt。 因为， +1. 下文中的安装命令均是在 anaconda powershell 中测试验证的。 +2. 使用管理员权限，可以把第三方库安装到系统目录。能够简化 MMDeploy 编译命令。 +说明：如果你对 cmake 工作原理很熟悉，也可以使用普通用户权限打开 anaconda powershell prompt。 + |
+
| PyTorch (>=1.8.0) |
+ 安装 PyTorch，要求版本是 torch>=1.8.0。可查看官网获取更多详细的安装教程。请确保 PyTorch 要求的 CUDA 版本和您主机的 CUDA 版本是一致 + |
+
| mmcv | +参考如下命令安装 mmcv。更多安装方式，可查看 mmcv 官网 + |
+
| 名称 | +安装方法 | +
|---|---|
| OpenCV | +
+ 1. 从这里下载 OpenCV 3+。
+ 2. 您可以下载并安装 OpenCV 预编译包到指定的目录下。也可以选择源码编译安装的方式
+ 3. 在安装目录中，找到 OpenCVConfig.cmake，并把它的路径添加到环境变量 PATH 中。像这样：
+ |
+
| pplcv | +pplcv 是 openPPL 开发的高性能图像处理库。 此依赖项为可选项，只有在 cuda 平台下，才需安装。 + |
+
| 推理引擎 | +依赖包 | +安装方法 | +
|---|---|---|
| ONNXRuntime | +onnxruntime (>=1.8.1) |
+
+ 1. 安装 onnxruntime 的 python 包
+ |
+
| TensorRT |
+ TensorRT |
+
+ 1. 登录 NVIDIA 官网，从这里选取并下载 TensorRT tar 包。要保证它和您机器的 CPU 架构以及 CUDA 版本是匹配的。您可以参考这份 指南 安装 TensorRT。 + 2. 这里也有一份 TensorRT 8.2 GA Update 2 在 Windows x86_64 和 CUDA 11.x 下的安装示例，供您参考。首先，点击此处下载 CUDA 11.x TensorRT 8.2.3.0。然后，根据如下命令，安装并配置 TensorRT 以及相关依赖。 + |
+
| cudnn | +
+ 1. 从 cuDNN Archive 中选择和您环境中 CPU 架构、CUDA 版本以及 TensorRT 版本配套的 cuDNN。以前文 TensorRT 安装说明为例，它需要 cudnn8.2。因此，可以下载 CUDA 11.x cuDNN 8.2 + 2. 解压压缩包，并设置环境变量 + |
+ |
| PPL.NN | +ppl.nn | +TODO | +
| OpenVINO | +openvino | +TODO | +
| ncnn | +ncnn | +TODO | +
| 在 v2.25.0 之前 | +v2.25.0 及之后 | +
| + +``` +'mask2former_xxx_coco.py' 代表全景分割的配置文件 +``` + + | ++ +``` +'mask2former_xxx_coco.py' 代表实例分割的配置文件 +'mask2former_xxx_coco-panoptic.py' 代表全景分割的配置文件 +``` + + |
|---|
| 原配置 | ++ +```python +# 图像归一化参数 +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True) +pipeline=[ + ..., + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), # 图像 padding 到 32 的倍数 + ... +] +``` + + | +
| 新配置 | ++ +```python +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + # 图像归一化参数 + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + # 图像 padding 参数 + pad_mask=True, # 在实例分割中，需要将 mask 也进行 padding + pad_size_divisor=32) # 图像 padding 到 32 的倍数 +) +``` + + | +
| 原配置 | ++ +```python +data = dict( + samples_per_gpu=2, + workers_per_gpu=2, + train=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_train2017.json', + img_prefix=data_root + 'train2017/', + pipeline=train_pipeline), + val=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'val2017/', + pipeline=test_pipeline), + test=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'val2017/', + pipeline=test_pipeline)) +``` + + | +
| 新配置 | ++ +```python +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, # 避免每次迭代后 dataloader 重新创建子进程 + sampler=dict(type='DefaultSampler', shuffle=True), # 默认的 sampler，同时支持分布式训练和非分布式训练 + batch_sampler=dict(type='AspectRatioBatchSampler'), # 默认的 batch_sampler，用于保证 batch 中的图片具有相似的长宽比，从而可以更好地利用显存 + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline)) +# 在 3.x 版本中可以独立配置验证和测试的 dataloader +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader # 测试 dataloader 的配置与验证 dataloader 的配置相同，这里省略 +``` + + | +
| 原配置 | ++ +```python +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', img_scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +``` + + | +
| 新配置 | ++ +```python +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +``` + + | +
| 原配置 | ++ +```python +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(1333, 800), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=True), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +``` + + | +
| 新配置 | ++ +```python +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +``` + + | +
| 名称 | +原配置 | +新配置 | +
|---|---|---|
| Resize | ++ +```python +dict(type='Resize', + img_scale=(1333, 800), + keep_ratio=True) +``` + + | + ++ +```python +dict(type='Resize', + scale=(1333, 800), + keep_ratio=True) +``` + + | +
| RandomResize | ++ +```python +dict( + type='Resize', + img_scale=[ + (1333, 640), (1333, 800)], + multiscale_mode='range', + keep_ratio=True) +``` + + | ++ +```python +dict( + type='RandomResize', + scale=[ + (1333, 640), (1333, 800)], + keep_ratio=True) +``` + + | +
| RandomChoiceResize | ++ +```python +dict( + type='Resize', + img_scale=[ + (1333, 640), (1333, 672), + (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + multiscale_mode='value', + keep_ratio=True) +``` + + | ++ +```python +dict( + type='RandomChoiceResize', + scales=[ + (1333, 640), (1333, 672), + (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True) +``` + + | +
| RandomFlip | ++ +```python +dict(type='RandomFlip', + flip_ratio=0.5) +``` + + | ++ +```python +dict(type='RandomFlip', + prob=0.5) +``` + + | +
| 评测指标名称 | +原配置 | +新配置 | +
|---|---|---|
| COCO | ++ +```python +data = dict( + val=dict( + type='CocoDataset', + ann_file=data_root + 'annotations/instances_val2017.json')) +evaluation = dict(metric=['bbox', 'segm']) +``` + + | + ++ +```python +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False) +``` + + | +
| Pascal VOC | ++ +```python +data = dict( + val=dict( + type=dataset_type, + ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt')) +evaluation = dict(metric='mAP') +``` + + | ++ +```python +val_evaluator = dict( + type='VOCMetric', + metric='mAP', + eval_mode='11points') +``` + + | +
| OpenImages | ++ +```python +data = dict( + val=dict( + type='OpenImagesDataset', + ann_file=data_root + 'annotations/validation-annotations-bbox.csv', + img_prefix=data_root + 'OpenImages/validation/', + label_file=data_root + 'annotations/class-descriptions-boxable.csv', + hierarchy_file=data_root + + 'annotations/bbox_labels_600_hierarchy.json', + meta_file=data_root + 'annotations/validation-image-metas.pkl', + image_level_ann_file=data_root + + 'annotations/validation-annotations-human-imagelabels-boxable.csv')) +evaluation = dict(interval=1, metric='mAP') +``` + + | ++ +```python +val_evaluator = dict( + type='OpenImagesMetric', + iou_thrs=0.5, + ioa_thrs=0.5, + use_group_of=True, + get_supercategory=True) +``` + + | +
| CityScapes | ++ +```python +data = dict( + val=dict( + type='CityScapesDataset', + ann_file=data_root + + 'annotations/instancesonly_filtered_gtFine_val.json', + img_prefix=data_root + 'leftImg8bit/val/', + pipeline=test_pipeline)) +evaluation = dict(metric=['bbox', 'segm']) +``` + + | ++ +```python +val_evaluator = [ + dict( + type='CocoMetric', + ann_file=data_root + + 'annotations/instancesonly_filtered_gtFine_val.json', + metric=['bbox', 'segm']), + dict( + type='CityScapesMetric', + ann_file=data_root + + 'annotations/instancesonly_filtered_gtFine_val.json', + seg_prefix=data_root + '/gtFine/val', + outfile_prefix='./work_dirs/cityscapes_metric/instance') +] +``` + + | +
| 原配置 | ++ +```python +runner = dict( + type='EpochBasedRunner', # 训练循环的类型 + max_epochs=12) # 最大训练轮次 +evaluation = dict(interval=2) # 验证间隔。每 2 个 epoch 验证一次 +``` + + | +
| 新配置 | ++ +```python +train_cfg = dict( + type='EpochBasedTrainLoop', # 训练循环的类型，请参考 https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py + max_epochs=12, # 最大训练轮次 + val_interval=2) # 验证间隔。每 2 个 epoch 验证一次 +val_cfg = dict(type='ValLoop') # 验证循环的类型 +test_cfg = dict(type='TestLoop') # 测试循环的类型 +``` + + | +
| 原配置 | ++ +```python +optimizer = dict( + type='SGD', # 随机梯度下降优化器 + lr=0.02, # 基础学习率 + momentum=0.9, # 带动量的随机梯度下降 + weight_decay=0.0001) # 权重衰减 +optimizer_config = dict(grad_clip=None) # 梯度裁剪的配置，设置为 None 关闭梯度裁剪 +``` + + | +
| 新配置 | ++ +```python +optim_wrapper = dict( # 优化器封装的配置 + type='OptimWrapper', # 优化器封装的类型。可以切换至 AmpOptimWrapper 来启用混合精度训练 + optimizer=dict( # 优化器配置。支持 PyTorch 的各种优化器。请参考 https://pytorch.org/docs/stable/optim.html#algorithms + type='SGD', # 随机梯度下降优化器 + lr=0.02, # 基础学习率 + momentum=0.9, # 带动量的随机梯度下降 + weight_decay=0.0001), # 权重衰减 + clip_grad=None, # 梯度裁剪的配置，设置为 None 关闭梯度裁剪。使用方法请见 https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html + ) +``` + + | +
| 原配置 | ++ +```python +lr_config = dict( + policy='step', # 在训练过程中使用 multi step 学习率策略 + warmup='linear', # 使用线性学习率预热 + warmup_iters=500, # 到第 500 个 iteration 结束预热 + warmup_ratio=0.001, # 学习率预热的系数 + step=[8, 11], # 在哪几个 epoch 进行学习率衰减 + gamma=0.1) # 学习率衰减系数 +``` + + | +
| 新配置 | ++ +```python +param_scheduler = [ + dict( + type='LinearLR', # 使用线性学习率预热 + start_factor=0.001, # 学习率预热的系数 + by_epoch=False, # 按 iteration 更新预热学习率 + begin=0, # 从第一个 iteration 开始 + end=500), # 到第 500 个 iteration 结束 + dict( + type='MultiStepLR', # 在训练过程中使用 multi step 学习率策略 + by_epoch=True, # 按 epoch 更新学习率 + begin=0, # 从第一个 epoch 开始 + end=12, # 到第 12 个 epoch 结束 + milestones=[8, 11], # 在哪几个 epoch 进行学习率衰减 + gamma=0.1) # 学习率衰减系数 +] +``` + + | +
| 功能 | +原配置 | +新配置 | +
|---|---|---|
| 设置保存间隔 | ++ +```python +checkpoint_config = dict( + interval=1) +``` + + | + ++ +```python +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=1)) +``` + + | +
| 保存最佳模型 | ++ +```python +evaluation = dict( + save_best='auto') +``` + + | ++ +```python +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + save_best='auto')) +``` + + | +
| 只保留最新的几个模型 | ++ +```python +checkpoint_config = dict( + max_keep_ckpts=3) +``` + + | ++ +```python +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + max_keep_ckpts=3)) +``` + + | +
| 功能 | +原配置 | +新配置 | +
|---|---|---|
| 设置日志打印间隔 | ++ +```python +log_config = dict( + interval=50) +``` + + | + ++ +```python +default_hooks = dict( + logger=dict( + type='LoggerHook', + interval=50)) +# 可选： 配置日志打印数值的平滑窗口大小 +log_processor = dict( + type='LogProcessor', + window_size=50) +``` + + | +
| 使用 TensorBoard 或 WandB 可视化日志 | ++ +```python +log_config = dict( + interval=50, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook'), + dict(type='MMDetWandbHook', + init_kwargs={ + 'project': 'mmdetection', + 'group': 'maskrcnn-r50-fpn-1x-coco' + }, + interval=50, + log_checkpoint=True, + log_checkpoint_metadata=True, + num_eval_images=100) + ]) +``` + + | ++ +```python +vis_backends = [ + dict(type='LocalVisBackend'), + dict(type='TensorboardVisBackend'), + dict(type='WandbVisBackend', + init_kwargs={ + 'project': 'mmdetection', + 'group': 'maskrcnn-r50-fpn-1x-coco' + }) +] +visualizer = dict( + type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer') +``` + + | +
| 原配置 | +新配置 | +
|---|---|
| + +```python +cudnn_benchmark = False +opencv_num_threads = 0 +mp_start_method = 'fork' +dist_params = dict(backend='nccl') +log_level = 'INFO' +load_from = None +resume_from = None + + +``` + + | ++ +```python +env_cfg = dict( + cudnn_benchmark=False, + mp_cfg=dict(mp_start_method='fork', + opencv_num_threads=0), + dist_cfg=dict(backend='nccl')) +log_level = 'INFO' +load_from = None +resume = False +``` + + | +
+
+
+
+如果想进行多种类型的识别，需要使用 `xx . xx .` 的格式在 `--texts` 字段后声明目标类型:
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts 'bench . car .'
+```
+
+结果如下图所示：
+
+
+
+
+
+
+推理脚本还支持输入一个句子作为 `--texts` 字段的输入：
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts 'There are a lot of cars here.'
+```
+
+结果可以参考下图：
+
+
+
+
+
+
+### 验证演示
+
+MMDetection 支持后的 GLIP 算法对比官方版本没有精度上的损失， benchmark 如下所示：
+
+| Model | official mAP | mmdet mAP |
+| ----------------------- | :----------: | :-------: |
+| glip_A_Swin_T_O365.yaml | 42.9 | 43.0 |
+| glip_Swin_T_O365.yaml | 44.9 | 44.9 |
+| glip_Swin_L.yaml | 51.4 | 51.3 |
+
+用户可以使用 `test.py` 脚本对模型精度进行验证，使用如下所示：
+
+```shell
+# 1 gpu
+python tools/test.py configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365.py glip_tiny_a_mmdet-b3654169.pth
+
+# 8 GPU
+./tools/dist_test.sh configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365.py glip_tiny_a_mmdet-b3654169.pth 8
+```
+
+验证结果大致如下：
+
+```shell
+Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.428
+Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.594
+Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.466
+Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.300
+Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.477
+Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.534
+Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.634
+Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.634
+Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.634
+Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.473
+Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.690
+Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.789
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/init_cfg.md b/internlm_langchain/knowledge_base/MMDetection/content/init_cfg.md
new file mode 100644
index 00000000..b58b19d5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/init_cfg.md
@@ -0,0 +1,161 @@
+# 权重初始化
+
+在训练过程中，适当的初始化策略有利于加快训练速度或获得更⾼的性能。 [MMCV](https://github.com/open-mmlab/mmcv/blob/master/mmcv/cnn/utils/weight_init.py) 提供了一些常⽤的初始化模块的⽅法，如 `nn.Conv2d`。 MMdetection 中的模型初始化主要使⽤ `init_cfg`。⽤⼾可以通过以下两个步骤来初始化模型：
+
+1. 在 `model_cfg` 中为模型或其组件定义 `init_cfg`，但⼦组件的 `init_cfg` 优先级更⾼，会覆盖⽗模块的 `init_cfg` 。
+2. 像往常一样构建模型，然后显式调⽤ `model.init_weights()` ⽅法，此时模型参数将会被按照配置文件写法进行初始化。
+
+MMdetection 初始化工作流的高层 API 调用流程是：
+
+model_cfg(init_cfg) -> build_from_cfg -> model -> init_weight() -> initialize(self, self.init_cfg) -> children's init_weight()
+
+### 描述
+
+它的数据类型是 dict 或者 list\[dict\]，包含了下列键值:
+
+- `type` (str)，包含 `INTIALIZERS` 中的初始化器名称，后面跟着初始化器的参数。
+- `layer`（str 或 list\[str\]），包含 Pytorch 或 MMCV 中基本层的名称，以及将被初始化的可学习参数，例如 `'Conv2d'`，`'DeformConv2d'`。
+- `override` (dict 或 list\[dict\])，包含不继承⾃ `BaseModule` 且其初始化配置与 `layer` 键中的其他层不同的⼦模块。 `type` 中定义的初始化器将适⽤于 `layer` 中定义的所有层，因此如果⼦模块不是 `BaseModule` 的派⽣类但可以与 `layer` 中的层相同的⽅式初始化，则不需要使⽤ `override`。`override` 包含了：
+ - `type` 后跟初始化器的参数；
+ - `name` 用以指⽰将被初始化的⼦模块。
+
+### 初始化参数
+
+从 `mmcv.runner.BaseModule` 或 `mmdet.models` 继承一个新模型。这里我们用 FooModel 来举个例子。
+
+```python
+import torch.nn as nn
+from mmcv.runner import BaseModule
+
+class FooModel(BaseModule)
+ def __init__(self,
+ arg1,
+ arg2,
+ init_cfg=None):
+ super(FooModel, self).__init__(init_cfg)
+ ...
+```
+
+- 直接在代码中使⽤ `init_cfg` 初始化模型
+
+ ```python
+ import torch.nn as nn
+ from mmcv.runner import BaseModule
+ # or directly inherit mmdet models
+
+ class FooModel(BaseModule)
+ def __init__(self,
+ arg1,
+ arg2,
+ init_cfg=XXX):
+ super(FooModel, self).__init__(init_cfg)
+ ...
+ ```
+
+- 在 `mmcv.Sequential` 或 `mmcv.ModuleList` 代码中直接使⽤ `init_cfg` 初始化模型
+
+ ```python
+ from mmcv.runner import BaseModule, ModuleList
+
+ class FooModel(BaseModule)
+ def __init__(self,
+ arg1,
+ arg2,
+ init_cfg=None):
+ super(FooModel, self).__init__(init_cfg)
+ ...
+ self.conv1 = ModuleList(init_cfg=XXX)
+ ```
+
+- 使⽤配置⽂件中的 `init_cfg` 初始化模型
+
+ ```python
+ model = dict(
+ ...
+ model = dict(
+ type='FooModel',
+ arg1=XXX,
+ arg2=XXX,
+ init_cfg=XXX),
+ ...
+ ```
+
+### init_cfg 的使用
+
+1. 用 `layer` 键初始化模型
+
+ 如果我们只定义了 `layer`, 它只会在 `layer` 键中初始化网络层。
+
+ 注意： `layer` 键对应的值是 Pytorch 的带有 weights 和 bias 属性的类名（因此不⽀持 `MultiheadAttention` 层）。
+
+- 定义⽤于初始化具有相同配置的模块的 `layer` 键。
+
+ ```python
+ init_cfg = dict(type='Constant', layer=['Conv1d', 'Conv2d', 'Linear'], val=1)
+ # ⽤相同的配置初始化整个模块
+ ```
+
+- 定义⽤于初始化具有不同配置的层的 `layer` 键。
+
+ ```python
+ init_cfg = [dict(type='Constant', layer='Conv1d', val=1),
+ dict(type='Constant', layer='Conv2d', val=2),
+ dict(type='Constant', layer='Linear', val=3)]
+ # nn.Conv1d 将被初始化为 dict(type='Constant', val=1)
+ # nn.Conv2d 将被初始化为 dict(type='Constant', val=2)
+ # nn.Linear 将被初始化为 dict(type='Constant', val=3)
+ ```
+
+2. 使⽤ `override` 键初始化模型
+
+- 当使⽤属性名初始化某些特定部分时，我们可以使⽤ `override` 键， `override` 中的值将忽略 init_cfg 中的值。
+
+ ```python
+ # layers：
+ # self.feat = nn.Conv1d(3, 1, 3)
+ # self.reg = nn.Conv2d(3, 3, 3)
+ # self.cls = nn.Linear(1,2)
+
+ init_cfg = dict(type='Constant',
+ layer=['Conv1d','Conv2d'], val=1, bias=2,
+ override=dict(type='Constant', name='reg', val=3, bias=4))
+ # self.feat and self.cls 将被初始化为 dict(type='Constant', val=1, bias=2)
+ # 叫 'reg' 的模块将被初始化为 dict(type='Constant', val=3, bias=4)
+ ```
+
+- 如果 init_cfg 中的 `layer` 为 None，则只会初始化 override 中有 name 的⼦模块，⽽ override 中的 type 和其他参数可以省略。
+
+ ```python
+ # layers：
+ # self.feat = nn.Conv1d(3, 1, 3)
+ # self.reg = nn.Conv2d(3, 3, 3)
+ # self.cls = nn.Linear(1,2)
+
+ init_cfg = dict(type='Constant', val=1, bias=2, override=dict(name='reg'))
+
+ # self.feat and self.cls 将被 Pytorch 初始化
+ # 叫 'reg' 的模块将被 dict(type='Constant', val=1, bias=2) 初始化
+ ```
+
+- 如果我们不定义 `layer` 或 `override` 键，它不会初始化任何东西。
+
+- 无效的使用
+
+ ```python
+ # override 没有 name 键的话是无效的
+ init_cfg = dict(type='Constant', layer=['Conv1d','Conv2d'], val=1, bias=2,
+ override=dict(type='Constant', val=3, bias=4))
+
+ # override 有 name 键和其他参数但是没有 type 键也是无效的
+ init_cfg = dict(type='Constant', layer=['Conv1d','Conv2d'], val=1, bias=2,
+ override=dict(name='reg', val=3, bias=4))
+ ```
+
+3. 使⽤预训练模型初始化模型
+
+ ```python
+ init_cfg = dict(type='Pretrained',
+ checkpoint='torchvision://resnet50')
+ ```
+
+更多细节可以参考 [MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/initialize.html) 的文档
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/label_studio.md b/internlm_langchain/knowledge_base/MMDetection/content/label_studio.md
new file mode 100644
index 00000000..202122f6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/label_studio.md
@@ -0,0 +1,255 @@
+# 使用 MMDetection 和 Label-Studio 进行半自动化目标检测标注
+
+标注数据是一个费时费力的任务，本文介绍了如何使用 MMDetection 中的 RTMDet 算法联合 Label-Studio 软件进行半自动化标注。具体来说，使用 RTMDet 预测图片生成标注，然后使用 Label-Studio 进行微调标注，社区用户可以参考此流程和方法，将其应用到其他领域。
+
+- RTMDet：RTMDet 是 OpenMMLab 自研的高精度单阶段的目标检测算法，开源于 MMDetection 目标检测工具箱中，其开源协议为 Apache 2.0，工业界的用户可以不受限的免费使用。
+- [Label Studio](https://github.com/heartexlabs/label-studio) 是一款优秀的标注软件，覆盖图像分类、目标检测、分割等领域数据集标注的功能。
+
+本文将使用[喵喵数据集](https://download.openmmlab.com/mmyolo/data/cat_dataset.zip)的图片，进行半自动化标注。
+
+## 环境配置
+
+首先需要创建一个虚拟环境，然后安装 PyTorch 和 MMCV。在本文中，我们将指定 PyTorch 和 MMCV 的版本。接下来安装 MMDetection、Label-Studio 和 label-studio-ml-backend，具体步骤如下：
+
+创建虚拟环境：
+
+```shell
+conda create -n rtmdet python=3.9 -y
+conda activate rtmdet
+```
+
+安装 PyTorch
+
+```shell
+# Linux and Windows CPU only
+pip install torch==1.10.1+cpu torchvision==0.11.2+cpu torchaudio==0.10.1 -f https://download.pytorch.org/whl/cpu/torch_stable.html
+# Linux and Windows CUDA 11.3
+pip install torch==1.10.1+cu113 torchvision==0.11.2+cu113 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu113/torch_stable.html
+# OSX
+pip install torch==1.10.1 torchvision==0.11.2 torchaudio==0.10.1
+```
+
+安装 MMCV
+
+```shell
+pip install -U openmim
+mim install "mmcv>=2.0.0"
+# 安装 mmcv 的过程中会自动安装 mmengine
+```
+
+安装 MMDetection
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection
+cd mmdetection
+pip install -v -e .
+```
+
+安装 Label-Studio 和 label-studio-ml-backend
+
+```shell
+# 安装 label-studio 需要一段时间,如果找不到版本请使用官方源
+pip install label-studio==1.7.2
+pip install label-studio-ml==1.0.9
+```
+
+下载rtmdet权重
+
+```shell
+cd path/to/mmetection
+mkdir work_dirs
+cd work_dirs
+wget https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth
+```
+
+## 启动服务
+
+启动 RTMDet 后端推理服务：
+
+```shell
+cd path/to/mmetection
+
+label-studio-ml start projects/LabelStudio/backend_template --with \
+config_file=configs/rtmdet/rtmdet_m_8xb32-300e_coco.py \
+checkpoint_file=./work_dirs/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth \
+device=cpu \
+--port 8003
+# device=cpu 为使用 CPU 推理，如果使用 GPU 推理，将 cpu 替换为 cuda:0
+```
+
+
+
+此时，RTMDet 后端推理服务已经启动，后续在 Label-Studio Web 系统中配置 http://localhost:8003 后端推理服务即可。
+
+现在启动 Label-Studio 网页服务：
+
+```shell
+label-studio start
+```
+
+
+
+打开浏览器访问 [http://localhost:8080/](http://localhost:8080/) 即可看到 Label-Studio 的界面。
+
+
+
+我们注册一个用户，然后创建一个 RTMDet-Semiautomatic-Label 项目。
+
+
+
+我们通过下面的方式下载好示例的喵喵图片，点击 Data Import 导入需要标注的猫图片。
+
+```shell
+cd path/to/mmetection
+mkdir data && cd data
+
+wget https://download.openmmlab.com/mmyolo/data/cat_dataset.zip && unzip cat_dataset.zip
+```
+
+
+
+
+
+然后选择 Object Detection With Bounding Boxes 模板
+
+
+
+```shell
+airplane
+apple
+backpack
+banana
+baseball_bat
+baseball_glove
+bear
+bed
+bench
+bicycle
+bird
+boat
+book
+bottle
+bowl
+broccoli
+bus
+cake
+car
+carrot
+cat
+cell_phone
+chair
+clock
+couch
+cow
+cup
+dining_table
+dog
+donut
+elephant
+fire_hydrant
+fork
+frisbee
+giraffe
+hair_drier
+handbag
+horse
+hot_dog
+keyboard
+kite
+knife
+laptop
+microwave
+motorcycle
+mouse
+orange
+oven
+parking_meter
+person
+pizza
+potted_plant
+refrigerator
+remote
+sandwich
+scissors
+sheep
+sink
+skateboard
+skis
+snowboard
+spoon
+sports_ball
+stop_sign
+suitcase
+surfboard
+teddy_bear
+tennis_racket
+tie
+toaster
+toilet
+toothbrush
+traffic_light
+train
+truck
+tv
+umbrella
+vase
+wine_glass
+zebra
+```
+
+然后将上述类别复制添加到 Label-Studio，然后点击 Save。
+
+
+
+然后在设置中点击 Add Model 添加 RTMDet 后端推理服务。
+
+
+
+点击 Validate and Save，然后点击 Start Labeling。
+
+
+
+看到如下 Connected 就说明后端推理服务添加成功。
+
+
+
+## 开始半自动化标注
+
+点击 Label 开始标注
+
+
+
+我们可以看到 RTMDet 后端推理服务已经成功返回了预测结果并显示在图片上，我们可以发现这个喵喵预测的框有点大。
+
+
+
+我们手工拖动框，修正一下框的位置，得到以下修正过后的标注，然后点击 Submit，本张图片就标注完毕了。
+
+
+
+我们 submit 完毕所有图片后，点击 exprot 导出 COCO 格式的数据集，就能把标注好的数据集的压缩包导出来了。
+
+
+
+用 vscode 打开解压后的文件夹，可以看到标注好的数据集，包含了图片和 json 格式的标注文件。
+
+
+
+到此半自动化标注就完成了，我们可以用这个数据集在 MMDetection 训练精度更高的模型了，训练出更好的模型，然后再用这个模型继续半自动化标注新采集的图片，这样就可以不断迭代，扩充高质量数据集，提高模型的精度。
+
+## 使用 MMYOLO 作为后端推理服务
+
+如果想在 MMYOLO 中使用 Label-Studio，可以参考在启动后端推理服务时，将 config_file 和 checkpoint_file 替换为 MMYOLO 的配置文件和权重文件即可。
+
+```shell
+cd path/to/mmetection
+
+label-studio-ml start projects/LabelStudio/backend_template --with \
+config_file= path/to/mmyolo_config.py \
+checkpoint_file= path/to/mmyolo_weights.pth \
+device=cpu \
+--port 8003
+# device=cpu 为使用 CPU 推理，如果使用 GPU 推理，将 cpu 替换为 cuda:0
+```
+
+旋转目标检测和实例分割还在支持中，敬请期待。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/migration.md b/internlm_langchain/knowledge_base/MMDetection/content/migration.md
new file mode 100644
index 00000000..d706856f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/migration.md
@@ -0,0 +1,12 @@
+# 从 MMDetection 2.x 迁移至 3.x
+
+MMDetection 3.x 版本是一个重大更新，包含了许多 API 和配置文件的变化。本文档旨在帮助用户从 MMDetection 2.x 版本迁移到 3.x 版本。
+我们将迁移指南分为以下几个部分：
+
+- [配置文件迁移](./config_migration.md)
+- [API 和 Registry 迁移](./api_and_registry_migration.md)
+- [数据集迁移](./dataset_migration.md)
+- [模型迁移](./model_migration.md)
+- [常见问题](./migration_faq.md)
+
+如果您在迁移过程中遇到任何问题，欢迎在 issue 中提出。我们也欢迎您为本文档做出贡献。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/migration_faq.md b/internlm_langchain/knowledge_base/MMDetection/content/migration_faq.md
new file mode 100644
index 00000000..208a138b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/migration_faq.md
@@ -0,0 +1 @@
+# 迁移 FAQ
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/model_migration.md b/internlm_langchain/knowledge_base/MMDetection/content/model_migration.md
new file mode 100644
index 00000000..d7992440
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/model_migration.md
@@ -0,0 +1 @@
+# 将模型从 MMDetection 2.x 迁移至 3.x
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/model_zoo.md b/internlm_langchain/knowledge_base/MMDetection/content/model_zoo.md
new file mode 100644
index 00000000..b5376152
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/model_zoo.md
@@ -0,0 +1,333 @@
+# 模型库
+
+## 镜像地址
+
+从 MMDetection V2.0 起，我们只通过阿里云维护模型库。V1.x 版本的模型已经弃用。
+
+## 共同设置
+
+- 所有模型都是在 `coco_2017_train` 上训练，在 `coco_2017_val` 上测试。
+- 我们使用分布式训练。
+- 所有 pytorch-style 的 ImageNet 预训练主干网络来自 PyTorch 的模型库，caffe-style 的预训练主干网络来自 detectron2 最新开源的模型。
+- 为了与其他代码库公平比较，文档中所写的 GPU 内存是8个 GPU 的 `torch.cuda.max_memory_allocated()` 的最大值，此值通常小于 nvidia-smi 显示的值。
+- 我们以网络 forward 和后处理的时间加和作为推理时间，不包含数据加载时间。所有结果通过 [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) 脚本计算所得。该脚本会计算推理 2000 张图像的平均时间。
+
+## ImageNet 预训练模型
+
+通过 ImageNet 分类任务预训练的主干网络进行初始化是很常见的操作。所有预训练模型的链接都可以在 [open_mmlab](https://github.com/open-mmlab/mmcv/blob/master/mmcv/model_zoo/open_mmlab.json) 中找到。根据 `img_norm_cfg` 和原始权重，我们可以将所有 ImageNet 预训练模型分为以下几种情况：
+
+- TorchVision：torchvision 模型权重，包含 ResNet50, ResNet101。`img_norm_cfg` 为 `dict(mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)`。
+- Pycls：[pycls](https://github.com/facebookresearch/pycls) 模型权重，包含 RegNetX。`img_norm_cfg` 为 `dict( mean=[103.530, 116.280, 123.675], std=[57.375, 57.12, 58.395], to_rgb=False)`。
+- MSRA styles：[MSRA](https://github.com/KaimingHe/deep-residual-networks) 模型权重，包含 ResNet50_Caffe，ResNet101_Caffe。`img_norm_cfg` 为 `dict( mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)`。
+- Caffe2 styles：现阶段只包含 ResNext101_32x8d。`img_norm_cfg` 为 `dict(mean=[103.530, 116.280, 123.675], std=[57.375, 57.120, 58.395], to_rgb=False)`。
+- Other styles: SSD 的 `img_norm_cfg` 为 `dict(mean=[123.675, 116.28, 103.53], std=[1, 1, 1], to_rgb=True)`，YOLOv3 的 `img_norm_cfg` 为 `dict(mean=[0, 0, 0], std=[255., 255., 255.], to_rgb=True)`。
+
+MMdetection 常用到的主干网络细节如下表所示：
+
+| 模型 | 来源 | 链接 | 描述 |
+| ---------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ResNet50 | TorchVision | [torchvision 中的 ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth) | 来自 [torchvision 中的 ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth)。 |
+| ResNet101 | TorchVision | [torchvision 中的 ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth) | 来自 [torchvision 中的 ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth)。 |
+| RegNetX | Pycls | [RegNetX_3.2gf](https://download.openmmlab.com/pretrain/third_party/regnetx_3.2gf-c2599b0f.pth)，[RegNetX_800mf](https://download.openmmlab.com/pretrain/third_party/regnetx_800mf-1f4be4c7.pth) 等 | 来自 [pycls](https://github.com/facebookresearch/pycls)。 |
+| ResNet50_Caffe | MSRA | [MSRA 中的 ResNet-50](https://download.openmmlab.com/pretrain/third_party/resnet50_caffe-788b5fa3.pth) | 由 [Detectron2 中的 R-50.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-50.pkl) 转化的副本。原始权重文件来自 [MSRA 中的原始 ResNet-50](https://github.com/KaimingHe/deep-residual-networks)。 |
+| ResNet101_Caffe | MSRA | [MSRA 中的 ResNet-101](https://download.openmmlab.com/pretrain/third_party/resnet101_caffe-3ad79236.pth) | 由 [Detectron2 中的 R-101.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-101.pkl) 转化的副本。原始权重文件来自 [MSRA 中的原始 ResNet-101](https://github.com/KaimingHe/deep-residual-networks)。 |
+| ResNext101_32x8d | Caffe2 | [Caffe2 ResNext101_32x8d](https://download.openmmlab.com/pretrain/third_party/resnext101_32x8d-1516f1aa.pth) | 由 [Detectron2 中的 X-101-32x8d.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/FAIR/X-101-32x8d.pkl) 转化的副本。原始 ResNeXt-101-32x8d 由 FB 使用 Caffe2 训练。 |
+
+## Baselines
+
+### RPN
+
+请参考 [RPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/rpn)。
+
+### Faster R-CNN
+
+请参考 [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn)。
+
+### Mask R-CNN
+
+请参考 [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn)。
+
+### Fast R-CNN (使用提前计算的 proposals)
+
+请参考 [Fast R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/fast_rcnn)。
+
+### RetinaNet
+
+请参考 [RetinaNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet)。
+
+### Cascade R-CNN and Cascade Mask R-CNN
+
+请参考 [Cascade R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/cascade_rcnn)。
+
+### Hybrid Task Cascade (HTC)
+
+请参考 [HTC](https://github.com/open-mmlab/mmdetection/blob/main/configs/htc)。
+
+### SSD
+
+请参考 [SSD](https://github.com/open-mmlab/mmdetection/blob/main/configs/ssd)。
+
+### Group Normalization (GN)
+
+请参考 [Group Normalization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn)。
+
+### Weight Standardization
+
+请参考 [Weight Standardization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn+ws)。
+
+### Deformable Convolution v2
+
+请参考 [Deformable Convolutional Networks](https://github.com/open-mmlab/mmdetection/blob/main/configs/dcn)。
+
+### CARAFE: Content-Aware ReAssembly of FEatures
+
+请参考 [CARAFE](https://github.com/open-mmlab/mmdetection/blob/main/configs/carafe)。
+
+### Instaboost
+
+请参考 [Instaboost](https://github.com/open-mmlab/mmdetection/blob/main/configs/instaboost)。
+
+### Libra R-CNN
+
+请参考 [Libra R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/libra_rcnn)。
+
+### Guided Anchoring
+
+请参考 [Guided Anchoring](https://github.com/open-mmlab/mmdetection/blob/main/configs/guided_anchoring)。
+
+### FCOS
+
+请参考 [FCOS](https://github.com/open-mmlab/mmdetection/blob/main/configs/fcos)。
+
+### FoveaBox
+
+请参考 [FoveaBox](https://github.com/open-mmlab/mmdetection/blob/main/configs/foveabox)。
+
+### RepPoints
+
+请参考 [RepPoints](https://github.com/open-mmlab/mmdetection/blob/main/configs/reppoints)。
+
+### FreeAnchor
+
+请参考 [FreeAnchor](https://github.com/open-mmlab/mmdetection/blob/main/configs/free_anchor)。
+
+### Grid R-CNN (plus)
+
+请参考 [Grid R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/grid_rcnn)。
+
+### GHM
+
+请参考 [GHM](https://github.com/open-mmlab/mmdetection/blob/main/configs/ghm)。
+
+### GCNet
+
+请参考 [GCNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/gcnet)。
+
+### HRNet
+
+请参考 [HRNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/hrnet)。
+
+### Mask Scoring R-CNN
+
+请参考 [Mask Scoring R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/ms_rcnn)。
+
+### Train from Scratch
+
+请参考 [Rethinking ImageNet Pre-training](https://github.com/open-mmlab/mmdetection/blob/main/configs/scratch)。
+
+### NAS-FPN
+
+请参考 [NAS-FPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/nas_fpn)。
+
+### ATSS
+
+请参考 [ATSS](https://github.com/open-mmlab/mmdetection/blob/main/configs/atss)。
+
+### FSAF
+
+请参考 [FSAF](https://github.com/open-mmlab/mmdetection/blob/main/configs/fsaf)。
+
+### RegNetX
+
+请参考 [RegNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet)。
+
+### Res2Net
+
+请参考 [Res2Net](https://github.com/open-mmlab/mmdetection/blob/main/configs/res2net)。
+
+### GRoIE
+
+请参考 [GRoIE](https://github.com/open-mmlab/mmdetection/blob/main/configs/groie)。
+
+### Dynamic R-CNN
+
+请参考 [Dynamic R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/dynamic_rcnn)。
+
+### PointRend
+
+请参考 [PointRend](https://github.com/open-mmlab/mmdetection/blob/main/configs/point_rend)。
+
+### DetectoRS
+
+请参考 [DetectoRS](https://github.com/open-mmlab/mmdetection/blob/main/configs/detectors)。
+
+### Generalized Focal Loss
+
+请参考 [Generalized Focal Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/gfl)。
+
+### CornerNet
+
+请参考 [CornerNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/cornernet)。
+
+### YOLOv3
+
+请参考 [YOLOv3](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolo)。
+
+### PAA
+
+请参考 [PAA](https://github.com/open-mmlab/mmdetection/blob/main/configs/paa)。
+
+### SABL
+
+请参考 [SABL](https://github.com/open-mmlab/mmdetection/blob/main/configs/sabl)。
+
+### CentripetalNet
+
+请参考 [CentripetalNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centripetalnet)。
+
+### ResNeSt
+
+请参考 [ResNeSt](https://github.com/open-mmlab/mmdetection/blob/main/configs/resnest)。
+
+### DETR
+
+请参考 [DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/detr)。
+
+### Deformable DETR
+
+请参考 [Deformable DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/deformable_detr)。
+
+### AutoAssign
+
+请参考 [AutoAssign](https://github.com/open-mmlab/mmdetection/blob/main/configs/autoassign)。
+
+### YOLOF
+
+请参考 [YOLOF](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolof)。
+
+### Seesaw Loss
+
+请参考 [Seesaw Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/seesaw_loss)。
+
+### CenterNet
+
+请参考 [CenterNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centernet)。
+
+### YOLOX
+
+请参考 [YOLOX](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolox)。
+
+### PVT
+
+请参考 [PVT](https://github.com/open-mmlab/mmdetection/blob/main/configs/pvt)。
+
+### SOLO
+
+请参考 [SOLO](https://github.com/open-mmlab/mmdetection/blob/main/configs/solo)。
+
+### QueryInst
+
+请参考 [QueryInst](https://github.com/open-mmlab/mmdetection/blob/main/configs/queryinst)。
+
+### Other datasets
+
+我们还在 [PASCAL VOC](https://github.com/open-mmlab/mmdetection/blob/main/configs/pascal_voc)，[Cityscapes](https://github.com/open-mmlab/mmdetection/blob/main/configs/cityscapes) 和 [WIDER FACE](https://github.com/open-mmlab/mmdetection/blob/main/configs/wider_face) 上对一些方法进行了基准测试。
+
+### Pre-trained Models
+
+我们还通过多尺度训练和更长的训练策略来训练用 ResNet-50 和 [RegNetX-3.2G](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet) 作为主干网络的 [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn) 和 [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn)。这些模型可以作为下游任务的预训练模型。
+
+## 速度基准
+
+### 训练速度基准
+
+我们提供 [analyze_logs.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/analyze_logs.py) 来得到训练中每一次迭代的平均时间。示例请参考 [Log Analysis](https://mmdetection.readthedocs.io/en/latest/useful_tools.html#log-analysis)。
+
+我们与其他流行框架的 Mask R-CNN 训练速度进行比较（数据是从 [detectron2](https://github.com/facebookresearch/detectron2/blob/main/docs/notes/benchmarks.md/) 复制而来）。在 mmdetection 中，我们使用 [mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py) 进行基准测试。它与 detectron2 的 [mask_rcnn_R_50_FPN_noaug_1x.yaml](https://github.com/facebookresearch/detectron2/blob/main/configs/Detectron1-Comparisons/mask_rcnn_R_50_FPN_noaug_1x.yaml) 设置完全一样。同时，我们还提供了[模型权重](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_compare_20200518-10127928.pth)和[训练 log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_20200518_105755.log.json) 作为参考。为了跳过 GPU 预热时间，吞吐量按照100-500次迭代之间的平均吞吐量来计算。
+
+| 框架 | 吞吐量 (img/s) |
+| -------------------------------------------------------------------------------------- | -------------- |
+| [Detectron2](https://github.com/facebookresearch/detectron2) | 62 |
+| [MMDetection](https://github.com/open-mmlab/mmdetection) | 61 |
+| [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/) | 53 |
+| [tensorpack](https://github.com/tensorpack/tensorpack/tree/master/examples/FasterRCNN) | 50 |
+| [simpledet](https://github.com/TuSimple/simpledet/) | 39 |
+| [Detectron](https://github.com/facebookresearch/Detectron) | 19 |
+| [matterport/Mask_RCNN](https://github.com/matterport/Mask_RCNN/) | 14 |
+
+### 推理时间基准
+
+我们提供 [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) 对推理时间进行基准测试。此脚本将推理 2000 张图片并计算忽略前 5 次推理的平均推理时间。可以通过设置 `LOG-INTERVAL` 来改变 log 输出间隔（默认为 50）。
+
+```shell
+python tools/benchmark.py ${CONFIG} ${CHECKPOINT} [--log-interval $[LOG-INTERVAL]] [--fuse-conv-bn]
+```
+
+模型库中，所有模型在基准测量推理时间时都没设置 `fuse-conv-bn`, 此设置可以使推理时间更短。
+
+## 与 Detectron2 对比
+
+我们在速度和精度方面对 mmdetection 和 [Detectron2](https://github.com/facebookresearch/detectron2.git) 进行对比。对比所使用的 detectron2 的 commit id 为 [185c27e](https://github.com/facebookresearch/detectron2/tree/185c27e4b4d2d4c68b5627b3765420c6d7f5a659)(30/4/2020)。
+为了公平对比，我们所有的实验都在同一机器下进行。
+
+### 硬件
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### 软件环境
+
+- Python 3.7
+- PyTorch 1.4
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### 精度
+
+| 模型 | 训练策略 | Detectron2 | mmdetection | 下载 |
+| ------------------------------------------------------------------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py) | 1x | [37.9](https://github.com/facebookresearch/detectron2/blob/main/configs/COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml) | 38.0 | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco-5324cff8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco_20200429_234554.log.json) |
+| [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py) | 1x | [38.6 & 35.2](https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml) | 38.8 & 35.4 | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco-dbecf295.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco_20200430_054239.log.json) |
+| [Retinanet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py) | 1x | [36.5](https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-Detection/retinanet_R_50_FPN_1x.yaml) | 37.0 | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco-586977a0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco_20200430_014748.log.json) |
+
+### 训练速度
+
+训练速度使用 s/iter 来度量。结果越低越好。
+
+| 模型 | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 0.210 | 0.216 |
+| Mask R-CNN | 0.261 | 0.265 |
+| Retinanet | 0.200 | 0.205 |
+
+### 推理速度
+
+推理速度通过单张 GPU 下的 fps(img/s) 来度量，越高越好。
+为了与 Detectron2 保持一致，我们所写的推理时间除去了数据加载时间。
+对于 Mask RCNN，我们去除了后处理中 RLE 编码的时间。
+我们在括号中给出了官方给出的速度。由于硬件差异，官方给出的速度会比我们所测试得到的速度快一些。
+
+| 模型 | Detectron2 | mmdetection |
+| ------------ | ----------- | ----------- |
+| Faster R-CNN | 25.6 (26.3) | 22.2 |
+| Mask R-CNN | 22.5 (23.3) | 19.6 |
+| Retinanet | 17.8 (18.2) | 20.6 |
+
+### 训练内存
+
+| 模型 | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 3.0 | 3.8 |
+| Mask R-CNN | 3.4 | 3.9 |
+| Retinanet | 3.9 | 3.4 |
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/models.md b/internlm_langchain/knowledge_base/MMDetection/content/models.md
new file mode 100644
index 00000000..c5119d06
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/models.md
@@ -0,0 +1 @@
+# 模型（待更新）
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/new_model.md b/internlm_langchain/knowledge_base/MMDetection/content/new_model.md
new file mode 100644
index 00000000..424c4f90
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/new_model.md
@@ -0,0 +1,289 @@
+# 在标准数据集上训练自定义模型（待更新）
+
+在本文中，你将知道如何在标准数据集上训练、测试和推理自定义模型。我们将在 cityscapes 数据集上以自定义 Cascade Mask R-CNN R50 模型为例演示整个过程，为了方便说明，我们将 neck 模块中的 `FPN` 替换为 `AugFPN`，并且在训练中的自动增强类中增加 `Rotate` 或 `TranslateX`。
+
+基本步骤如下所示：
+
+1. 准备标准数据集
+2. 准备你的自定义模型
+3. 准备配置文件
+4. 在标准数据集上对模型进行训练、测试和推理
+
+## 准备标准数据集
+
+在本文中，我们使用 cityscapes 标准数据集为例进行说明。
+
+推荐将数据集根路径采用符号链接方式链接到 `$MMDETECTION/data`。
+
+如果你的文件结构不同，你可能需要在配置文件中进行相应的路径更改。标准的文件组织格式如下所示：
+
+```none
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│ ├── coco
+│ │ ├── annotations
+│ │ ├── train2017
+│ │ ├── val2017
+│ │ ├── test2017
+│ ├── cityscapes
+│ │ ├── annotations
+│ │ ├── leftImg8bit
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ ├── gtFine
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── VOCdevkit
+│ │ ├── VOC2007
+│ │ ├── VOC2012
+```
+
+你也可以通过如下方式设定数据集根路径
+
+```bash
+export MMDET_DATASETS=$data_root
+```
+
+我们将会使用环境便变量 `$MMDET_DATASETS` 作为数据集的根目录，因此你无需再修改相应配置文件的路径信息。
+
+你需要使用脚本 `tools/dataset_converters/cityscapes.py` 将 cityscapes 标注转化为 coco 标注格式。
+
+```shell
+pip install cityscapesscripts
+python tools/dataset_converters/cityscapes.py ./data/cityscapes --nproc 8 --out-dir ./data/cityscapes/annotations
+```
+
+目前在 `cityscapes `文件夹中的配置文件所对应模型是采用 COCO 预训练权重进行初始化的。
+
+如果你的网络不可用或者比较慢，建议你先手动下载对应的预训练权重，否则可能在训练开始时候出现错误。
+
+## 准备你的自定义模型
+
+第二步是准备你的自定义模型或者训练相关配置。假设你想在已有的 Cascade Mask R-CNN R50 检测模型基础上，新增一个新的 neck 模块 `AugFPN` 去代替默认的 `FPN`，以下是具体实现：
+
+### 1 定义新的 neck (例如 AugFPN)
+
+首先创建新文件 `mmdet/models/necks/augfpn.py`.
+
+```python
+import torch.nn as nn
+from mmdet.registry import MODELS
+
+@MODELS.register_module()
+class AugFPN(nn.Module):
+
+ def __init__(self,
+ in_channels,
+ out_channels,
+ num_outs,
+ start_level=0,
+ end_level=-1,
+ add_extra_convs=False):
+ pass
+
+ def forward(self, inputs):
+ # implementation is ignored
+ pass
+```
+
+### 2 导入模块
+
+你可以采用两种方式导入模块，第一种是在 `mmdet/models/necks/__init__.py` 中添加如下内容
+
+```python
+from .augfpn import AugFPN
+```
+
+第二种是增加如下代码到对应配置中，这种方式的好处是不需要改动代码
+
+```python
+custom_imports = dict(
+ imports=['mmdet.models.necks.augfpn'],
+ allow_failed_imports=False)
+```
+
+### 3 修改配置
+
+```python
+neck=dict(
+ type='AugFPN',
+ in_channels=[256, 512, 1024, 2048],
+ out_channels=256,
+ num_outs=5)
+```
+
+关于自定义模型其余相关细节例如实现新的骨架网络，头部网络、损失函数，以及运行时训练配置例如定义新的优化器、使用梯度裁剪、定制训练调度策略和钩子等，请参考文档 [自定义模型](tutorials/customize_models.md) 和 [自定义运行时训练配置](tutorials/customize_runtime.md)。
+
+## 准备配置文件
+
+第三步是准备训练配置所需要的配置文件。假设你打算基于 cityscapes 数据集，在 Cascade Mask R-CNN R50 中新增 `AugFPN` 模块，同时增加 `Rotate` 或者 `Translate` 数据增强策略，假设你的配置文件位于 `configs/cityscapes/` 目录下，并且取名为 `cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py`，则配置信息如下：
+
+```python
+# 继承 base 配置，然后进行针对性修改
+_base_ = [
+ '../_base_/models/cascade-mask-rcnn_r50_fpn.py',
+ '../_base_/datasets/cityscapes_instance.py', '../_base_/default_runtime.py'
+]
+
+model = dict(
+ # 设置 `init_cfg` 为 None，表示不加载 ImageNet 预训练权重，
+ # 后续可以设置 `load_from` 参数用来加载 COCO 预训练权重
+ backbone=dict(init_cfg=None),
+ # 使用新增的 `AugFPN` 模块代替默认的 `FPN`
+ neck=dict(
+ type='AugFPN',
+ in_channels=[256, 512, 1024, 2048],
+ out_channels=256,
+ num_outs=5),
+ # 我们也需要将 num_classes 从 80 修改为 8 来匹配 cityscapes 数据集标注
+ # 这个修改包括 `bbox_head` 和 `mask_head`.
+ roi_head=dict(
+ bbox_head=[
+ dict(
+ type='Shared2FCBBoxHead',
+ in_channels=256,
+ fc_out_channels=1024,
+ roi_feat_size=7,
+ # 将 COCO 类别修改为 cityscapes 类别
+ num_classes=8,
+ bbox_coder=dict(
+ type='DeltaXYWHBBoxCoder',
+ target_means=[0., 0., 0., 0.],
+ target_stds=[0.1, 0.1, 0.2, 0.2]),
+ reg_class_agnostic=True,
+ loss_cls=dict(
+ type='CrossEntropyLoss',
+ use_sigmoid=False,
+ loss_weight=1.0),
+ loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+ loss_weight=1.0)),
+ dict(
+ type='Shared2FCBBoxHead',
+ in_channels=256,
+ fc_out_channels=1024,
+ roi_feat_size=7,
+ # 将 COCO 类别修改为 cityscapes 类别
+ num_classes=8,
+ bbox_coder=dict(
+ type='DeltaXYWHBBoxCoder',
+ target_means=[0., 0., 0., 0.],
+ target_stds=[0.05, 0.05, 0.1, 0.1]),
+ reg_class_agnostic=True,
+ loss_cls=dict(
+ type='CrossEntropyLoss',
+ use_sigmoid=False,
+ loss_weight=1.0),
+ loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+ loss_weight=1.0)),
+ dict(
+ type='Shared2FCBBoxHead',
+ in_channels=256,
+ fc_out_channels=1024,
+ roi_feat_size=7,
+ # 将 COCO 类别修改为 cityscapes 类别
+ num_classes=8,
+ bbox_coder=dict(
+ type='DeltaXYWHBBoxCoder',
+ target_means=[0., 0., 0., 0.],
+ target_stds=[0.033, 0.033, 0.067, 0.067]),
+ reg_class_agnostic=True,
+ loss_cls=dict(
+ type='CrossEntropyLoss',
+ use_sigmoid=False,
+ loss_weight=1.0),
+ loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
+ ],
+ mask_head=dict(
+ type='FCNMaskHead',
+ num_convs=4,
+ in_channels=256,
+ conv_out_channels=256,
+ # 将 COCO 类别修改为 cityscapes 类别
+ num_classes=8,
+ loss_mask=dict(
+ type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))))
+
+# 覆写 `train_pipeline`，然后新增 `AutoAugment` 训练配置
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+ dict(
+ type='AutoAugment',
+ policies=[
+ [dict(
+ type='Rotate',
+ level=5,
+ img_border_value=(124, 116, 104),
+ prob=0.5)
+ ],
+ [dict(type='Rotate', level=7, img_border_value=(124, 116, 104)),
+ dict(
+ type='TranslateX',
+ level=5,
+ prob=0.5,
+ img_border_value=(124, 116, 104))
+ ],
+ ]),
+ dict(
+ type='RandomResize',
+ scale=[(2048, 800), (2048, 1024)],
+ keep_ratio=True),
+ dict(type='RandomFlip', prob=0.5),
+ dict(type='PackDetInputs'),
+]
+
+# 设置每张显卡的批处理大小，同时设置新的训练 pipeline
+data = dict(
+ samples_per_gpu=1,
+ workers_per_gpu=3,
+ train=dict(dataset=dict(pipeline=train_pipeline)))
+
+# 设置优化器
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001))
+
+# 设置定制的学习率策略
+param_scheduler = [
+ dict(
+ type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+ dict(
+ type='MultiStepLR',
+ begin=0,
+ end=10,
+ by_epoch=True,
+ milestones=[8],
+ gamma=0.1)
+]
+
+# 训练，验证，测试配置
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=10, val_interval=1)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+# 我们采用 COCO 预训练过的 Cascade Mask R-CNN R50 模型权重作为初始化权重，可以得到更加稳定的性能
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth'
+```
+
+## 训练新模型
+
+为了能够使用新增配置来训练模型，你可以运行如下命令：
+
+```shell
+python tools/train.py configs/cityscapes/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py
+```
+
+如果想了解更多用法，可以参考 [例子1](1_exist_data_model.md)。
+
+## 测试和推理
+
+为了能够测试训练好的模型，你可以运行如下命令：
+
+```shell
+python tools/test.py configs/cityscapes/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py work_dirs/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes/epoch_10.pth
+```
+
+如果想了解更多用法，可以参考 [例子1](1_exist_data_model.md)。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/overview.md b/internlm_langchain/knowledge_base/MMDetection/content/overview.md
new file mode 100644
index 00000000..5269aed8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/overview.md
@@ -0,0 +1,54 @@
+# 概述
+
+本章向您介绍 MMDetection 的整体框架，并提供详细的教程链接。
+
+## 什么是 MMDetection
+
+
+
+MMDetection 是一个目标检测工具箱，包含了丰富的目标检测、实例分割、全景分割算法以及相关的组件和模块，下面是它的整体框架：
+
+MMDetection 由 7 个主要部分组成，apis、structures、datasets、models、engine、evaluation 和 visualization。
+
+- **apis** 为模型推理提供高级 API。
+- **structures** 提供 bbox、mask 和 DetDataSample 等数据结构。
+- **datasets** 支持用于目标检测、实例分割和全景分割的各种数据集。
+ - **transforms** 包含各种数据增强变换。
+ - **samplers** 定义了不同的数据加载器采样策略。
+- **models** 是检测器最重要的部分，包含检测器的不同组件。
+ - **detectors** 定义所有检测模型类。
+ - **data_preprocessors** 用于预处理模型的输入数据。
+ - **backbones** 包含各种骨干网络。
+ - **necks** 包含各种模型颈部组件。
+ - **dense_heads** 包含执行密集预测的各种检测头。
+ - **roi_heads** 包含从 RoI 预测的各种检测头。
+ - **seg_heads** 包含各种分割头。
+ - **losses** 包含各种损失函数。
+ - **task_modules** 为检测任务提供模块，例如 assigners、samplers、box coders 和 prior generators。
+ - **layers** 提供了一些基本的神经网络层。
+- **engine** 是运行时组件的一部分。
+ - **runner** 为 [MMEngine 的执行器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)提供扩展。
+ - **schedulers** 提供用于调整优化超参数的调度程序。
+ - **optimizers** 提供优化器和优化器封装。
+ - **hooks** 提供执行器的各种钩子。
+- **evaluation** 为评估模型性能提供不同的指标。
+- **visualization** 用于可视化检测结果。
+
+## 如何使用本指南
+
+以下是 MMDetection 的详细指南：
+
+1. 安装说明见[开始你的第一步](get_started.md)。
+
+2. MMDetection 的基本使用方法请参考以下教程。
+
+ - [训练和测试](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/index.html#train-test)
+
+ - [实用工具](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/index.html#useful-tools)
+
+3. 参考以下教程深入了解：
+
+ - [基础概念](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#basic-concepts)
+ - [组件定制](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#component-customization)
+
+4. 对于 MMDetection 2.x 版本的用户，我们提供了[迁移指南](./migration/migration.md)，帮助您完成新版本的适配。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/projects.md b/internlm_langchain/knowledge_base/MMDetection/content/projects.md
new file mode 100644
index 00000000..6b9d300d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/projects.md
@@ -0,0 +1,48 @@
+# 基于 MMDetection 的项目
+
+有许多开源项目都是基于 MMDetection 搭建的，我们在这里列举一部分作为样例，展示如何基于 MMDetection 搭建您自己的项目。
+由于这个页面列举的项目并不完全，我们欢迎社区提交 Pull Request 来更新这个文档。
+
+## MMDetection 的拓展项目
+
+一些项目拓展了 MMDetection 的边界，如将 MMDetection 拓展支持 3D 检测或者将 MMDetection 用于部署。
+它们展示了 MMDetection 的许多可能性，所以我们在这里也列举一些。
+
+- [OTEDetection](https://github.com/opencv/mmdetection): OpenVINO training extensions for object detection.
+- [MMDetection3d](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection.
+
+## 研究项目
+
+同样有许多研究论文是基于 MMDetection 进行的。许多论文都发表在了顶级的会议或期刊上，或者对社区产生了深远的影响。
+为了向社区提供一个可以参考的论文列表，帮助大家开发或者比较新的前沿算法，我们在这里也遵循会议的时间顺序列举了一些论文。
+MMDetection 中已经支持的算法不在此列。
+
+- Involution: Inverting the Inherence of Convolution for Visual Recognition, CVPR21. [\[paper\]](https://arxiv.org/abs/2103.06255)[\[github\]](https://github.com/d-li14/involution)
+- Multiple Instance Active Learning for Object Detection, CVPR 2021. [\[paper\]](https://openaccess.thecvf.com/content/CVPR2021/papers/Yuan_Multiple_Instance_Active_Learning_for_Object_Detection_CVPR_2021_paper.pdf)[\[github\]](https://github.com/yuantn/MI-AOD)
+- Adaptive Class Suppression Loss for Long-Tail Object Detection, CVPR 2021. [\[paper\]](https://arxiv.org/abs/2104.00885)[\[github\]](https://github.com/CASIA-IVA-Lab/ACSL)
+- Generalizable Pedestrian Detection: The Elephant In The Room, CVPR2021. [\[paper\]](https://arxiv.org/abs/2003.08799)[\[github\]](https://github.com/hasanirtiza/Pedestron)
+- Group Fisher Pruning for Practical Network Compression, ICML2021. [\[paper\]](https://github.com/jshilong/FisherPruning/blob/main/resources/paper.pdf)[\[github\]](https://github.com/jshilong/FisherPruning)
+- Overcoming Classifier Imbalance for Long-tail Object Detection with Balanced Group Softmax, CVPR2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/papers/Li_Overcoming_Classifier_Imbalance_for_Long-Tail_Object_Detection_With_Balanced_Group_CVPR_2020_paper.pdf)[\[github\]](https://github.com/FishYuLi/BalancedGroupSoftmax)
+- Coherent Reconstruction of Multiple Humans from a Single Image, CVPR2020. [\[paper\]](https://jiangwenpl.github.io/multiperson/)[\[github\]](https://github.com/JiangWenPL/multiperson)
+- Look-into-Object: Self-supervised Structure Modeling for Object Recognition, CVPR 2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/papers/Zhou_Look-Into-Object_Self-Supervised_Structure_Modeling_for_Object_Recognition_CVPR_2020_paper.pdf)[\[github\]](https://github.com/JDAI-CV/LIO)
+- Video Panoptic Segmentation, CVPR2020. [\[paper\]](https://arxiv.org/abs/2006.11339)[\[github\]](https://github.com/mcahny/vps)
+- D2Det: Towards High Quality Object Detection and Instance Segmentation, CVPR2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/html/Cao_D2Det_Towards_High_Quality_Object_Detection_and_Instance_Segmentation_CVPR_2020_paper.html)[\[github\]](https://github.com/JialeCao001/D2Det)
+- CentripetalNet: Pursuing High-quality Keypoint Pairs for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.09119)[\[github\]](https://github.com/KiveeDong/CentripetalNet)
+- Learning a Unified Sample Weighting Network for Object Detection, CVPR 2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/html/Cai_Learning_a_Unified_Sample_Weighting_Network_for_Object_Detection_CVPR_2020_paper.html)[\[github\]](https://github.com/caiqi/sample-weighting-network)
+- Scale-equalizing Pyramid Convolution for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2005.03101) [\[github\]](https://github.com/jshilong/SEPC)
+- Revisiting the Sibling Head in Object Detector, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.07540)[\[github\]](https://github.com/Sense-X/TSD)
+- PolarMask: Single Shot Instance Segmentation with Polar Representation, CVPR2020. [\[paper\]](https://arxiv.org/abs/1909.13226)[\[github\]](https://github.com/xieenze/PolarMask)
+- Hit-Detector: Hierarchical Trinity Architecture Search for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.11818)[\[github\]](https://github.com/ggjy/HitDet.pytorch)
+- ZeroQ: A Novel Zero Shot Quantization Framework, CVPR2020. [\[paper\]](https://arxiv.org/abs/2001.00281)[\[github\]](https://github.com/amirgholami/ZeroQ)
+- CBNet: A Novel Composite Backbone Network Architecture for Object Detection, AAAI2020. [\[paper\]](https://aaai.org/Papers/AAAI/2020GB/AAAI-LiuY.1833.pdf)[\[github\]](https://github.com/VDIGPKU/CBNet)
+- RDSNet: A New Deep Architecture for Reciprocal Object Detection and Instance Segmentation, AAAI2020. [\[paper\]](https://arxiv.org/abs/1912.05070)[\[github\]](https://github.com/wangsr126/RDSNet)
+- Training-Time-Friendly Network for Real-Time Object Detection, AAAI2020. [\[paper\]](https://arxiv.org/abs/1909.00700)[\[github\]](https://github.com/ZJULearning/ttfnet)
+- Cascade RPN: Delving into High-Quality Region Proposal Network with Adaptive Convolution, NeurIPS 2019. [\[paper\]](https://arxiv.org/abs/1909.06720)[\[github\]](https://github.com/thangvubk/Cascade-RPN)
+- Reasoning R-CNN: Unifying Adaptive Global Reasoning into Large-scale Object Detection, CVPR2019. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2019/papers/Xu_Reasoning-RCNN_Unifying_Adaptive_Global_Reasoning_Into_Large-Scale_Object_Detection_CVPR_2019_paper.pdf)[\[github\]](https://github.com/chanyn/Reasoning-RCNN)
+- Learning RoI Transformer for Oriented Object Detection in Aerial Images, CVPR2019. [\[paper\]](https://arxiv.org/abs/1812.00155)[\[github\]](https://github.com/dingjiansw101/AerialDetection)
+- SOLO: Segmenting Objects by Locations. [\[paper\]](https://arxiv.org/abs/1912.04488)[\[github\]](https://github.com/WXinlong/SOLO)
+- SOLOv2: Dynamic, Faster and Stronger. [\[paper\]](https://arxiv.org/abs/2003.10152)[\[github\]](https://github.com/WXinlong/SOLO)
+- Dense Peppoints: Representing Visual Objects with Dense Point Sets. [\[paper\]](https://arxiv.org/abs/1912.11473)[\[github\]](https://github.com/justimyhxu/Dense-RepPoints)
+- IterDet: Iterative Scheme for Object Detection in Crowded Environments. [\[paper\]](https://arxiv.org/abs/2005.05708)[\[github\]](https://github.com/saic-vul/iterdet)
+- Cross-Iteration Batch Normalization. [\[paper\]](https://arxiv.org/abs/2002.05712)[\[github\]](https://github.com/Howal/Cross-iterationBatchNorm)
+- A Ranking-based, Balanced Loss Function Unifying Classification and Localisation in Object Detection, NeurIPS2020 [\[paper\]](https://arxiv.org/abs/2009.13592)[\[github\]](https://github.com/kemaloksuz/aLRPLoss)
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/robustness_benchmarking.md b/internlm_langchain/knowledge_base/MMDetection/content/robustness_benchmarking.md
new file mode 100644
index 00000000..e95c79a9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/robustness_benchmarking.md
@@ -0,0 +1,109 @@
+# 检测器鲁棒性检查
+
+## 介绍
+
+我们提供了在 [Benchmarking Robustness in Object Detection: Autonomous Driving when Winter is Coming](https://arxiv.org/abs/1907.07484) 中定义的「图像损坏基准测试」上测试目标检测和实例分割模型的工具。
+此页面提供了如何使用该基准测试的基本教程。
+
+```latex
+@article{michaelis2019winter,
+ title={Benchmarking Robustness in Object Detection:
+ Autonomous Driving when Winter is Coming},
+ author={Michaelis, Claudio and Mitzkus, Benjamin and
+ Geirhos, Robert and Rusak, Evgenia and
+ Bringmann, Oliver and Ecker, Alexander S. and
+ Bethge, Matthias and Brendel, Wieland},
+ journal={arXiv:1907.07484},
+ year={2019}
+}
+```
+
+
+
+## 关于基准测试
+
+要将结果提交到基准测试，请访问[基准测试主页](https://github.com/bethgelab/robust-detection-benchmark)
+
+基准测试是仿照 [imagenet-c 基准测试](https://github.com/hendrycks/robustness)，由 Dan Hendrycks 和 Thomas Dietterich 在[Benchmarking Neural Network Robustness to Common Corruptions and Perturbations](https://arxiv.org/abs/1903.12261)(ICLR 2019)中发表。
+
+图像损坏变换功能包含在此库中，但可以使用以下方法单独安装：
+
+```shell
+pip install imagecorruptions
+```
+
+与 imagenet-c 相比，我们必须进行一些更改以处理任意大小的图像和灰度图像。
+我们还修改了“运动模糊”和“雪”损坏，以解除对于 linux 特定库的依赖，
+否则必须单独安装这些库。有关详细信息，请参阅 [imagecorruptions](https://github.com/bethgelab/imagecorruptions)。
+
+## 使用预训练模型进行推理
+
+我们提供了一个测试脚本来评估模型在基准测试中提供的各种损坏变换组合下的性能。
+
+### 在数据集上测试
+
+- [x] 单张 GPU 测试
+- [ ] 多张 GPU 测试
+- [ ] 可视化检测结果
+
+您可以使用以下命令在基准测试中使用 15 种损坏变换来测试模型性能。
+
+```shell
+# single-gpu testing
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}]
+```
+
+也可以选择其它不同类型的损坏变换。
+
+```shell
+# noise
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions noise
+
+# blur
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions blur
+
+# wetaher
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions weather
+
+# digital
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions digital
+```
+
+或者使用一组自定义的损坏变换，例如：
+
+```shell
+# gaussian noise, zoom blur and snow
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions gaussian_noise zoom_blur snow
+```
+
+最后，我们也可以选择施加在图像上的损坏变换的严重程度。
+严重程度从 1 到 5 逐级增强，0 表示不对图像施加损坏变换，即原始图像数据。
+
+```shell
+# severity 1
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --severities 1
+
+# severities 0,2,4
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --severities 0 2 4
+```
+
+## 模型测试结果
+
+下表是各模型在 COCO 2017val 上的测试结果。
+
+| Model | Backbone | Style | Lr schd | box AP clean | box AP corr. | box % | mask AP clean | mask AP corr. | mask % |
+| :-----------------: | :-----------------: | :-----: | :-----: | :----------: | :----------: | :---: | :-----------: | :-----------: | :----: |
+| Faster R-CNN | R-50-FPN | pytorch | 1x | 36.3 | 18.2 | 50.2 | - | - | - |
+| Faster R-CNN | R-101-FPN | pytorch | 1x | 38.5 | 20.9 | 54.2 | - | - | - |
+| Faster R-CNN | X-101-32x4d-FPN | pytorch | 1x | 40.1 | 22.3 | 55.5 | - | - | - |
+| Faster R-CNN | X-101-64x4d-FPN | pytorch | 1x | 41.3 | 23.4 | 56.6 | - | - | - |
+| Faster R-CNN | R-50-FPN-DCN | pytorch | 1x | 40.0 | 22.4 | 56.1 | - | - | - |
+| Faster R-CNN | X-101-32x4d-FPN-DCN | pytorch | 1x | 43.4 | 26.7 | 61.6 | - | - | - |
+| Mask R-CNN | R-50-FPN | pytorch | 1x | 37.3 | 18.7 | 50.1 | 34.2 | 16.8 | 49.1 |
+| Mask R-CNN | R-50-FPN-DCN | pytorch | 1x | 41.1 | 23.3 | 56.7 | 37.2 | 20.7 | 55.7 |
+| Cascade R-CNN | R-50-FPN | pytorch | 1x | 40.4 | 20.1 | 49.7 | - | - | - |
+| Cascade Mask R-CNN | R-50-FPN | pytorch | 1x | 41.2 | 20.7 | 50.2 | 35.7 | 17.6 | 49.3 |
+| RetinaNet | R-50-FPN | pytorch | 1x | 35.6 | 17.8 | 50.1 | - | - | - |
+| Hybrid Task Cascade | X-101-64x4d-FPN-DCN | pytorch | 1x | 50.6 | 32.7 | 64.7 | 43.8 | 28.1 | 64.0 |
+
+由于对图像的损坏变换存在随机性，测试结果可能略有不同。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/semi_det.md b/internlm_langchain/knowledge_base/MMDetection/content/semi_det.md
new file mode 100644
index 00000000..a2235237
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/semi_det.md
@@ -0,0 +1,320 @@
+# 半监督目标检测
+
+半监督目标检测同时利用标签数据和无标签数据进行训练，一方面可以减少模型对检测框数量的依赖，另一方面也可以利用大量的未标记数据进一步提高模型。
+
+按照以下流程进行半监督目标检测：
+
+- [半监督目标检测](#半监督目标检测)
+ - [准备和拆分数据集](#准备和拆分数据集)
+ - [配置多分支数据流程](#配置多分支数据流程)
+ - [配置半监督数据加载](#配置半监督数据加载)
+ - [配置半监督模型](#配置半监督模型)
+ - [配置MeanTeacherHook](#配置meanteacherhook)
+ - [配置TeacherStudentValLoop](#配置teacherstudentvalloop)
+
+## 准备和拆分数据集
+
+我们提供了数据集下载脚本，默认下载 coco2017 数据集，并且自动解压。
+
+```shell
+python tools/misc/download_dataset.py
+```
+
+解压后的数据集目录如下：
+
+```plain
+mmdetection
+├── data
+│ ├── coco
+│ │ ├── annotations
+│ │ │ ├── image_info_unlabeled2017.json
+│ │ │ ├── instances_train2017.json
+│ │ │ ├── instances_val2017.json
+│ │ ├── test2017
+│ │ ├── train2017
+│ │ ├── unlabeled2017
+│ │ ├── val2017
+```
+
+半监督目标检测在 coco 数据集上有两种比较通用的实验设置：
+
+（1）将 `train2017` 按照固定百分比（1%，2%，5% 和 10%）划分出一部分数据作为标签数据集，剩余的训练集数据作为无标签数据集，同时考虑划分不同的训练集数据作为标签数据集对半监督训练的结果影响较大，所以采用五折交叉验证来评估算法性能。我们提供了数据集划分脚本：
+
+```shell
+python tools/misc/split_coco.py
+```
+
+该脚本默认会按照 1%，2%，5% 和 10% 的标签数据占比划分 `train2017`，每一种划分会随机重复 5 次，用于交叉验证。生成的半监督标注文件名称格式如下：
+
+- 标签数据集标注名称格式：`instances_train2017.{fold}@{percent}.json`
+
+- 无标签数据集名称标注：`instances_train2017.{fold}@{percent}-unlabeled.json`
+
+其中，`fold` 用于交叉验证，`percent` 表示标签数据的占比。 划分后的数据集目录结构如下：
+
+```plain
+mmdetection
+├── data
+│ ├── coco
+│ │ ├── annotations
+│ │ │ ├── image_info_unlabeled2017.json
+│ │ │ ├── instances_train2017.json
+│ │ │ ├── instances_val2017.json
+│ │ ├── semi_anns
+│ │ │ ├── instances_train2017.1@1.json
+│ │ │ ├── instances_train2017.1@1-unlabeled.json
+│ │ │ ├── instances_train2017.1@2.json
+│ │ │ ├── instances_train2017.1@2-unlabeled.json
+│ │ │ ├── instances_train2017.1@5.json
+│ │ │ ├── instances_train2017.1@5-unlabeled.json
+│ │ │ ├── instances_train2017.1@10.json
+│ │ │ ├── instances_train2017.1@10-unlabeled.json
+│ │ │ ├── instances_train2017.2@1.json
+│ │ │ ├── instances_train2017.2@1-unlabeled.json
+│ │ ├── test2017
+│ │ ├── train2017
+│ │ ├── unlabeled2017
+│ │ ├── val2017
+```
+
+（2）将 `train2017` 作为标签数据集，`unlabeled2017` 作为无标签数据集。由于 `image_info_unlabeled2017.json` 没有 `categories` 信息，无法初始化 `CocoDataset` ，所以需要将 `instances_train2017.json` 的 `categories` 写入 `image_info_unlabeled2017.json` ，另存为 `instances_unlabeled2017.json`，相关脚本如下：
+
+```python
+from mmengine.fileio import load, dump
+
+anns_train = load('instances_train2017.json')
+anns_unlabeled = load('image_info_unlabeled2017.json')
+anns_unlabeled['categories'] = anns_train['categories']
+dump(anns_unlabeled, 'instances_unlabeled2017.json')
+```
+
+处理后的数据集目录如下：
+
+```plain
+mmdetection
+├── data
+│ ├── coco
+│ │ ├── annotations
+│ │ │ ├── image_info_unlabeled2017.json
+│ │ │ ├── instances_train2017.json
+│ │ │ ├── instances_unlabeled2017.json
+│ │ │ ├── instances_val2017.json
+│ │ ├── test2017
+│ │ ├── train2017
+│ │ ├── unlabeled2017
+│ │ ├── val2017
+```
+
+## 配置多分支数据流程
+
+半监督学习有两个主要的方法，分别是
+[一致性正则化](https://research.nvidia.com/sites/default/files/publications/laine2017iclr_paper.pdf)
+和[伪标签](https://www.researchgate.net/profile/Dong-Hyun-Lee/publication/280581078_Pseudo-Label_The_Simple_and_Efficient_Semi-Supervised_Learning_Method_for_Deep_Neural_Networks/links/55bc4ada08ae092e9660b776/Pseudo-Label-The-Simple-and-Efficient-Semi-Supervised-Learning-Method-for-Deep-Neural-Networks.pdf) 。
+一致性正则化往往需要一些精心的设计，而伪标签的形式比较简单，更容易拓展到下游任务。我们主要采用了基于伪标签的教师学生联合训练的半监督目标检测框架，对于标签数据和无标签数据需要配置不同的数据流程：
+（1）标签数据的数据流程：
+
+```python
+# pipeline used to augment labeled data,
+# which will be sent to student model for supervised training.
+sup_pipeline = [
+ dict(type='LoadImageFromFile',backend_args = backend_args),
+ dict(type='LoadAnnotations', with_bbox=True),
+ dict(type='RandomResize', scale=scale, keep_ratio=True),
+ dict(type='RandomFlip', prob=0.5),
+ dict(type='RandAugment', aug_space=color_space, aug_num=1),
+ dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+ dict(type='MultiBranch', sup=dict(type='PackDetInputs'))
+]
+```
+
+（2）无标签的数据流程：
+
+```python
+# pipeline used to augment unlabeled data weakly,
+# which will be sent to teacher model for predicting pseudo instances.
+weak_pipeline = [
+ dict(type='RandomResize', scale=scale, keep_ratio=True),
+ dict(type='RandomFlip', prob=0.5),
+ dict(
+ type='PackDetInputs',
+ meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+ 'scale_factor', 'flip', 'flip_direction',
+ 'homography_matrix')),
+]
+
+# pipeline used to augment unlabeled data strongly,
+# which will be sent to student model for unsupervised training.
+strong_pipeline = [
+ dict(type='RandomResize', scale=scale, keep_ratio=True),
+ dict(type='RandomFlip', prob=0.5),
+ dict(
+ type='RandomOrder',
+ transforms=[
+ dict(type='RandAugment', aug_space=color_space, aug_num=1),
+ dict(type='RandAugment', aug_space=geometric, aug_num=1),
+ ]),
+ dict(type='RandomErasing', n_patches=(1, 5), ratio=(0, 0.2)),
+ dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+ dict(
+ type='PackDetInputs',
+ meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+ 'scale_factor', 'flip', 'flip_direction',
+ 'homography_matrix')),
+]
+
+# pipeline used to augment unlabeled data into different views
+unsup_pipeline = [
+ dict(type='LoadImageFromFile', backend_args = backend_args),
+ dict(type='LoadEmptyAnnotations'),
+ dict(
+ type='MultiBranch',
+ unsup_teacher=weak_pipeline,
+ unsup_student=strong_pipeline,
+ )
+]
+```
+
+## 配置半监督数据加载
+
+（1）构建半监督数据集。使用 `ConcatDataset` 拼接标签数据集和无标签数据集。
+
+```python
+labeled_dataset = dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_file='annotations/instances_train2017.json',
+ data_prefix=dict(img='train2017/'),
+ filter_cfg=dict(filter_empty_gt=True, min_size=32),
+ pipeline=sup_pipeline)
+
+unlabeled_dataset = dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_file='annotations/instances_unlabeled2017.json',
+ data_prefix=dict(img='unlabeled2017/'),
+ filter_cfg=dict(filter_empty_gt=False),
+ pipeline=unsup_pipeline)
+
+train_dataloader = dict(
+ batch_size=batch_size,
+ num_workers=num_workers,
+ persistent_workers=True,
+ sampler=dict(
+ type='GroupMultiSourceSampler',
+ batch_size=batch_size,
+ source_ratio=[1, 4]),
+ dataset=dict(
+ type='ConcatDataset', datasets=[labeled_dataset, unlabeled_dataset]))
+```
+
+（2）使用多源数据集采样器。 使用 `GroupMultiSourceSampler` 从 `labeled_dataset` 和 `labeled_dataset` 采样数据组成 batch , `source_ratio` 控制 batch 中标签数据和无标签数据的占比。`GroupMultiSourceSampler` 还保证了同一个 batch 中的图片具有相近的长宽比例，如果不需要保证batch内图片的长宽比例，可以使用 `MultiSourceSampler`。`GroupMultiSourceSampler` 采样示意图如下：
+
+
+
+
+
+
+`sup=1000` 表示标签数据集的规模为 1000 ，`sup_h=200` 表示标签数据集中长宽比大于等于1的图片规模为 200，`sup_w=800` 表示标签数据集中长宽比小于1的图片规模为 800 ，`unsup=9000` 表示无标签数据集的规模为 9000 ，`unsup_h=1800` 表示无标签数据集中长宽比大于等于1的图片规模为 1800，`unsup_w=7200` 表示标签数据集中长宽比小于1的图片规模为 7200 ，`GroupMultiSourceSampler` 每次按照标签数据集和无标签数据集的图片的总体长宽比分布随机选择一组，然后按照 `source_ratio` 从两个数据集中采样组成 batch ，因此标签数据集和无标签数据集重复采样次数不同。
+
+## 配置半监督模型
+
+我们选择 `Faster R-CNN` 作为 `detector` 进行半监督训练，以半监督目标检测算法 `SoftTeacher` 为例，模型的配置可以继承 `_base_/models/faster-rcnn_r50_fpn.py`，将检测器的骨干网络替换成 `caffe` 风格。
+注意，与监督训练的配置文件不同的是，`Faster R-CNN` 作为 `detector`，是作为 `model`的一个属性，而不是 `model` 。此外，还需要将`data_preprocessor`设置为`MultiBranchDataPreprocessor`，用于处理不同数据流程图片的填充和归一化。
+最后，可以通过 `semi_train_cfg` 和 `semi_test_cfg` 配置半监督训练和测试需要的参数。
+
+```python
+_base_ = [
+ '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/default_runtime.py',
+ '../_base_/datasets/semi_coco_detection.py'
+]
+
+detector = _base_.model
+detector.data_preprocessor = dict(
+ type='DetDataPreprocessor',
+ mean=[103.530, 116.280, 123.675],
+ std=[1.0, 1.0, 1.0],
+ bgr_to_rgb=False,
+ pad_size_divisor=32)
+detector.backbone = dict(
+ type='ResNet',
+ depth=50,
+ num_stages=4,
+ out_indices=(0, 1, 2, 3),
+ frozen_stages=1,
+ norm_cfg=dict(type='BN', requires_grad=False),
+ norm_eval=True,
+ style='caffe',
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint='open-mmlab://detectron2/resnet50_caffe'))
+
+model = dict(
+ _delete_=True,
+ type='SoftTeacher',
+ detector=detector,
+ data_preprocessor=dict(
+ type='MultiBranchDataPreprocessor',
+ data_preprocessor=detector.data_preprocessor),
+ semi_train_cfg=dict(
+ freeze_teacher=True,
+ sup_weight=1.0,
+ unsup_weight=4.0,
+ pseudo_label_initial_score_thr=0.5,
+ rpn_pseudo_thr=0.9,
+ cls_pseudo_thr=0.9,
+ reg_pseudo_thr=0.02,
+ jitter_times=10,
+ jitter_scale=0.06,
+ min_pseudo_bbox_wh=(1e-2, 1e-2)),
+ semi_test_cfg=dict(predict_on='teacher'))
+```
+
+此外，我们也支持其他检测模型进行半监督训练，比如，`RetinaNet` 和 `Cascade R-CNN`。由于 `SoftTeacher` 仅支持 `Faster R-CNN`，所以需要将其替换为 `SemiBaseDetector`，示例如下：
+
+```python
+_base_ = [
+ '../_base_/models/retinanet_r50_fpn.py', '../_base_/default_runtime.py',
+ '../_base_/datasets/semi_coco_detection.py'
+]
+
+detector = _base_.model
+
+model = dict(
+ _delete_=True,
+ type='SemiBaseDetector',
+ detector=detector,
+ data_preprocessor=dict(
+ type='MultiBranchDataPreprocessor',
+ data_preprocessor=detector.data_preprocessor),
+ semi_train_cfg=dict(
+ freeze_teacher=True,
+ sup_weight=1.0,
+ unsup_weight=1.0,
+ cls_pseudo_thr=0.9,
+ min_pseudo_bbox_wh=(1e-2, 1e-2)),
+ semi_test_cfg=dict(predict_on='teacher'))
+```
+
+沿用 `SoftTeacher` 的半监督训练配置，将 `batch_size` 改为 2 ，`source_ratio` 改为 `[1, 1]`，`RetinaNet`，`Faster R-CNN`， `Cascade R-CNN` 以及 `SoftTeacher` 在 10% coco 训练集上的监督训练和半监督训练的实验结果如下：
+
+| Model | Detector | BackBone | Style | sup-0.1-coco mAP | semi-0.1-coco mAP |
+| :--------------: | :-----------: | :------: | :---: | :--------------: | :---------------: |
+| SemiBaseDetector | RetinaNet | R-50-FPN | caffe | 23.5 | 27.7 |
+| SemiBaseDetector | Faster R-CNN | R-50-FPN | caffe | 26.7 | 28.4 |
+| SemiBaseDetector | Cascade R-CNN | R-50-FPN | caffe | 28.0 | 29.7 |
+| SoftTeacher | Faster R-CNN | R-50-FPN | caffe | 26.7 | 31.1 |
+
+## 配置MeanTeacherHook
+
+通常，教师模型采用对学生模型指数滑动平均（EMA）的方式进行更新，进而教师模型随着学生模型的优化而优化，可以通过配置 `custom_hooks` 实现：
+
+```python
+custom_hooks = [dict(type='MeanTeacherHook')]
+```
+
+## 配置TeacherStudentValLoop
+
+由于教师学生联合训练框架存在两个模型，我们可以用 `TeacherStudentValLoop` 替换 `ValLoop`，在训练的过程中同时检验两个模型的精度。
+
+```python
+val_cfg = dict(type='TeacherStudentValLoop')
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/single_stage_as_rpn.md b/internlm_langchain/knowledge_base/MMDetection/content/single_stage_as_rpn.md
new file mode 100644
index 00000000..39db35c2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/single_stage_as_rpn.md
@@ -0,0 +1,171 @@
+# 将单阶段检测器作为 RPN
+
+候选区域网络 (Region Proposal Network, RPN) 作为 [Faster R-CNN](https://arxiv.org/abs/1506.01497) 的一个子模块，将为 Faster R-CNN 的第二阶段产生候选区域。在 MMDetection 里大多数的二阶段检测器使用 [`RPNHead`](../../../mmdet/models/dense_heads/rpn_head.py)作为候选区域网络来产生候选区域。然而，任何的单阶段检测器都可以作为候选区域网络，是因为他们对边界框的预测可以被视为是一种候选区域，并且因此能够在 R-CNN 中得到改进。因此在 MMDetection v3.0 中会支持将单阶段检测器作为 RPN 使用。
+
+接下来我们通过一个例子，即如何在 [Faster R-CNN](../../../configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py) 中使用一个无锚框的单阶段的检测器模型 [FCOS](../../../configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py) 作为 RPN ，详细阐述具体的全部流程。
+
+主要流程如下:
+
+1. 在 Faster R-CNN 中使用 `FCOSHead` 作为 `RPNHead`
+2. 评估候选区域
+3. 用预先训练的 FCOS 训练定制的 Faster R-CNN
+
+## 在 Faster R-CNN 中使用 `FCOSHead` 作为` RPNHead`
+
+为了在 Faster R-CNN 中使用 `FCOSHead` 作为 `RPNHead` ，我们应该创建一个名为 `configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py` 的配置文件，并且在 `configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py` 中将 `rpn_head` 的设置替换为 `bbox_head` 的设置，此外我们仍然使用 FCOS 的瓶颈设置，步幅为`[8,16,32,64,128]`，并且更新 `bbox_roi_extractor` 的 `featmap_stride` 为 ` [8,16,32,64,128]`。为了避免损失变慢，我们在前1000次迭代而不是前500次迭代中应用预热，这意味着 lr 增长得更慢。相关配置如下:
+
+```python
+_base_ = [
+ '../_base_/models/faster-rcnn_r50_fpn.py',
+ '../_base_/datasets/coco_detection.py',
+ '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+ # 从 configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py 复制
+ neck=dict(
+ start_level=1,
+ add_extra_convs='on_output', # 使用 P5
+ relu_before_extra_convs=True),
+ rpn_head=dict(
+ _delete_=True, # 忽略未使用的旧设置
+ type='FCOSHead',
+ num_classes=1, # 对于 rpn, num_classes = 1，如果 num_classes > 1，它将在 TwoStageDetector 中自动设置为1
+ in_channels=256,
+ stacked_convs=4,
+ feat_channels=256,
+ strides=[8, 16, 32, 64, 128],
+ loss_cls=dict(
+ type='FocalLoss',
+ use_sigmoid=True,
+ gamma=2.0,
+ alpha=0.25,
+ loss_weight=1.0),
+ loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+ loss_centerness=dict(
+ type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+ roi_head=dict( # featmap_strides 的更新取决于于颈部的步伐
+ bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128])))
+# 学习率
+param_scheduler = [
+ dict(
+ type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+ end=1000), # 慢慢增加 lr，否则损失变成 NAN
+ dict(
+ type='MultiStepLR',
+ begin=0,
+ end=12,
+ by_epoch=True,
+ milestones=[8, 11],
+ gamma=0.1)
+]
+```
+
+然后，我们可以使用下面的命令来训练我们的定制模型。更多训练命令，请参考[这里](train.md)。
+
+```python
+# 使用8个 GPU 进行训练
+bash
+tools/dist_train.sh
+configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py
+--work-dir /work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco
+```
+
+## 评估候选区域
+
+候选区域的质量对检测器的性能有重要影响，因此，我们也提供了一种评估候选区域的方法。和上面一样创建一个新的名为 `configs/rpn/fcos-rpn_r50_fpn_1x_coco.py` 的配置文件，并且在 `configs/rpn/fcos-rpn_r50_fpn_1x_coco.py` 中将 `rpn_head` 的设置替换为 `bbox_head` 的设置。
+
+```python
+_base_ = [
+ '../_base_/models/rpn_r50_fpn.py', '../_base_/datasets/coco_detection.py',
+ '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+val_evaluator = dict(metric='proposal_fast')
+test_evaluator = val_evaluator
+model = dict(
+ # 从 configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py 复制
+ neck=dict(
+ start_level=1,
+ add_extra_convs='on_output', # 使用 P5
+ relu_before_extra_convs=True),
+ rpn_head=dict(
+ _delete_=True, # 忽略未使用的旧设置
+ type='FCOSHead',
+ num_classes=1, # 对于 rpn, num_classes = 1，如果 num_classes >为1，它将在 rpn 中自动设置为1
+ in_channels=256,
+ stacked_convs=4,
+ feat_channels=256,
+ strides=[8, 16, 32, 64, 128],
+ loss_cls=dict(
+ type='FocalLoss',
+ use_sigmoid=True,
+ gamma=2.0,
+ alpha=0.25,
+ loss_weight=1.0),
+ loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+ loss_centerness=dict(
+ type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)))
+```
+
+假设我们在训练之后有检查点 `./work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco/epoch_12.pth` ，然后，我们可以使用下面的命令来评估建议的质量。
+
+```python
+# 使用8个 GPU 进行测试
+bash
+tools/dist_test.sh
+configs/rpn/fcos-rpn_r50_fpn_1x_coco.py
+--work_dirs /faster-rcnn_r50_fpn_fcos-rpn_1x_coco/epoch_12.pth
+```
+
+## 用预先训练的 FCOS 训练定制的 Faster R-CNN
+
+预训练不仅加快了训练的收敛速度，而且提高了检测器的性能。因此，我们在这里给出一个例子来说明如何使用预先训练的 FCOS 作为 RPN 来加速训练和提高精度。假设我们想在 Faster R-CNN 中使用 `FCOSHead` 作为 `rpn_head`，并加载预先训练权重来进行训练 [`fcos_r50-caffe_fpn_gn-head_1x_coco`](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth)。 配置文件 `configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_fcos- rpn_1x_copy .py` 的内容如下所示。注意，`fcos_r50-caffe_fpn_gn-head_1x_coco` 使用 ResNet50 的 caffe 版本，因此需要更新 `data_preprocessor` 中的像素平均值和 std。
+
+```python
+_base_ = [
+ '../_base_/models/faster-rcnn_r50_fpn.py',
+ '../_base_/datasets/coco_detection.py',
+ '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+ data_preprocessor=dict(
+ mean=[103.530, 116.280, 123.675],
+ std=[1.0, 1.0, 1.0],
+ bgr_to_rgb=False),
+ backbone=dict(
+ norm_cfg=dict(type='BN', requires_grad=False),
+ style='caffe',
+ init_cfg=None), # the checkpoint in ``load_from`` contains the weights of backbone
+ neck=dict(
+ start_level=1,
+ add_extra_convs='on_output', # 使用 P5
+ relu_before_extra_convs=True),
+ rpn_head=dict(
+ _delete_=True, # 忽略未使用的旧设置
+ type='FCOSHead',
+ num_classes=1, # 对于 rpn, num_classes = 1，如果 num_classes > 1，它将在 TwoStageDetector 中自动设置为1
+ in_channels=256,
+ stacked_convs=4,
+ feat_channels=256,
+ strides=[8, 16, 32, 64, 128],
+ loss_cls=dict(
+ type='FocalLoss',
+ use_sigmoid=True,
+ gamma=2.0,
+ alpha=0.25,
+ loss_weight=1.0),
+ loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+ loss_centerness=dict(
+ type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+ roi_head=dict( # update featmap_strides due to the strides in neck
+ bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128])))
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth'
+```
+
+训练命令如下。
+
+```python
+bash
+tools/dist_train.sh
+configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco.py \
+--work-dir /work_dirs/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/structures.md b/internlm_langchain/knowledge_base/MMDetection/content/structures.md
new file mode 100644
index 00000000..c2118c34
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/structures.md
@@ -0,0 +1 @@
+# 数据结构（待更新）
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/test.md b/internlm_langchain/knowledge_base/MMDetection/content/test.md
new file mode 100644
index 00000000..1b165b04
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/test.md
@@ -0,0 +1,285 @@
+# 测试现有模型
+
+我们提供了测试脚本，能够测试一个现有模型在所有数据集（COCO，Pascal VOC，Cityscapes 等）上的性能。我们支持在如下环境下测试：
+
+- 单 GPU 测试
+- CPU 测试
+- 单节点多 GPU 测试
+- 多节点测试
+
+根据以上测试环境，选择合适的脚本来执行测试过程。
+
+```shell
+# 单 GPU 测试
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ [--out ${RESULT_FILE}] \
+ [--show]
+
+# CPU 测试：禁用 GPU 并运行单 GPU 测试脚本
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ [--out ${RESULT_FILE}] \
+ [--show]
+
+# 单节点多 GPU 测试
+bash tools/dist_test.sh \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ ${GPU_NUM} \
+ [--out ${RESULT_FILE}]
+```
+
+`tools/dist_test.sh` 也支持多节点测试，不过需要依赖 PyTorch 的 [启动工具](https://pytorch.org/docs/stable/distributed.html#launch-utility) 。
+
+可选参数：
+
+- `RESULT_FILE`: 结果文件名称，需以 .pkl 形式存储。如果没有声明，则不将结果存储到文件。
+- `--show`: 如果开启，检测结果将被绘制在图像上，以一个新窗口的形式展示。它只适用于单 GPU 的测试，是用于调试和可视化的。请确保使用此功能时，你的 GUI 可以在环境中打开。否则，你可能会遇到这么一个错误 `cannot connect to X server`。
+- `--show-dir`: 如果指明，检测结果将会被绘制在图像上并保存到指定目录。它只适用于单 GPU 的测试，是用于调试和可视化的。即使你的环境中没有 GUI，这个选项也可使用。
+- `--cfg-options`: 如果指明，这里的键值对将会被合并到配置文件中。
+
+### 样例
+
+假设你已经下载了 checkpoint 文件到 `checkpoints/` 文件下了。
+
+1. 测试 RTMDet 并可视化其结果。按任意键继续下张图片的测试。配置文件和 checkpoint 文件 [在此](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) 。
+
+ ```shell
+ python tools/test.py \
+ configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+ checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+ --show
+ ```
+
+2. 测试 RTMDet，并为了之后的可视化保存绘制的图像。配置文件和 checkpoint 文件 [在此](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) 。
+
+ ```shell
+ python tools/test.py \
+ configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+ checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+ --show-dir rtmdet_l_8xb32-300e_coco_results
+ ```
+
+3. 在 Pascal VOC 数据集上测试 Faster R-CNN，不保存测试结果，测试 `mAP`。配置文件和 checkpoint 文件 [在此](../../../configs/pascal_voc) 。
+
+ ```shell
+ python tools/test.py \
+ configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712.py \
+ checkpoints/faster_rcnn_r50_fpn_1x_voc0712_20200624-c9895d40.pth
+ ```
+
+4. 使用 8 块 GPU 测试 Mask R-CNN，测试 `bbox` 和 `mAP` 。配置文件和 checkpoint 文件 [在此](../../../configs/mask_rcnn) 。
+
+ ```shell
+ ./tools/dist_test.sh \
+ configs/mask-rcnn_r50_fpn_1x_coco.py \
+ checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+ 8 \
+ --out results.pkl
+ ```
+
+5. 使用 8 块 GPU 测试 Mask R-CNN，测试**每类**的 `bbox` 和 `mAP`。配置文件和 checkpoint 文件 [在此](../../../configs/mask_rcnn) 。
+
+ ```shell
+ ./tools/dist_test.sh \
+ configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+ checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+ 8
+ ```
+
+ 该命令生成两个JSON文件 `./work_dirs/coco_instance/test.bbox.json` 和 `./work_dirs/coco_instance/test.segm.json`。
+
+6. 在 COCO test-dev 数据集上，使用 8 块 GPU 测试 Mask R-CNN，并生成 JSON 文件提交到官方评测服务器，配置文件和 checkpoint 文件 [在此](../../../configs/mask_rcnnn) 。你可以在 [config](./././configs/_base_/datasets/coco_instance.py) 的注释中用 test_evaluator 和 test_dataloader 替换原来的 test_evaluator 和 test_dataloader，然后运行：
+
+ ```shell
+ ./tools/dist_test.sh \
+ configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py \
+ checkpoints/mask_rcnn_r50_fpn_1x_cityscapes_20200227-afe51d5a.pth \
+ 8
+ ```
+
+ 这行命令生成两个 JSON 文件 `mask_rcnn_test-dev_results.bbox.json` 和 `mask_rcnn_test-dev_results.segm.json`。
+
+7. 在 Cityscapes 数据集上，使用 8 块 GPU 测试 Mask R-CNN，生成 txt 和 png 文件，并上传到官方评测服务器。配置文件和 checkpoint 文件 [在此](../../../configs/cityscapes) 。 你可以在 [config](./././configs/_base_/datasets/cityscapes_instance.py) 的注释中用 test_evaluator 和 test_dataloader 替换原来的 test_evaluator 和 test_dataloader，然后运行：
+
+ ```shell
+ ./tools/dist_test.sh \
+ configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py \
+ checkpoints/mask_rcnn_r50_fpn_1x_cityscapes_20200227-afe51d5a.pth \
+ 8
+ ```
+
+ 生成的 png 和 txt 文件在 `./work_dirs/cityscapes_metric` 文件夹下。
+
+### 不使用 Ground Truth 标注进行测试
+
+MMDetection 支持在不使用 ground-truth 标注的情况下对模型进行测试，这需要用到 `CocoDataset`。如果你的数据集格式不是 COCO 格式的，请将其转化成 COCO 格式。如果你的数据集格式是 VOC 或者 Cityscapes，你可以使用 [tools/dataset_converters](https://github.com/open-mmlab/mmdetection/tree/main/tools/dataset_converters) 内的脚本直接将其转化成 COCO 格式。如果是其他格式，可以使用 [images2coco 脚本](https://github.com/open-mmlab/mmdetection/tree/master/tools/dataset_converters/images2coco.py) 进行转换。
+
+```shell
+python tools/dataset_converters/images2coco.py \
+ ${IMG_PATH} \
+ ${CLASSES} \
+ ${OUT} \
+ [--exclude-extensions]
+```
+
+参数：
+
+- `IMG_PATH`: 图片根路径。
+- `CLASSES`: 类列表文本文件名。文本中每一行存储一个类别。
+- `OUT`: 输出 json 文件名。 默认保存目录和 `IMG_PATH` 在同一级。
+- `exclude-extensions`: 待排除的文件后缀名。
+
+在转换完成后，使用如下命令进行测试
+
+```shell
+# 单 GPU 测试
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ [--show]
+
+# CPU 测试：禁用 GPU 并运行单 GPU 测试脚本
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ [--out ${RESULT_FILE}] \
+ [--show]
+
+# 单节点多 GPU 测试
+bash tools/dist_test.sh \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ ${GPU_NUM} \
+ [--show]
+```
+
+假设 [model zoo](https://mmdetection.readthedocs.io/en/latest/modelzoo_statistics.html) 中的 checkpoint 文件被下载到了 `checkpoints/` 文件夹下，
+我们可以使用以下命令，用 8 块 GPU 在 COCO test-dev 数据集上测试 Mask R-CNN，并且生成 JSON 文件。
+
+```sh
+./tools/dist_test.sh \
+ configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+ checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+ 8
+```
+
+这行命令生成两个 JSON 文件 `./work_dirs/coco_instance/test.bbox.jso` 和 `./work_dirs/coco_instance/test.segm.jsonn`。
+
+### 批量推理
+
+MMDetection 在测试模式下，既支持单张图片的推理，也支持对图像进行批量推理。默认情况下，我们使用单张图片的测试，你可以通过修改测试数据配置文件中的 `samples_per_gpu` 来开启批量测试。
+开启批量推理的配置文件修改方法为：
+
+```shell
+data = dict(train_dataloader=dict(...), val_dataloader=dict(...), test_dataloader=dict(batch_size=2, ...))
+```
+
+或者你可以通过将 `--cfg-options` 设置为 `--cfg-options test_dataloader.batch_size=` 来开启它。
+
+## 测试时增强 (TTA)
+
+测试时增强 (TTA) 是一种在测试阶段使用的数据增强策略。它对同一张图片应用不同的增强，例如翻转和缩放，用于模型推理，然后将每个增强后的图像的预测结果合并，以获得更准确的预测结果。为了让用户更容易使用 TTA，MMEngine 提供了 [BaseTTAModel](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.model.BaseTTAModel.html#mmengine.model.BaseTTAModel) 类，允许用户根据自己的需求通过简单地扩展 BaseTTAModel 类来实现不同的 TTA 策略。
+
+在 MMDetection 中，我们提供了 [DetTTAModel](../../../mmdet/models/test_time_augs/det_tta.py) 类，它继承自 BaseTTAModel。
+
+### 使用案例
+
+使用 TTA 需要两个步骤。首先，你需要在配置文件中添加 `tta_model` 和 `tta_pipeline`：
+
+```shell
+tta_model = dict(
+ type='DetTTAModel',
+ tta_cfg=dict(nms=dict(
+ type='nms',
+ iou_threshold=0.5),
+ max_per_img=100))
+
+tta_pipeline = [
+ dict(type='LoadImageFromFile',
+ backend_args=None),
+ dict(
+ type='TestTimeAug',
+ transforms=[[
+ dict(type='Resize', scale=(1333, 800), keep_ratio=True)
+ ], [ # It uses 2 flipping transformations (flipping and not flipping).
+ dict(type='RandomFlip', prob=1.),
+ dict(type='RandomFlip', prob=0.)
+ ], [
+ dict(
+ type='PackDetInputs',
+ meta_keys=('img_id', 'img_path', 'ori_shape',
+ 'img_shape', 'scale_factor', 'flip',
+ 'flip_direction'))
+ ]])]
+```
+
+第二步，运行测试脚本时，设置 `--tta` 参数，如下所示：
+
+```shell
+# 单 GPU 测试
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ [--tta]
+
+# CPU 测试：禁用 GPU 并运行单 GPU 测试脚本
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ [--out ${RESULT_FILE}] \
+ [--tta]
+
+# 多 GPU 测试
+bash tools/dist_test.sh \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ ${GPU_NUM} \
+ [--tta]
+```
+
+你也可以自己修改 TTA 配置，例如添加缩放增强：
+
+```shell
+tta_model = dict(
+ type='DetTTAModel',
+ tta_cfg=dict(nms=dict(
+ type='nms',
+ iou_threshold=0.5),
+ max_per_img=100))
+
+img_scales = [(1333, 800), (666, 400), (2000, 1200)]
+tta_pipeline = [
+ dict(type='LoadImageFromFile',
+ backend_args=None),
+ dict(
+ type='TestTimeAug',
+ transforms=[[
+ dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales
+ ], [
+ dict(type='RandomFlip', prob=1.),
+ dict(type='RandomFlip', prob=0.)
+ ], [
+ dict(
+ type='PackDetInputs',
+ meta_keys=('img_id', 'img_path', 'ori_shape',
+ 'img_shape', 'scale_factor', 'flip',
+ 'flip_direction'))
+ ]])]
+```
+
+以上数据增强管道将首先对图像执行 3 个多尺度转换，然后执行 2 个翻转转换（翻转和不翻转），最后使用 PackDetInputs 将图像打包到最终结果中。
+这里有更多的 TTA 使用案例供您参考：
+
+- [RetinaNet](../../../configs/retinanet/retinanet_tta.py)
+- [CenterNet](../../../configs/centernet/centernet_tta.py)
+- [YOLOX](../../../configs/rtmdet/rtmdet_tta.py)
+- [RTMDet](../../../configs/yolox/yolox_tta.py)
+
+更多高级用法和 TTA 的数据流，请参考 [MMEngine](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/test_time_augmentation.html#data-flow)。我们将在后续支持实例分割 TTA。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/test_results_submission.md b/internlm_langchain/knowledge_base/MMDetection/content/test_results_submission.md
new file mode 100644
index 00000000..7a076585
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/test_results_submission.md
@@ -0,0 +1,174 @@
+# 提交测试结果
+
+## 全景分割测试结果提交
+
+下面几节介绍如何在 COCO 测试开发集上生成泛视分割模型的预测结果，并将预测提交到 [COCO评估服务器](https://competitions.codalab.org/competitions/19507)
+
+### 前提条件
+
+- 下载 [COCO测试数据集图像](http://images.cocodataset.org/zips/test2017.zip)，[测试图像信息](http://images.cocodataset.org/annotations/image_info_test2017.zip)，和[全景训练/相关注释](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip)，然后解压缩它们，把 `test2017` 放到 `data/coco/`，把 json 文件和注释文件放到 `data/coco/annotations/` 。
+
+```shell
+# 假设 data/coco/ 不存在
+mkdir -pv data/coco/
+# 下载 test2017
+wget -P data/coco/ http://images.cocodataset.org/zips/test2017.zip
+wget -P data/coco/ http://images.cocodataset.org/annotations/image_info_test2017.zip
+wget -P data/coco/ http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip
+# 解压缩它们
+unzip data/coco/test2017.zip -d data/coco/
+unzip data/coco/image_info_test2017.zip -d data/coco/
+unzip data/coco/panoptic_annotations_trainval2017.zip -d data/coco/
+# 删除 zip 文件(可选)
+rm -rf data/coco/test2017.zip data/coco/image_info_test2017.zip data/coco/panoptic_annotations_trainval2017.zip
+```
+
+- 运行以下代码更新测试图像信息中的类别信息。由于 `image_info_test-dev2017.json` 的类别信息中缺少属性 `isthing` ，我们需要用 `panoptic_val2017.json` 中的类别信息更新它。
+
+```shell
+python tools/misc/gen_coco_panoptic_test_info.py data/coco/annotations
+```
+
+在完成上述准备之后，你的 `data` 目录结构应该是这样:
+
+```text
+data
+`-- coco
+ |-- annotations
+ | |-- image_info_test-dev2017.json
+ | |-- image_info_test2017.json
+ | |-- panoptic_image_info_test-dev2017.json
+ | |-- panoptic_train2017.json
+ | |-- panoptic_train2017.zip
+ | |-- panoptic_val2017.json
+ | `-- panoptic_val2017.zip
+ `-- test2017
+```
+
+### coco 测试开发的推理
+
+要在 coco test-dev 上进行推断，我们应该首先更新 `test_dataloder` 和 `test_evaluator` 的设置。有两种方法可以做到这一点:1. 在配置文件中更新它们;2. 在命令行中更新它们。
+
+#### 在配置文件中更新它们
+
+相关的设置在 `configs/_base_/datasets/ coco_panoptical .py` 的末尾，如下所示。
+
+```python
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=1,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_file='annotations/panoptic_image_info_test-dev2017.json',
+ data_prefix=dict(img='test2017/'),
+ test_mode=True,
+ pipeline=test_pipeline))
+test_evaluator = dict(
+ type='CocoPanopticMetric',
+ format_only=True,
+ ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+ outfile_prefix='./work_dirs/coco_panoptic/test')
+```
+
+以下任何一种方法都可以用于更新 coco test-dev 集上的推理设置
+
+情况1:直接取消注释 `configs/_base_/datasets/ coco_panoptical .py` 中的设置。
+
+情况2:将以下设置复制到您现在使用的配置文件中。
+
+```python
+test_dataloader = dict(
+ dataset=dict(
+ ann_file='annotations/panoptic_image_info_test-dev2017.json',
+ data_prefix=dict(img='test2017/', _delete_=True)))
+test_evaluator = dict(
+ format_only=True,
+ ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+ outfile_prefix='./work_dirs/coco_panoptic/test')
+```
+
+然后通过以下命令对 coco test-dev et 进行推断。
+
+```shell
+python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE}
+```
+
+#### 在命令行中更新它们
+
+coco test-dev 上更新相关设置和推理的命令如下所示。
+
+```shell
+# 用一个 gpu 测试
+CUDA_VISIBLE_DEVICES=0 python tools/test.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ --cfg-options \
+ test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+ test_dataloader.dataset.data_prefix.img=test2017 \
+ test_dataloader.dataset.data_prefix._delete_=True \
+ test_evaluator.format_only=True \
+ test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+ test_evaluator.outfile_prefix=${WORK_DIR}/results
+# 用四个 gpu 测试
+CUDA_VISIBLE_DEVICES=0,1,3,4 bash tools/dist_test.sh \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ 8 \ # eights gpus
+ --cfg-options \
+ test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+ test_dataloader.dataset.data_prefix.img=test2017 \
+ test_dataloader.dataset.data_prefix._delete_=True \
+ test_evaluator.format_only=True \
+ test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+ test_evaluator.outfile_prefix=${WORK_DIR}/results
+# 用 slurm 测试
+GPUS=8 tools/slurm_test.sh \
+ ${Partition} \
+ ${JOB_NAME} \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT_FILE} \
+ --cfg-options \
+ test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+ test_dataloader.dataset.data_prefix.img=test2017 \
+ test_dataloader.dataset.data_prefix._delete_=True \
+ test_evaluator.format_only=True \
+ test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+ test_evaluator.outfile_prefix=${WORK_DIR}/results
+```
+
+例子:假设我们使用预先训练的带有 ResNet-50 骨干网的 MaskFormer 对 `test2017` 执行推断。
+
+```shell
+# 单 gpu 测试
+CUDA_VISIBLE_DEVICES=0 python tools/test.py \
+ configs/maskformer/maskformer_r50_mstrain_16x1_75e_coco.py \
+ checkpoints/maskformer_r50_mstrain_16x1_75e_coco_20220221_141956-bc2699cb.pth \
+ --cfg-options \
+ test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+ test_dataloader.dataset.data_prefix.img=test2017 \
+ test_dataloader.dataset.data_prefix._delete_=True \
+ test_evaluator.format_only=True \
+ test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+ test_evaluator.outfile_prefix=work_dirs/maskformer/results
+```
+
+### 重命名文件并压缩结果
+
+推理之后，全景分割结果(一个 json 文件和一个存储掩码的目录)将在 `WORK_DIR` 中。我们应该按照 [COCO's Website](https://cocodataset.org/#upload)上的命名约定重新命名它们。最后，我们需要将 json 和存储掩码的目录压缩到 zip 文件中，并根据命名约定重命名该 zip 文件。注意， zip 文件应该**直接**包含上述两个文件。
+
+重命名文件和压缩结果的命令:
+
+```shell
+# 在 WORK_DIR 中，我们有 panoptic 分割结果: 'panoptic' 和 'results. panoptical .json'。
+cd ${WORK_DIR}
+# 将 '[algorithm_name]' 替换为您使用的算法名称
+mv ./panoptic ./panoptic_test-dev2017_[algorithm_name]_results
+mv ./results.panoptic.json ./panoptic_test-dev2017_[algorithm_name]_results.json
+zip panoptic_test-dev2017_[algorithm_name]_results.zip -ur panoptic_test-dev2017_[algorithm_name]_results panoptic_test-dev2017_[algorithm_name]_results.json
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/train.md b/internlm_langchain/knowledge_base/MMDetection/content/train.md
new file mode 100644
index 00000000..8feb1aa6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/train.md
@@ -0,0 +1,451 @@
+# 在标准数据集上训练预定义的模型
+
+MMDetection 也为训练检测模型提供了开盖即食的工具。本节将展示在标准数据集（比如 COCO）上如何训练一个预定义的模型。
+
+### 数据集
+
+训练需要准备好数据集，细节请参考 [数据集准备](#%E6%95%B0%E6%8D%AE%E9%9B%86%E5%87%86%E5%A4%87) 。
+
+**注意**：
+目前，`configs/cityscapes` 文件夹下的配置文件都是使用 COCO 预训练权值进行初始化的。如果网络连接不可用或者速度很慢，你可以提前下载现存的模型。否则可能在训练的开始会有错误发生。
+
+### 学习率自动缩放
+
+**注意**：在配置文件中的学习率是在 8 块 GPU，每块 GPU 有 2 张图像（批大小为 8\*2=16）的情况下设置的。其已经设置在 `config/_base_/schedules/schedule_1x.py` 中的 `auto_scale_lr.base_batch_size`。学习率会基于批次大小为 `16`时的值进行自动缩放。同时，为了不影响其他基于 mmdet 的 codebase，启用自动缩放标志 `auto_scale_lr.enable` 默认设置为 `False`。
+
+如果要启用此功能，需在命令添加参数 `--auto-scale-lr`。并且在启动命令之前，请检查下即将使用的配置文件的名称，因为配置名称指示默认的批处理大小。
+在默认情况下，批次大小是 `8 x 2 = 16`，例如：`faster_rcnn_r50_caffe_fpn_90k_coco.py` 或者 `pisa_faster_rcnn_x101_32x4d_fpn_1x_coco.py`；若不是默认批次，你可以在配置文件看到像 `_NxM_` 字样的，例如：`cornernet_hourglass104_mstest_32x3_210e_coco.py` 的批次大小是 `32 x 3 = 96`, 或者 `scnet_x101_64x4d_fpn_8x1_20e_coco.py` 的批次大小是 `8 x 1 = 8`。
+
+**请记住：如果使用不是默认批次大小为 `16`的配置文件，请检查配置文件中的底部，会有 `auto_scale_lr.base_batch_size`。如果找不到，可以在其继承的 `_base_=[xxx]` 文件中找到。另外，如果想使用自动缩放学习率的功能，请不要修改这些值。**
+
+学习率自动缩放基本用法如下：
+
+```shell
+python tools/train.py \
+ ${CONFIG_FILE} \
+ --auto-scale-lr \
+ [optional arguments]
+```
+
+执行命令之后，会根据机器的GPU数量和训练的批次大小对学习率进行自动缩放，缩放方式详见 [线性扩展规则](https://arxiv.org/abs/1706.02677) ，比如：在 4 块 GPU 并且每张 GPU 上有 2 张图片的情况下 `lr=0.01`，那么在 16 块 GPU 并且每张 GPU 上有 4 张图片的情况下, LR 会自动缩放至 `lr=0.08`。
+
+如果不启用该功能，则需要根据 [线性扩展规则](https://arxiv.org/abs/1706.02677) 来手动计算并修改配置文件里面 `optimizer.lr` 的值。
+
+### 使用单 GPU 训练
+
+我们提供了 `tools/train.py` 来开启在单张 GPU 上的训练任务。基本使用如下：
+
+```shell
+python tools/train.py \
+ ${CONFIG_FILE} \
+ [optional arguments]
+```
+
+在训练期间，日志文件和 checkpoint 文件将会被保存在工作目录下，它需要通过配置文件中的 `work_dir` 或者 CLI 参数中的 `--work-dir` 来指定。
+
+默认情况下，模型将在每轮训练之后在 validation 集上进行测试，测试的频率可以通过设置配置文件来指定：
+
+```python
+# 每 12 轮迭代进行一次测试评估
+train_cfg = dict(val_interval=12)
+```
+
+这个工具接受以下参数：
+
+- `--work-dir ${WORK_DIR}`: 覆盖工作目录.
+- `--resume`：自动从work_dir中的最新检查点恢复.
+- `--resume ${CHECKPOINT_FILE}`: 从某个 checkpoint 文件继续训练.
+- `--cfg-options 'Key=value'`: 覆盖使用的配置文件中的其他设置.
+
+**注意**：
+`resume` 和 `load-from` 的区别：
+
+`resume` 既加载了模型的权重和优化器的状态，也会继承指定 checkpoint 的迭代次数，不会重新开始训练。`load-from` 则是只加载模型的权重，它的训练是从头开始的，经常被用于微调模型。其中load-from需要写入配置文件中，而resume作为命令行参数传入。
+
+### 使用 CPU 训练
+
+使用 CPU 训练的流程和使用单 GPU 训练的流程一致，我们仅需要在训练流程开始前禁用 GPU。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+之后运行单 GPU 训练脚本即可。
+
+**注意**：
+
+我们不推荐用户使用 CPU 进行训练，这太过缓慢。我们支持这个功能是为了方便用户在没有 GPU 的机器上进行调试。
+
+### 在多 GPU 上训练
+
+我们提供了 `tools/dist_train.sh` 来开启在多 GPU 上的训练。基本使用如下：
+
+```shell
+bash ./tools/dist_train.sh \
+ ${CONFIG_FILE} \
+ ${GPU_NUM} \
+ [optional arguments]
+```
+
+可选参数和单 GPU 训练的可选参数一致。
+
+#### 同时启动多个任务
+
+如果你想在一台机器上启动多个任务的话，比如在一个有 8 块 GPU 的机器上启动 2 个需要 4 块GPU的任务，你需要给不同的训练任务指定不同的端口（默认为 29500）来避免冲突。
+
+如果你使用 `dist_train.sh` 来启动训练任务，你可以使用命令来设置端口。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+### 使用多台机器训练
+
+如果您想使用由 ethernet 连接起来的多台机器， 您可以使用以下命令:
+
+在第一台机器上:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+在第二台机器上:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+但是，如果您不使用高速网路连接这几台机器的话，训练将会非常慢。
+
+### 使用 Slurm 来管理任务
+
+Slurm 是一个常见的计算集群调度系统。在 Slurm 管理的集群上，你可以使用 `slurm.sh` 来开启训练任务。它既支持单节点训练也支持多节点训练。
+
+基本使用如下：
+
+```shell
+[GPUS=${GPUS}] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
+```
+
+以下是在一个名称为 _dev_ 的 Slurm 分区上，使用 16 块 GPU 来训练 Mask R-CNN 的例子，并且将 `work-dir` 设置在了某些共享文件系统下。
+
+```shell
+GPUS=16 ./tools/slurm_train.sh dev mask_r50_1x configs/mask_rcnn_r50_fpn_1x_coco.py /nfs/xxxx/mask_rcnn_r50_fpn_1x
+```
+
+你可以查看 [源码](https://github.com/open-mmlab/mmdetection/blob/main/tools/slurm_train.sh) 来检查全部的参数和环境变量.
+
+在使用 Slurm 时，端口需要以下方的某个方法之一来设置。
+
+1. 通过 `--options` 来设置端口。我们非常建议用这种方法，因为它无需改变原始的配置文件。
+
+ ```shell
+ CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR} --cfg-options 'dist_params.port=29500'
+ CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR} --cfg-options 'dist_params.port=29501'
+ ```
+
+2. 修改配置文件来设置不同的交流端口。
+
+ 在 `config1.py` 中，设置：
+
+ ```python
+ dist_params = dict(backend='nccl', port=29500)
+ ```
+
+ 在 `config2.py` 中，设置：
+
+ ```python
+ dist_params = dict(backend='nccl', port=29501)
+ ```
+
+ 然后你可以使用 `config1.py` 和 `config2.py` 来启动两个任务了。
+
+ ```shell
+ CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+ CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+ ```
+
+# 在自定义数据集上进行训练
+
+通过本文档，你将会知道如何使用自定义数据集对预先定义好的模型进行推理，测试以及训练。我们使用 [balloon dataset](https://github.com/matterport/Mask_RCNN/tree/master/samples/balloon) 作为例子来描述整个过程。
+
+基本步骤如下：
+
+1. 准备自定义数据集
+2. 准备配置文件
+3. 在自定义数据集上进行训练，测试和推理。
+
+## 准备自定义数据集
+
+MMDetection 一共支持三种形式应用新数据集：
+
+1. 将数据集重新组织为 COCO 格式。
+2. 将数据集重新组织为一个中间格式。
+3. 实现一个新的数据集。
+
+我们通常建议使用前面两种方法，因为它们通常来说比第三种方法要简单。
+
+在本文档中，我们展示一个例子来说明如何将数据转化为 COCO 格式。
+
+**注意**：在 MMDetection 3.0 之后，数据集和指标已经解耦（除了 CityScapes）。因此，用户在验证阶段使用任意的评价指标来评价模型在任意数据集上的性能。比如，用 VOC 评价指标来评价模型在 COCO 数据集的性能，或者同时使用 VOC 评价指标和 COCO 评价指标来评价模型在 OpenImages 数据集上的性能。
+
+### COCO标注格式
+
+用于实例分割的 COCO 数据集格式如下所示，其中的键（key）都是必要的，参考[这里](https://cocodataset.org/#format-data)来获取更多细节。
+
+```json
+{
+ "images": [image],
+ "annotations": [annotation],
+ "categories": [category]
+}
+
+
+image = {
+ "id": int,
+ "width": int,
+ "height": int,
+ "file_name": str,
+}
+
+annotation = {
+ "id": int,
+ "image_id": int,
+ "category_id": int,
+ "segmentation": RLE or [polygon],
+ "area": float,
+ "bbox": [x,y,width,height], # (x, y) 为 bbox 左上角的坐标
+ "iscrowd": 0 or 1,
+}
+
+categories = [{
+ "id": int,
+ "name": str,
+ "supercategory": str,
+}]
+```
+
+现在假设我们使用 balloon dataset。
+
+下载了数据集之后，我们需要实现一个函数将标注格式转化为 COCO 格式。然后我们就可以使用已经实现的 `CocoDataset` 类来加载数据并进行训练以及评测。
+
+如果你浏览过新数据集，你会发现格式如下：
+
+```json
+{'base64_img_data': '',
+ 'file_attributes': {},
+ 'filename': '34020010494_e5cb88e1c4_k.jpg',
+ 'fileref': '',
+ 'regions': {'0': {'region_attributes': {},
+ 'shape_attributes': {'all_points_x': [1020,
+ 1000,
+ 994,
+ 1003,
+ 1023,
+ 1050,
+ 1089,
+ 1134,
+ 1190,
+ 1265,
+ 1321,
+ 1361,
+ 1403,
+ 1428,
+ 1442,
+ 1445,
+ 1441,
+ 1427,
+ 1400,
+ 1361,
+ 1316,
+ 1269,
+ 1228,
+ 1198,
+ 1207,
+ 1210,
+ 1190,
+ 1177,
+ 1172,
+ 1174,
+ 1170,
+ 1153,
+ 1127,
+ 1104,
+ 1061,
+ 1032,
+ 1020],
+ 'all_points_y': [963,
+ 899,
+ 841,
+ 787,
+ 738,
+ 700,
+ 663,
+ 638,
+ 621,
+ 619,
+ 643,
+ 672,
+ 720,
+ 765,
+ 800,
+ 860,
+ 896,
+ 942,
+ 990,
+ 1035,
+ 1079,
+ 1112,
+ 1129,
+ 1134,
+ 1144,
+ 1153,
+ 1166,
+ 1166,
+ 1150,
+ 1136,
+ 1129,
+ 1122,
+ 1112,
+ 1084,
+ 1037,
+ 989,
+ 963],
+ 'name': 'polygon'}}},
+ 'size': 1115004}
+```
+
+标注文件时是 JSON 格式的，其中所有键（key）组成了一张图片的所有标注。
+
+其中将 balloon dataset 转化为 COCO 格式的代码如下所示。
+
+```python
+import os.path as osp
+
+import mmcv
+
+from mmengine.fileio import dump, load
+from mmengine.utils import track_iter_progress
+
+
+def convert_balloon_to_coco(ann_file, out_file, image_prefix):
+ data_infos = load(ann_file)
+
+ annotations = []
+ images = []
+ obj_count = 0
+ for idx, v in enumerate(track_iter_progress(data_infos.values())):
+ filename = v['filename']
+ img_path = osp.join(image_prefix, filename)
+ height, width = mmcv.imread(img_path).shape[:2]
+
+ images.append(
+ dict(id=idx, file_name=filename, height=height, width=width))
+
+ for _, obj in v['regions'].items():
+ assert not obj['region_attributes']
+ obj = obj['shape_attributes']
+ px = obj['all_points_x']
+ py = obj['all_points_y']
+ poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]
+ poly = [p for x in poly for p in x]
+
+ x_min, y_min, x_max, y_max = (min(px), min(py), max(px), max(py))
+
+ data_anno = dict(
+ image_id=idx,
+ id=obj_count,
+ category_id=0,
+ bbox=[x_min, y_min, x_max - x_min, y_max - y_min],
+ area=(x_max - x_min) * (y_max - y_min),
+ segmentation=[poly],
+ iscrowd=0)
+ annotations.append(data_anno)
+ obj_count += 1
+
+ coco_format_json = dict(
+ images=images,
+ annotations=annotations,
+ categories=[{
+ 'id': 0,
+ 'name': 'balloon'
+ }])
+ dump(coco_format_json, out_file)
+
+
+if __name__ == '__main__':
+ convert_balloon_to_coco(ann_file='data/balloon/train/via_region_data.json',
+ out_file='data/balloon/train/annotation_coco.json',
+ image_prefix='data/balloon/train')
+ convert_balloon_to_coco(ann_file='data/balloon/val/via_region_data.json',
+ out_file='data/balloon/val/annotation_coco.json',
+ image_prefix='data/balloon/val')
+```
+
+使用如上的函数，用户可以成功将标注文件转化为 JSON 格式，之后可以使用 `CocoDataset` 对模型进行训练，并用 `CocoMetric` 评测。
+
+## 准备配置文件
+
+第二步需要准备一个配置文件来成功加载数据集。假设我们想要用 balloon dataset 来训练配备了 FPN 的 Mask R-CNN ，如下是我们的配置文件。假设配置文件命名为 `mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py`，相应保存路径为 `configs/balloon/`，配置文件内容如下所示。详细的配置文件方法可以参考[学习配置文件 — MMDetection 3.0.0 文档](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/config.html#base)。
+
+```python
+# 新配置继承了基本配置，并做了必要的修改
+_base_ = '../mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py'
+
+# 我们还需要更改 head 中的 num_classes 以匹配数据集中的类别数
+model = dict(
+ roi_head=dict(
+ bbox_head=dict(num_classes=1), mask_head=dict(num_classes=1)))
+
+# 修改数据集相关配置
+data_root = 'data/balloon/'
+metainfo = {
+ 'classes': ('balloon', ),
+ 'palette': [
+ (220, 20, 60),
+ ]
+}
+train_dataloader = dict(
+ batch_size=1,
+ dataset=dict(
+ data_root=data_root,
+ metainfo=metainfo,
+ ann_file='train/annotation_coco.json',
+ data_prefix=dict(img='train/')))
+val_dataloader = dict(
+ dataset=dict(
+ data_root=data_root,
+ metainfo=metainfo,
+ ann_file='val/annotation_coco.json',
+ data_prefix=dict(img='val/')))
+test_dataloader = val_dataloader
+
+# 修改评价指标相关配置
+val_evaluator = dict(ann_file=data_root + 'val/annotation_coco.json')
+test_evaluator = val_evaluator
+
+# 使用预训练的 Mask R-CNN 模型权重来做初始化，可以提高模型性能
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'
+
+```
+
+## 训练一个新的模型
+
+为了使用新的配置方法来对模型进行训练，你只需要运行如下命令。
+
+```shell
+python tools/train.py configs/balloon/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py
+```
+
+参考 [在标准数据集上训练预定义的模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/train.html#id1) 来获取更多详细的使用方法。
+
+## 测试以及推理
+
+为了测试训练完毕的模型，你只需要运行如下命令。
+
+```shell
+python tools/test.py configs/balloon/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py work_dirs/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon/epoch_12.pth
+```
+
+参考 [测试现有模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/test.html) 来获取更多详细的使用方法。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/transforms.md b/internlm_langchain/knowledge_base/MMDetection/content/transforms.md
new file mode 100644
index 00000000..07d7db24
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/transforms.md
@@ -0,0 +1,43 @@
+# 数据变换（待更新）
+
+按照惯例，我们使用 `Dataset` 和 `DataLoader` 进行多进程的数据加载。`Dataset` 返回字典类型的数据，数据内容为模型 `forward` 方法的各个参数。由于在目标检测中，输入的图像数据具有不同的大小，我们在 `MMCV` 里引入一个新的 `DataContainer` 类去收集和分发不同大小的输入数据。更多细节请参考[这里](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py)。
+
+数据的准备流程和数据集是解耦的。通常一个数据集定义了如何处理标注数据（annotations）信息，而一个数据流程定义了准备一个数据字典的所有步骤。一个流程包括一系列的操作，每个操作都把一个字典作为输入，然后再输出一个新的字典给下一个变换操作。
+
+我们在下图展示了一个经典的数据处理流程。蓝色块是数据处理操作，随着数据流程的处理，每个操作都可以在结果字典中加入新的键（标记为绿色）或更新现有的键（标记为橙色）。
+
+
+
+这些操作可以分为数据加载（data loading）、预处理（pre-processing）、格式变化（formatting）和测试时数据增强（test-time augmentation）。
+
+下面的例子是 `Faster R-CNN` 的一个流程：
+
+```python
+img_norm_cfg = dict(
+ mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations', with_bbox=True),
+ dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
+ dict(type='RandomFlip', flip_ratio=0.5),
+ dict(type='Normalize', **img_norm_cfg),
+ dict(type='Pad', size_divisor=32),
+ dict(type='DefaultFormatBundle'),
+ dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
+]
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(
+ type='MultiScaleFlipAug',
+ img_scale=(1333, 800),
+ flip=False,
+ transforms=[
+ dict(type='Resize', keep_ratio=True),
+ dict(type='RandomFlip'),
+ dict(type='Normalize', **img_norm_cfg),
+ dict(type='Pad', size_divisor=32),
+ dict(type='ImageToTensor', keys=['img']),
+ dict(type='Collect', keys=['img']),
+ ])
+]
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/useful_hooks.md b/internlm_langchain/knowledge_base/MMDetection/content/useful_hooks.md
new file mode 100644
index 00000000..07a59df2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/useful_hooks.md
@@ -0,0 +1,107 @@
+# 实用的钩子
+
+MMDetection 和 MMEngine 为用户提供了多种多样实用的钩子（Hook），包括 `MemoryProfilerHook`、`NumClassCheckHook` 等等。
+这篇教程介绍了 MMDetection 中实现的钩子功能及使用方式。若使用 MMEngine 定义的钩子请参考 [MMEngine 的钩子API文档](https://github.com/open-mmlab/mmengine/tree/main/docs/en/tutorials/hook.md).
+
+## CheckInvalidLossHook
+
+## NumClassCheckHook
+
+## MemoryProfilerHook
+
+[内存分析钩子](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/engine/hooks/memory_profiler_hook.py)
+记录了包括虚拟内存、交换内存、当前进程在内的所有内存信息，它能够帮助捕捉系统的使用状况与发现隐藏的内存泄露问题。为了使用这个钩子，你需要先通过 `pip install memory_profiler psutil` 命令安装 `memory_profiler` 和 `psutil`。
+
+### 使用
+
+为了使用这个钩子，使用者需要添加如下代码至 config 文件
+
+```python
+custom_hooks = [
+ dict(type='MemoryProfilerHook', interval=50)
+]
+```
+
+### 结果
+
+在训练中，你会看到 `MemoryProfilerHook` 记录的如下信息：
+
+```text
+The system has 250 GB (246360 MB + 9407 MB) of memory and 8 GB (5740 MB + 2452 MB) of swap memory in total. Currently 9407 MB (4.4%) of memory and 5740 MB (29.9%) of swap memory were consumed. And the current training process consumed 5434 MB of memory.
+```
+
+```text
+2022-04-21 08:49:56,881 - mmengine - INFO - Memory information available_memory: 246360 MB, used_memory: 9407 MB, memory_utilization: 4.4 %, available_swap_memory: 5740 MB, used_swap_memory: 2452 MB, swap_memory_utilization: 29.9 %, current_process_memory: 5434 MB
+```
+
+## SetEpochInfoHook
+
+## SyncNormHook
+
+## SyncRandomSizeHook
+
+## YOLOXLrUpdaterHook
+
+## YOLOXModeSwitchHook
+
+## 如何实现自定义钩子
+
+通常，从模型训练的开始到结束，共有20个点位可以执行钩子。我们可以实现自定义钩子在不同点位执行，以便在训练中实现自定义操作。
+
+- global points: `before_run`, `after_run`
+- points in training: `before_train`, `before_train_epoch`, `before_train_iter`, `after_train_iter`, `after_train_epoch`, `after_train`
+- points in validation: `before_val`, `before_val_epoch`, `before_val_iter`, `after_val_iter`, `after_val_epoch`, `after_val`
+- points at testing: `before_test`, `before_test_epoch`, `before_test_iter`, `after_test_iter`, `after_test_epoch`, `after_test`
+- other points: `before_save_checkpoint`, `after_save_checkpoint`
+
+比如，我们要实现一个检查 loss 的钩子，当损失为 NaN 时自动结束训练。我们可以把这个过程分为三步：
+
+1. 在 MMEngine 实现一个继承于 `Hook` 类的新钩子，并实现 `after_train_iter` 方法用于检查每 `n` 次训练迭代后损失是否变为 NaN 。
+2. 使用 `@HOOKS.register_module()` 注册实现好了的自定义钩子，如下列代码所示。
+3. 在配置文件中添加 `custom_hooks = [dict(type='MemoryProfilerHook', interval=50)]`
+
+```python
+from typing import Optional
+
+import torch
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class CheckInvalidLossHook(Hook):
+ """Check invalid loss hook.
+
+ This hook will regularly check whether the loss is valid
+ during training.
+
+ Args:
+ interval (int): Checking interval (every k iterations).
+ Default: 50.
+ """
+
+ def __init__(self, interval: int = 50) -> None:
+ self.interval = interval
+
+ def after_train_iter(self,
+ runner: Runner,
+ batch_idx: int,
+ data_batch: Optional[dict] = None,
+ outputs: Optional[dict] = None) -> None:
+ """Regularly check whether the loss is valid every n iterations.
+
+ Args:
+ runner (:obj:`Runner`): The runner of the training process.
+ batch_idx (int): The index of the current batch in the train loop.
+ data_batch (dict, Optional): Data from dataloader.
+ Defaults to None.
+ outputs (dict, Optional): Outputs from model. Defaults to None.
+ """
+ if self.every_n_train_iters(runner, self.interval):
+ assert torch.isfinite(outputs['loss']), \
+ runner.logger.info('loss become infinite or NaN!')
+```
+
+请参考 [自定义训练配置](../advanced_guides/customize_runtime.md) 了解更多与自定义钩子相关的内容。
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/useful_tools.md b/internlm_langchain/knowledge_base/MMDetection/content/useful_tools.md
new file mode 100644
index 00000000..e53ffdfc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/useful_tools.md
@@ -0,0 +1,562 @@
+除了训练和测试脚本，我们还在 `tools/` 目录下提供了许多有用的工具。
+
+## 日志分析
+
+`tools/analysis_tools/analyze_logs.py` 可利用指定的训练 log 文件绘制 loss/mAP 曲线图，
+第一次运行前请先运行 `pip install seaborn` 安装必要依赖.
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve [--keys ${KEYS}] [--eval-interval ${EVALUATION_INTERVAL}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+
+
+样例:
+
+- 绘制分类损失曲线图
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls --legend loss_cls
+ ```
+
+- 绘制分类损失、回归损失曲线图，保存图片为对应的 pdf 文件
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls loss_bbox --out losses.pdf
+ ```
+
+- 在相同图像中比较两次运行结果的 bbox mAP
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys bbox_mAP --legend run1 run2
+ ```
+
+- 计算平均训练速度
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py cal_train_time log.json [--include-outliers]
+ ```
+
+ 输出以如下形式展示
+
+ ```text
+ -----Analyze train time of work_dirs/some_exp/20190611_192040.log.json-----
+ slowest epoch 11, average time is 1.2024
+ fastest epoch 1, average time is 1.1909
+ time std over epochs is 0.0028
+ average iter time: 1.1959 s/iter
+ ```
+
+## 结果分析
+
+使用 `tools/analysis_tools/analyze_results.py` 可计算每个图像 mAP，随后根据真实标注框与预测框的比较结果，展示或保存最高与最低 top-k 得分的预测图像。
+
+**使用方法**
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+ ${CONFIG} \
+ ${PREDICTION_PATH} \
+ ${SHOW_DIR} \
+ [--show] \
+ [--wait-time ${WAIT_TIME}] \
+ [--topk ${TOPK}] \
+ [--show-score-thr ${SHOW_SCORE_THR}] \
+ [--cfg-options ${CFG_OPTIONS}]
+```
+
+各个参数选项的作用:
+
+- `config`: model config 文件的路径。
+- `prediction_path`: 使用 `tools/test.py` 输出的 pickle 格式结果文件。
+- `show_dir`: 绘制真实标注框与预测框的图像存放目录。
+- `--show`：决定是否展示绘制 box 后的图片，默认值为 `False`。
+- `--wait-time`: show 时间的间隔，若为 0 表示持续显示。
+- `--topk`: 根据最高或最低 `topk` 概率排序保存的图片数量，若不指定，默认设置为 `20`。
+- `--show-score-thr`: 能够展示的概率阈值，默认为 `0`。
+- `--cfg-options`: 如果指定，可根据指定键值对覆盖更新配置文件的对应选项
+
+**样例**:
+假设你已经通过 `tools/test.py` 得到了 pickle 格式的结果文件，路径为 './result.pkl'。
+
+1. 测试 Faster R-CNN 并可视化结果，保存图片至 `results/`
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+ configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+ result.pkl \
+ results \
+ --show
+```
+
+2. 测试 Faster R-CNN 并指定 top-k 参数为 50，保存结果图片至 `results/`
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+ configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+ result.pkl \
+ results \
+ --topk 50
+```
+
+3. 如果你想过滤低概率的预测结果，指定 `show-score-thr` 参数
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+ configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+ result.pkl \
+ results \
+ --show-score-thr 0.3
+```
+
+## 可视化
+
+### 可视化数据集
+
+`tools/analysis_tools/browse_dataset.py` 可帮助使用者检查所使用的检测数据集（包括图像和标注），或保存图像至指定目录。
+
+```shell
+python tools/misc/browse_dataset.py ${CONFIG} [-h] [--skip-type ${SKIP_TYPE[SKIP_TYPE...]}] [--output-dir ${OUTPUT_DIR}] [--not-show] [--show-interval ${SHOW_INTERVAL}]
+```
+
+### 可视化模型
+
+在可视化之前，需要先转换模型至 ONNX 格式，[可参考此处](#convert-mmdetection-model-to-onnx-experimental)。
+注意，现在只支持 RetinaNet，之后的版本将会支持其他模型
+转换后的模型可以被其他工具可视化[Netron](https://github.com/lutzroeder/netron)。
+
+### 可视化预测结果
+
+如果你想要一个轻量 GUI 可视化检测结果，你可以参考 [DetVisGUI project](https://github.com/Chien-Hung/DetVisGUI/tree/mmdetection)。
+
+## 误差分析
+
+`tools/analysis_tools/coco_error_analysis.py` 使用不同标准分析每个类别的 COCO 评估结果。同时将一些有帮助的信息体现在图表上。
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py ${RESULT} ${OUT_DIR} [-h] [--ann ${ANN}] [--types ${TYPES[TYPES...]}]
+```
+
+样例:
+
+假设你已经把 [Mask R-CNN checkpoint file](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) 放置在文件夹 'checkpoint' 中（其他模型请在 [model zoo](./model_zoo.md) 中获取）。
+
+为了保存 bbox 结果信息，我们需要用下列方式修改 `test_evaluator` :
+
+1. 查找当前 config 文件相对应的 'configs/base/datasets' 数据集信息。
+2. 用当前数据集 config 中的 test_evaluator 以及 test_dataloader 替换原始文件的 test_evaluator 以及 test_dataloader。
+3. 使用以下命令得到 bbox 或 segmentation 的 json 格式文件。
+
+```shell
+python tools/test.py \
+ configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+ checkpoint/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+```
+
+1. 得到每一类的 COCO bbox 误差结果，并保存分析结果图像至指定目录。（在 [config](../../../configs/_base_/datasets/coco_instance.py) 中默认目录是 './work_dirs/coco_instance/test')
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py \
+ results.bbox.json \
+ results \
+ --ann=data/coco/annotations/instances_val2017.json \
+```
+
+2. 得到每一类的 COCO 分割误差结果，并保存分析结果图像至指定目录。
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py \
+ results.segm.json \
+ results \
+ --ann=data/coco/annotations/instances_val2017.json \
+ --types='segm'
+```
+
+## 模型服务部署
+
+如果你想使用 [`TorchServe`](https://pytorch.org/serve/) 搭建一个 `MMDetection` 模型服务，可以参考以下步骤：
+
+### 1. 安装 TorchServe
+
+假设你已经成功安装了包含 `PyTorch` 和 `MMDetection` 的 `Python` 环境，那么你可以运行以下命令来安装 `TorchServe` 及其依赖项。有关更多其他安装选项，请参考[快速入门](https://github.com/pytorch/serve/blob/master/README.md#serve-a-model)。
+
+```shell
+python -m pip install torchserve torch-model-archiver torch-workflow-archiver nvgpu
+```
+
+**注意**: 如果你想在 docker 中使用`TorchServe`，请参考[torchserve docker](https://github.com/pytorch/serve/blob/master/docker/README.md)。
+
+### 2. 把 MMDetection 模型转换至 TorchServe
+
+```shell
+python tools/deployment/mmdet2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+### 3. 启动 `TorchServe`
+
+```shell
+torchserve --start --ncs \
+ --model-store ${MODEL_STORE} \
+ --models ${MODEL_NAME}.mar
+```
+
+### 4. 测试部署效果
+
+```shell
+curl -O curl -O https://raw.githubusercontent.com/pytorch/serve/master/docs/images/3dogs.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg
+```
+
+你可以得到下列 json 信息：
+
+```json
+[
+ {
+ "class_label": 16,
+ "class_name": "dog",
+ "bbox": [
+ 294.63409423828125,
+ 203.99111938476562,
+ 417.048583984375,
+ 281.62744140625
+ ],
+ "score": 0.9987992644309998
+ },
+ {
+ "class_label": 16,
+ "class_name": "dog",
+ "bbox": [
+ 404.26019287109375,
+ 126.0080795288086,
+ 574.5091552734375,
+ 293.6662292480469
+ ],
+ "score": 0.9979367256164551
+ },
+ {
+ "class_label": 16,
+ "class_name": "dog",
+ "bbox": [
+ 197.2144775390625,
+ 93.3067855834961,
+ 307.8505554199219,
+ 276.7560119628906
+ ],
+ "score": 0.993338406085968
+ }
+]
+```
+
+#### 结果对比
+
+你也可以使用 `test_torchserver.py` 来比较 `TorchServe` 和 `PyTorch` 的结果，并可视化：
+
+```shell
+python tools/deployment/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}] [--score-thr ${SCORE_THR}] [--work-dir ${WORK_DIR}]
+```
+
+样例:
+
+```shell
+python tools/deployment/test_torchserver.py \
+demo/demo.jpg \
+configs/yolo/yolov3_d53_8xb8-320-273e_coco.py \
+checkpoint/yolov3_d53_320_273e_coco-421362b6.pth \
+yolov3 \
+--work-dir ./work-dir
+```
+
+### 5. 停止 `TorchServe`
+
+```shell
+torchserve --stop
+```
+
+## 模型复杂度
+
+`tools/analysis_tools/get_flops.py` 工具可用于计算指定模型的 FLOPs、参数量大小（改编自 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) ）。
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+获得的结果如下：
+
+```text
+==============================
+Input shape: (3, 1280, 800)
+Flops: 239.32 GFLOPs
+Params: 37.74 M
+==============================
+```
+
+**注意**：这个工具还只是实验性质，我们不保证这个数值是绝对正确的。你可以将他用于简单的比较，但如果用于科技论文报告需要再三检查确认。
+
+1. FLOPs 与输入的形状大小相关，参数量没有这个关系，默认的输入形状大小为 (1, 3, 1280, 800) 。
+2. 一些算子并不计入 FLOPs，比如 GN 或其他自定义的算子。你可以参考 [`mmcv.cnn.get_model_complexity_info()`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/utils/flops_counter.py) 查看更详细的说明。
+3. 两阶段检测的 FLOPs 大小取决于 proposal 的数量。
+
+## 模型转换
+
+### MMDetection 模型转换至 ONNX 格式
+
+我们提供了一个脚本用于转换模型至 [ONNX](https://github.com/onnx/onnx) 格式。同时还支持比较 Pytorch 与 ONNX 模型的输出结果以便对照。更详细的内容可以参考 [mmdeploy](https://github.com/open-mmlab/mmdeploy)。
+
+### MMDetection 1.x 模型转换至 MMDetection 2.x 模型
+
+`tools/model_converters/upgrade_model_version.py` 可将旧版本的 MMDetection checkpoints 转换至新版本。但要注意此脚本不保证在新版本加入非兼容更新后还能正常转换，建议您直接使用新版本的 checkpoints。
+
+```shell
+python tools/model_converters/upgrade_model_version.py ${IN_FILE} ${OUT_FILE} [-h] [--num-classes NUM_CLASSES]
+```
+
+### RegNet 模型转换至 MMDetection 模型
+
+`tools/model_converters/regnet2mmdet.py` 将 pycls 编码的预训练 RegNet 模型转换为 MMDetection 风格。
+
+```shell
+python tools/model_converters/regnet2mmdet.py ${SRC} ${DST} [-h]
+```
+
+### Detectron ResNet 模型转换至 Pytorch 模型
+
+`tools/model_converters/detectron2pytorch.py` 将 detectron 的原始预训练 RegNet 模型转换为 MMDetection 风格。
+
+```shell
+python tools/model_converters/detectron2pytorch.py ${SRC} ${DST} ${DEPTH} [-h]
+```
+
+### 制作发布用模型
+
+`tools/model_converters/publish_model.py` 可用来制作一个发布用的模型。
+
+在发布模型至 AWS 之前，你可能需要：
+
+1. 将模型转换至 CPU 张量
+2. 删除优化器状态
+3. 计算 checkpoint 文件的 hash 值，并将 hash 号码记录至文件名。
+
+```shell
+python tools/model_converters/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+样例：
+
+```shell
+python tools/model_converters/publish_model.py work_dirs/faster_rcnn/latest.pth faster_rcnn_r50_fpn_1x_20190801.pth
+```
+
+最后输出的文件名如下所示： `faster_rcnn_r50_fpn_1x_20190801-{hash id}.pth`.
+
+## 数据集转换
+
+`tools/data_converters/` 提供了将 Cityscapes 数据集与 Pascal VOC 数据集转换至 COCO 数据集格式的工具
+
+```shell
+python tools/dataset_converters/cityscapes.py ${CITYSCAPES_PATH} [-h] [--img-dir ${IMG_DIR}] [--gt-dir ${GT_DIR}] [-o ${OUT_DIR}] [--nproc ${NPROC}]
+python tools/dataset_converters/pascal_voc.py ${DEVKIT_PATH} [-h] [-o ${OUT_DIR}]
+```
+
+## 数据集下载
+
+`tools/misc/download_dataset.py` 可以下载各类形如 COCO， VOC， LVIS 数据集。
+
+```shell
+python tools/misc/download_dataset.py --dataset-name coco2017
+python tools/misc/download_dataset.py --dataset-name voc2007
+python tools/misc/download_dataset.py --dataset-name lvis
+```
+
+对于中国境内的用户，我们也推荐使用开源数据平台 [OpenDataLab](https://opendatalab.com/?source=OpenMMLab%20GitHub) 来获取这些数据集，以获得更好的下载体验:
+
+- [COCO2017](https://opendatalab.com/COCO_2017/download?source=OpenMMLab%20GitHub)
+- [VOC2007](https://opendatalab.com/PASCAL_VOC2007/download?source=OpenMMLab%20GitHub)
+- [VOC2012](https://opendatalab.com/PASCAL_VOC2012/download?source=OpenMMLab%20GitHub)
+- [LVIS](https://opendatalab.com/LVIS/download?source=OpenMMLab%20GitHub)
+
+## 基准测试
+
+### 鲁棒性测试基准
+
+`tools/analysis_tools/test_robustness.py` 及 `tools/analysis_tools/robustness_eval.py` 帮助使用者衡量模型的鲁棒性。其核心思想来源于 [Benchmarking Robustness in Object Detection: Autonomous Driving when Winter is Coming](https://arxiv.org/abs/1907.07484)。如果你想了解如何在污损图像上评估模型的效果，以及参考该基准的一组标准模型，请参照 [robustness_benchmarking.md](robustness_benchmarking.md)。
+
+### FPS 测试基准
+
+`tools/analysis_tools/benchmark.py` 可帮助使用者计算 FPS，FPS 计算包括了模型向前传播与后处理过程。为了得到更精确的计算值，现在的分布式计算模式只支持一个 GPU。
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=${PORT} tools/analysis_tools/benchmark.py \
+ ${CONFIG} \
+ [--checkpoint ${CHECKPOINT}] \
+ [--repeat-num ${REPEAT_NUM}] \
+ [--max-iter ${MAX_ITER}] \
+ [--log-interval ${LOG_INTERVAL}] \
+ --launcher pytorch
+```
+
+样例：假设你已经下载了 `Faster R-CNN` 模型 checkpoint 并放置在 `checkpoints/` 目录下。
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=29500 tools/analysis_tools/benchmark.py \
+ configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+ checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
+ --launcher pytorch
+```
+
+## 更多工具
+
+### 以某个评估标准进行评估
+
+`tools/analysis_tools/eval_metric.py` 根据配置文件中的评估方式对 pkl 结果文件进行评估。
+
+```shell
+python tools/analysis_tools/eval_metric.py ${CONFIG} ${PKL_RESULTS} [-h] [--format-only] [--eval ${EVAL[EVAL ...]}]
+ [--cfg-options ${CFG_OPTIONS [CFG_OPTIONS ...]}]
+ [--eval-options ${EVAL_OPTIONS [EVAL_OPTIONS ...]}]
+```
+
+### 打印全部 config
+
+`tools/misc/print_config.py` 可将所有配置继承关系展开，完全打印相应的配置文件。
+
+```shell
+python tools/misc/print_config.py ${CONFIG} [-h] [--options ${OPTIONS [OPTIONS...]}]
+```
+
+## 超参数优化
+
+### YOLO Anchor 优化
+
+`tools/analysis_tools/optimize_anchors.py` 提供了两种方法优化 YOLO 的 anchors。
+
+其中一种方法使用 K 均值 anchor 聚类（k-means anchor cluster），源自 [darknet](https://github.com/AlexeyAB/darknet/blob/master/src/detector.c#L1421)。
+
+```shell
+python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm k-means --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR}
+```
+
+另一种方法使用差分进化算法优化 anchors。
+
+```shell
+python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm differential_evolution --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR}
+```
+
+样例：
+
+```shell
+python tools/analysis_tools/optimize_anchors.py configs/yolo/yolov3_d53_8xb8-320-273e_coco.py --algorithm differential_evolution --input-shape 608 608 --device cuda --output-dir work_dirs
+```
+
+你可能会看到如下结果：
+
+```
+loading annotations into memory...
+Done (t=9.70s)
+creating index...
+index created!
+2021-07-19 19:37:20,951 - mmdet - INFO - Collecting bboxes from annotation...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 117266/117266, 15874.5 task/s, elapsed: 7s, ETA: 0s
+
+2021-07-19 19:37:28,753 - mmdet - INFO - Collected 849902 bboxes.
+differential_evolution step 1: f(x)= 0.506055
+differential_evolution step 2: f(x)= 0.506055
+......
+
+differential_evolution step 489: f(x)= 0.386625
+2021-07-19 19:46:40,775 - mmdet - INFO Anchor evolution finish. Average IOU: 0.6133754253387451
+2021-07-19 19:46:40,776 - mmdet - INFO Anchor differential evolution result:[[10, 12], [15, 30], [32, 22], [29, 59], [61, 46], [57, 116], [112, 89], [154, 198], [349, 336]]
+2021-07-19 19:46:40,798 - mmdet - INFO Result saved in work_dirs/anchor_optimize_result.json
+```
+
+## 混淆矩阵
+
+混淆矩阵是对检测结果的概览。
+`tools/analysis_tools/confusion_matrix.py` 可对预测结果进行分析，绘制成混淆矩阵表。
+首先，运行 `tools/test.py` 保存 `.pkl` 预测结果。
+之后再运行：
+
+```
+python tools/analysis_tools/confusion_matrix.py ${CONFIG} ${DETECTION_RESULTS} ${SAVE_DIR} --show
+```
+
+最后你可以得到如图的混淆矩阵：
+
+
+
+## COCO 分离和遮挡实例分割性能评估
+
+对于最先进的目标检测器来说，检测被遮挡的物体仍然是一个挑战。
+我们实现了论文 [A Tri-Layer Plugin to Improve Occluded Detection](https://arxiv.org/abs/2210.10046) 中提出的指标来计算分离和遮挡目标的召回率。
+
+使用此评价指标有两种方法：
+
+### 离线评测
+
+我们提供了一个脚本对存储后的检测结果文件计算指标。
+
+首先，使用 `tools/test.py` 脚本存储检测结果：
+
+```shell
+python tools/test.py ${CONFIG} ${MODEL_PATH} --out results.pkl
+```
+
+然后，运行 `tools/analysis_tools/coco_occluded_separated_recall.py` 脚本来计算分离和遮挡目标的掩码的召回率:
+
+```shell
+python tools/analysis_tools/coco_occluded_separated_recall.py results.pkl --out occluded_separated_recall.json
+```
+
+输出如下：
+
+```
+loading annotations into memory...
+Done (t=0.51s)
+creating index...
+index created!
+processing detection results...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 5000/5000, 109.3 task/s, elapsed: 46s, ETA: 0s
+computing occluded mask recall...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 5550/5550, 780.5 task/s, elapsed: 7s, ETA: 0s
+COCO occluded mask recall: 58.79%
+COCO occluded mask success num: 3263
+computing separated mask recall...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 3522/3522, 778.3 task/s, elapsed: 5s, ETA: 0s
+COCO separated mask recall: 31.94%
+COCO separated mask success num: 1125
+
++-----------+--------+-------------+
+| mask type | recall | num correct |
++-----------+--------+-------------+
+| occluded | 58.79% | 3263 |
+| separated | 31.94% | 1125 |
++-----------+--------+-------------+
+Evaluation results have been saved to occluded_separated_recall.json.
+```
+
+### 在线评测
+
+我们实现继承自 `CocoMetic` 的 `CocoOccludedSeparatedMetric`。
+要在训练期间评估分离和遮挡掩码的召回率，只需在配置中将 evaluator 类型替换为 `CocoOccludedSeparatedMetric`：
+
+```python
+val_evaluator = dict(
+ type='CocoOccludedSeparatedMetric', # 修改此处
+ ann_file=data_root + 'annotations/instances_val2017.json',
+ metric=['bbox', 'segm'],
+ format_only=False)
+test_evaluator = val_evaluator
+```
+
+如果您使用了此指标，请引用论文：
+
+```latex
+@article{zhan2022triocc,
+ title={A Tri-Layer Plugin to Improve Occluded Detection},
+ author={Zhan, Guanqi and Xie, Weidi and Zisserman, Andrew},
+ journal={British Machine Vision Conference},
+ year={2022}
+}
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection/content/visualization.md b/internlm_langchain/knowledge_base/MMDetection/content/visualization.md
new file mode 100644
index 00000000..f90ab6d4
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection/content/visualization.md
@@ -0,0 +1,93 @@
+# 可视化
+
+在阅读本教程之前，建议先阅读 MMEngine 的 [Visualization](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) 文档，以对 `Visualizer` 的定义和用法有一个初步的了解。
+
+简而言之，`Visualizer` 在 MMEngine 中实现以满足日常可视化需求，并包含以下三个主要功能：
+
+- 实现通用的绘图 API，例如 [`draw_bboxes`](mmengine.visualization.Visualizer.draw_bboxes) 实现了绘制边界框的功能，[`draw_lines`](mmengine.visualization.Visualizer.draw_lines) 实现了绘制线条的功能。
+- 支持将可视化结果、学习率曲线、损失函数曲线以及验证精度曲线写入到各种后端中，包括本地磁盘以及常见的深度学习训练日志工具，例如 [TensorBoard](https://www.tensorflow.org/tensorboard) 和 [Wandb](https://wandb.ai/site)。
+- 支持在代码的任何位置调用以可视化或记录模型在训练或测试期间的中间状态，例如特征图和验证结果。
+
+基于 MMEngine 的 `Visualizer`，MMDet 提供了各种预构建的可视化工具，用户可以通过简单地修改以下配置文件来使用它们。
+
+- `tools/analysis_tools/browse_dataset.py` 脚本提供了一个数据集可视化功能，可以在数据经过数据转换后绘制图像和相应的注释，具体描述请参见[`browse_dataset.py`](useful_tools.md#Visualization)。
+
+- MMEngine实现了`LoggerHook`，使用`Visualizer`将学习率、损失和评估结果写入由`Visualizer`设置的后端。因此，通过修改配置文件中的`Visualizer`后端，例如修改为`TensorBoardVISBackend`或`WandbVISBackend`，可以实现日志记录到常用的训练日志工具，如`TensorBoard`或`WandB`，从而方便用户使用这些可视化工具来分析和监控训练过程。
+
+- 在MMDet中实现了`VisualizerHook`，它使用`Visualizer`将验证或预测阶段的预测结果可视化或存储到由`Visualizer`设置的后端。因此，通过修改配置文件中的`Visualizer`后端，例如修改为`TensorBoardVISBackend`或`WandbVISBackend`，可以将预测图像存储到`TensorBoard`或`Wandb`中。
+
+## 配置
+
+由于使用了注册机制，在MMDet中我们可以通过修改配置文件来设置`Visualizer`的行为。通常，我们会在`configs/_base_/default_runtime.py`中为可视化器定义默认配置，详细信息请参见[配置教程](config.md)。
+
+```Python
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+ type='DetLocalVisualizer',
+ vis_backends=vis_backends,
+ name='visualizer')
+```
+
+基于上面的例子，我们可以看到`Visualizer`的配置由两个主要部分组成，即`Visualizer`类型和其使用的可视化后端`vis_backends`。
+
+- 用户可直接使用`DetLocalVisualizer`来可视化支持任务的标签或预测结果。
+- MMDet默认将可视化后端`vis_backend`设置为本地可视化后端`LocalVisBackend`，将所有可视化结果和其他训练信息保存在本地文件夹中。
+
+## 存储
+
+MMDet默认使用本地可视化后端[`LocalVisBackend`](mmengine.visualization.LocalVisBackend)，`VisualizerHook`和`LoggerHook`中存储的模型损失、学习率、模型评估精度和可视化信息，包括损失、学习率、评估精度将默认保存到`{work_dir}/{config_name}/{time}/{vis_data}`文件夹中。此外，MMDet还支持其他常见的可视化后端，例如`TensorboardVisBackend`和`WandbVisBackend`，您只需要在配置文件中更改`vis_backends`类型为相应的可视化后端即可。例如，只需在配置文件中插入以下代码块即可将数据存储到`TensorBoard`和`Wandb`中。
+
+```Python
+# https://mmengine.readthedocs.io/en/latest/api/visualization.html
+_base_.visualizer.vis_backends = [
+ dict(type='LocalVisBackend'), #
+ dict(type='TensorboardVisBackend'),
+ dict(type='WandbVisBackend'),]
+```
+
+## 绘图
+
+### 绘制预测结果
+
+MMDet主要使用[`DetVisualizationHook`](mmdet.engine.hooks.DetVisualizationHook)来绘制验证和测试的预测结果，默认情况下`DetVisualizationHook`是关闭的，其默认配置如下。
+
+```Python
+visualization=dict( #用户可视化验证和测试结果
+ type='DetVisualizationHook',
+ draw=False,
+ interval=1,
+ show=False)
+```
+
+以下表格展示了`DetVisualizationHook`支持的参数。
+
+| 参数 | 描述 |
+| :------: | :------------------------------------------------------------------------------: |
+| draw | DetVisualizationHook通过enable参数打开和关闭，默认状态为关闭。 |
+| interval | 控制在DetVisualizationHook启用时存储或显示验证或测试结果的间隔，单位为迭代次数。 |
+| show | 控制是否可视化验证或测试的结果。 |
+
+如果您想在训练或测试期间启用 `DetVisualizationHook` 相关功能和配置，您只需要修改配置文件，以 `configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py` 为例，同时绘制注释和预测，并显示图像，配置文件可以修改如下：
+
+```Python
+visualization = _base_.default_hooks.visualization
+visualization.update(dict(draw=True, show=True))
+```
+
+
+
+
+
+
+`test.py`程序提供了`--show`和`--show-dir`参数，可以在测试过程中可视化注释和预测结果，而不需要修改配置文件，从而进一步简化了测试过程。
+
+```Shell
+# 展示测试结果
+python tools/test.py configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --show
+
+# 指定存储预测结果的位置
+python tools/test.py configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --show-dir imgs/
+```
+
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMDetection/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMDetection/vector_store/index.faiss
new file mode 100644
index 00000000..dd3b34cf
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMDetection/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/backends_support.md b/internlm_langchain/knowledge_base/MMDetection3D/content/backends_support.md
new file mode 100644
index 00000000..80c535de
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/backends_support.md
@@ -0,0 +1,154 @@
+# 后端支持
+
+我们支持不同的文件客户端后端：磁盘、Ceph 和 LMDB 等。下面是修改配置使之从 Ceph 加载和保存数据的示例。
+
+## 从 Ceph 读取数据和标注文件
+
+我们支持从 Ceph 加载数据和生成的标注信息文件（pkl 和 json）：
+
+```python
+# set file client backends as Ceph
+backend_args = dict(
+ backend='petrel',
+ path_mapping=dict({
+ './data/nuscenes/':
+ 's3://openmmlab/datasets/detection3d/nuscenes/', # replace the path with your data path on Ceph
+ 'data/nuscenes/':
+ 's3://openmmlab/datasets/detection3d/nuscenes/' # replace the path with your data path on Ceph
+ }))
+
+db_sampler = dict(
+ data_root=data_root,
+ info_path=data_root + 'kitti_dbinfos_train.pkl',
+ rate=1.0,
+ prepare=dict(filter_by_difficulty=[-1], filter_by_min_points=dict(Car=5)),
+ sample_groups=dict(Car=15),
+ classes=class_names,
+ # set file client for points loader to load training data
+ points_loader=dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=4,
+ use_dim=4,
+ backend_args=backend_args),
+ # set file client for data base sampler to load db info file
+ backend_args=backend_args)
+
+train_pipeline = [
+ # set file client for loading training data
+ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4, backend_args=backend_args),
+ # set file client for loading training data annotations
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True, backend_args=backend_args),
+ dict(type='ObjectSample', db_sampler=db_sampler),
+ dict(
+ type='ObjectNoise',
+ num_try=100,
+ translation_std=[0.25, 0.25, 0.25],
+ global_rot_range=[0.0, 0.0],
+ rot_range=[-0.15707963267, 0.15707963267]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.78539816, 0.78539816],
+ scale_ratio_range=[0.95, 1.05]),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='PointShuffle'),
+ dict(type='DefaultFormatBundle3D', class_names=class_names),
+ dict(type='Collect3D', keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+test_pipeline = [
+ # set file client for loading validation/testing data
+ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4, backend_args=backend_args),
+ dict(
+ type='MultiScaleFlipAug3D',
+ img_scale=(1333, 800),
+ pts_scale_ratio=1,
+ flip=False,
+ transforms=[
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[0, 0],
+ scale_ratio_range=[1., 1.],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D'),
+ dict(
+ type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(
+ type='DefaultFormatBundle3D',
+ class_names=class_names,
+ with_label=False),
+ dict(type='Collect3D', keys=['points'])
+ ])
+]
+
+data = dict(
+ # set file client for loading training info files (.pkl)
+ train=dict(
+ type='RepeatDataset',
+ times=2,
+ dataset=dict(pipeline=train_pipeline, classes=class_names, backend_args=backend_args)),
+ # set file client for loading validation info files (.pkl)
+ val=dict(pipeline=test_pipeline, classes=class_names,backend_args=backend_args),
+ # set file client for loading testing info files (.pkl)
+ test=dict(pipeline=test_pipeline, classes=class_names, backend_args=backend_args))
+```
+
+## 从 Ceph 读取预训练模型
+
+```python
+model = dict(
+ pts_backbone=dict(
+ _delete_=True,
+ type='NoStemRegNet',
+ arch='regnetx_1.6gf',
+ init_cfg=dict(
+ type='Pretrained', checkpoint='s3://openmmlab/checkpoints/mmdetection3d/regnetx_1.6gf'), # replace the path with your pretrained model path on Ceph
+ ...
+```
+
+## 从 Ceph 读取模型权重文件
+
+```python
+# replace the path with your checkpoint path on Ceph
+load_from = 's3://openmmlab/checkpoints/mmdetection3d/v0.1.0_models/pointpillars/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20200620_230614-77663cd6.pth'
+resume_from = None
+workflow = [('train', 1)]
+```
+
+## 保存模型权重文件至 Ceph
+
+```python
+# checkpoint saving
+# replace the path with your checkpoint saving path on Ceph
+checkpoint_config = dict(interval=1, max_keep_ckpts=2, out_dir='s3://openmmlab/mmdetection3d')
+```
+
+## EvalHook 保存最优模型权重文件至 Ceph
+
+```python
+# replace the path with your checkpoint saving path on Ceph
+evaluation = dict(interval=1, save_best='bbox', out_dir='s3://openmmlab/mmdetection3d')
+```
+
+## 训练日志保存至 Ceph
+
+训练后的训练日志会备份到指定的 Ceph 路径。
+
+```python
+log_config = dict(
+ interval=50,
+ hooks=[
+ dict(type='TextLoggerHook', out_dir='s3://openmmlab/mmdetection3d'),
+ ])
+```
+
+您还可以通过设置 `keep_local = False` 备份到指定的 Ceph 路径后删除本地训练日志。
+
+```python
+log_config = dict(
+ interval=50,
+ hooks=[
+ dict(type='TextLoggerHook', out_dir='s3://openmmlab/mmdetection3d', keep_local=False),
+ ])
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/benchmarks.md b/internlm_langchain/knowledge_base/MMDetection3D/content/benchmarks.md
new file mode 100644
index 00000000..52b92270
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/benchmarks.md
@@ -0,0 +1,285 @@
+# 基准测试
+
+这里我们对 MMDetection3D 和其他开源 3D 目标检测代码库中模型的训练速度和测试速度进行了基准测试。
+
+## 配置
+
+- 硬件：8 NVIDIA Tesla V100 (32G) GPUs, Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+- 软件：Python 3.7, CUDA 10.1, cuDNN 7.6.5, PyTorch 1.3, numba 0.48.0.
+- 模型：由于不同代码库所实现的模型种类有所不同，在基准测试中我们选择了 SECOND、PointPillars、Part-A2 和 VoteNet 几种模型，分别与其他代码库中的相应模型实现进行了对比。
+- 度量方法：我们使用整个训练过程中的平均吞吐量作为度量方法，并跳过每个 epoch 的前 50 次迭代以消除训练预热的影响。
+
+## 主要结果
+
+对于模型的训练速度（样本/秒），我们将 MMDetection3D 与其他实现了相同模型的代码库进行了对比。结果如下所示，表格内的数字越大，代表模型的训练速度越快。代码库中不支持的模型使用 `×` 进行标识。
+
+| 模型 | MMDetection3D | OpenPCDet | votenet | Det3D |
+| :-----------------: | :-----------: | :-------: | :-----: | :---: |
+| VoteNet | 358 | × | 77 | × |
+| PointPillars-car | 141 | × | × | 140 |
+| PointPillars-3class | 107 | 44 | × | × |
+| SECOND | 40 | 30 | × | × |
+| Part-A2 | 17 | 14 | × | × |
+
+## 测试细节
+
+### 为了计算速度所做的修改
+
+- __MMDetection3D__：我们尝试使用与其他代码库中尽可能相同的配置，具体配置细节见 [基准测试配置](https://github.com/open-mmlab/MMDetection3D/blob/main/configs/benchmark)。
+
+- __Det3D__：为了与 Det3D 进行比较，我们使用了 commit [519251e](https://github.com/poodarchu/Det3D/tree/519251e72a5c1fdd58972eabeac67808676b9bb7) 所对应的代码版本。
+
+- __OpenPCDet__：为了与 OpenPCDet 进行比较，我们使用了 commit [b32fbddb](https://github.com/open-mmlab/OpenPCDet/tree/b32fbddbe06183507bad433ed99b407cbc2175c2) 所对应的代码版本。
+
+ 为了计算训练速度，我们在 `./tools/train_utils/train_utils.py` 文件中添加了用于记录运行时间的代码。我们对每个 epoch 的训练速度进行计算，并报告所有 epoch 的平均速度。
+
+
+
+
+
+### VoteNet
+
+- __MMDetection3D__：在 v0.1.0 版本下, 执行如下命令：
+
+ ```bash
+ ./tools/dist_train.sh configs/votenet/votenet_8xb16_sunrgbd-3d.py 8 --no-validate
+ ```
+
+- __votenet__：在 commit [2f6d6d3](https://github.com/facebookresearch/votenet/tree/2f6d6d36ff98d96901182e935afe48ccee82d566) 版本下，执行如下命令：
+
+ ```bash
+ python train.py --dataset sunrgbd --batch_size 16
+ ```
+
+ 然后执行如下命令，对测试速度进行评估：
+
+ ```bash
+ python eval.py --dataset sunrgbd --checkpoint_path log_sunrgbd/checkpoint.tar --batch_size 1 --dump_dir eval_sunrgbd --cluster_sampling seed_fps --use_3d_nms --use_cls_nms --per_class_proposal
+ ```
+
+ 注意，为了计算推理速度，我们对 `eval.py` 进行了修改。
+
+ + （为了使用相同方法进行测试所做的具体修改 - 点击展开） +
+ + ```diff + diff --git a/tools/train_utils/train_utils.py b/tools/train_utils/train_utils.py + index 91f21dd..021359d 100644 + --- a/tools/train_utils/train_utils.py + +++ b/tools/train_utils/train_utils.py + @@ -2,6 +2,7 @@ import torch + import os + import glob + import tqdm + +import datetime + from torch.nn.utils import clip_grad_norm_ + + + @@ -13,7 +14,10 @@ def train_one_epoch(model, optimizer, train_loader, model_func, lr_scheduler, ac + if rank == 0: + pbar = tqdm.tqdm(total=total_it_each_epoch, leave=leave_pbar, desc='train', dynamic_ncols=True) + + + start_time = None + for cur_it in range(total_it_each_epoch): + + if cur_it > 49 and start_time is None: + + start_time = datetime.datetime.now() + try: + batch = next(dataloader_iter) + except StopIteration: + @@ -55,9 +59,11 @@ def train_one_epoch(model, optimizer, train_loader, model_func, lr_scheduler, ac + tb_log.add_scalar('learning_rate', cur_lr, accumulated_iter) + for key, val in tb_dict.items(): + tb_log.add_scalar('train_' + key, val, accumulated_iter) + + endtime = datetime.datetime.now() + + speed = (endtime - start_time).seconds / (total_it_each_epoch - 50) + if rank == 0: + pbar.close() + - return accumulated_iter + + return accumulated_iter, speed + + + def train_model(model, optimizer, train_loader, model_func, lr_scheduler, optim_cfg, + @@ -65,6 +71,7 @@ def train_model(model, optimizer, train_loader, model_func, lr_scheduler, optim_ + lr_warmup_scheduler=None, ckpt_save_interval=1, max_ckpt_save_num=50, + merge_all_iters_to_one_epoch=False): + accumulated_iter = start_iter + + speeds = [] + with tqdm.trange(start_epoch, total_epochs, desc='epochs', dynamic_ncols=True, leave=(rank == 0)) as tbar: + total_it_each_epoch = len(train_loader) + if merge_all_iters_to_one_epoch: + @@ -82,7 +89,7 @@ def train_model(model, optimizer, train_loader, model_func, lr_scheduler, optim_ + cur_scheduler = lr_warmup_scheduler + else: + cur_scheduler = lr_scheduler + - accumulated_iter = train_one_epoch( + + accumulated_iter, speed = train_one_epoch( + model, optimizer, train_loader, model_func, + lr_scheduler=cur_scheduler, + accumulated_iter=accumulated_iter, optim_cfg=optim_cfg, + @@ -91,7 +98,7 @@ def train_model(model, optimizer, train_loader, model_func, lr_scheduler, optim_ + total_it_each_epoch=total_it_each_epoch, + dataloader_iter=dataloader_iter + ) + - + + speeds.append(speed) + # save trained model + trained_epoch = cur_epoch + 1 + if trained_epoch % ckpt_save_interval == 0 and rank == 0: + @@ -107,6 +114,8 @@ def train_model(model, optimizer, train_loader, model_func, lr_scheduler, optim_ + save_checkpoint( + checkpoint_state(model, optimizer, trained_epoch, accumulated_iter), filename=ckpt_name, + ) + + print(speed) + + print(f'*******{sum(speeds) / len(speeds)}******') + + + def model_state_to_cpu(model_state): + ``` + +
+ kitti
+```
+
+**小贴士**：
+
+- **现成的标注文件**：我们已经提供了离线处理好的 [KITTI 标注文件](#数据集标注文件列表)。您直接下载他们并放到 `data/kitti/` 目录下。然而，如果你想在点云检测方法中使用 `ObjectSample` 这一数据增强，你可以再额外使用以下命令来生成物体标注框数据库：
+
+```bash
+python tools/create_data.py kitti --root-path ./data/kitti --out-dir ./data/kitti --extra-tag kitti --only-gt-database
+```
+
+### Waymo
+
+在[这里](https://waymo.com/open/download/)下载 Waymo 公开数据集 1.2 版本，在[这里](https://drive.google.com/drive/folders/18BVuF_RYJF0NjZpt8SnfzANiakoRMf0o?usp=sharing)下载其数据划分文件。然后，将 `.tfrecord` 文件置于 `data/waymo/waymo_format/` 目录下的相应位置，并将数据划分的 `.txt` 文件置于 `data/waymo/kitti_format/ImageSets` 目录下。在[这里](https://console.cloud.google.com/storage/browser/waymo_open_dataset_v_1_2_0/validation/ground_truth_objects)下载验证集的真实标签（`.bin` 文件）并将其置于 `data/waymo/waymo_format/`。提示：你可以使用 `gsutil` 来用命令下载大规模的数据集。更多细节请参考此[工具](https://github.com/RalphMao/Waymo-Dataset-Tool)。完成以上各步后，可以通过运行以下指令对 Waymo 数据进行预处理：
+
+```bash
+python tools/create_data.py waymo --root-path ./data/waymo/ --out-dir ./data/waymo/ --workers 128 --extra-tag waymo
+```
+
+注意:
+
+- 如果你的硬盘空间大小不足以存储转换后的数据，你可以将 `--out-dir` 参数设定为别的路径。你只需要记得在那个路径下创建文件夹并下载数据，然后在数据预处理完成后将其链接回 `data/waymo/kitti_format` 即可。
+
+**小贴士**：
+
+- **现成的标注文件**: 我们已经提供了离线处理好的 [Waymo 标注文件](#数据集标注文件列表)。您直接下载他们并放到 `data/waymo/kitti_format/` 目录下。然而，您还是需要自己使用上面的脚本将 Waymo 的原始数据还需要转成 kitti 格式。
+
+- **Waymo-mini**： 如果你只是为了验证某些方法或者 debug, 你可以使用我们提供的 [Waymo-mini](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_mini_kitti_format.tar.gz)。它只包含原始数据集中训练集中的 2 个 segments 和 验证集中的 1 个 segment。您只需要下载并且解压到 `data/waymo/`，即可使用它：
+
+ ```bash
+ tar -xzvf waymo_mini_kitti_format.tar.gz -C ./data/waymo
+ ```
+
+- **更快的评估**： 如果你想在 Waymo 上进行更快的评估，你可以下载已经预处理好的[元信息文件](https://download.openmmlab.com/mmdetection3d/data/waymo/idx2metainfo.pkl)并将其放置在 `data/waymo/waymo_format/` 目录下。接着，你可以按照以下来修改数据集的配置：
+
+ ```python
+ val_evaluator = dict(
+ type='WaymoMetric',
+ ann_file='./data/waymo/kitti_format/waymo_infos_val.pkl',
+ waymo_bin_file='./data/waymo/waymo_format/gt.bin',
+ data_root='./data/waymo/waymo_format',
+ backend_args=backend_args,
+ convert_kitti_format=True,
+ idx2metainfo='data/waymo/waymo_format/idx2metainfo.pkl'
+ )
+ ```
+
+ 目前这种方式仅限于纯点云检测任务。
+
+### NuScenes
+
+在[这里](https://www.nuscenes.org/download)下载 nuScenes 数据集 1.0 版本的完整数据文件。通过运行以下指令对 nuScenes 数据进行预处理：
+
+```bash
+python tools/create_data.py nuscenes --root-path ./data/nuscenes --out-dir ./data/nuscenes --extra-tag nuscenes
+```
+
+**小贴士**：
+
+- **现成的标注文件**：我们已经提供了离线处理好的 [NuScenes 标注文件](#数据集标注文件列表)。您直接下载他们并放到 `data/nuscenes/` 目录下。然而，如果你想在点云检测方法中使用 `ObjectSample` 这一数据增强，你可以再额外使用以下命令来生成物体标注框数据库：
+
+```bash
+python tools/create_data.py nuscenes --root-path ./data/nuscenes --out-dir ./data/nuscenes --extra-tag nuscenes --only-gt-database
+```
+
+### Lyft
+
+在[这里](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/data)下载 Lyft 3D 检测数据。通过运行以下指令对 Lyft 数据进行预处理：
+
+```bash
+python tools/create_data.py lyft --root-path ./data/lyft --out-dir ./data/lyft --extra-tag lyft --version v1.01
+python tools/data_converter/lyft_data_fixer.py --version v1.01 --root-folder ./data/lyft
+```
+
+注意，为了文件结构的清晰性，我们遵从了 Lyft 数据原先的文件夹名称。请按照上面展示出的文件结构对原始文件夹进行重命名。同样值得注意的是，第二行命令的目的是为了修复一个损坏的激光雷达数据文件。更多细节请参考[该讨论](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/discussion/110000)。
+
+### SemanticKITTI
+
+在[这里](http://semantic-kitti.org/dataset.html#download)下载 SemanticKITTI 数据集并解压所有文件。通过运行以下指令对 SemanticKITTI 数据进行预处理：
+
+```bash
+python ./tools/create_data.py semantickitti --root-path ./data/semantickitti --out-dir ./data/semantickitti --extra-tag semantickitti
+```
+
+**小贴士**：
+
+- **现成的标注文件**. 我们已经提供了离线处理好的 [SemanticKITTI 标注文件](#数据集标注文件列表)。您直接下载他们并放到 `data/semantickitti` 目录下。
+
+### S3DIS、ScanNet 和 SUN RGB-D
+
+请参考 S3DIS [README](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/data/s3dis/README.md) 文件以对其进行数据预处理。
+
+请参考 ScanNet [README](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/data/scannet/README.md) 文件以对其进行数据预处理。
+
+请参考 SUN RGB-D [README](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/data/sunrgbd/README.md) 文件以对其进行数据预处理。
+
+**小贴士**：对于 S3DIS, ScanNet 和 SUN RGB-D 数据集，我们已经提供了离线处理好的 [标注文件](#数据集标注文件列表)。您可以直接下载他们并放到 `data/${DATASET}/` 目录下。然而，您还是需要自己利用我们的脚本来生成点云文件以及语义掩膜文件(如果该数据集有的话)。
+
+### 自定义数据集
+
+关于如何使用自定义数据集，请参考[自定义数据集](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/docs/zh_cn/advanced_guides/customize_dataset.md)。
+
+### 更新数据信息
+
+如果你之前已经使用 v1.0.0rc1-v1.0.0rc4 版的 mmdetection3d 创建数据信息，现在你想使用最新的 v1.1.0 版 mmdetection3d，你需要更新数据信息文件。
+
+```bash
+python tools/dataset_converters/update_infos_to_v2.py --dataset ${DATA_SET} --pkl-path ${PKL_PATH} --out-dir ${OUT_DIR}
+```
+
+- `--dataset`：数据集名。
+- `--pkl-path`：指定数据信息 pkl 文件路径。
+- `--out-dir`：输出数据信息 pkl 文件目录。
+
+例如：
+
+```bash
+python tools/dataset_converters/update_infos_to_v2.py --dataset kitti --pkl-path ./data/kitti/kitti_infos_trainval.pkl --out-dir ./data/kitti
+```
+
+### 数据集标注文件列表
+
+我们提供了离线生成好的数据集标注文件以供参考。为了方便，您也可以直接使用他们。
+
+| 数据集 | 训练集标注文件 | 验证集标注文件 | 测试集标注文件 |
+| :--------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------: |
+| KITTI | [kitti_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/kitti/kitti_infos_train.pkl) | [kitti_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/kitti/kitti_infos_val.pkl) | [kitti_infos_test](https://download.openmmlab.com/mmdetection3d/data/kitti/kitti_infos_test.pkl) |
+| NuScenes | [nuscenes_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/nuscenes/nuscenes_infos_train.pkl) [nuscenes_mini_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/nuscenes/nuscenes_mini_infos_train.pkl) | [nuscenes_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/nuscenes/nuscenes_infos_val.pkl) [nuscenes_mini_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/nuscenes/nuscenes_mini_infos_val.pkl) | |
+| Waymo | [waymo_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_infos_train.pkl) [waymo_mini_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_mini_infos_train.pkl) | [waymo_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_infos_val.pkl) [waymo_mini_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_mini_infos_val.pkl) | [waymo_infos_test.pkl](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_infos_test.pkl) |
+| [Waymo-mini kitti-format data](https://download.openmmlab.com/mmdetection3d/data/waymo/waymo_mini_kitti_format.tar.gz) | | | |
+| SUN RGB-D | [sunrgbd_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/sunrgbd/sunrgbd_infos_train.pkl) | [sunrgbd_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/sunrgbd/sunrgbd_infos_val.pkl) | |
+| ScanNet | [scannet_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/scannet/scannet_infos_train.pkl) | [scannet_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/scannet/scannet_infos_val.pkl) | [scannet_infos_test.pkl](https://download.openmmlab.com/mmdetection3d/data/scannet/scannet_infos_test.pkl) |
+| SemanticKitti | [semantickitti_infos_train.pkl](https://download.openmmlab.com/mmdetection3d/data/semantickitti/semantickitti_infos_train.pkl) | [semantickitti_infos_val.pkl](https://download.openmmlab.com/mmdetection3d/data/semantickitti/semantickitti_infos_val.pkl) | [semantickitti_infos_test.pkl](https://download.openmmlab.com/mmdetection3d/data/semantickitti/semantickitti_infos_test.pkl) |
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/faq.md b/internlm_langchain/knowledge_base/MMDetection3D/content/faq.md
new file mode 100644
index 00000000..6b5a9896
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/faq.md
@@ -0,0 +1,58 @@
+# 常见问题解答
+
+我们列出了一些用户和开发者在开发过程中会遇到的常见问题以及对应的解决方案，如果您发现了任何频繁出现的问题，请随时扩充本列表，非常欢迎您提出的任何解决方案。如果您在环境配置、模型训练等工作中遇到任何的问题，请使用[问题模板](https://github.com/open-mmlab/mmdetection3d/blob/master/.github/ISSUE_TEMPLATE/error-report.md)来创建相应的 issue，并将所需的所有信息填入到问题模板中，我们会尽快解决您的问题。
+
+## MMEngine/MMCV/MMDet/MMDet3D 安装
+
+- 跟 MMEngine, MMCV, MMDetection 和 MMDetection3D 相关的编译问题; "ConvWS is already registered in conv layer"; "AssertionError: MMCV==xxx is used but incompatible. Please install mmcv>=xxx, \<=xxx."
+
+- MMDetection3D 需要的 MMEngine, MMCV 和 MMDetection 的版本列在了下面。请安装正确版本的 MMEngine、MMCV 和 MMDetection 以避免相关的安装问题。
+
+ | MMDetection3D 版本 | MMEngine 版本 | MMCV 版本 | MMDetection 版本 |
+ | ------------------ | :----------------------: | :---------------------: | :----------------------: |
+ | dev-1.x | mmengine>=0.7.1, \<1.0.0 | mmcv>=2.0.0rc4, \<2.1.0 | mmdet>=3.0.0, \<3.1.0 |
+ | main | mmengine>=0.7.1, \<1.0.0 | mmcv>=2.0.0rc4, \<2.1.0 | mmdet>=3.0.0, \<3.1.0 |
+ | v1.1.0rc3 | mmengine>=0.1.0, \<1.0.0 | mmcv>=2.0.0rc3, \<2.1.0 | mmdet>=3.0.0rc0, \<3.1.0 |
+ | v1.1.0rc2 | mmengine>=0.1.0, \<1.0.0 | mmcv>=2.0.0rc3, \<2.1.0 | mmdet>=3.0.0rc0, \<3.1.0 |
+ | v1.1.0rc1 | mmengine>=0.1.0, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | mmdet>=3.0.0rc0, \<3.1.0 |
+ | v1.1.0rc0 | mmengine>=0.1.0, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | mmdet>=3.0.0rc0, \<3.1.0 |
+
+ **注意**：如果你想安装 mmdet3d-v1.0.0rcx，可以在[此处](https://mmdetection3d.readthedocs.io/en/latest/faq.html#mmcv-mmdet-mmdet3d-installation)找到 MMDetection，MMSegmentation 和 MMCV 的兼容版本。请选择正确版本的 MMCV、MMDetection 和 MMSegmentation 以避免安装问题。
+
+- 如果您在 `import open3d` 时遇到下面的问题：
+
+ `OSError: /lib/x86_64-linux-gnu/libm.so.6: version 'GLIBC_2.27' not found`
+
+ 请将 open3d 的版本降级至 0.9.0.0，因为最新版 open3d 需要 'GLIBC_2.27' 文件的支持， Ubuntu 16.04 系统中缺失该文件，且该文件仅存在于 Ubuntu 18.04 及之后的系统中。
+
+- 如果您在 `import pycocotools` 时遇到版本错误的问题，这是由于 nuscenes-devkit 需要安装 pycocotools，然而 mmdet 依赖于 mmpycocotools，当前的解决方案如下所示，我们将会在之后全面支持 pycocotools ：
+
+ ```shell
+ pip uninstall pycocotools mmpycocotools
+ pip install mmpycocotools
+ ```
+
+ **注意**： 我们已经在 0.13.0 及之后的版本中全面支持 pycocotools。
+
+- 如果您在导入 pycocotools 相关包时遇到下面的问题：
+
+ `ValueError: numpy.ndarray size changed, may indicate binary incompatibility. Expected 88 from C header, got 80 from PyObject`
+
+ 请将 pycocotools 的版本降级至 2.0.1，这是由于最新版本的 pycocotools 与 numpy \< 1.20.0 不兼容。或者通过下面的方式从源码进行编译来安装最新版本的 pycocotools ：
+
+ `pip install -e "git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI"`
+
+ 或者
+
+ `pip install -e "git+https://github.com/ppwwyyxx/cocoapi#egg=pycocotools&subdirectory=PythonAPI"`
+
+- 如果您使用 cuda-9.0 的环境并遇到关于 numba 的错误， 您应该检查下 numba 的版本。在 cuda-9.0 环境中，高版本的 numba 是不支持的，我们建议安装 numba==0.53.0.
+
+## 如何标注点云？
+
+MMDetection3D 不支持点云标注。我们提供一些开源的标注工具供参考：
+
+- [SUSTechPOINTS](https://github.com/naurril/SUSTechPOINTS)
+- [LATTE](https://github.com/bernwang/latte)
+
+此外，我们改进了 [LATTE](https://github.com/bernwang/latte) 以便更方便的标注。更多的细节请参考[这里](https://arxiv.org/abs/2011.10174)。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/get_started.md b/internlm_langchain/knowledge_base/MMDetection3D/content/get_started.md
new file mode 100644
index 00000000..9f0c1cb5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/get_started.md
@@ -0,0 +1,294 @@
+# 开始你的第一步
+
+## 依赖
+
+在本节中，我们将展示如何使用 PyTorch 准备环境。
+
+MMDetection3D 支持在 Linux，Windows（实验性支持），MacOS 上运行，它需要 Python 3.7 以上，CUDA 9.2 以上和 PyTorch 1.6 以上。
+
+```{note}
+如果您对 PyTorch 有经验并且已经安装了它，您可以直接跳转到[下一小节](#安装流程)。否则，您可以按照下述步骤进行准备。
+```
+
+**步骤 0.** 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda。
+
+**步骤 1.** 创建并激活一个 conda 环境。
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**步骤 2.** 基于 [PyTorch 官方说明](https://pytorch.org/get-started/locally/)安装 PyTorch，例如：
+
+在 GPU 平台上：
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+在 CPU 平台上：
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## 安装流程
+
+我们推荐用户参照我们的最佳实践安装 MMDetection3D。不过，整个过程也是可定制化的，更多信息请参考[自定义安装](#自定义安装)章节。
+
+### 最佳实践
+
+**步骤 0.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine)，[MMCV](https://github.com/open-mmlab/mmcv) 和 [MMDetection](https://github.com/open-mmlab/mmdetection)。
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install 'mmcv>=2.0.0rc4'
+mim install 'mmdet>=3.0.0'
+```
+
+**注意**：在 MMCV-v2.x 中，`mmcv-full` 改名为 `mmcv`，如果您想安装不包含 CUDA 算子的 `mmcv`，您可以使用 `mim install "mmcv-lite>=2.0.0rc4"` 安装精简版。
+
+**步骤 1.** 安装 MMDetection3D。
+
+方案 a：如果您开发并直接运行 mmdet3d，从源码安装它：
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection3d.git -b dev-1.x
+# "-b dev-1.x" 表示切换到 `dev-1.x` 分支。
+cd mmdetection3d
+pip install -v -e .
+# "-v" 指详细说明，或更多的输出
+# "-e" 表示在可编辑模式下安装项目，因此对代码所做的任何本地修改都会生效，从而无需重新安装。
+```
+
+方案 b：如果您将 mmdet3d 作为依赖或第三方 Python 包使用，使用 MIM 安装：
+
+```shell
+mim install "mmdet3d>=1.1.0rc0"
+```
+
+注意：
+
+1. 如果您希望使用 `opencv-python-headless` 而不是 `opencv-python`，您可以在安装 MMCV 之前安装它。
+
+2. 一些安装依赖是可选的。简单地运行 `pip install -v -e .` 将会安装最低运行要求的版本。如果想要使用一些可选依赖项，例如 `albumentations` 和 `imagecorruptions`，可以使用 `pip install -r requirements/optional.txt` 进行手动安装，或者在使用 `pip` 时指定所需的附加功能（例如 `pip install -v -e .[optional]`），支持附加功能的有效键值包括 `all`、`tests`、`build` 以及 `optional`。
+
+ 我们已经支持 `spconv 2.0`。如果用户已经安装 `spconv 2.0`，代码会默认使用 `spconv 2.0`，它会比原生 `mmcv spconv` 使用更少的 GPU 内存。用户可以使用下列的命令来安装 `spconv 2.0`：
+
+ ```shell
+ pip install cumm-cuxxx
+ pip install spconv-cuxxx
+ ```
+
+ `xxx` 表示环境中的 CUDA 版本。
+
+ 例如，使用 CUDA 10.2，对应命令是 `pip install cumm-cu102 && pip install spconv-cu102`。
+
+ 支持的 CUDA 版本包括 10.2，11.1，11.3 和 11.4。用户也可以通过源码编译来安装。更多细节请参考[spconv v2.x](https://github.com/traveller59/spconv)。
+
+ 我们也支持 `Minkowski Engine` 作为稀疏卷积的后端。如果需要，请参考[安装指南](https://github.com/NVIDIA/MinkowskiEngine#installation) 或者使用 `pip` 来安装：
+
+ ```shell
+ conda install openblas-devel -c anaconda
+ export CPLUS_INCLUDE_PATH=CPLUS_INCLUDE_PATH:${YOUR_CONDA_ENVS_DIR}/include
+ # replace ${YOUR_CONDA_ENVS_DIR} to your anaconda environment path e.g. `/home/username/anaconda3/envs/openmmlab`.
+ pip install -U git+https://github.com/NVIDIA/MinkowskiEngine -v --no-deps --install-option="--blas_include_dirs=/opt/conda/include" --install-option="--blas=openblas"
+ ```
+
+ 我们还支持 `Torchsparse` 作为稀疏卷积的后端。如果需要，请参考[安装指南](https://github.com/mit-han-lab/torchsparse#installation) 或者使用 `pip` 来安装：
+
+ ```shell
+ sudo apt install libsparsehash-dev
+ pip install --upgrade git+https://github.com/mit-han-lab/torchsparse.git@v1.4.0
+ ```
+
+ 或者通过以下安装绕过sudo权限
+
+ ```shell
+ conda install -c bioconda sparsehash
+ export CPLUS_INCLUDE_PATH=CPLUS_INCLUDE_PATH:${YOUR_CONDA_ENVS_DIR}/include
+ # replace ${YOUR_CONDA_ENVS_DIR} to your anaconda environment path e.g. `/home/username/anaconda3/envs/openmmlab`.
+ pip install --upgrade git+https://github.com/mit-han-lab/torchsparse.git@v1.4.0
+ ```
+
+3. 我们的代码目前不能在只有 CPU 的环境（CUDA 不可用）下编译。
+
+### 验证安装
+
+为了验证 MMDetection3D 是否安装正确，我们提供了一些示例代码来执行模型推理。
+
+**步骤 1.** 我们需要下载配置文件和模型权重文件。
+
+```shell
+mim download mmdet3d --config pointpillars_hv_secfpn_8xb6-160e_kitti-3d-car --dest .
+```
+
+下载将需要几秒钟或更长时间，这取决于您的网络环境。完成后，您会在当前文件夹中发现两个文件 `pointpillars_hv_secfpn_8xb6-160e_kitti-3d-car.py` 和 `hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth`。
+
+**步骤 2.** 推理验证。
+
+方案 a：如果您从源码安装 MMDetection3D，那么直接运行以下命令进行验证：
+
+```shell
+python demo/pcd_demo.py demo/data/kitti/000008.bin pointpillars_hv_secfpn_8xb6-160e_kitti-3d-car.py hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth --show
+```
+
+您会看到一个带有点云的可视化界面，其中包含有在汽车上绘制的检测框。
+
+**注意**：
+
+如果您想输入一个 `.ply` 文件，您可以使用如下函数将它转换成 `.bin` 格式。然后您可以使用转化的 `.bin` 文件来运行样例。请注意在使用此脚本之前，您需要安装 `pandas` 和 `plyfile`。这个函数也可以用于训练 `ply 数据`时作为数据预处理来使用。
+
+```python
+import numpy as np
+import pandas as pd
+from plyfile import PlyData
+
+def convert_ply(input_path, output_path):
+ plydata = PlyData.read(input_path) # 读取文件
+ data = plydata.elements[0].data # 读取数据
+ data_pd = pd.DataFrame(data) # 转换成 DataFrame
+ data_np = np.zeros(data_pd.shape, dtype=np.float) # 初始化数组来存储数据
+ property_names = data[0].dtype.names # 读取属性名称
+ for i, name in enumerate(
+ property_names): # 通过属性读取数据
+ data_np[:, i] = data_pd[name]
+ data_np.astype(np.float32).tofile(output_path)
+```
+
+例如：
+
+```python
+convert_ply('./test.ply', './test.bin')
+```
+
+如果您有其他格式的点云数据（`.off`，`.obj` 等），您可以使用 `trimesh` 将它们转化成 `.ply`。
+
+```python
+import trimesh
+
+def to_ply(input_path, output_path, original_type):
+ mesh = trimesh.load(input_path, file_type=original_type) # 读取文件
+ mesh.export(output_path, file_type='ply') # 转换成 ply
+```
+
+例如：
+
+```python
+to_ply('./test.obj', './test.ply', 'obj')
+```
+
+方案 b：如果您使用 MIM 安装 MMDetection3D，那么可以打开您的 Python 解析器，复制并粘贴以下代码：
+
+```python
+from mmdet3d.apis import init_model, inference_detector
+
+config_file = 'pointpillars_hv_secfpn_8xb6-160e_kitti-3d-car.py'
+checkpoint_file = 'hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth'
+model = init_model(config_file, checkpoint_file)
+inference_detector(model, 'demo/data/kitti/000008.bin')
+```
+
+您将会看到一个包含 `Det3DDataSample` 的列表，预测结果在 `pred_instances_3d` 里面，包含有检测框，类别和得分。
+
+### 自定义安装
+
+#### CUDA 版本
+
+在安装 PyTorch 时，您需要指定 CUDA 的版本。如果您不清楚应该选择哪一个，请遵循我们的建议：
+
+- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 系列以及 NVIDIA A100，CUDA 11 是必需的。
+- 对于更早的 NVIDIA GPU，CUDA 11 是向后兼容的，但 CUDA 10.2 提供更好的兼容性，并且更轻量。
+
+请确保 GPU 驱动版本满足最低的版本需求。更多信息请参考此[表格](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。
+
+```{note}
+如果您遵循我们的最佳实践，您只需要安装 CUDA 运行库，这是因为不需要在本地编译 CUDA 代码。但如果您希望从源码编译 MMCV，或者开发其他 CUDA 算子，那么您需要从 NVIDIA 的[官网](https://developer.nvidia.com/cuda-downloads)安装完整的 CUDA 工具链，并且该版本应该与 PyTorch 的 CUDA 版本相匹配，比如在 `conda install` 指令里指定 cudatoolkit 版本。
+```
+
+#### 不通过 MIM 安装 MMEngine
+
+如果想要使用 pip 而不是 MIM 安装 MMEngine，请参考 [MMEngine 安装指南](https://mmengine.readthedocs.io/zh_CN/latest/get_started/installation.html)。
+
+例如，您可以通过以下指令安装 MMEngine：
+
+```shell
+pip install mmengine
+```
+
+#### 不通过 MIM 安装 MMCV
+
+MMCV 包含 C++ 和 CUDA 拓展，因此其对 PyTorch 的依赖更复杂。MIM 会自动解决此类依赖关系并使安装更容易。但这不是必需的。
+
+如果想要使用 pip 而不是 MIM 安装 MMCV，请参考 [MMCV 安装指南](https://mmcv.readthedocs.io/zh_CN/2.x/get_started/installation.html)。这需要用指定 url 的形式手动指定对应的 PyTorch 和 CUDA 版本。
+
+例如，下述指令将会安装基于 PyTorch 1.12.x 和 CUDA 11.6 编译的 MMCV：
+
+```shell
+pip install "mmcv>=2.0.0rc4" -f https://download.openmmlab.com/mmcv/dist/cu116/torch1.12.0/index.html
+```
+
+#### 在 Google Colab 中安装
+
+[Google Colab](https://colab.research.google.com/) 通常已经安装了 PyTorch，因此我们只需要用如下命令安装 MMEngine，MMCV，MMDetection 和 MMDetection3D 即可。
+
+**步骤 1.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine)，[MMCV](https://github.com/open-mmlab/mmcv) 和 [MMDetection](https://github.com/open-mmlab/mmdetection)。
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0rc4,<2.1.0"
+!mim install "mmdet>=3.0.0,<3.1.0"
+```
+
+**步骤 2.** 从源码安装 MMDetection3D。
+
+```shell
+!git clone https://github.com/open-mmlab/mmdetection3d.git -b dev-1.x
+%cd mmdetection3d
+!pip install -e .
+```
+
+**步骤 3.** 验证安装是否成功。
+
+```python
+import mmdet3d
+print(mmdet3d.__version__)
+# 预期输出：1.1.0rc0 或其它版本号。
+```
+
+```{note}
+在 Jupyter Notebook 中，感叹号 `!` 用于执行外部命令，而 `%cd` 是一个[魔术命令](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd)，用于切换 Python 的工作路径。
+```
+
+#### 通过 Docker 使用 MMDetection3D
+
+我们提供了 [Dockerfile](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/docker/Dockerfile) 来构建一个镜像。请确保您的 [docker 版本](https://docs.docker.com/engine/install/) >= 19.03。
+
+```shell
+# 基于 PyTorch 1.9，CUDA 11.1 构建镜像
+# 如果您想要其他版本，只需要修改 Dockerfile
+docker build -t mmdetection3d docker/
+```
+
+用以下命令运行 Docker 镜像：
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmdetection3d/data mmdetection3d
+```
+
+### 故障排除
+
+如果您在安装过程中遇到一些问题，请先参考 [FAQ](notes/faq.md) 页面。如果没有找到对应的解决方案，您也可以在 GitHub [提一个问题](https://github.com/open-mmlab/mmdetection3d/issues/new/choose)。
+
+### 使用多个 MMDetection3D 版本进行开发
+
+训练和测试的脚本已经在 `PYTHONPATH` 中进行了修改，以确保脚本使用当前目录中的 MMDetection3D。
+
+要使环境中安装默认版本的 MMDetection3D 而不是当前正在使用的，可以删除出现在相关脚本中的代码：
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/inference.md b/internlm_langchain/knowledge_base/MMDetection3D/content/inference.md
new file mode 100644
index 00000000..a3a62b53
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/inference.md
@@ -0,0 +1,101 @@
+# 推理
+
+## 介绍
+
+我们提供了多模态/单模态（基于激光雷达/图像）、室内/室外场景的 3D 检测和 3D 语义分割样例的脚本，预训练模型可以从 [Model Zoo](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/docs/zh_cn/model_zoo.md) 下载。我们也提供了 KITTI、SUN RGB-D、nuScenes 和 ScanNet 数据集的预处理样本数据，你可以根据我们的预处理步骤使用任何其它数据。
+
+## 测试
+
+### 3D 检测
+
+#### 点云样例
+
+在点云数据上测试 3D 检测器，运行：
+
+```shell
+python demo/pcd_demo.py ${PCD_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${GPU_ID}] [--score-thr ${SCORE_THR}] [--out-dir ${OUT_DIR}] [--show]
+```
+
+点云和预测 3D 框的可视化结果会被保存在 `${OUT_DIR}/PCD_NAME`，它可以使用 [MeshLab](http://www.meshlab.net/) 打开。注意如果你设置了 `--show`，通过 [Open3D](http://www.open3d.org/) 可以在线显示预测结果。
+
+在 KITTI 数据上测试 [PointPillars 模型](https://download.openmmlab.com/mmdetection3d/v1.0.0_models/pointpillars/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car/hv_pointpillars_secfpn_6x8_160e_kitti-3d-car_20220331_134606-d42d15ed.pth)：
+
+```shell
+python demo/pcd_demo.py demo/data/kitti/000008.bin configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-car.py ${CHECKPOINT_FILE} --show
+```
+
+在 SUN RGB-D 数据上测试 [VoteNet 模型](https://download.openmmlab.com/mmdetection3d/v1.0.0_models/votenet/votenet_16x8_sunrgbd-3d-10class/votenet_16x8_sunrgbd-3d-10class_20210820_162823-bf11f014.pth)：
+
+```shell
+python demo/pcd_demo.py demo/data/sunrgbd/sunrgbd_000017.bin configs/votenet/votenet_8xb16_sunrgbd-3d.py ${CHECKPOINT_FILE} --show
+```
+
+#### 单目 3D 样例
+
+在图像数据上测试单目 3D 检测器，运行：
+
+```shell
+python demo/mono_det_demo.py ${IMAGE_FILE} ${ANNOTATION_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${GPU_ID}] [--out-dir ${OUT_DIR}] [--show]
+```
+
+`ANNOTATION_FILE` 需要提供 3D 到 2D 的仿射矩阵（相机内参矩阵），可视化结果会被保存在 `${OUT_DIR}/PCD_NAME`，其中包括图像以及预测 3D 框在图像上的投影。
+
+在 KITTI 数据上测试 [PGD 模型](https://download.openmmlab.com/mmdetection3d/v1.0.0_models/pgd/pgd_r101_caffe_fpn_gn-head_3x4_4x_kitti-mono3d/pgd_r101_caffe_fpn_gn-head_3x4_4x_kitti-mono3d_20211022_102608-8a97533b.pth)：
+
+```shell
+python demo/mono_det_demo.py demo/data/kitti/000008.png demo/data/kitti/000008.pkl configs/pgd/pgd_r101-caffe_fpn_head-gn_4xb3-4x_kitti-mono3d.py ${CHECKPOINT_FILE} --show --cam-type CAM2 --score-thr 8
+```
+
+**注意**： PGD 方法的预测框分数并不是在 (0, 1) 之间
+
+在 nuScenes 数据上测试 [FCOS3D 模型](https://download.openmmlab.com/mmdetection3d/v0.1.0_models/fcos3d/fcos3d_r101_caffe_fpn_gn-head_dcn_2x8_1x_nus-mono3d_finetune/fcos3d_r101_caffe_fpn_gn-head_dcn_2x8_1x_nus-mono3d_finetune_20210717_095645-8d806dc2.pth)：
+
+```shell
+python demo/mono_det_demo.py demo/data/nuscenes/n015-2018-07-24-11-22-45+0800__CAM_BACK__1532402927637525.jpg demo/data/nuscenes/n015-2018-07-24-11-22-45+0800.pkl configs/fcos3d/fcos3d_r101-caffe-dcn_fpn_head-gn_8xb2-1x_nus-mono3d_finetune.py ${CHECKPOINT_FILE} --show --cam-type CAM_BACK
+```
+
+**注意**： 当对翻转图像可视化单目 3D 检测结果是，相机内参矩阵也应该相应修改。在 PR [#744](https://github.com/open-mmlab/mmdetection3d/pull/744) 中可以了解更多细节和示例。
+
+#### 多模态样例
+
+在多模态数据（通常是点云和图像）上测试 3D 检测器，运行：
+
+```shell
+python demo/multi_modality_demo.py ${PCD_FILE} ${IMAGE_FILE} ${ANNOTATION_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${GPU_ID}] [--score-thr ${SCORE_THR}] [--out-dir ${OUT_DIR}] [--show]
+```
+
+`ANNOTATION_FILE` 需要提供 3D 到 2D 的仿射矩阵，可视化结果会被保存在 `${OUT_DIR}/PCD_NAME`，其中包括点云、图像、预测的 3D 框以及它们在图像上的投影。
+
+在 KITTI 数据上测试 [MVX-Net 模型](https://download.openmmlab.com/mmdetection3d/v1.1.0_models/mvxnet/mvxnet_fpn_dv_second_secfpn_8xb2-80e_kitti-3d-3class/mvxnet_fpn_dv_second_secfpn_8xb2-80e_kitti-3d-3class-8963258a.pth)：
+
+```shell
+python demo/multi_modality_demo.py demo/data/kitti/000008.bin demo/data/kitti/000008.png demo/data/kitti/000008.pkl configs/mvxnet/mvxnet_fpn_dv_second_secfpn_8xb2-80e_kitti-3d-3class.py ${CHECKPOINT_FILE} --cam-type CAM2 --show
+```
+
+在 SUN RGB-D 数据上测试 [ImVoteNet 模型](https://download.openmmlab.com/mmdetection3d/v1.0.0_models/imvotenet/imvotenet_stage2_16x8_sunrgbd-3d-10class/imvotenet_stage2_16x8_sunrgbd-3d-10class_20210819_192851-1bcd1b97.pth)：
+
+```shell
+python demo/multi_modality_demo.py demo/data/sunrgbd/000017.bin demo/data/sunrgbd/000017.jpg demo/data/sunrgbd/sunrgbd_000017_infos.pkl configs/imvotenet/imvotenet_stage2_8xb16_sunrgbd-3d.py ${CHECKPOINT_FILE} --cam-type CAM0 --show --score-thr 0.6
+```
+
+在 NuScenes 数据上测试 [BEVFusion 模型](https://drive.google.com/file/d/1QkvbYDk4G2d6SZoeJqish13qSyXA4lp3/view?usp=share_link)
+
+```shell
+python demo/multi_modality_demo.py demo/data/nuscenes/n015-2018-07-24-11-22-45+0800__LIDAR_TOP__1532402927647951.pcd.bin demo/data/nuscenes/ demo/data/nuscenes/n015-2018-07-24-11-22-45+0800.pkl projects/BEVFusion/configs/bevfusion_voxel0075_second_secfpn_8xb4-cyclic-20e_nus-3d.py ${CHECKPOINT_FILE} --cam-type all --score-thr 0.2 --show
+```
+
+### 3D 分割
+
+在点云数据上测试 3D 分割器，运行：
+
+```shell
+python demo/pc_seg_demo.py ${PCD_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${GPU_ID}] [--out-dir ${OUT_DIR}] [--show]
+```
+
+可视化结果会被保存在 `${OUT_DIR}/PCD_NAME`，其中包括点云以及预测的 3D 分割掩码。
+
+在 ScanNet 数据上测试 [PointNet++ (SSG) 模型](https://download.openmmlab.com/mmdetection3d/v0.1.0_models/pointnet2/pointnet2_ssg_16x2_cosine_200e_scannet_seg-3d-20class/pointnet2_ssg_16x2_cosine_200e_scannet_seg-3d-20class_20210514_143644-ee73704a.pth)：
+
+```shell
+python demo/pcd_seg_demo.py demo/data/scannet/scene0000_00.bin configs/pointnet2/pointnet2_ssg_2xb16-cosine-200e_scannet-seg.py ${CHECKPOINT_FILE} --show
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/kitti.md b/internlm_langchain/knowledge_base/MMDetection3D/content/kitti.md
new file mode 100644
index 00000000..4b86215b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/kitti.md
@@ -0,0 +1,206 @@
+# KITTI 数据集
+
+本页提供了有关在 MMDetection3D 中使用 KITTI 数据集的具体教程。
+
+## 数据准备
+
+您可以在[这里](http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d)下载 KITTI 3D 检测数据并解压缩所有 zip 文件。此外，您可以在[这里](https://download.openmmlab.com/mmdetection3d/data/train_planes.zip)下载道路平面信息，其在训练过程中作为一个可选项，用来提高模型的性能。道路平面信息由 [AVOD](https://github.com/kujason/avod) 生成，更多细节请参考[此处](https://github.com/kujason/avod/issues/19)。
+
+像准备数据集的一般方法一样，建议将数据集根目录链接到 `$MMDETECTION3D/data`。
+
+在我们处理之前，文件夹结构应按如下方式组织：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── kitti
+│ │ ├── ImageSets
+│ │ ├── testing
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── velodyne
+│ │ ├── training
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── label_2
+│ │ │ ├── velodyne
+│ │ │ ├── planes (optional)
+```
+
+### 创建 KITTI 数据集
+
+为了创建 KITTI 点云数据，首先需要加载原始的点云数据并生成相关的包含目标标签和标注框的数据标注文件，同时还需要为 KITTI 数据集生成每个单独的训练目标的点云数据，并将其存储在 `data/kitti/kitti_gt_database` 的 `.bin` 格式的文件中，此外，需要为训练数据或者验证数据生成 `.pkl` 格式的包含数据信息的文件。随后，通过运行下面的命令来创建最终的 KITTI 数据：
+
+```bash
+mkdir ./data/kitti/ && mkdir ./data/kitti/ImageSets
+
+# 下载数据划分
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/test.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/test.txt
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/train.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/train.txt
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/val.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/val.txt
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/trainval.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/trainval.txt
+
+python tools/create_data.py kitti --root-path ./data/kitti --out-dir ./data/kitti --extra-tag kitti --with-plane
+```
+
+需要注意的是，如果您的本地磁盘没有充足的存储空间来存储转换后的数据，您可以通过改变 `--out-dir` 来指定其他任意的存储路径。如果您没有准备 `planes` 数据，您需要移除 `--with-plane` 标志。
+
+处理后的文件夹结构应该如下：
+
+```
+kitti
+├── ImageSets
+│ ├── test.txt
+│ ├── train.txt
+│ ├── trainval.txt
+│ ├── val.txt
+├── testing
+│ ├── calib
+│ ├── image_2
+│ ├── velodyne
+│ ├── velodyne_reduced
+├── training
+│ ├── calib
+│ ├── image_2
+│ ├── label_2
+│ ├── velodyne
+│ ├── velodyne_reduced
+│ ├── planes (optional)
+├── kitti_gt_database
+│ ├── xxxxx.bin
+├── kitti_infos_train.pkl
+├── kitti_infos_val.pkl
+├── kitti_dbinfos_train.pkl
+├── kitti_infos_test.pkl
+├── kitti_infos_trainval.pkl
+```
+
+- `kitti_gt_database/xxxxx.bin`：训练数据集中包含在 3D 标注框中的点云数据。
+- `kitti_infos_train.pkl`：训练数据集，该字典包含了两个键值：`metainfo` 和 `data_list`。`metainfo` 包含数据集的基本信息，例如 `categories`, `dataset` 和 `info_version`。`data_list` 是由字典组成的列表，每个字典（以下简称 `info`）包含了单个样本的所有详细信息。
+ - info\['sample_idx'\]：该样本在整个数据集的索引。
+ - info\['images'\]：多个相机捕获的图像信息。是一个字典，包含 5 个键值：`CAM0`, `CAM1`, `CAM2`, `CAM3`, `R0_rect`。
+ - info\['images'\]\['R0_rect'\]：校准旋转矩阵，是一个 4x4 数组。
+ - info\['images'\]\['CAM2'\]：包含 `CAM2` 相机传感器的信息。
+ - info\['images'\]\['CAM2'\]\['img_path'\]：图像的文件名。
+ - info\['images'\]\['CAM2'\]\['height'\]：图像的高。
+ - info\['images'\]\['CAM2'\]\['width'\]：图像的宽。
+ - info\['images'\]\['CAM2'\]\['cam2img'\]：相机到图像的变换矩阵，是一个 4x4 数组。
+ - info\['images'\]\['CAM2'\]\['lidar2cam'\]：激光雷达到相机的变换矩阵，是一个 4x4 数组。
+ - info\['images'\]\['CAM2'\]\['lidar2img'\]：激光雷达到图像的变换矩阵，是一个 4x4 数组。
+ - info\['lidar_points'\]：是一个字典，包含了激光雷达点相关的信息。
+ - info\['lidar_points'\]\['lidar_path'\]：激光雷达点云数据的文件名。
+ - info\['lidar_points'\]\['num_pts_feats'\]：点的特征维度。
+ - info\['lidar_points'\]\['Tr_velo_to_cam'\]：Velodyne 坐标到相机坐标的变换矩阵，是一个 4x4 数组。
+ - info\['lidar_points'\]\['Tr_imu_to_velo'\]：IMU 坐标到 Velodyne 坐标的变换矩阵，是一个 4x4 数组。
+ - info\['instances'\]：是一个字典组成的列表。每个字典包含单个实例的所有标注信息。对于其中的第 i 个实例，我们有：
+ - info\['instances'\]\[i\]\['bbox'\]：长度为 4 的列表，以 (x1, y1, x2, y2) 的顺序表示实例的 2D 边界框。
+ - info\['instances'\]\[i\]\['bbox_3d'\]：长度为 7 的列表，以 (x, y, z, l, h, w, yaw) 的顺序表示实例的 3D 边界框。
+ - info\['instances'\]\[i\]\['bbox_label'\]：是一个整数，表示实例的 2D 标签，-1 代表忽略。
+ - info\['instances'\]\[i\]\['bbox_label_3d'\]：是一个整数，表示实例的 3D 标签，-1 代表忽略。
+ - info\['instances'\]\[i\]\['depth'\]：3D 边界框投影到相关图像平面的中心点的深度。
+ - info\['instances'\]\[i\]\['num_lidar_pts'\]：3D 边界框内的激光雷达点数。
+ - info\['instances'\]\[i\]\['center_2d'\]：3D 边界框投影的 2D 中心。
+ - info\['instances'\]\[i\]\['difficulty'\]：KITTI 官方定义的困难度，包括简单、适中、困难。
+ - info\['instances'\]\[i\]\['truncated'\]：从 0（非截断）到 1（截断）的浮点数，其中截断指的是离开检测图像边界的检测目标。
+ - info\['instances'\]\[i\]\['occluded'\]：整数 (0,1,2,3) 表示目标的遮挡状态：0 = 完全可见，1 = 部分遮挡，2 = 大面积遮挡，3 = 未知。
+ - info\['instances'\]\[i\]\['group_ids'\]：用于多部分的物体。
+ - info\['plane'\]（可选）：地平面信息。
+
+更多细节请参考 [kitti_converter.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/kitti_converter.py) 和 [update_infos_to_v2.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/update_infos_to_v2.py)。
+
+## 训练流程
+
+下面展示了一个使用 KITTI 数据集进行 3D 目标检测的典型流程：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=4, # x, y, z, intensity
+ use_dim=4),
+ dict(
+ type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(type='ObjectSample', db_sampler=db_sampler),
+ dict(
+ type='ObjectNoise',
+ num_try=100,
+ translation_std=[1.0, 1.0, 0.5],
+ global_rot_range=[0.0, 0.0],
+ rot_range=[-0.78539816, 0.78539816]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.78539816, 0.78539816],
+ scale_ratio_range=[0.95, 1.05]),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='PointShuffle'),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+```
+
+- 数据增强：
+ - `ObjectNoise`：对场景中的每个真实标注框目标添加噪音。
+ - `RandomFlip3D`：对输入点云数据进行随机地水平翻转或者垂直翻转。
+ - `GlobalRotScaleTrans`：对输入点云数据进行旋转。
+
+## 评估
+
+使用 8 个 GPU 以及 KITTI 指标评估的 PointPillars 的示例如下：
+
+```shell
+bash tools/dist_test.sh configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py work_dirs/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class/latest.pth 8
+```
+
+## 度量指标
+
+KITTI 官方使用全类平均精度（mAP）和平均方向相似度（AOS）来评估 3D 目标检测的性能，更多细节请参考[官方网站](http://www.cvlibs.net/datasets/kitti/eval_3dobject.php)和[论文](http://www.cvlibs.net/publications/Geiger2012CVPR.pdf)。
+
+MMDetection3D 采用相同的方法在 KITTI 数据集上进行评估，下面展示了一个评估结果的例子：
+
+```
+Car AP@0.70, 0.70, 0.70:
+bbox AP:97.9252, 89.6183, 88.1564
+bev AP:90.4196, 87.9491, 85.1700
+3d AP:88.3891, 77.1624, 74.4654
+aos AP:97.70, 89.11, 87.38
+Car AP@0.70, 0.50, 0.50:
+bbox AP:97.9252, 89.6183, 88.1564
+bev AP:98.3509, 90.2042, 89.6102
+3d AP:98.2800, 90.1480, 89.4736
+aos AP:97.70, 89.11, 87.38
+```
+
+## 测试和提交
+
+使用 8 个 GPU 在 KITTI 上测试 PointPillars 并生成对排行榜的提交的示例如下：
+
+- 首先，你需要在你的配置文件中修改 `test_dataloader` 和 `test_evaluator` 字典，如下所示：
+
+ ```python
+ data_root = 'data/kitti/'
+ test_dataloader = dict(
+ dataset=dict(
+ ann_file='kitti_infos_test.pkl',
+ load_eval_anns=False,
+ data_prefix=dict(pts='testing/velodyne_reduced')))
+ test_evaluator = dict(
+ ann_file=data_root + 'kitti_infos_test.pkl',
+ format_only=True,
+ pklfile_prefix='results/kitti-3class/kitti_results',
+ submission_prefix='results/kitti-3class/kitti_results')
+ ```
+
+- 接下来，你可以运行如下测试脚本。
+
+ ```shell
+ ./tools/dist_test.sh configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py work_dirs/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class/latest.pth 8
+ ```
+
+在生成 `results/kitti-3class/kitti_results/xxxxx.txt` 后，您可以提交这些文件到 KITTI 官方网站进行基准测试，更多细节请参考 [KITTI 官方网站](http://www.cvlibs.net/datasets/kitti/index.php)。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/lidar_det3d.md b/internlm_langchain/knowledge_base/MMDetection3D/content/lidar_det3d.md
new file mode 100644
index 00000000..1277e310
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/lidar_det3d.md
@@ -0,0 +1,83 @@
+# 基于激光雷达的 3D 检测
+
+基于激光雷达的 3D 检测是 MMDetection3D 支持的最基础的任务之一。它期望给定的模型以激光雷达采集的任意数量的特征点为输入，并为每一个感兴趣的目标预测 3D 框及类别标签。接下来，我们以 KITTI 数据集上的 PointPillars 为例，展示如何准备数据，在标准的 3D 检测基准上训练并测试模型，以及可视化并验证结果。
+
+## 数据准备
+
+首先，我们需要下载原始数据并按照[数据准备文档](https://mmdetection3d.readthedocs.io/zh_CN/dev-1.x/user_guides/dataset_prepare.html)中提供的标准方式重新组织数据。
+
+由于不同数据集的原始数据有不同的组织方式，我们通常需要用 `.pkl` 文件收集有用的数据信息。因此，在准备好所有的原始数据之后，我们需要运行 `create_data.py` 中提供的脚本来为不同的数据集生成数据集信息。例如，对于 KITTI，我们需要运行如下命令：
+
+```shell
+python tools/create_data.py kitti --root-path ./data/kitti --out-dir ./data/kitti --extra-tag kitti
+```
+
+随后，相关的目录结构将如下所示：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── kitti
+│ │ ├── ImageSets
+│ │ ├── testing
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── velodyne
+│ │ │ ├── velodyne_reduced
+│ │ ├── training
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── label_2
+│ │ │ ├── velodyne
+│ │ │ ├── velodyne_reduced
+│ │ ├── kitti_gt_database
+│ │ ├── kitti_infos_train.pkl
+│ │ ├── kitti_infos_trainval.pkl
+│ │ ├── kitti_infos_val.pkl
+│ │ ├── kitti_infos_test.pkl
+│ │ ├── kitti_dbinfos_train.pkl
+```
+
+## 训练
+
+接着，我们将使用提供的配置文件训练 PointPillars。当您使用不同的 GPU 设置进行训练时，您可以按照这个[教程](https://mmdetection3d.readthedocs.io/en/dev-1.x/user_guides/train_test.html)的示例。假设我们在一台具有 8 块 GPU 的机器上使用分布式训练：
+
+```shell
+./tools/dist_train.sh configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py 8
+```
+
+注意，配置文件名中的 `8xb6` 是指训练用了 8 块 GPU，每块 GPU 上有 6 个数据样本。如果您的自定义设置不同于此，那么有时候您需要相应地调整学习率。基本规则可以参考[此处](https://arxiv.org/abs/1706.02677)。我们已经支持了使用 `--auto-scale-lr` 来自动缩放学习率。
+
+## 定量评估
+
+在训练期间，模型权重文件将会根据配置文件中的 `train_cfg = dict(val_interval=xxx)` 设置被周期性地评估。我们支持不同数据集的官方评估方案。对于 KITTI，将对 3 个类别使用交并比（IoU）阈值分别为 0.5/0.7 的平均精度（mAP）来评估模型。评估结果将会被打印到终端中，如下所示：
+
+```
+Car AP@0.70, 0.70, 0.70:
+bbox AP:98.1839, 89.7606, 88.7837
+bev AP:89.6905, 87.4570, 85.4865
+3d AP:87.4561, 76.7569, 74.1302
+aos AP:97.70, 88.73, 87.34
+Car AP@0.70, 0.50, 0.50:
+bbox AP:98.1839, 89.7606, 88.7837
+bev AP:98.4400, 90.1218, 89.6270
+3d AP:98.3329, 90.0209, 89.4035
+aos AP:97.70, 88.73, 87.34
+```
+
+此外，在训练完成后您也可以评估特定的模型权重文件。您可以简单地执行以下脚本：
+
+```shell
+./tools/dist_test.sh configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py work_dirs/pointpillars/latest.pth 8
+```
+
+## 测试与提交
+
+如果您只想在在线基准上进行推理或测试模型性能，您需要在相应的评估器中指定 `submission_prefix`，例如，在配置文件中添加 `test_evaluator = dict(type='KittiMetric', ann_file=data_root + 'kitti_infos_test.pkl', format_only=True, pklfile_prefix='results/kitti-3class/kitti_results', submission_prefix='results/kitti-3class/kitti_results')`，然后可以得到结果文件。请确保配置文件中的[测试信息](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/datasets/kitti-3d-3class.py#L117)的 `data_prefix` 和 `ann_file` 由验证集相应地改为测试集。在生成结果后，您可以压缩文件夹并上传至 KITTI 评估服务器上。
+
+## 定性评估
+
+MMDetection3D 还提供了通用的可视化工具，以便于我们可以对训练好的模型预测的检测结果有一个直观的感受。您也可以在评估阶段通过设置 `--show` 来在线可视化检测结果，或者使用 `tools/misc/visualize_results.py` 来离线地进行可视化。此外，我们还提供了脚本 `tools/misc/browse_dataset.py` 用于可视化数据集而不做推理。更多的细节请参考[可视化文档](https://mmdetection3d.readthedocs.io/zh_CN/dev-1.x/user_guides/visualization.html)。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/lidar_sem_seg3d.md b/internlm_langchain/knowledge_base/MMDetection3D/content/lidar_sem_seg3d.md
new file mode 100644
index 00000000..d35636ad
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/lidar_sem_seg3d.md
@@ -0,0 +1,78 @@
+# 基于激光雷达的 3D 语义分割
+
+基于激光雷达的 3D 语义分割是 MMDetection3D 支持的最基础的任务之一。它期望给定的模型以激光雷达采集的任意数量的特征点为输入，并预测每个输入点的语义标签。接下来，我们以 ScanNet 数据集上的 PointNet++ (SSG) 为例，展示如何准备数据，在标准的 3D 语义分割基准上训练并测试模型，以及可视化并验证结果。
+
+## 数据准备
+
+首先，我们需要从 ScanNet [官方网站](http://kaldir.vc.in.tum.de/scannet_benchmark/documentation)下载原始数据。
+
+由于不同数据集的原始数据有不同的组织方式，我们通常需要用 pkl 或 json 文件收集有用的数据信息。
+
+因此，在准备好所有的原始数据之后，我们可以遵循 [ScanNet 文档](https://github.com/open-mmlab/mmdetection3d/blob/master/data/scannet/README.md/)中的说明生成数据信息。
+
+随后，相关的目录结构将如下所示：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── scannet
+│ │ ├── scannet_utils.py
+│ │ ├── batch_load_scannet_data.py
+│ │ ├── load_scannet_data.py
+│ │ ├── scannet_utils.py
+│ │ ├── README.md
+│ │ ├── scans
+│ │ ├── scans_test
+│ │ ├── scannet_instance_data
+│ │ ├── points
+│ │ ├── instance_mask
+│ │ ├── semantic_mask
+│ │ ├── seg_info
+│ │ │ ├── train_label_weight.npy
+│ │ │ ├── train_resampled_scene_idxs.npy
+│ │ │ ├── val_label_weight.npy
+│ │ │ ├── val_resampled_scene_idxs.npy
+│ │ ├── scannet_infos_train.pkl
+│ │ ├── scannet_infos_val.pkl
+│ │ ├── scannet_infos_test.pkl
+```
+
+## 训练
+
+接着，我们将使用提供的配置文件训练 PointNet++ (SSG) 模型。当你使用不同的 GPU 设置进行训练时，你基本上可以按照这个[教程](https://mmdetection3d.readthedocs.io/zh_CN/latest/1_exist_data_model.html#inference-with-existing-models)的示例脚本。假设我们在一台具有 2 块 GPU 的机器上使用分布式训练：
+
+```
+./tools/dist_train.sh configs/pointnet2/pointnet2_ssg_2xb16-cosine-200e_scannet-seg.py 2
+```
+
+注意，配置文件名中的 `16x2` 是指训练时用了 2 块 GPU，每块 GPU 上有 16 个样本。如果你的自定义设置不同于此，那么有时候你需要相应的调整学习率。基本规则可以参考[此处](https://arxiv.org/abs/1706.02677)。
+
+## 定量评估
+
+在训练期间，模型权重将会根据配置文件中的 `train_cfg = dict(val_interval=xxx)` 设置被周期性地评估。我们支持不同数据集的官方评估方案。对于 ScanNet，将使用 20 个类别的平均交并比 (mIoU) 对模型进行评估。评估结果将会被打印到终端中，如下所示：
+
+```
++---------+--------+--------+---------+--------+--------+--------+--------+--------+--------+-----------+---------+---------+--------+---------+--------------+----------------+--------+--------+---------+----------------+--------+--------+---------+
+| classes | wall | floor | cabinet | bed | chair | sofa | table | door | window | bookshelf | picture | counter | desk | curtain | refrigerator | showercurtrain | toilet | sink | bathtub | otherfurniture | miou | acc | acc_cls |
++---------+--------+--------+---------+--------+--------+--------+--------+--------+--------+-----------+---------+---------+--------+---------+--------------+----------------+--------+--------+---------+----------------+--------+--------+---------+
+| results | 0.7257 | 0.9373 | 0.4625 | 0.6613 | 0.7707 | 0.5562 | 0.5864 | 0.4010 | 0.4558 | 0.7011 | 0.2500 | 0.4645 | 0.4540 | 0.5399 | 0.2802 | 0.3488 | 0.7359 | 0.4971 | 0.6922 | 0.3681 | 0.5444 | 0.8118 | 0.6695 |
++---------+--------+--------+---------+--------+--------+--------+--------+--------+--------+-----------+---------+---------+--------+---------+--------------+----------------+--------+--------+---------+----------------+--------+--------+---------+
+```
+
+此外，在训练完成后你也可以评估特定的模型权重文件。你可以简单地执行以下脚本：
+
+```
+./tools/dist_test.sh configs/pointnet2/pointnet2_ssg_16x2_cosine_200e_scannet-seg.py work_dirs/pointnet2_ssg/latest.pth 8
+```
+
+## 测试与提交
+
+如果你只想在在线基准上进行推理或测试模型性能，你需要在配置文件中的 `test_evalutor` 字段增加 `submission_prefix`， 例如配置文件增加 `test_evaluator = dict(type='SegMetric',submission_prefix=work_dirs/pointnet2_ssg/test_submission`)。
+并将 ScanNet 数据集[配置文件](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/_base_/datasets/scannet-seg.py#L129)中的 `ann_file=scannet_infos_val.pkl` 变成 `ann_file=scannet_infos_test.pkl`。在生成结果后，你可以压缩文件夹并上传至 [ScanNet 评估服务器](http://kaldir.vc.in.tum.de/scannet_benchmark/semantic_label_3d)上。
+
+## 定性评估
+
+MMDetection3D 还提供了通用的可视化工具，以便于我们可以对训练好的模型预测的分割结果有一个直观的感受。你也可以在评估阶段通过设置 `--eval-options 'show=True' 'out_dir=${SHOW_DIR}'` 来在线可视化分割结果，或者使用 `tools/misc/visualize_results.py` 来离线地进行可视化。此外，我们还提供了脚本 `tools/misc/browse_dataset.py` 用于可视化数据集而不做推理。更多的细节请参考[可视化文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/useful_tools.html#visualization)。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/lyft.md b/internlm_langchain/knowledge_base/MMDetection3D/content/lyft.md
new file mode 100644
index 00000000..eab8b529
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/lyft.md
@@ -0,0 +1,195 @@
+# Lyft 数据集
+
+本页提供了有关在 MMDetection3D 中使用 Lyft 数据集的具体教程。
+
+## 准备之前
+
+您可以在[这里](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/data)下载 Lyft 3D 检测数据并解压缩所有 zip 文件。
+
+像准备数据集的一般方法一样，建议将数据集根目录链接到 `$MMDETECTION3D/data`。
+
+在进行处理之前，文件夹结构应按如下方式组织：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── lyft
+│ │ ├── v1.01-train
+│ │ │ ├── v1.01-train (train_data)
+│ │ │ ├── lidar (train_lidar)
+│ │ │ ├── images (train_images)
+│ │ │ ├── maps (train_maps)
+│ │ ├── v1.01-test
+│ │ │ ├── v1.01-test (test_data)
+│ │ │ ├── lidar (test_lidar)
+│ │ │ ├── images (test_images)
+│ │ │ ├── maps (test_maps)
+│ │ ├── train.txt
+│ │ ├── val.txt
+│ │ ├── test.txt
+│ │ ├── sample_submission.csv
+```
+
+其中 `v1.01-train` 和 `v1.01-test` 包含与 nuScenes 数据集相同的元文件，`.txt` 文件包含数据划分的信息。Lyft 不提供训练集和验证集的官方划分方案，因此 MMDetection3D 对不同场景下的不同类别的目标数量进行分析，并提供了一个数据集划分方案。`sample_submission.csv` 是用于提交到 Kaggle 评估服务器的基本文件。需要注意的是，我们遵循了 Lyft 最初的文件夹命名以实现更清楚的文件组织。请将下载下来的原始文件夹按照上述组织结构重新命名。
+
+## 数据准备
+
+组织 Lyft 数据集的方式和组织 nuScenes 的方式相同，首先会生成几乎具有相同结构的 `.pkl` 文件，接着需要重点关注这两个数据集之间的不同点，更多关于数据集信息文件结构的说明请参考 [nuScenes 教程](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/docs/zh_cn/advanced_guides/datasets/nuscenes_det.md)。
+
+请通过运行下面的命令来生成 Lyft 的数据集信息文件：
+
+```bash
+python tools/create_data.py lyft --root-path ./data/lyft --out-dir ./data/lyft --extra-tag lyft --version v1.01
+python tools/data_converter/lyft_data_fixer.py --version v1.01 --root-folder ./data/lyft
+```
+
+请注意，上面的第二行命令用于修复损坏的 lidar 数据文件，更多细节请参考此处[讨论](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/discussion/110000)。
+
+处理后的文件夹结构应该如下：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── lyft
+│ │ ├── v1.01-train
+│ │ │ ├── v1.01-train (train_data)
+│ │ │ ├── lidar (train_lidar)
+│ │ │ ├── images (train_images)
+│ │ │ ├── maps (train_maps)
+│ │ ├── v1.01-test
+│ │ │ ├── v1.01-test (test_data)
+│ │ │ ├── lidar (test_lidar)
+│ │ │ ├── images (test_images)
+│ │ │ ├── maps (test_maps)
+│ │ ├── train.txt
+│ │ ├── val.txt
+│ │ ├── test.txt
+│ │ ├── sample_submission.csv
+│ │ ├── lyft_infos_train.pkl
+│ │ ├── lyft_infos_val.pkl
+│ │ ├── lyft_infos_test.pkl
+```
+
+- `lyft_infos_train.pkl`：训练数据集信息，该字典包含两个关键字：`metainfo` 和 `data_list`。`metainfo` 包含数据集的基本信息，例如 `categories`, `dataset` 和 `info_version`。`data_list` 是由字典组成的列表，每个字典（以下简称 `info`）包含了单个样本的所有详细信息。
+ - info\['sample_idx'\]：样本在整个数据集的索引。
+ - info\['token'\]：样本数据标记。
+ - info\['timestamp'\]：样本数据时间戳。
+ - info\['lidar_points'\]：是一个字典，包含了所有与激光雷达点相关的信息。
+ - info\['lidar_points'\]\['lidar_path'\]：激光雷达点云数据的文件名。
+ - info\['lidar_points'\]\['num_pts_feats'\]：点的特征维度。
+ - info\['lidar_points'\]\['lidar2ego'\]：该激光雷达传感器到自车的变换矩阵。（4x4 列表）
+ - info\['lidar_points'\]\['ego2global'\]：自车到全局坐标的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]：是一个列表，包含了扫描信息（没有标注的中间帧）。
+ - info\['lidar_sweeps'\]\[i\]\['lidar_points'\]\['data_path'\]：第 i 次扫描的激光雷达数据的文件路径。
+ - info\['lidar_sweeps'\]\[i\]\['lidar_points'\]\[lidar2ego''\]：当前激光雷达传感器到自车在第 i 次扫描的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]\[i\]\['lidar_points'\]\['ego2global'\]：自车在第 i 次扫描到全局坐标的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]\[i\]\['lidar2sensor'\]：从当前帧主激光雷达到第 i 帧扫描激光雷达的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]\[i\]\['timestamp'\]：扫描数据的时间戳。
+ - info\['lidar_sweeps'\]\[i\]\['sample_data_token'\]：扫描样本数据标记。
+ - info\['images'\]：是一个字典，包含与每个相机对应的六个键值：`'CAM_FRONT'`, `'CAM_FRONT_RIGHT'`, `'CAM_FRONT_LEFT'`, `'CAM_BACK'`, `'CAM_BACK_LEFT'`, `'CAM_BACK_RIGHT'`。每个字典包含了对应相机的所有数据信息。
+ - info\['images'\]\['CAM_XXX'\]\['img_path'\]：图像的文件名。
+ - info\['images'\]\['CAM_XXX'\]\['cam2img'\]：当 3D 点投影到图像平面时需要的内参信息相关的变换矩阵。（3x3 列表）
+ - info\['images'\]\['CAM_XXX'\]\['sample_data_token'\]：图像样本数据标记。
+ - info\['images'\]\['CAM_XXX'\]\['timestamp'\]：图像的时间戳。
+ - info\['images'\]\['CAM_XXX'\]\['cam2ego'\]：该相机传感器到自车的变换矩阵。（4x4 列表）
+ - info\['images'\]\['CAM_XXX'\]\['lidar2cam'\]：激光雷达传感器到该相机的变换矩阵。（4x4 列表）
+ - info\['instances'\]：是一个字典组成的列表。每个字典包含单个实例的所有标注信息。对于其中的第 i 个实例，我们有：
+ - info\['instances'\]\[i\]\['bbox_3d'\]：长度为 7 的列表，以 (x, y, z, l, w, h, yaw) 的顺序表示实例在激光雷达坐标系下的 3D 边界框。
+ - info\['instances'\]\[i\]\['bbox_label_3d'\]：整数从 0 开始表示实例的标签，其中 -1 代表忽略该类别。
+ - info\['instances'\]\[i\]\['bbox_3d_isvalid'\]：每个包围框是否有效。一般情况下，我们只将包含至少一个激光雷达或雷达点的 3D 框作为有效框。
+
+接下来将详细介绍 Lyft 数据集和 nuScenes 数据集之间的数据集信息文件中的不同点：
+
+- `lyft_database/xxxxx.bin` 文件不存在：由于真实标注框的采样对实验的影响可以忽略不计，在 Lyft 数据集中不会提取该目录和相关的 `.bin` 文件。
+
+- `lyft_infos_train.pkl`
+
+ - info\['instances'\]\[i\]\['velocity'\] 不存在：Lyft 数据集中不存在速度评估信息。
+ - info\['instances'\]\[i\]\['num_lidar_pts'\] 及 info\['instances'\]\[i\]\['num_radar_pts'\] 不存在。
+
+这里仅介绍存储在训练数据文件的数据记录信息。这同样适用于验证集和测试集（没有实例）。
+
+更多关于 `lyft_infos_xxx.pkl` 的结构信息请参考 [lyft_converter.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/lyft_converter.py)。
+
+## 训练流程
+
+### 基于 LiDAR 的方法
+
+Lyft 上基于 LiDAR 的 3D 检测（包括多模态方法）的训练流程与 nuScenes 几乎相同，如下所示：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=5,
+ use_dim=5),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10),
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.3925, 0.3925],
+ scale_ratio_range=[0.95, 1.05],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='PointShuffle'),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+```
+
+与 nuScenes 相似，在 Lyft 上进行训练的模型也需要 `LoadPointsFromMultiSweeps` 步骤来从连续帧中加载点云数据。另外，考虑到 Lyft 中所收集的激光雷达点的强度是无效的，因此将 `LoadPointsFromMultiSweeps` 中的 `use_dim` 默认值设置为 `[0, 1, 2, 4]`，其中前三个维度表示点的坐标，最后一个维度表示时间戳的差异。
+
+## 评估
+
+使用 8 个 GPU 以及 Lyft 指标评估的 PointPillars 的示例如下：
+
+```shell
+bash ./tools/dist_test.sh configs/pointpillars/pointpillars_hv_fpn_sbn-all_8xb2-2x_lyft-3d.py checkpoints/hv_pointpillars_fpn_sbn-all_2x8_2x_lyft-3d_20210517_202818-fc6904c3.pth 8
+```
+
+## 度量指标
+
+Lyft 提出了一个更加严格的用以评估所预测的 3D 检测框的度量指标。判断一个预测框是否是正类的基本评判标准和 KITTI 一样，如基于 3D 交并比进行评估，然而，Lyft 采用与 COCO 相似的方式来计算平均精度 -- 计算 3D 交并比在 0.5-0.95 之间的不同阈值下的平均精度。实际上，重叠部分大于 0.7 的 3D 交并比是一项对于 3D 检测方法比较严格的标准，因此整体的性能似乎会偏低。相比于其他数据集，Lyft 上不同类别的标注不平衡是导致最终结果偏低的另一个重要原因。更多关于度量指标的定义请参考[官方网址](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/overview/evaluation)。
+
+这里将采用官方方法对 Lyft 进行评估，下面展示了一个评估结果的例子：
+
+```
++mAPs@0.5:0.95------+--------------+
+| class | mAP@0.5:0.95 |
++-------------------+--------------+
+| animal | 0.0 |
+| bicycle | 0.099 |
+| bus | 0.177 |
+| car | 0.422 |
+| emergency_vehicle | 0.0 |
+| motorcycle | 0.049 |
+| other_vehicle | 0.359 |
+| pedestrian | 0.066 |
+| truck | 0.176 |
+| Overall | 0.15 |
++-------------------+--------------+
+```
+
+## 测试和提交
+
+使用 8 个 GPU 在 Lyft 上测试 PointPillars 并生成对排行榜的提交的示例如下：
+
+```shell
+./tools/dist_test.sh configs/pointpillars/pointpillars_hv_fpn_sbn-all_8xb2-2x_lyft-3d.py work_dirs/pp-lyft/latest.pth 8 --cfg-options test_evaluator.jsonfile_prefix=work_dirs/pp-lyft/results_challenge test_evaluator.csv_savepath=results/pp-lyft/results_challenge.csv
+```
+
+在生成 `work_dirs/pp-lyft/results_challenge.csv`，您可以将生成的文件提交到 Kaggle 评估服务器，请参考[官方网址](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles)获取更多细节。
+
+同时还可以使用可视化工具将预测结果进行可视化，更多细节请参考[可视化文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/useful_tools.html#visualization)。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/model_deployment.md b/internlm_langchain/knowledge_base/MMDetection3D/content/model_deployment.md
new file mode 100644
index 00000000..f66172c1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/model_deployment.md
@@ -0,0 +1,4 @@
+# 模型部署（待更新）
+
+MMDet3D 1.1 完全基于 [MMDeploy](https://mmdeploy.readthedocs.io/) 來部署模型。
+我们将在下一个版本完善这个文档。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/model_zoo.md b/internlm_langchain/knowledge_base/MMDetection3D/content/model_zoo.md
new file mode 100644
index 00000000..ec08bb25
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/model_zoo.md
@@ -0,0 +1,141 @@
+# 模型库
+
+## 通用设置
+
+- 使用分布式训练；
+- 为了和其他代码库做公平对比，本文展示的是使用 `torch.cuda.max_memory_allocated()` 在 8 个 GPUs 上得到的最大 GPU 显存占用值，需要注意的是，这些显存占用值通常小于 `nvidia-smi` 显示出来的显存占用值；
+- 在模型库中所展示的推理时间是包括网络前向传播和后处理所需的总时间，不包括数据加载所需的时间，模型库中所展示的结果均由 [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/master/tools/analysis_tools/benchmark.py) 脚本文件在 2000 张图像上所计算的平均时间。
+
+## 基准结果
+
+### SECOND
+
+请参考 [SECOND](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/second) 获取更多的细节，我们在 KITTI 和 Waymo 数据集上都给出了相应的基准结果。
+
+### PointPillars
+
+请参考 [PointPillars](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/pointpillars) 获取更多细节，我们在 KITTI 、nuScenes 、Lyft 、Waymo 数据集上给出了相应的基准结果。
+
+### Part-A2
+
+请参考 [Part-A2](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/parta2) 获取更多细节。
+
+### VoteNet
+
+请参考 [VoteNet](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/votenet) 获取更多细节，我们在 ScanNet 和 SUNRGBD 数据集上给出了相应的基准结果。
+
+### Dynamic Voxelization
+
+请参考 [Dynamic Voxelization](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/dynamic_voxelization) 获取更多细节。
+
+### MVXNet
+
+请参考 [MVXNet](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/mvxnet) 获取更多细节。
+
+### RegNetX
+
+请参考 [RegNet](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/regnet) 获取更多细节，我们将 pointpillars 的主干网络替换成 RegNetX，并在 nuScenes 和 Lyft 数据集上给出了相应的基准结果。
+
+### nuImages
+
+我们在 [nuImages 数据集](https://www.nuscenes.org/nuimages) 上也提供基准模型，请参考 [nuImages](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/nuimages) 获取更多细节，我们在该数据集上提供 Mask R-CNN ， Cascade Mask R-CNN 和 HTC 的结果。
+
+### H3DNet
+
+请参考 [H3DNet](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/h3dnet) 获取更多细节。
+
+### 3DSSD
+
+请参考 [3DSSD](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/3dssd) 获取更多细节。
+
+### CenterPoint
+
+请参考 [CenterPoint](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/centerpoint) 获取更多细节。
+
+### SSN
+
+请参考 [SSN](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/ssn) 获取更多细节，我们将 pointpillars 中的检测头替换成 SSN 模型中所使用的 ‘shape-aware grouping heads’，并在 nuScenes 和 Lyft 数据集上给出了相应的基准结果。
+
+### ImVoteNet
+
+请参考 [ImVoteNet](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/imvotenet) 获取更多细节，我们在 SUNRGBD 数据集上给出了相应的结果。
+
+### FCOS3D
+
+请参考 [FCOS3D](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/fcos3d) 获取更多细节，我们在 nuScenes 数据集上给出了相应的结果。
+
+### PointNet++
+
+请参考 [PointNet++](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/pointnet2) 获取更多细节，我们在 ScanNet 和 S3DIS 数据集上给出了相应的结果。
+
+### Group-Free-3D
+
+请参考 [Group-Free-3D](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/groupfree3d) 获取更多细节，我们在 ScanNet 数据集上给出了相应的结果。
+
+### ImVoxelNet
+
+请参考 [ImVoxelNet](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/imvoxelnet) 获取更多细节，我们在 KITTI 数据集上给出了相应的结果。
+
+### PAConv
+
+请参考 [PAConv](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/paconv) 获取更多细节，我们在 S3DIS 数据集上给出了相应的结果。
+
+### DGCNN
+
+请参考 [DGCNN](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/dgcnn) 获取更多细节，我们在 S3DIS 数据集上给出了相应的结果。
+
+### SMOKE
+
+请参考 [SMOKE](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/smoke) 获取更多细节，我们在 KITTI 数据集上给出了相应的结果。
+
+### PGD
+
+请参考 [PGD](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/pgd) 获取更多细节，我们在 KITTI 和 nuScenes 数据集上给出了相应的结果。
+
+### PointRCNN
+
+请参考 [PointRCNN](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/point_rcnn) 获取更多细节，我们在 KITTI 数据集上给出了相应的结果。
+
+### MonoFlex
+
+请参考 [MonoFlex](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/monoflex) 获取更多细节，我们在 KITTI 数据集上给出了相应的结果。
+
+### SA-SSD
+
+请参考 [SA-SSD](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/sassd) 获取更多的细节，我们在 KITTI 数据集上给出了相应的基准结果。
+
+### FCAF3D
+
+请参考 [FCAF3D](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/fcaf3d) 获取更多的细节，我们在 ScanNet, S3DIS 和 SUN RGB-D 数据集上给出了相应的基准结果。
+
+### PV-RCNN
+
+请参考 [PV-RCNN](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/pv_rcnn) 获取更多的细节，我们在 KITTI 数据集上给出了相应的基准结果。
+
+### BEVFusion
+
+请参考 [BEVFusion](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/projects/BEVFusion) 获取更多的细节, 我们在 NuScenes 数据集上给出了相应的基准结果。
+
+### CenterFormer
+
+请参考 [CenterFormer](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/projects/CenterFormer) 获取更多的细节, 我们在 Waymo 数据集上给出了相应的基准结果。
+
+### TR3D
+
+请参考 [TR3D](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/projects/TR3D) 获取更多的细节, 我们在 ScanNet, SUN RGB-D 和 S3DIS 数据集上给出了相应的基准结果。
+
+### DETR3D
+
+请参考 [DETR3D](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/projects/DETR3D) 获取更多的细节, 我们在 NuScenes 数据集上给出了相应的基准结果。
+
+### PETR
+
+请参考 [PETR](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/projects/PETR) 获取更多的细节, 我们在 NuScenes 数据集上给出了相应的基准结果。
+
+### TPVFormer
+
+请参考 [TPVFormer](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/projects/TPVFormer) 获取更多的细节, 我们在 NuScenes 数据集上给出了相应的基准结果。
+
+### Mixed Precision (FP16) Training
+
+细节请参考 [Mixed Precision (FP16) Training 在 PointPillars 训练的样例](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/pointpillars/pointpillars_hv_fpn_sbn-all_8xb2-amp-2x_nus-3d.py)。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/new_data_model.md b/internlm_langchain/knowledge_base/MMDetection3D/content/new_data_model.md
new file mode 100644
index 00000000..add2fe5e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/new_data_model.md
@@ -0,0 +1,102 @@
+# 在自定义数据集上进行训练
+
+本文将主要介绍如何使用自定义数据集来进行模型的训练和测试，以 Waymo 数据集作为示例来说明整个流程。
+
+基本步骤如下所示：
+
+1. 准备自定义数据集；
+2. 准备配置文件；
+3. 在自定义数据集上进行模型的训练、测试和推理。
+
+## 准备自定义数据集
+
+在 MMDetection3D 中有三种方式来自定义一个新的数据集：
+
+1. 将新数据集的数据格式重新组织成已支持的数据集格式；
+2. 将新数据集的数据格式重新组织成已支持的一种中间格式；
+3. 从头开始创建一个新的数据集。
+
+由于前两种方式比第三种方式更加容易，我们更加建议采用前两种方式来自定义数据集。
+
+在本文中，我们给出示例将数据转换成 KITTI 数据集的数据格式，你可以参考此处将你的数据集重新组织成 KITTI 格式。关于标准格式的数据集，你可以参考[自定义数据集文档](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/docs/zh_cn/advanced_guides/customize_dataset.md)。
+
+**注意**：考虑到 Waymo 数据集的格式与现有的其他数据集的格式的差别较大，因此本文以该数据集为例来讲解如何自定义数据集，从而方便理解数据集自定义的过程。若需要创建的新数据集与现有的数据集的组织格式较为相似，如 Lyft 数据集和 nuScenes 数据集，采用对数据集的中间格式进行转换的方式（第二种方式）相比于采用对数据格式进行转换的方式（第一种方式）会更加简单易行。
+
+### KITTI 数据集格式
+
+应用于 3D 目标检测的 KITTI 原始数据集的组织方式通常如下所示，其中 `ImageSets` 包含数据集划分文件，用以划分训练集/验证集/测试集，`calib` 包含对于每个数据样本的标定信息，`image_2` 和 `velodyne` 分别包含图像数据和点云数据，`label_2` 包含与 3D 目标检测相关的标注文件。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── kitti
+│ │ ├── ImageSets
+│ │ ├── testing
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── velodyne
+│ │ ├── training
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── label_2
+│ │ │ ├── velodyne
+```
+
+KITTI 官方提供的目标检测开发[工具包](https://s3.eu-central-1.amazonaws.com/avg-kitti/devkit_object.zip)详细描述了 KITTI 数据集的标注格式，例如，KITTI 标注格式包含了以下的标注信息：
+
+```
+# 值 名称 描述
+----------------------------------------------------------------------------
+ 1 类型 描述检测目标的类型：'Car'，'Van'，'Truck'，
+ 'Pedestrian'，'Person_sitting'，'Cyclist'，'Tram'，
+ 'Misc' 或 'DontCare'
+ 1 截断程度 从 0（非截断）到 1（截断）的浮点数，其中截断指的是离开检测图像边界的检测目标
+ 1 遮挡程度 用来表示遮挡状态的四种整数（0，1，2，3）:
+ 0 = 可见，1 = 部分遮挡
+ 2 = 大面积遮挡，3 = 未知
+ 1 观测角 观测目标的角度，取值范围为 [-pi..pi]
+ 4 标注框 检测目标在图像中的二维标注框（以0为初始下标）：包括每个检测目标的左上角和右下角的坐标
+ 3 维度 检测目标的三维维度：高度、宽度、长度（以米为单位）
+ 3 位置 相机坐标系下的三维位置 x，y，z（以米为单位）
+ 1 y 旋转 相机坐标系下检测目标绕着Y轴的旋转角，取值范围为 [-pi..pi]
+ 1 得分 仅在计算结果时使用，检测中表示置信度的浮点数，用于生成 p/r 曲线，在p/r 图中，越高的曲线表示结果越好。
+```
+
+假定我们使用 Waymo 数据集。
+
+在下载好数据集后，我们需要实现一个函数用来将输入数据和标注文件转换成 KITTI 风格。然后我们可以通过继承 `KittiDataset` 实现 `WaymoDataset`，用来加载数据以及训练模型，通过继承 `KittiMetric` 实现 `WaymoMetric` 来做模型的评估。
+
+具体来说，首先使用[数据转换器](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/waymo_converter.py)将 Waymo 数据集转换成 KITTI 数据集的格式，并定义 [Waymo 类](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/datasets/waymo_dataset.py)对转换的数据进行处理。此外需要添加 waymo [评估类](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/evaluation/metrics/waymo_metric.py)来评估结果。因为我们将 Waymo 原始数据集进行预处理并重新组织成 KITTI 数据集的格式，因此可以比较容易通过继承 KittiDataset 类来实现 WaymoDataset 类。需要注意的是，由于 Waymo 数据集有相应的官方评估方法，我们需要进一步实现新的 Waymo 评估方法，更多关于评估方法参考[评估文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/metric_and_evaluator.md)。最后，用户可以成功地转换数据并使用 `WaymoDataset` 训练以及 `WaymoMetric` 评估模型。
+
+更多关于 Waymo 数据集预处理的中间结果的细节，请参照对应的[说明文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/datasets/waymo_det.html)。
+
+## 准备配置文件
+
+第二步是准备配置文件来帮助数据集的读取和使用，另外，为了在 3D 检测中获得不错的性能，调整超参数通常是必要的。
+
+假设我们想要使用 PointPillars 模型在 Waymo 数据集上实现三类的 3D 目标检测：vehicle、cyclist、pedestrian，参照 KITTI 数据集[配置文件](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/datasets/kitti-3d-3class.py)、模型[配置文件](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/models/pointpillars_hv_secfpn_kitti.py)和[整体配置文件](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py)，我们需要准备[数据集配置文件](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/datasets/waymoD5-3d-3class.py)、[模型配置文件](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/models/pointpillars_hv_secfpn_waymo.py)，并将这两种文件进行结合得到[整体配置文件](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/pointpillars/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymoD5-3d-3class.py)。
+
+## 训练一个新的模型
+
+为了使用一个新的配置文件来训练模型，可以通过下面的命令来实现：
+
+```shell
+python tools/train.py configs/pointpillars/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymoD5-3d-3class.py
+```
+
+更多的使用细节，请参考[案例 1](https://mmdetection3d.readthedocs.io/zh_CN/latest/1_exist_data_model.html)。
+
+## 测试和推理
+
+为了测试已经训练好的模型的性能，可以通过下面的命令来实现：
+
+```shell
+python tools/test.py configs/pointpillars/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymoD5-3d-3class.py work_dirs/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymoD5-3d-3class/latest.pth
+```
+
+**注意**：为了使用 Waymo 数据集的评估方法，需要参考[说明文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/datasets/waymo_det.html)并按照官方指导来准备与评估相关联的文件。
+
+更多有关测试和推理的使用细节，请参考[案例 1](https://mmdetection3d.readthedocs.io/zh_CN/latest/1_exist_data_model.html) 。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/nuscenes.md b/internlm_langchain/knowledge_base/MMDetection3D/content/nuscenes.md
new file mode 100644
index 00000000..dcac78b2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/nuscenes.md
@@ -0,0 +1,239 @@
+# NuScenes 数据集
+
+本页提供了有关在 MMDetection3D 中使用 nuScenes 数据集的具体教程。
+
+## 准备之前
+
+您可以在[这里](https://www.nuscenes.org/download)下载 nuScenes 3D 检测数据 Full dataset (v1.0) 并解压缩所有 zip 文件。
+
+如果您想进行 3D 语义分割任务，需要额外下载 nuScenes-lidarseg 数据标注，并将解压的文件放入 nuScenes 对应的文件夹下。
+
+**注意**：nuScenes-lidarseg 中的 v1.0trainval(test)/categroy.json 会替换原先 Full dataset (v1.0) 原先的 v1.0trainval(test)/categroy.json，但是不会对 3D 目标检测任务造成影响。
+
+像准备数据集的一般方法一样，建议将数据集根目录链接到 `$MMDETECTION3D/data`。
+
+在我们处理之前，文件夹结构应按如下方式组织。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── nuscenes
+│ │ ├── maps
+│ │ ├── samples
+│ │ ├── sweeps
+│ │ ├── lidarseg (optional)
+│ │ ├── v1.0-test
+| | ├── v1.0-trainval
+```
+
+## 数据准备
+
+我们通常需要通过特定样式来使用 `.pkl` 文件组织有用的数据信息。要为 nuScenes 准备这些文件，请运行以下命令：
+
+```bash
+python tools/create_data.py nuscenes --root-path ./data/nuscenes --out-dir ./data/nuscenes --extra-tag nuscenes
+```
+
+处理后的文件夹结构应该如下。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── nuscenes
+│ │ ├── maps
+│ │ ├── samples
+│ │ ├── sweeps
+│ │ ├── lidarseg (optional)
+│ │ ├── v1.0-test
+| | ├── v1.0-trainval
+│ │ ├── nuscenes_database
+│ │ ├── nuscenes_infos_train.pkl
+│ │ ├── nuscenes_infos_val.pkl
+│ │ ├── nuscenes_infos_test.pkl
+│ │ ├── nuscenes_dbinfos_train.pkl
+```
+
+- `nuscenes_database/xxxxx.bin`：训练数据集的每个 3D 包围框中包含的点云数据。
+- `nuscenes_infos_train.pkl`：训练数据集，该字典包含了两个键值：`metainfo` 和 `data_list`。`metainfo` 包含数据集的基本信息，例如 `categories`, `dataset` 和 `info_version`。`data_list` 是由字典组成的列表，每个字典（以下简称 `info`）包含了单个样本的所有详细信息。
+ - info\['sample_idx'\]：样本在整个数据集的索引。
+ - info\['token'\]：样本数据标记。
+ - info\['timestamp'\]：样本数据时间戳。
+ - info\['ego2global'\]：自车到全局坐标的变换矩阵。（4x4 列表）
+ - info\['lidar_points'\]：是一个字典，包含了所有与激光雷达点相关的信息。
+ - info\['lidar_points'\]\['lidar_path'\]：激光雷达点云数据的文件名。
+ - info\['lidar_points'\]\['num_pts_feats'\]：点的特征维度。
+ - info\['lidar_points'\]\['lidar2ego'\]：该激光雷达传感器到自车的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]：是一个列表，包含了扫描信息（没有标注的中间帧）。
+ - info\['lidar_sweeps'\]\[i\]\['lidar_points'\]\['data_path'\]：第 i 次扫描的激光雷达数据的文件路径。
+ - info\['lidar_sweeps'\]\[i\]\['lidar_points'\]\[lidar2ego''\]：当前激光雷达传感器到自车的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]\[i\]\['lidar_points'\]\['ego2global'\]：自车到全局坐标的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]\[i\]\['lidar2sensor'\]：从主激光雷达传感器到当前传感器（用于收集扫描数据）的变换矩阵。（4x4 列表）
+ - info\['lidar_sweeps'\]\[i\]\['timestamp'\]：扫描数据的时间戳。
+ - info\['lidar_sweeps'\]\[i\]\['sample_data_token'\]：扫描样本数据标记。
+ - info\['images'\]：是一个字典，包含与每个相机对应的六个键值：`'CAM_FRONT'`, `'CAM_FRONT_RIGHT'`, `'CAM_FRONT_LEFT'`, `'CAM_BACK'`, `'CAM_BACK_LEFT'`, `'CAM_BACK_RIGHT'`。每个字典包含了对应相机的所有数据信息。
+ - info\['images'\]\['CAM_XXX'\]\['img_path'\]：图像的文件名。
+ - info\['images'\]\['CAM_XXX'\]\['cam2img'\]：当 3D 点投影到图像平面时需要的内参信息相关的变换矩阵。（3x3 列表）
+ - info\['images'\]\['CAM_XXX'\]\['sample_data_token'\]：图像样本数据标记。
+ - info\['images'\]\['CAM_XXX'\]\['timestamp'\]：图像的时间戳。
+ - info\['images'\]\['CAM_XXX'\]\['cam2ego'\]：该相机传感器到自车的变换矩阵。（4x4 列表）
+ - info\['images'\]\['CAM_XXX'\]\['lidar2cam'\]：激光雷达传感器到该相机的变换矩阵。（4x4 列表）
+ - info\['instances'\]：是一个字典组成的列表。每个字典包含单个实例的所有标注信息。对于其中的第 i 个实例，我们有：
+ - info\['instances'\]\[i\]\['bbox_3d'\]：长度为 7 的列表，以 (x, y, z, l, w, h, yaw) 的顺序表示实例的 3D 边界框。
+ - info\['instances'\]\[i\]\['bbox_label_3d'\]：整数表示实例的标签，-1 代表忽略。
+ - info\['instances'\]\[i\]\['velocity'\]：3D 边界框的速度（由于不正确，没有垂直测量），大小为 (2, ) 的列表。
+ - info\['instances'\]\[i\]\['num_lidar_pts'\]：每个 3D 边界框内包含的激光雷达点数。
+ - info\['instances'\]\[i\]\['num_radar_pts'\]：每个 3D 边界框内包含的雷达点数。
+ - info\['instances'\]\[i\]\['bbox_3d_isvalid'\]：每个包围框是否有效。一般情况下，我们只将包含至少一个激光雷达或雷达点的 3D 框作为有效框。
+ - info\['cam_instances'\]：是一个字典，包含以下键值：`'CAM_FRONT'`, `'CAM_FRONT_RIGHT'`, `'CAM_FRONT_LEFT'`, `'CAM_BACK'`, `'CAM_BACK_LEFT'`, `'CAM_BACK_RIGHT'`。对于基于视觉的 3D 目标检测任务，我们将整个场景的 3D 标注划分至它们所属于的相应相机中。对于其中的第 i 个实例，我们有：
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['bbox_label'\]：实例标签。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['bbox_label_3d'\]：实例标签。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['bbox'\]：2D 边界框标注（3D 框投影的矩形框），顺序为 \[x1, y1, x2, y2\] 的列表。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['center_2d'\]：3D 框投影到图像上的中心点，大小为 (2, ) 的列表。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['depth'\]：3D 框投影中心的深度。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['velocity'\]：3D 边界框的速度（由于不正确，没有垂直测量），大小为 (2, ) 的列表。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['attr_label'\]：实例的属性标签。我们为属性分类维护了一个属性集合和映射。
+ - info\['cam_instances'\]\['CAM_XXX'\]\[i\]\['bbox_3d'\]：长度为 7 的列表，以 (x, y, z, l, h, w, yaw) 的顺序表示实例的 3D 边界框。
+ - info\['pts_semantic_mask_path'\]：激光雷达语义分割标注的文件名。
+
+注意：
+
+1. `instances` 和 `cam_instances` 中 `bbox_3d` 的区别。`bbox_3d` 都被转换到 MMDet3D 定义的坐标系下，`instances` 中的 `bbox_3d` 是在激光雷达坐标系下，而 `cam_instances` 是在相机坐标系下。注意它们 3D 框中表示的不同（'l, w, h' 和 'l, h, w'）。
+
+2. 这里我们只解释训练信息文件中记录的数据。这同样适用于验证集和测试集（测试集的 `.pkl` 文件中不包含 `instances` 以及 `cam_instances`）。
+
+获取 `nuscenes_infos_xxx.pkl` 的核心函数为 [\_fill_trainval_infos](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/nuscenes_converter.py#L146)。更多细节请参考 [nuscenes_converter.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/nuscenes_converter.py)。
+
+## 训练流程
+
+### 基于 LiDAR 的方法
+
+nuScenes 上基于 LiDAR 的 3D 检测（包括多模态方法）的典型训练流程如下。
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=5,
+ use_dim=5),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10),
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.3925, 0.3925],
+ scale_ratio_range=[0.95, 1.05],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectNameFilter', classes=class_names),
+ dict(type='PointShuffle'),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+```
+
+与一般情况相比，nuScenes 有一个特定的 `'LoadPointsFromMultiSweeps'` 流水线来从连续帧加载点云。这是此设置中使用的常见做法。更多细节请参考 nuScenes [原始论文](https://arxiv.org/abs/1903.11027)。`'LoadPointsFromMultiSweeps'` 中的默认 `use_dim` 是 `[0, 1, 2, 4]`，其中前 3 个维度是指点坐标，最后一个是指时间戳差异。由于在拼接来自不同帧的点时使用点云的强度信息会产生噪声，因此默认情况下不使用点云的强度信息。
+
+### 基于视觉的方法
+
+nuScenes 上基于图像的 3D 检测的典型训练流水线如下。
+
+```python
+train_pipeline = [
+ dict(type='LoadImageFromFileMono3D'),
+ dict(
+ type='LoadAnnotations3D',
+ with_bbox=True,
+ with_label=True,
+ with_attr_label=True,
+ with_bbox_3d=True,
+ with_label_3d=True,
+ with_bbox_depth=True),
+ dict(type='mmdet.Resize', img_scale=(1600, 900), keep_ratio=True),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(
+ type='Pack3DDetInputs',
+ keys=[
+ 'img', 'gt_bboxes', 'gt_bboxes_labels', 'attr_labels', 'gt_bboxes_3d',
+ 'gt_labels_3d', 'centers_2d', 'depths'
+ ]),
+]
+```
+
+它遵循 2D 检测的一般流水线，但在一些细节上有所不同：
+
+- 它使用单目流水线加载图像，其中包括额外的必需信息，如相机内参矩阵。
+- 它需要加载 3D 标注。
+- 一些数据增强技术需要调整，例如`RandomFlip3D`。目前我们不支持更多的增强方法，因为如何迁移和应用其他技术仍在探索中。
+
+## 评估
+
+使用 8 个 GPU 以及 nuScenes 指标评估的 PointPillars 的示例如下
+
+```shell
+bash ./tools/dist_test.sh configs/pointpillars/pointpillars_hv_fpn_sbn-all_8xb4-2x_nus-3d.py checkpoints/hv_pointpillars_fpn_sbn-all_4x8_2x_nus-3d_20200620_230405-2fa62f3d.pth 8
+```
+
+## 指标
+
+NuScenes 提出了一个综合指标，即 nuScenes 检测分数（NDS），以评估不同的方法并设置基准测试。它由平均精度（mAP）、平均平移误差（ATE）、平均尺度误差（ASE）、平均方向误差（AOE）、平均速度误差（AVE）和平均属性误差（AAE）组成。更多细节请参考其[官方网站](https://www.nuscenes.org/object-detection?externalData=all&mapData=all&modalities=Any)。
+
+我们也采用这种方法对 nuScenes 进行评估。打印的评估结果示例如下：
+
+```
+mAP: 0.3197
+mATE: 0.7595
+mASE: 0.2700
+mAOE: 0.4918
+mAVE: 1.3307
+mAAE: 0.1724
+NDS: 0.3905
+Eval time: 170.8s
+
+Per-class results:
+Object Class AP ATE ASE AOE AVE AAE
+car 0.503 0.577 0.152 0.111 2.096 0.136
+truck 0.223 0.857 0.224 0.220 1.389 0.179
+bus 0.294 0.855 0.204 0.190 2.689 0.283
+trailer 0.081 1.094 0.243 0.553 0.742 0.167
+construction_vehicle 0.058 1.017 0.450 1.019 0.137 0.341
+pedestrian 0.392 0.687 0.284 0.694 0.876 0.158
+motorcycle 0.317 0.737 0.265 0.580 2.033 0.104
+bicycle 0.308 0.704 0.299 0.892 0.683 0.010
+traffic_cone 0.555 0.486 0.309 nan nan nan
+barrier 0.466 0.581 0.269 0.169 nan nan
+```
+
+## 测试和提交
+
+使用 8 个 GPU 在 nuScenes 上测试 PointPillars 并生成对排行榜的提交的示例如下
+
+你需要在对应的配置文件中的 `test_evaluator` 里修改 `jsonfile_prefix`。举个例子，添加 `test_evaluator = dict(type='NuScenesMetric', jsonfile_prefix='work_dirs/pp-nus/results_eval.json')` 或在测试命令后使用 `--cfg-options "test_evaluator.jsonfile_prefix=work_dirs/pp-nus/results_eval.json)`。
+
+```shell
+./tools/dist_test.sh configs/pointpillars/pointpillars_hv_fpn_sbn-all_8xb4-2x_nus-3d.py work_dirs/pp-nus/latest.pth 8 --cfg-options 'test_evaluator.jsonfile_prefix=work_dirs/pp-nus/results_eval'
+```
+
+请注意，在[这里](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/datasets/nus-3d.py#L132)测试信息应更改为测试集而不是验证集。
+
+生成 `work_dirs/pp-nus/results_eval.json` 后，您可以压缩并提交给 nuScenes 基准测试。更多信息请参考 [nuScenes 官方网站](https://www.nuscenes.org/object-detection?externalData=all&mapData=all&modalities=Any)。
+
+我们还可以使用我们开发的可视化工具将预测结果可视化。更多细节请参考[可视化文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/useful_tools.html#id2)。
+
+## 注意
+
+### `NuScenesBox` 和我们的 `CameraInstanceBoxes` 之间的转换。
+
+总的来说，`NuScenesBox` 和我们的 `CameraInstanceBoxes` 的主要区别主要体现在转向角（yaw）定义上。 `NuScenesBox` 定义了一个四元数或三个欧拉角的旋转，而我们的由于实际情况只定义了一个转向角（yaw），它需要我们在预处理和后处理中手动添加一些额外的旋转，例如[这里](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/datasets/nuscenes_mono_dataset.py#L673)。
+
+另外，请注意，角点和位置的定义在 `NuScenesBox` 中是分离的。例如，在单目 3D 检测中，框位置的定义在其相机坐标中（有关汽车设置，请参阅其官方[插图](https://www.nuscenes.org/nuscenes#data-collection)），即与[我们的](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/core/bbox/structures/cam_box3d.py)一致。相比之下，它的角点是通过[惯例](https://github.com/nutonomy/nuscenes-devkit/blob/02e9200218977193a1058dd7234f935834378319/python-sdk/nuscenes/utils/data_classes.py#L527) 定义的，“x 向前， y 向左， z 向上”。它导致了与我们的 `CameraInstanceBoxes` 不同的维度和旋转定义理念。一个移除相似冲突的例子是 PR [#744](https://github.com/open-mmlab/mmdetection3d/pull/744)。同样的问题也存在于 LiDAR 系统中。为了解决它们，我们通常会在预处理和后处理中添加一些转换，以保证在整个训练和推理过程中框都在我们的坐标系系统里。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/s3dis.md b/internlm_langchain/knowledge_base/MMDetection3D/content/s3dis.md
new file mode 100644
index 00000000..7af22390
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/s3dis.md
@@ -0,0 +1,271 @@
+# S3DIS 数据集
+
+## 数据集的准备
+
+对于数据集准备的整体流程，请参考 S3DIS 的[指南](https://github.com/open-mmlab/mmdetection3d/blob/master/data/s3dis/README.md/)。
+
+### 提取 S3DIS 数据
+
+通过从原始数据中提取 S3DIS 数据，我们将点云数据读取并保存下相关的标注信息，例如语义分割标签和实例分割标签。
+
+数据提取前的目录结构应该如下所示：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── s3dis
+│ │ ├── meta_data
+│ │ ├── Stanford3dDataset_v1.2_Aligned_Version
+│ │ │ ├── Area_1
+│ │ │ │ ├── conferenceRoom_1
+│ │ │ │ ├── office_1
+│ │ │ │ ├── ...
+│ │ │ ├── Area_2
+│ │ │ ├── Area_3
+│ │ │ ├── Area_4
+│ │ │ ├── Area_5
+│ │ │ ├── Area_6
+│ │ ├── indoor3d_util.py
+│ │ ├── collect_indoor3d_data.py
+│ │ ├── README.md
+```
+
+在 `Stanford3dDataset_v1.2_Aligned_Version` 目录下，所有房间依据所属区域被分为 6 组。
+我们通常使用 5 个区域进行训练，然后在余下 1 个区域上进行测试 (被余下的 1 个区域通常为区域 5)。
+在每个区域的目录下包含有多个房间的文件夹，每个文件夹是一个房间的原始点云数据和相关的标注信息。
+例如，在 `Area_1/office_1` 目录下的文件如下所示：
+
+- `office_1.txt`：一个 txt 文件存储着原始点云数据每个点的坐标和颜色信息。
+
+- `Annotations/`：这个文件夹里包含有此房间中实例物体的信息 (以 txt 文件的形式存储)。每个 txt 文件表示一个实例，例如：
+
+ - `chair_1.txt`：存储有该房间中一把椅子的点云数据。
+
+ 如果我们将 `Annotations/` 下的所有 txt 文件合并起来，得到的点云就和 `office_1.txt` 中的点云是一致的。
+
+你可以通过 `python collect_indoor3d_data.py` 指令进行 S3DIS 数据的提取。
+主要步骤包括：
+
+- 从原始 txt 文件中读取点云数据、语义分割标签和实例分割标签。
+- 将点云数据和相关标注文件存储下来。
+
+这其中的核心函数 `indoor3d_util.py` 中的 `export` 函数实现如下：
+
+```python
+def export(anno_path, out_filename):
+ """将原始数据集的文件转化为点云、语义分割标签和实例分割掩码文件。
+ 我们将同一房间中所有实例的点进行聚合。
+
+ 参数列表:
+ anno_path (str): 标注信息的路径，例如 Area_1/office_2/Annotations/
+ out_filename (str): 保存点云和标签的路径
+ file_format (str): txt 或 numpy，指定保存的文件格式
+
+ 注意:
+ 点云在处理过程中被整体移动了，保存下的点最小位于原点 (即没有负数坐标值)
+ """
+ points_list = []
+ ins_idx = 1 # 实例标签从 1 开始，因此最终实例标签为 0 的点就是无标注的点
+
+ # `anno_path` 的一个例子：Area_1/office_1/Annotations
+ # 其中以 txt 文件存储有该房间中所有实例物体的点云
+ for f in glob.glob(osp.join(anno_path, '*.txt')):
+ # get class name of this instance
+ one_class = osp.basename(f).split('_')[0]
+ if one_class not in class_names: # 某些房间有 'staris' 类物体
+ one_class = 'clutter'
+ points = np.loadtxt(f)
+ labels = np.ones((points.shape[0], 1)) * class2label[one_class]
+ ins_labels = np.ones((points.shape[0], 1)) * ins_idx
+ ins_idx += 1
+ points_list.append(np.concatenate([points, labels, ins_labels], 1))
+
+ data_label = np.concatenate(points_list, 0) # [N, 8], (pts, rgb, sem, ins)
+ # 将点云对齐到原点
+ xyz_min = np.amin(data_label, axis=0)[0:3]
+ data_label[:, 0:3] -= xyz_min
+
+ np.save(f'{out_filename}_point.npy', data_label[:, :6].astype(np.float32))
+ np.save(f'{out_filename}_sem_label.npy', data_label[:, 6].astype(np.int64))
+ np.save(f'{out_filename}_ins_label.npy', data_label[:, 7].astype(np.int64))
+
+```
+
+上述代码中，我们读取 `Annotations/` 下的所有点云实例，将其合并得到整体房屋的点云，同时生成语义/实例分割的标签。
+在提取完每个房间的数据后，点云、语义分割和实例分割的标签文件应以 `.npy` 的格式被保存下来。
+
+### 创建数据集
+
+```shell
+python tools/create_data.py s3dis --root-path ./data/s3dis \
+--out-dir ./data/s3dis --extra-tag s3dis
+```
+
+上述指令首先读取以 `.npy` 格式存储的点云、语义分割和实例分割标签文件，然后进一步将它们以 `.bin` 格式保存。
+同时，每个区域 `.pkl` 格式的信息文件也会被保存下来。
+
+数据预处理后的目录结构如下所示：
+
+```
+s3dis
+├── meta_data
+├── indoor3d_util.py
+├── collect_indoor3d_data.py
+├── README.md
+├── Stanford3dDataset_v1.2_Aligned_Version
+├── s3dis_data
+├── points
+│ ├── xxxxx.bin
+├── instance_mask
+│ ├── xxxxx.bin
+├── semantic_mask
+│ ├── xxxxx.bin
+├── seg_info
+│ ├── Area_1_label_weight.npy
+│ ├── Area_1_resampled_scene_idxs.npy
+│ ├── Area_2_label_weight.npy
+│ ├── Area_2_resampled_scene_idxs.npy
+│ ├── Area_3_label_weight.npy
+│ ├── Area_3_resampled_scene_idxs.npy
+│ ├── Area_4_label_weight.npy
+│ ├── Area_4_resampled_scene_idxs.npy
+│ ├── Area_5_label_weight.npy
+│ ├── Area_5_resampled_scene_idxs.npy
+│ ├── Area_6_label_weight.npy
+│ ├── Area_6_resampled_scene_idxs.npy
+├── s3dis_infos_Area_1.pkl
+├── s3dis_infos_Area_2.pkl
+├── s3dis_infos_Area_3.pkl
+├── s3dis_infos_Area_4.pkl
+├── s3dis_infos_Area_5.pkl
+├── s3dis_infos_Area_6.pkl
+```
+
+- `points/xxxxx.bin`：提取的点云数据。
+- `instance_mask/xxxxx.bin`：每个点云的实例标签，取值范围为 \[0, ${实例个数}\]，其中 0 代表未标注的点。
+- `semantic_mask/xxxxx.bin`：每个点云的语义标签，取值范围为 \[0, 12\]。
+- `s3dis_infos_Area_1.pkl`：区域 1 的数据信息，每个房间的详细信息如下：
+ - info\['point_cloud'\]: {'num_features': 6, 'lidar_idx': sample_idx}.
+ - info\['pts_path'\]: `points/xxxxx.bin` 点云的路径。
+ - info\['pts_instance_mask_path'\]: `instance_mask/xxxxx.bin` 实例标签的路径。
+ - info\['pts_semantic_mask_path'\]: `semantic_mask/xxxxx.bin` 语义标签的路径。
+- `seg_info`：为支持语义分割任务所生成的信息文件。
+ - `Area_1_label_weight.npy`：每一语义类别的权重系数。因为 S3DIS 中属于不同类的点的数量相差很大，一个常见的操作是在计算损失时对不同类别进行加权 (label re-weighting) 以得到更好的分割性能。
+ - `Area_1_resampled_scene_idxs.npy`：每一个场景 (房间) 的重采样标签。在训练过程中，我们依据每个场景的点的数量，会对其进行不同次数的重采样，以保证训练数据均衡。
+
+## 训练流程
+
+S3DIS 上 3D 语义分割的一种典型数据载入流程如下所示：
+
+```python
+class_names = ('ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door',
+ 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter')
+num_points = 4096
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='DEPTH',
+ shift_height=False,
+ use_color=True,
+ load_dim=6,
+ use_dim=[0, 1, 2, 3, 4, 5]),
+ dict(
+ type='LoadAnnotations3D',
+ with_bbox_3d=False,
+ with_label_3d=False,
+ with_mask_3d=False,
+ with_seg_3d=True),
+ dict(
+ type='PointSegClassMapping'),
+ dict(
+ type='IndoorPatchPointSample',
+ num_points=num_points,
+ block_size=1.0,
+ ignore_index=None,
+ use_normalized_coord=True,
+ enlarge_size=None,
+ min_unique_num=num_points // 4,
+ eps=0.0),
+ dict(type='NormalizePointsColor', color_mean=None),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-3.141592653589793, 3.141592653589793], # [-pi, pi]
+ scale_ratio_range=[0.8, 1.2],
+ translation_std=[0, 0, 0]),
+ dict(
+ type='RandomJitterPoints',
+ jitter_std=[0.01, 0.01, 0.01],
+ clip_range=[-0.05, 0.05]),
+ dict(type='RandomDropPointsColor', drop_ratio=0.2),
+ dict(type='Pack3DDetInputs', keys=['points', 'pts_semantic_mask'])
+]
+```
+
+- `PointSegClassMapping`：在训练过程中，只有被使用的类别的序号会被映射到类似 \[0, 13) 范围内的类别标签。其余的类别序号会被转换为 `ignore_index` 所制定的忽略标签，在本例中是 `13`。
+- `IndoorPatchPointSample`：从输入点云中裁剪一个含有固定数量点的小块 (patch)。`block_size` 指定了裁剪块的边长，在 S3DIS 上这个数值一般设置为 `1.0`。
+- `NormalizePointsColor`：将输入点的颜色信息归一化，通过将 RGB 值除以 `255` 来实现。
+- 数据增广：
+ - `GlobalRotScaleTrans`：对输入点云进行随机旋转和放缩变换。
+ - `RandomJitterPoints`：通过对每一个点施加不同的噪声向量以实现对点云的随机扰动。
+ - `RandomDropPointsColor`：以 `drop_ratio` 的概率随机将点云的颜色值全部置零。
+
+## 度量指标
+
+通常我们使用平均交并比 (mean Intersection over Union, mIoU) 作为 S3DIS 语义分割任务的度量指标。
+具体而言，我们先计算所有类别的 IoU，然后取平均值作为 mIoU。
+更多实现细节请参考 [seg_eval.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/evaluation/functional/seg_eval.py)。
+
+正如在 `提取 S3DIS 数据` 一节中所提及的，S3DIS 通常在 5 个区域上进行训练，然后在余下的 1 个区域上进行测试。但是在其他论文中，也有不同的划分方式。
+为了便于灵活划分训练和测试的子集，我们首先定义子数据集 (sub-dataset) 来表示每一个区域，然后根据区域划分对其进行合并，以得到完整的训练集。
+以下是在区域 1、2、3、4、6 上训练并在区域 5 上测试的一个配置文件例子：
+
+```python
+dataset_type = 'S3DISSegDataset'
+data_root = './data/s3dis/'
+class_names = ('ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door',
+ 'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter')
+train_area = [1, 2, 3, 4, 6]
+test_area = 5
+train_dataloader = dict(
+ batch_size=8,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_files=[f's3dis_infos_Area_{i}.pkl' for i in train_area],
+ metainfo=metainfo,
+ data_prefix=data_prefix,
+ pipeline=train_pipeline,
+ modality=input_modality,
+ ignore_index=len(class_names),
+ scene_idxs=[
+ f'seg_info/Area_{i}_resampled_scene_idxs.npy' for i in train_area
+ ],
+ test_mode=False))
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=1,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_files=f's3dis_infos_Area_{test_area}.pkl',
+ metainfo=metainfo,
+ data_prefix=data_prefix,
+ pipeline=test_pipeline,
+ modality=input_modality,
+ ignore_index=len(class_names),
+ scene_idxs=f'seg_info/Area_{test_area}_resampled_scene_idxs.npy',
+ test_mode=True))
+val_dataloader = test_dataloader
+```
+
+可以看到，我们通过将多个相应路径构成的列表 (list) 输入 `ann_files` 和 `scene_idxs` 以实现训练测试集的划分。
+如果修改训练测试区域的划分，只需要简单修改 `train_area` 和 `test_area` 即可。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/scannet.md b/internlm_langchain/knowledge_base/MMDetection3D/content/scannet.md
new file mode 100644
index 00000000..bbba255a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/scannet.md
@@ -0,0 +1,354 @@
+# ScanNet 数据集
+
+MMDetection3D 支持在 ScanNet 数据集上进行 3D 目标检测\\语义分割 任务。本页提供了有关在 MMDetection3D 中使用 ScanNet 数据集的具体教程。
+
+## 数据集准备
+
+请参考 ScanNet 的[指南](https://github.com/open-mmlab/mmdetection3d/blob/master/data/scannet/README.md)以查看总体流程。
+
+### 提取 ScanNet 点云数据
+
+通过提取 ScanNet 数据，我们加载原始点云文件，并生成包括语义标签、实例标签和真实物体包围框在内的相关标注。
+
+```shell
+python batch_load_scannet_data.py
+```
+
+数据处理之前的文件目录结构如下：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── scannet
+│ │ ├── meta_data
+│ │ ├── scans
+│ │ │ ├── scenexxxx_xx
+│ │ ├── batch_load_scannet_data.py
+│ │ ├── load_scannet_data.py
+│ │ ├── scannet_utils.py
+│ │ ├── README.md
+```
+
+在 `scans` 文件夹下总共有 1201 个训练样本文件夹和 312 个验证样本文件夹，其中存有未处理的点云数据和相关的标注。比如说，在文件夹 `scene0001_01` 下文件是这样组织的：
+
+- `scene0001_01_vh_clean_2.ply`：存有每个顶点坐标和颜色的网格文件。网格的顶点被直接用作未处理的点云数据。
+- `scene0001_01.aggregation.json`：包含物体 ID、分割部分 ID、标签的标注文件。
+- `scene0001_01_vh_clean_2.0.010000.segs.json`：包含分割部分 ID 和顶点的分割标注文件。
+- `scene0001_01.txt`：包括对齐矩阵等的元文件。
+- `scene0001_01_vh_clean_2.labels.ply`：包含每个顶点类别的标注文件。
+
+通过运行 `python batch_load_scannet_data.py` 来提取 ScanNet 数据的处理过程主要包含以下几步：
+
+- 从原始文件中提取出点云、实例标签、语义标签和包围框标签文件。
+- 下采样原始点云并过滤掉不合法的类别。
+- 保存处理后的点云数据和相关的标注文件。
+
+`load_scannet_data.py` 中的核心函数 `export` 如下：
+
+```python
+def export(mesh_file,
+ agg_file,
+ seg_file,
+ meta_file,
+ label_map_file,
+ output_file=None,
+ test_mode=False):
+
+ # 标签映射文件：./data/scannet/meta_data/scannetv2-labels.combined.tsv
+ # 该标签映射文件中有多种标签标准，比如 'nyu40id'
+ label_map = scannet_utils.read_label_mapping(
+ label_map_file, label_from='raw_category', label_to='nyu40id')
+ # 加载原始点云数据，特征包括6维：XYZRGB
+ mesh_vertices = scannet_utils.read_mesh_vertices_rgb(mesh_file)
+
+ # 加载场景坐标轴对齐矩阵：一个 4x4 的变换矩阵
+ # 将传感器坐标系下的原始点转化到另一个坐标系下
+ # 该坐标系与房屋的两边平行（也就是与坐标轴平行）
+ lines = open(meta_file).readlines()
+ # 测试集的数据没有对齐矩阵
+ axis_align_matrix = np.eye(4)
+ for line in lines:
+ if 'axisAlignment' in line:
+ axis_align_matrix = [
+ float(x)
+ for x in line.rstrip().strip('axisAlignment = ').split(' ')
+ ]
+ break
+ axis_align_matrix = np.array(axis_align_matrix).reshape((4, 4))
+
+ # 对网格顶点进行全局的对齐
+ pts = np.ones((mesh_vertices.shape[0], 4))
+ # 同种类坐标下的原始点云，每一行的数据是 [x, y, z, 1]
+ pts[:, 0:3] = mesh_vertices[:, 0:3]
+ # 将原始网格顶点转换为对齐后的顶点
+ pts = np.dot(pts, axis_align_matrix.transpose()) # Nx4
+ aligned_mesh_vertices = np.concatenate([pts[:, 0:3], mesh_vertices[:, 3:]],
+ axis=1)
+
+ # 加载语义与实例标签
+ if not test_mode:
+ # 每个物体都有一个语义标签，并且包含几个分割部分
+ object_id_to_segs, label_to_segs = read_aggregation(agg_file)
+ # 很多点属于同一分割部分
+ seg_to_verts, num_verts = read_segmentation(seg_file)
+ label_ids = np.zeros(shape=(num_verts), dtype=np.uint32)
+ object_id_to_label_id = {}
+ for label, segs in label_to_segs.items():
+ label_id = label_map[label]
+ for seg in segs:
+ verts = seg_to_verts[seg]
+ # 每个点都有一个语义标签
+ label_ids[verts] = label_id
+ instance_ids = np.zeros(
+ shape=(num_verts), dtype=np.uint32) # 0：未标注的
+ for object_id, segs in object_id_to_segs.items():
+ for seg in segs:
+ verts = seg_to_verts[seg]
+ # object_id 从 1 开始计数，比如 1,2,3,.,,,.NUM_INSTANCES
+ # 每个点都属于一个物体
+ instance_ids[verts] = object_id
+ if object_id not in object_id_to_label_id:
+ object_id_to_label_id[object_id] = label_ids[verts][0]
+ # 包围框格式为 [x, y, z, dx, dy, dz, label_id]
+ # [x, y, z] 是包围框的重力中心, [dx, dy, dz] 是与坐标轴平行的
+ # [label_id] 是 'nyu40id' 标准下的语义标签
+ # 注意：因为三维包围框是与坐标轴平行的，所以旋转角是 0
+ unaligned_bboxes = extract_bbox(mesh_vertices, object_id_to_segs,
+ object_id_to_label_id, instance_ids)
+ aligned_bboxes = extract_bbox(aligned_mesh_vertices, object_id_to_segs,
+ object_id_to_label_id, instance_ids)
+ ...
+
+ return mesh_vertices, label_ids, instance_ids, unaligned_bboxes, \
+ aligned_bboxes, object_id_to_label_id, axis_align_matrix
+
+```
+
+在从每个场景的扫描文件提取数据后，如果原始点云点数过多，可以将其下采样（比如到 50000 个点），但在三维语义分割任务中，点云不会被下采样。此外，在 `nyu40id` 标准之外的不合法语义标签或者可选的 `DONOT CARE` 类别标签应被过滤。最终，点云文件、语义标签、实例标签和真实物体的集合应被存储于 `.npy` 文件中。
+
+### 提取 ScanNet RGB 色彩数据（可选的）
+
+通过提取 ScanNet RGB 色彩数据，对于每个场景我们加载 RGB 图像与配套 4x4 位姿矩阵、单个 4x4 相机内参矩阵的集合。请注意，这一步是可选的，除非要运行多视图物体检测，否则可以略去这步。
+
+```shell
+python extract_posed_images.py
+```
+
+1201 个训练样本，312 个验证样本和 100 个测试样本中的每一个都包含一个单独的 `.sens` 文件。比如说，对于场景 `0001_01` 我们有 `data/scannet/scans/scene0001_01/0001_01.sens`。对于这个场景所有图像和位姿数据都被提取至 `data/scannet/posed_images/scene0001_01`。具体来说，该文件夹下会有 300 个 xxxxx.jpg 格式的图像数据，300 个 xxxxx.txt 格式的相机位姿数据和一个单独的 `intrinsic.txt` 内参文件。通常来说，一个场景包含数千张图像。默认情况下，我们只会提取其中的 300 张，从而只占用少于 100 Gb 的空间。要想提取更多图像，请使用 `--max-images-per-scene` 参数。
+
+### 创建数据集
+
+```shell
+python tools/create_data.py scannet --root-path ./data/scannet \
+--out-dir ./data/scannet --extra-tag scannet
+```
+
+上述提取的点云文件，语义类别标注文件，和物体实例标注文件被进一步以 `.bin` 格式保存。与此同时 `.pkl` 格式的文件被生成并用于训练和验证。获取数据信息的核心函数 `process_single_scene` 如下：
+
+```python
+def process_single_scene(sample_idx):
+
+ # 分别以 .bin 格式保存点云文件，语义类别标注文件和物体实例标注文件
+ # 获取 info['pts_path']，info['pts_instance_mask_path'] 和 info['pts_semantic_mask_path']
+ ...
+
+ # 获取标注
+ if has_label:
+ annotations = {}
+ # 包围框的形状为 [k, 6 + class]
+ aligned_box_label = self.get_aligned_box_label(sample_idx)
+ unaligned_box_label = self.get_unaligned_box_label(sample_idx)
+ annotations['gt_num'] = aligned_box_label.shape[0]
+ if annotations['gt_num'] != 0:
+ aligned_box = aligned_box_label[:, :-1] # k, 6
+ unaligned_box = unaligned_box_label[:, :-1]
+ classes = aligned_box_label[:, -1] # k
+ annotations['name'] = np.array([
+ self.label2cat[self.cat_ids2class[classes[i]]]
+ for i in range(annotations['gt_num'])
+ ])
+ # 为了向后兼容，默认的参数名赋予了与坐标轴平行的包围框
+ # 我们同时保存了对应的与坐标轴不平行的包围框的信息
+ annotations['location'] = aligned_box[:, :3]
+ annotations['dimensions'] = aligned_box[:, 3:6]
+ annotations['gt_boxes_upright_depth'] = aligned_box
+ annotations['unaligned_location'] = unaligned_box[:, :3]
+ annotations['unaligned_dimensions'] = unaligned_box[:, 3:6]
+ annotations[
+ 'unaligned_gt_boxes_upright_depth'] = unaligned_box
+ annotations['index'] = np.arange(
+ annotations['gt_num'], dtype=np.int32)
+ annotations['class'] = np.array([
+ self.cat_ids2class[classes[i]]
+ for i in range(annotations['gt_num'])
+ ])
+ axis_align_matrix = self.get_axis_align_matrix(sample_idx)
+ annotations['axis_align_matrix'] = axis_align_matrix # 4x4
+ info['annos'] = annotations
+ return info
+```
+
+如上数据处理后，文件目录结构应如下：
+
+```
+scannet
+├── meta_data
+├── batch_load_scannet_data.py
+├── load_scannet_data.py
+├── scannet_utils.py
+├── README.md
+├── scans
+├── scans_test
+├── scannet_instance_data
+├── points
+│ ├── xxxxx.bin
+├── instance_mask
+│ ├── xxxxx.bin
+├── semantic_mask
+│ ├── xxxxx.bin
+├── seg_info
+│ ├── train_label_weight.npy
+│ ├── train_resampled_scene_idxs.npy
+│ ├── val_label_weight.npy
+│ ├── val_resampled_scene_idxs.npy
+├── posed_images
+│ ├── scenexxxx_xx
+│ │ ├── xxxxxx.txt
+│ │ ├── xxxxxx.jpg
+│ │ ├── intrinsic.txt
+├── scannet_infos_train.pkl
+├── scannet_infos_val.pkl
+├── scannet_infos_test.pkl
+```
+
+- `points/xxxxx.bin`：下采样后，未与坐标轴平行（即没有对齐）的点云。因为 ScanNet 3D 检测任务将与坐标轴平行的点云作为输入，而 ScanNet 3D 语义分割任务将对齐前的点云作为输入，我们选择存储对齐前的点云和它们的对齐矩阵。请注意：在 3D 检测的预处理流程 [`GlobalAlignment`](https://github.com/open-mmlab/mmdetection3d/blob/9f0b01caf6aefed861ef4c3eb197c09362d26b32/mmdet3d/datasets/pipelines/transforms_3d.py#L423) 后，点云就都是与坐标轴平行的了。
+- `instance_mask/xxxxx.bin`：每个点的实例标签，值的范围为：\[0, NUM_INSTANCES\]，其中 0 表示没有标注。
+- `semantic_mask/xxxxx.bin`：每个点的语义标签，值的范围为：\[1, 40\], 也就是 `nyu40id` 的标准。请注意：在训练流程 `PointSegClassMapping` 中，`nyu40id` 的 ID 会被映射到训练 ID。
+- `seg_info`：为支持语义分割任务所生成的信息文件。
+ - `train_label_weight.npy`：每一语义类别的权重系数。因为 ScanNet 中属于不同类的点的数量相差很大，一个常见的操作是在计算损失时对不同类别进行加权 (label re-weighting) 以得到更好的分割性能。
+ - `train_resampled_scene_idxs.npy`：每一个场景 (房间) 的重采样标签。在训练过程中，我们依据每个场景的点的数量，会对其进行不同次数的重采样，以保证训练数据均衡。
+- `posed_images/scenexxxx_xx`：`.jpg` 图像的集合，还包含 `.txt` 格式的 4x4 相机姿态和单个 `.txt` 格式的相机内参矩阵文件。
+- `scannet_infos_train.pkl`：训练集的数据信息，每个场景的具体信息如下：
+ - info\['lidar_points'\]：字典包含与激光雷达点相关的信息。
+ - info\['lidar_points'\]\['lidar_path'\]：激光雷达点云数据的文件名。
+ - info\['lidar_points'\]\['num_pts_feats'\]：点的特征维度。
+ - info\['lidar_points'\]\['axis_align_matrix'\]：用于对齐坐标轴的变换矩阵。
+ - info\['pts_semantic_mask_path'\]：语义分割标注的文件名。
+ - info\['pts_instance_mask_path'\]：实例分割标注的文件名。
+ - info\['instances'\]：字典组成的列表，每个字典包含一个实例的所有标注信息。对于其中的第 i 个实例，我们有：
+ - info\['instances'\]\[i\]\['bbox_3d'\]：长度为 6 的列表，以 (x, y, z, l, w, h) 的顺序表示深度坐标系下与坐标轴平行的 3D 边界框。
+ - info\[instances\]\[i\]\['bbox_label_3d'\]：3D 边界框的标签。
+- `scannet_infos_val.pkl`：验证集上的数据信息，与 `scannet_infos_train.pkl` 格式完全一致。
+- `scannet_infos_test.pkl`：测试集上的数据信息，与 `scannet_infos_train.pkl` 格式几乎完全一致，除了缺少标注。
+
+## 训练流程
+
+ScanNet 进行 **3D 目标检测**的一种典型数据载入流程如下所示：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='DEPTH',
+ shift_height=True,
+ load_dim=6,
+ use_dim=[0, 1, 2]),
+ dict(
+ type='LoadAnnotations3D',
+ with_bbox_3d=True,
+ with_label_3d=True,
+ with_mask_3d=True,
+ with_seg_3d=True),
+ dict(type='GlobalAlignment', rotation_axis=2),
+ dict(type='PointSegClassMapping'),
+ dict(type='PointSample', num_points=40000),
+ dict(
+ type='RandomFlip3D',
+ sync_2d=False,
+ flip_ratio_bev_horizontal=0.5,
+ flip_ratio_bev_vertical=0.5),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.087266, 0.087266],
+ scale_ratio_range=[1.0, 1.0],
+ shift_height=True),
+ dict(
+ type='Pack3DDetInputs',
+ keys=[
+ 'points', 'gt_bboxes_3d', 'gt_labels_3d', 'pts_semantic_mask',
+ 'pts_instance_mask'
+ ])
+]
+```
+
+- `GlobalAlignment`：输入的点云在施加了坐标轴平行的矩阵后应被转换为与坐标轴平行的形式。
+- `PointSegClassMapping`：训练中，只有合法的类别 ID 才会被映射到类别标签，比如 \[0, 18)。
+- 数据增强:
+ - `PointSample`：下采样输入点云。
+ - `RandomFlip3D`：随机左右或前后翻转点云。
+ - `GlobalRotScaleTrans`：旋转输入点云，对于 ScanNet 角度通常落入 \[-5, 5\]（度）的范围；并放缩输入点云，对于 ScanNet 比例通常为 1.0（即不做缩放）；最后平移输入点云，对于 ScanNet 通常位移量为 0（即不做位移）。
+
+ScanNet 进行 **3D 语义分割**的一种典型数据载入流程如下所示：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='DEPTH',
+ shift_height=False,
+ use_color=True,
+ load_dim=6,
+ use_dim=[0, 1, 2, 3, 4, 5]),
+ dict(
+ type='LoadAnnotations3D',
+ with_bbox_3d=False,
+ with_label_3d=False,
+ with_mask_3d=False,
+ with_seg_3d=True),
+ dict(
+ type='PointSegClassMapping'),
+ dict(
+ type='IndoorPatchPointSample',
+ num_points=num_points,
+ block_size=1.5,
+ ignore_index=len(class_names),
+ use_normalized_coord=False,
+ enlarge_size=0.2,
+ min_unique_num=None),
+ dict(type='NormalizePointsColor', color_mean=None),
+ dict(type='Pack3DDetInputs', keys=['points', 'pts_semantic_mask'])
+]
+```
+
+- `PointSegClassMapping`：在训练过程中，只有被使用的类别的序号会被映射到类似 \[0, 20) 范围内的类别标签。其余的类别序号会被转换为 `ignore_index` 所制定的忽略标签，在本例中是 `20`。
+- `IndoorPatchPointSample`：从输入点云中裁剪一个含有固定数量点的小块 (patch)。`block_size` 指定了裁剪块的边长，在 ScanNet 上这个数值一般设置为 `1.5`。
+- `NormalizePointsColor`：将输入点的颜色信息归一化，通过将 RGB 值除以 `255` 来实现。
+
+## 评估指标
+
+- **目标检测**：通常使用全类平均精度（mAP）来评估 ScanNet 的 3D 检测任务的性能，比如 `mAP@0.25` 和 `mAP@0.5`。具体来说，评估时调用一个通用的计算 3D 物体检测多个类别的精度和召回率的函数。更多细节请参考 [indoor_eval](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/evaluation/functional/indoor_eval.py)。
+
+ **注意**：与在章节`提取 ScanNet 数据`中介绍的那样，所有真实物体的三维包围框是与坐标轴平行的，也就是说旋转角为 0。因此，预测包围框的网络接受的包围框旋转角监督也是 0，且在后处理阶段我们使用适用于与坐标轴平行的包围框的非极大值抑制（NMS），该过程不会考虑包围框的旋转。
+
+- **语义分割**：通常使用平均交并比 (mean Intersection over Union, mIoU) 来评估 ScanNet 的 3D 语义分割任务的性能。具体而言，我们先计算所有类别的 IoU，然后取平均值作为 mIoU。更多实现细节请参考 [seg_eval.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/evaluation/functional/seg_eval.py)。
+
+## 在测试集上测试并提交结果
+
+默认情况下，MMDet3D 的代码是在训练集上进行模型训练，然后在验证集上进行模型测试。
+
+如果你也想在在线基准上测试模型的性能（仅支持语义分割），请在测试命令中加上 `--format-only` 的标记，同时也要将 ScanNet 数据集[配置文件](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/_base_/datasets/scannet-seg.py#L126)中的 `ann_file=data_root + 'scannet_infos_val.pkl'` 改成 `ann_file=data_root + 'scannet_infos_test.pkl'`。
+
+请记得通过 `txt_prefix` 来指定想要保存测试结果的文件夹名称。
+
+以 PointNet++ (SSG) 在 ScanNet 上的测试为例，你可以运行以下命令来完成测试结果的保存：
+
+```
+./tools/dist_test.sh configs/pointnet2/pointnet2_ssg_16x2_cosine_200e_scannet-seg.py \
+ work_dirs/pointnet2_ssg/latest.pth --format-only \
+ --eval-options txt_prefix=work_dirs/pointnet2_ssg/test_submission
+```
+
+在保存测试结果后，你可以将该文件夹压缩，然后提交到 [ScanNet 在线测试服务器](http://kaldir.vc.in.tum.de/scannet_benchmark/semantic_label_3d)上进行验证。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/semantickitti.md b/internlm_langchain/knowledge_base/MMDetection3D/content/semantickitti.md
new file mode 100644
index 00000000..cd4f4dcb
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/semantickitti.md
@@ -0,0 +1,129 @@
+# SemanticKITTI 数据集
+
+本页提供了有关在 MMDetection3D 中使用 SemanticKITTI 数据集的具体教程。
+
+## 数据集准备
+
+您可以在[这里](http://semantic-kitti.org/dataset.html#download)下载 SemanticKITTI 数据集并解压缩所有 zip 文件。
+
+像准备数据集的一般方法一样，建议将数据集根目录链接到 `$MMDETECTION3D/data`。
+
+在我们处理之前，文件夹结构应按如下方式组织：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── semantickitti
+│ │ ├── sequences
+│ │ │ ├── 00
+│ │ │ │ ├── labels
+│ │ │ │ ├── velodyne
+│ │ │ ├── 01
+│ │ │ ├── ..
+│ │ │ ├── 22
+```
+
+SemanticKITTI 数据集包含 23 个序列，其中序列 \[0-7\] , \[9-10\] 作为训练集（约 19k 训练样本），序列 8 作为验证集（约 4k 验证样本），\[11-22\] 作为测试集 （约20k测试样本）。其中每个序列分别包含 velodyne 和 labels 两个文件夹分别存放激光雷达点云数据和分割标注 (其中高16位存放实例分割标注，低16位存放语义分割标注)。
+
+### 创建 SemanticKITTI 数据集
+
+我们提供了生成数据集信息的脚本，用于测试和训练。通过以下命令生成 `.pkl` 文件：
+
+```bash
+python ./tools/create_data.py semantickitti --root-path ./data/semantickitti --out-dir ./data/semantickitti --extra-tag semantickitti
+```
+
+处理后的文件夹结构应该如下：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── semantickitti
+│ │ ├── sequences
+│ │ │ ├── 00
+│ │ │ │ ├── labels
+│ │ │ │ ├── velodyne
+│ │ │ ├── 01
+│ │ │ ├── ..
+│ │ │ ├── 22
+│ │ ├── semantickitti_infos_test.pkl
+│ │ ├── semantickitti_infos_train.pkl
+│ │ ├── semantickitti_infos_val.pkl
+```
+
+- `semantickitti_infos_train.pkl`: 训练数据集, 该字典包含两个键值: `metainfo` 和 `data_list`.
+ `metainfo` 包含该数据集的基本信息。 `data_list` 是由字典组成的列表，每个字典（以下简称 `info`）包含了单个样本的所有详细信息。
+ - info\['sample_id'\]：该样本在整个数据集的索引。
+ - info\['lidar_points'\]：是一个字典，包含了激光雷达点相关的信息。
+ - info\['lidar_points'\]\['lidar_path'\]：激光雷达点云数据的文件名。
+ - info\['lidar_points'\]\['num_pts_feats'\]：点的特征维度
+ - info\['pts_semantic_mask_pth'\]：三维语义分割的标注文件的文件路径
+
+更多细节请参考 [semantickitti_converter.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/semantickitti_converter.py) 和 [update_infos_to_v2.py ](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/tools/dataset_converters/update_infos_to_v2.py) 。
+
+## Train pipeline
+
+下面展示了一个使用 SemanticKITTI 数据集进行 3D 语义分割的典型流程：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=4,
+ use_dim=4,
+ backend_args=backend_args),
+ dict(
+ type='LoadAnnotations3D',
+ with_bbox_3d=False,
+ with_label_3d=False,
+ with_seg_3d=True,
+ seg_3d_dtype='np.int32',
+ seg_offset=2**16,
+ dataset_type='semantickitti',
+ backend_args=backend_args),
+ dict(type='PointSegClassMapping'),
+ dict(
+ type='RandomFlip3D',
+ sync_2d=False,
+ flip_ratio_bev_horizontal=0.5,
+ flip_ratio_bev_vertical=0.5),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.78539816, 0.78539816],
+ scale_ratio_range=[0.95, 1.05],
+ translation_std=[0.1, 0.1, 0.1],
+ ),
+ dict(type='Pack3DDetInputs', keys=['points', 'pts_semantic_mask'])
+]
+```
+
+- 数据增强:
+ - `RandomFlip3D`：对输入点云数据进行随机地水平翻转或者垂直翻转。
+ - `GlobalRotScaleTrans`：对输入点云数据进行旋转、缩放、平移。
+
+## 评估
+
+使用 8 个 GPU 以及 SemanticKITTI 指标评估的 MinkUNet 的示例如下：
+
+```shell
+bash tools/dist_test.sh configs/minkunet/minkunet_w32_8xb2-15e_semantickitti.py checkpoints/minkunet_w32_8xb2-15e_semantickitti_20230309_160710-7fa0a6f1.pth 8
+```
+
+## 度量指标
+
+通常我们使用平均交并比 (mean Intersection over Union, mIoU) 作为 SemanticKITTI 语义分割任务的度量指标。
+具体而言，我们先计算所有类别的 IoU，然后取平均值作为 mIoU。
+更多实现细节请参考 [seg_eval.py](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/evaluation/functional/seg_eval.py)。
+
+以下是一个评估结果的样例:
+
+| classes | car | bicycle | motorcycle | truck | bus | person | bicyclist | motorcyclist | road | parking | sidewalk | other-ground | building | fence | vegetation | trunck | terrian | pole | traffic-sign | miou | acc | acc_cls |
+| ------- | ------ | ------- | ---------- | ------ | ------ | ------ | --------- | ------------ | ------ | ------- | -------- | ------------ | -------- | ------ | ---------- | ------ | ------- | ------ | ------------ | ------ | ------ | ------- |
+| results | 0.9687 | 0.1908 | 0.6313 | 0.8580 | 0.6359 | 0.6818 | 0.8444 | 0.0002 | 0.9353 | 0.4854 | 0.8106 | 0.0024 | 0.9050 | 0.6111 | 0.8822 | 0.6605 | 0.7493 | 0.6442 | 0.4837 | 0.6306 | 0.9202 | 0.6924 |
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/sunrgbd.md b/internlm_langchain/knowledge_base/MMDetection3D/content/sunrgbd.md
new file mode 100644
index 00000000..3c3875e5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/sunrgbd.md
@@ -0,0 +1,250 @@
+# SUN RGB-D 数据集
+
+## 数据集的准备
+
+对于数据集准备的整体流程，请参考 SUN RGB-D 的[指南](https://github.com/open-mmlab/mmdetection3d/blob/master/data/sunrgbd/README.md)。
+
+### 下载 SUN RGB-D 数据与工具包
+
+在[这里](http://rgbd.cs.princeton.edu/data/)下载 SUN RGB-D 的数据。接下来，将 `SUNRGBD.zip`、`SUNRGBDMeta2DBB_v2.mat`、`SUNRGBDMeta3DBB_v2.mat` 和 `SUNRGBDtoolbox.zip` 移动到 `OFFICIAL_SUNRGBD` 文件夹，并解压文件。
+
+下载完成后，数据处理之前的文件目录结构如下：
+
+```
+sunrgbd
+├── README.md
+├── matlab
+│ ├── extract_rgbd_data_v1.m
+│ ├── extract_rgbd_data_v2.m
+│ ├── extract_split.m
+├── OFFICIAL_SUNRGBD
+│ ├── SUNRGBD
+│ ├── SUNRGBDMeta2DBB_v2.mat
+│ ├── SUNRGBDMeta3DBB_v2.mat
+│ ├── SUNRGBDtoolbox
+```
+
+### 从原始数据中提取 3D 检测所需数据与标注
+
+通过运行如下指令从原始文件中提取出 SUN RGB-D 的标注（这需要您的机器中安装了 MATLAB）：
+
+```bash
+matlab -nosplash -nodesktop -r 'extract_split;quit;'
+matlab -nosplash -nodesktop -r 'extract_rgbd_data_v2;quit;'
+matlab -nosplash -nodesktop -r 'extract_rgbd_data_v1;quit;'
+```
+
+主要的步骤包括：
+
+- 提取出训练集和验证集的索引文件；
+- 从原始数据中提取出 3D 检测所需要的数据；
+- 从原始的标注数据中提取并组织检测任务使用的标注数据。
+
+用于从深度图中提取点云数据的 `extract_rgbd_data_v2.m` 的主要部分如下：
+
+```matlab
+data = SUNRGBDMeta(imageId);
+data.depthpath(1:16) = '';
+data.depthpath = strcat('../OFFICIAL_SUNRGBD', data.depthpath);
+data.rgbpath(1:16) = '';
+data.rgbpath = strcat('../OFFICIAL_SUNRGBD', data.rgbpath);
+
+% 从深度图获取点云
+[rgb,points3d,depthInpaint,imsize]=read3dPoints(data);
+rgb(isnan(points3d(:,1)),:) = [];
+points3d(isnan(points3d(:,1)),:) = [];
+points3d_rgb = [points3d, rgb];
+
+% MAT 文件比 TXT 文件小三倍。在 Python 中我们可以使用
+% scipy.io.loadmat('xxx.mat')['points3d_rgb'] 来加载数据
+mat_filename = strcat(num2str(imageId,'%06d'), '.mat');
+txt_filename = strcat(num2str(imageId,'%06d'), '.txt');
+% 保存点云数据
+parsave(strcat(depth_folder, mat_filename), points3d_rgb);
+```
+
+用于提取并组织检测任务标注的 `extract_rgbd_data_v1.m` 的主要部分如下：
+
+```matlab
+% 输出 2D 和 3D 包围框
+data2d = data;
+fid = fopen(strcat(det_label_folder, txt_filename), 'w');
+for j = 1:length(data.groundtruth3DBB)
+ centroid = data.groundtruth3DBB(j).centroid; % 3D 包围框中心
+ classname = data.groundtruth3DBB(j).classname; % 类名
+ orientation = data.groundtruth3DBB(j).orientation; % 3D 包围框方向
+ coeffs = abs(data.groundtruth3DBB(j).coeffs); % 3D 包围框大小
+ box2d = data2d.groundtruth2DBB(j).gtBb2D; % 2D 包围框
+ fprintf(fid, '%s %d %d %d %d %f %f %f %f %f %f %f %f\n', classname, box2d(1), box2d(2), box2d(3), box2d(4), centroid(1), centroid(2), centroid(3), coeffs(1), coeffs(2), coeffs(3), orientation(1), orientation(2));
+end
+fclose(fid);
+```
+
+上面的两个脚本调用了 SUN RGB-D 提供的[工具包](https://rgbd.cs.princeton.edu/data/SUNRGBDtoolbox.zip)中的一些函数，如 `read3dPoints`。
+
+使用上述脚本提取数据后，文件目录结构应如下：
+
+```
+sunrgbd
+├── README.md
+├── matlab
+│ ├── extract_rgbd_data_v1.m
+│ ├── extract_rgbd_data_v2.m
+│ ├── extract_split.m
+├── OFFICIAL_SUNRGBD
+│ ├── SUNRGBD
+│ ├── SUNRGBDMeta2DBB_v2.mat
+│ ├── SUNRGBDMeta3DBB_v2.mat
+│ ├── SUNRGBDtoolbox
+├── sunrgbd_trainval
+│ ├── calib
+│ ├── depth
+│ ├── image
+│ ├── label
+│ ├── label_v1
+│ ├── seg_label
+│ ├── train_data_idx.txt
+│ ├── val_data_idx.txt
+```
+
+在如下每个文件夹下，都有总计 5285 个训练集样本和 5050 个验证集样本：
+
+- `calib`：`.txt` 后缀的相机标定文件。
+- `depth`：`.mat` 后缀的点云文件，包含 xyz 坐标和 rgb 色彩值。
+- `image`：`.jpg` 后缀的二维图像文件。
+- `label`：`.txt` 后缀的用于检测任务的标注数据（版本二）。
+- `label_v1`：`.txt` 后缀的用于检测任务的标注数据（版本一）。
+- `seg_label`：`.txt` 后缀的用于分割任务的标注数据。
+
+目前，我们使用版本一的数据用于训练与测试，因此版本二的标注并未使用。
+
+### 创建数据集
+
+请运行如下指令创建数据集：
+
+```shell
+python tools/create_data.py sunrgbd --root-path ./data/sunrgbd \
+--out-dir ./data/sunrgbd --extra-tag sunrgbd
+```
+
+或者，如果使用 slurm，可以使用如下指令替代：
+
+```
+bash tools/create_data.sh sunrgbd
+```
+
+之前提到的点云数据就会被处理并以 `.bin` 格式重新存储。与此同时，`.pkl` 文件也被生成，用于存储数据标注和元信息。
+
+如上数据处理后，文件目录结构应如下：
+
+```
+sunrgbd
+├── README.md
+├── matlab
+│ ├── ...
+├── OFFICIAL_SUNRGBD
+│ ├── ...
+├── sunrgbd_trainval
+│ ├── ...
+├── points
+├── sunrgbd_infos_train.pkl
+├── sunrgbd_infos_val.pkl
+```
+
+- `points/xxxxxx.bin`：降采样后的点云数据。
+- `sunrgbd_infos_train.pkl`：训练集数据信息（标注与元信息），每个场景所含数据信息具体如下：
+ - info\['lidar_points'\]：字典包含了与激光雷达点相关的信息。
+ - info\['lidar_points'\]\['num_pts_feats'\]：点的特征维度。
+ - info\['lidar_points'\]\['lidar_path'\]：激光雷达点云数据的文件名。
+ - info\['images'\]：字典包含了与图像数据相关的信息。
+ - info\['images'\]\['CAM0'\]\['img_path'\]：图像的文件名。
+ - info\['images'\]\['CAM0'\]\['depth2img'\]：深度到图像的变换矩阵，形状为 (4, 4)。
+ - info\['images'\]\['CAM0'\]\['height'\]：图像的高。
+ - info\['images'\]\['CAM0'\]\['width'\]：图像的宽。
+ - info\['instances'\]：由字典组成的列表，包含了该帧的所有标注信息。每个字典与单个实例的标注相关。对于其中的第 i 个实例，我们有：
+ - info\['instances'\]\[i\]\['bbox_3d'\]：长度为 7 的列表，表示深度坐标系下的 3D 边界框。
+ - info\['instances'\]\[i\]\['bbox'\]：长度为 4 的列表，以 (x1, y1, x2, y2) 的顺序表示实例的 2D 边界框。
+ - info\['instances'\]\[i\]\['bbox_label_3d'\]：整数表示实例的 3D 标签，-1 表示忽略该类别。
+ - info\['instances'\]\[i\]\['bbox_label'\]：整数表示实例的 2D 标签，-1 表示忽略该类别。
+- `sunrgbd_infos_val.pkl`：验证集上的数据信息，与 `sunrgbd_infos_train.pkl` 格式完全一致。
+
+## 训练流程
+
+SUN RGB-D 上纯点云 3D 物体检测的典型流程如下：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='DEPTH',
+ shift_height=True,
+ load_dim=6,
+ use_dim=[0, 1, 2]),
+ dict(type='LoadAnnotations3D'),
+ dict(
+ type='RandomFlip3D',
+ sync_2d=False,
+ flip_ratio_bev_horizontal=0.5,
+ ),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.523599, 0.523599],
+ scale_ratio_range=[0.85, 1.15],
+ shift_height=True),
+ dict(type='PointSample', num_points=20000),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+```
+
+点云上的数据增强
+
+- `RandomFlip3D`：随机左右或前后翻转输入点云。
+- `GlobalRotScaleTrans`：旋转输入点云，对于 SUN RGB-D 角度通常落入 \[-30, 30\]（度）的范围；并放缩输入点云，对于 SUN RGB-D 比例通常落入 \[0.85, 1.15\] 的范围；最后平移输入点云，对于 SUN RGB-D 通常位移量为 0（即不做位移）。
+- `PointSample`：降采样输入点云。
+
+SUN RGB-D 上多模态（点云和图像）3D 物体检测的典型流程如下：
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='DEPTH',
+ shift_height=True,
+ load_dim=6,
+ use_dim=[0, 1, 2]),
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations3D'),
+ dict(type='LoadAnnotations', with_bbox=True),
+ dict(type='Resize', scale=(1333, 600), keep_ratio=True),
+ dict(type='RandomFlip', flip_ratio=0.0),
+ dict(type='Pad', size_divisor=32),
+ dict(
+ type='RandomFlip3D',
+ sync_2d=False,
+ flip_ratio_bev_horizontal=0.5,
+ ),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.523599, 0.523599],
+ scale_ratio_range=[0.85, 1.15],
+ shift_height=True),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_bboxes_3d', 'gt_labels_3d','img', 'gt_bboxes', 'gt_bboxes_labels'])
+]
+```
+
+图像上的数据增强
+
+- `Resize`：改变输入图像的大小，`keep_ratio=True` 意味着图像的比例不改变。
+- `RandomFlip`：随机地翻折图像。
+
+图像增强的实现取自 [MMDetection](https://github.com/open-mmlab/mmdetection/tree/dev-3.x/mmdet/datasets/transforms)。
+
+## 度量指标
+
+与 ScanNet 一样，通常使用 mAP（全类平均精度）来评估 SUN RGB-D 的检测任务的性能，比如 `mAP@0.25` 和 `mAP@0.5`。具体来说，评估时调用一个通用的计算 3D 物体检测多个类别的精度和召回率的函数。更多细节请参考 [`indoor_eval.py`](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/evaluation/functional/indoor_eval.py)。
+
+因为 SUN RGB-D 包含有图像数据，所以图像上的物体检测也是可行的。举个例子，在 ImVoteNet 中，我们首先训练了一个图像检测器，并且也使用 mAP 指标，如 `mAP@0.5`，来评估其表现。我们使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 库中的 `eval_map` 函数来计算 mAP。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/train_test.md b/internlm_langchain/knowledge_base/MMDetection3D/content/train_test.md
new file mode 100644
index 00000000..3b475a44
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/train_test.md
@@ -0,0 +1,254 @@
+# 在标注数据集上测试和训练
+
+### 在标准数据集上测试已有模型
+
+- 单显卡
+- CPU
+- 单节点多显卡
+- 多节点
+
+你可以通过以下命令来测试数据集：
+
+```shell
+# 单块显卡测试
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] [--show] [--show-dir ${SHOW_DIR}]
+
+# CPU：禁用显卡并运行单块 CPU 测试脚本（实验性）
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] [--show] [--show-dir ${SHOW_DIR}]
+
+# 多块显卡测试
+./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}]
+```
+
+**注意**:
+
+目前我们只支持 SMOKE 的 CPU 推理测试。
+
+可选参数：
+
+- `--show`：如果被指定，检测结果会在静默模式下被保存，用于调试和可视化，但只在单块 GPU 测试的情况下生效，和 `--show-dir` 搭配使用。
+- `--show-dir`：如果被指定，检测结果会被保存在指定文件夹下的 `***_points.obj` 和 `***_pred.obj` 文件中，用于调试和可视化，但只在单块 GPU 测试的情况下生效，对于这个选项，图形化界面在你的环境中不是必需的。
+
+所有和评估相关的参数在相应的数据集配置的 `test_evaluator` 中设置。例如 `test_evaluator = dict(type='KittiMetric', ann_file=data_root + 'kitti_infos_val.pkl', pklfile_prefix=None, submission_prefix=None)`
+
+参数：
+
+- `type`：相对应的评价指标名，通常和数据集相关联。
+- `ann_file`：标注文件路径。
+- `pklfile_prefix`：可选参数。输出结果保存成 pickle 格式的文件名。如果没有指定，结果将不会保存成文件。
+- `submission_prefix`：可选参数。结果将被保存到文件中，然后你可以将它上传到官方评估服务器中。
+
+示例：
+
+假定你已经把模型权重文件下载到 `checkpoints/` 文件夹下，
+
+1. 在 ScanNet 数据集上测试 VoteNet，保存模型，可视化预测结果
+
+ ```shell
+ python tools/test.py configs/votenet/votenet_8xb8_scannet-3d.py \
+ checkpoints/votenet_8x8_scannet-3d-18class_20200620_230238-2cea9c3a.pth \
+ --show --show-dir ./data/scannet/show_results
+ ```
+
+2. 在 ScanNet 数据集上测试 VoteNet，保存模型，可视化预测结果，可视化真实标签，计算 mAP
+
+ ```shell
+ python tools/test.py configs/votenet/votenet_8xb8_scannet-3d.py \
+ checkpoints/votenet_8x8_scannet-3d-18class_20200620_230238-2cea9c3a.pth \
+ --show --show-dir ./data/scannet/show_results
+ ```
+
+3. 在 ScanNet 数据集上测试 VoteNet（不保存测试结果），计算 mAP
+
+ ```shell
+ python tools/test.py configs/votenet/votenet_8xb8_scannet-3d.py \
+ checkpoints/votenet_8x8_scannet-3d-18class_20200620_230238-2cea9c3a.pth
+ ```
+
+4. 使用 8 块显卡在 KITTI 数据集上测试 SECOND，计算 mAP
+
+ ```shell
+ ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} configs/second/second_hv_secfpn_8xb6-80e_kitti-3d-3class.py \
+ checkpoints/hv_second_secfpn_6x8_80e_kitti-3d-3class_20200620_230238-9208083a.pth
+ ```
+
+5. 使用 8 块显卡在 nuScenes 数据集上测试 PointPillars，生成提交给官方评测服务器的 json 文件
+
+ ```shell
+ ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} configs/pointpillars/pointpillars_hv_secfpn_sbn-all_8xb4-2x_nus-3d.py \
+ checkpoints/hv_pointpillars_fpn_sbn-all_4x8_2x_nus-3d_20200620_230405-2fa62f3d.pth \
+ --cfg-options 'test_evaluator.jsonfile_prefix=./pointpillars_nuscenes_results'
+ ```
+
+ 生成的结果会保存在 `./pointpillars_nuscenes_results` 目录。
+
+6. 使用 8 块显卡在 KITTI 数据集上测试 SECOND，生成提交给官方评测服务器的 txt 文件
+
+ ```shell
+ ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} configs/second/second_hv_secfpn_8xb6-80e_kitti-3d-3class.py \
+ checkpoints/hv_second_secfpn_6x8_80e_kitti-3d-3class_20200620_230238-9208083a.pth \
+ --cfg-options 'test_evaluator.pklfile_prefix=./second_kitti_results' 'submission_prefix=./second_kitti_results'
+ ```
+
+ 生成的结果会保存在 `./second_kitti_results` 目录。
+
+7. 使用 8 块显卡在 Lyft 数据集上测试 PointPillars，生成提交给排行榜的 pkl 文件
+
+ ```shell
+ ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} configs/pointpillars/hv_pointpillars_fpn_sbn-2x8_2x_lyft-3d.py \
+ checkpoints/hv_pointpillars_fpn_sbn-2x8_2x_lyft-3d_latest.pth \
+ --cfg-options 'test_evaluator.jsonfile_prefix=results/pp_lyft/results_challenge' \
+ 'test_evaluator.csv_savepath=results/pp_lyft/results_challenge.csv' \
+ 'test_evaluator.pklfile_prefix=results/pp_lyft/results_challenge.pkl'
+ ```
+
+ **注意**：为了生成 Lyft 数据集的提交结果，`--eval-options` 必须指定 `csv_savepath`。生成 csv 文件后，你可以使用[网站](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/submit)上给出的 kaggle 命令提交结果。
+
+ 注意在 [Lyft 数据集的配置文件](../../configs/_base_/datasets/lyft-3d.py)，`test` 中的 `ann_file` 值为 `lyft_infos_test.pkl`，是没有标注的 Lyft 官方测试集。要在验证数据集上测试，请把它改为 `lyft_infos_val.pkl`。
+
+8. 使用 8 块显卡在 waymo 数据集上测试 PointPillars，使用 waymo 度量方法计算 mAP
+
+ ```shell
+ ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} configs/pointpillars/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymo-3d-car.py \
+ checkpoints/hv_pointpillars_secfpn_sbn-2x16_2x_waymo-3d-car_latest.pth \
+ --cfg-options 'test_evaluator.pklfile_prefix=results/waymo-car/kitti_results' \
+ 'test_evaluator.submission_prefix=results/waymo-car/kitti_results'
+ ```
+
+ **注意**：对于 waymo 数据集上的评估，请根据[说明](https://github.com/waymo-research/waymo-open-dataset/blob/master/docs/quick_start.md/)构建二进制文件 `compute_detection_metrics_main` 来做度量计算，并把它放在 `mmdet3d/core/evaluation/waymo_utils/`。（在使用 bazel 构建 `compute_detection_metrics_main` 时，有时会出现 `'round' is not a member of 'std'` 的错误，我们只需要把那个文件中 `round` 前的 `std::` 去掉。）二进制文件生成时需要在 `--eval-options` 中给定 `pklfile_prefix`。对于度量方法，`waymo` 是推荐的官方评估策略，目前 `kitti` 评估是依照 KITTI 而来的，每个难度的结果和 KITTI 的定义并不完全一致。目前大多数物体都被标记为0难度，会在未来修复。它的不稳定原因包括评估的计算大、转换后的数据缺乏遮挡和截断、难度的定义不同以及平均精度的计算方法不同。
+
+9. 使用 8 块显卡在 waymo 数据集上测试 PointPillars，生成 bin 文件并提交到排行榜
+
+ ```shell
+ ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} configs/pointpillars/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymo-3d-car.py \
+ checkpoints/hv_pointpillars_secfpn_sbn-2x16_2x_waymo-3d-car_latest.pth \
+ --cfg-options 'test_evaluator.pklfile_prefix=results/waymo-car/kitti_results' \
+ 'test_evaluator.submission_prefix=results/waymo-car/kitti_results'
+ ```
+
+ **注意**：生成 bin 文件后，你可以简单地构建二进制文件 `create_submission`，并根据[说明](https://github.com/waymo-research/waymo-open-dataset/blob/master/docs/quick_start.md/)创建提交的文件。要在验证服务器上评测验证数据集，你也可以用同样的方式生成提交的文件。
+
+## 在标准数据集上训练预定义模型
+
+MMDetection3D 分别用 `MMDistributedDataParallel` and `MMDataParallel` 实现了分布式训练和非分布式训练。
+
+所有的输出（日志文件和模型权重文件）都会被保存到工作目录下，通过配置文件里的 `work_dir` 指定。
+
+默认我们每过一个周期都在验证数据集上评测模型，你可以通过在训练配置里添加间隔参数来改变评测的时间间隔：
+
+```python
+train_cfg = dict(type='EpochBasedTrainLoop', val_interval=1) # 每12个周期评估一次模型
+```
+
+**重要**：配置文件中的默认学习率对应 8 块显卡，配置文件名里有具体的批量大小，比如 '2xb8' 表示一共 8 块显卡，每块显卡 2 个样本。
+根据 [Linear Scaling Rule](https://arxiv.org/abs/1706.02677)，当你使用不同数量的显卡或每块显卡有不同数量的图像时，需要依批量大小按比例调整学习率。如果用 4 块显卡、每块显卡 2 幅图像时学习率为 0.01，那么用 16 块显卡、每块显卡 4 幅图像时学习率应设为 0.08。然而，由于大多数模型使用 ADAM 而不是 SGD 进行优化，上述规则可能并不适用，用户需要自己调整学习率。
+
+### 使用单块显卡进行训练
+
+```shell
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+如果你想在命令中指定工作目录，添加参数 `--work-dir ${YOUR_WORK_DIR}`。
+
+### 使用 CPU 进行训练 (实验性)
+
+在 CPU 上训练的过程与单 GPU 训练一致。 我们只需要在训练过程之前禁用显卡。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+之后运行单显卡训练脚本即可。
+
+**注意**：
+
+目前，大多数点云相关算法都依赖于 3D CUDA 算子，无法在 CPU 上进行训练。 一些单目 3D 物体检测算法，例如 FCOS3D、SMOKE 可以在 CPU 上进行训练。我们不推荐用户使用 CPU 进行训练，这太过缓慢。我们支持这个功能是为了方便用户在没有显卡的机器上调试某些特定的方法。
+
+### 使用多块显卡进行训练
+
+```shell
+./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+可选参数：
+
+- `--cfg-options 'Key=value'`：覆盖使用的配置中的一些设定。
+
+### 使用多个机器进行训练
+
+如果要在 [slurm](https://slurm.schedmd.com/) 管理的集群上运行 MMDectection3D，你可以使用 `slurm_train.sh` 脚本（该脚本也支持单机训练）
+
+```shell
+[GPUS=${GPUS}] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
+```
+
+下面是一个使用 16 块显卡在 dev 分区上训练 Mask R-CNN 的示例：
+
+```shell
+GPUS=16 ./tools/slurm_train.sh dev pp_kitti_3class configs/pointpillars/pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py /nfs/xxxx/pp_kitti_3class
+```
+
+你可以查看 [slurm_train.sh](https://github.com/open-mmlab/mmdetection/blob/master/tools/slurm_train.sh) 来获取所有的参数和环境变量。
+
+如果您想使用由 ethernet 连接起来的多台机器， 您可以使用以下命令:
+
+在第一台机器上:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR ./tools/dist_train.sh $CONFIG $GPUS
+```
+
+在第二台机器上:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR ./tools/dist_train.sh $CONFIG $GPUS
+```
+
+但是，如果您不使用高速网路连接这几台机器的话，训练将会非常慢。
+
+### 在单个机器上启动多个任务
+
+如果你在单个机器上启动多个任务，比如，在具有8块显卡的机器上进行2个4块显卡训练的任务，你需要为每个任务指定不同的端口（默认为29500）以避免通信冲突。
+
+如果你使用 `dist_train.sh` 启动训练任务，可以在命令中设置端口：
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+如果你使用 Slurm 启动训练任务，有两种方式指定端口：
+
+1. 通过 `--cfg-options` 设置端口，这是更推荐的，因为它不改变原来的配置
+
+ ```shell
+ CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR} --cfg-options 'env_cfg.dist_cfg.port=29500'
+ CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR} --cfg-options 'env_cfg.dist_cfg.port=29501'
+ ```
+
+2. 修改配置文件（通常在配置文件的倒数第6行）来设置不同的通信端口
+
+ 在 `config1.py` 中，
+
+ ```python
+ env_cfg = dict(
+ dist_cfg=dict(backend='nccl', port=29500)
+ )
+ ```
+
+ 在 `config2.py` 中，
+
+ ```python
+ env_cfg = dict(
+ dist_cfg=dict(backend='nccl', port=29501)
+ )
+ ```
+
+ 然后，你可以使用 `config1.py` and `config2.py` 启动两个任务
+
+ ```shell
+ CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+ CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+ ```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/useful_tools.md b/internlm_langchain/knowledge_base/MMDetection3D/content/useful_tools.md
new file mode 100644
index 00000000..5cd256c7
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/useful_tools.md
@@ -0,0 +1,211 @@
+我们在 `tools/` 文件夹路径下提供了许多有用的工具。
+
+## 日志分析
+
+给定一个训练的日志文件，您可以绘制出 loss/mAP 曲线。首先需要运行 `pip install seaborn` 安装依赖包。
+
+
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve [--keys ${KEYS}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}] [--mode ${MODE}] [--interval ${INTERVAL}]
+```
+
+**注意**: 如果您想绘制的指标是在验证阶段计算得到的，您需要添加一个标志 `--mode eval` ，如果您每经过一个 `${INTERVAL}` 的间隔进行评估，您需要增加一个参数 `--interval ${INTERVAL}`。
+
+示例：
+
+- 绘制出某次运行的分类 loss。
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls --legend loss_cls
+ ```
+
+- 绘制出某次运行的分类和回归 loss，并且保存图片为 pdf 格式。
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls loss_bbox --out losses.pdf
+ ```
+
+- 在同一张图片中比较两次运行的 bbox mAP。
+
+ ```shell
+ # 根据 Car_3D_moderate_strict 在 KITTI 上评估 PartA2 和 second。
+ python tools/analysis_tools/analyze_logs.py plot_curve tools/logs/PartA2.log.json tools/logs/second.log.json --keys KITTI/Car_3D_moderate_strict --legend PartA2 second --mode eval --interval 1
+ # 根据 Car_3D_moderate_strict 在 KITTI 上分别对车和 3 类评估 PointPillars。
+ python tools/analysis_tools/analyze_logs.py plot_curve tools/logs/pp-3class.log.json tools/logs/pp.log.json --keys KITTI/Car_3D_moderate_strict --legend pp-3class pp --mode eval --interval 2
+ ```
+
+您也能计算平均训练速度。
+
+```shell
+python tools/analysis_tools/analyze_logs.py cal_train_time log.json [--include-outliers]
+```
+
+预期输出应该如下所示。
+
+```
+-----Analyze train time of work_dirs/some_exp/20190611_192040.log.json-----
+slowest epoch 11, average time is 1.2024
+fastest epoch 1, average time is 1.1909
+time std over epochs is 0.0028
+average iter time: 1.1959 s/iter
+```
+
+
+
+## 模型部署
+
+**注意**：此工具仍然处于试验阶段，目前只有 SECOND 支持用 [`TorchServe`](https://pytorch.org/serve/) 部署，我们将会在未来支持更多的模型。
+
+为了使用 [`TorchServe`](https://pytorch.org/serve/) 部署 `MMDetection3D` 模型，您可以遵循以下步骤：
+
+### 1. 将模型从 MMDetection3D 转换到 TorchServe
+
+```shell
+python tools/deployment/mmdet3d2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+**Note**: ${MODEL_STORE} 需要为文件夹的绝对路径。
+
+### 2. 构建 `mmdet3d-serve` 镜像
+
+```shell
+docker build -t mmdet3d-serve:latest docker/serve/
+```
+
+### 3. 运行 `mmdet3d-serve`
+
+查看官网文档来 [使用 docker 运行 TorchServe](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment)。
+
+为了在 GPU 上运行，您需要安装 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)。您可以忽略 `--gpus` 参数，从而在 CPU 上运行。
+
+例子：
+
+```shell
+docker run --rm \
+--cpus 8 \
+--gpus device=0 \
+-p8080:8080 -p8081:8081 -p8082:8082 \
+--mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
+mmdet3d-serve:latest
+```
+
+[阅读文档](https://github.com/pytorch/serve/blob/072f5d088cce9bb64b2a18af065886c9b01b317b/docs/rest_api.md/) 关于 Inference (8080), Management (8081) and Metrics (8082) 接口。
+
+### 4. 测试部署
+
+您可以使用 `test_torchserver.py` 进行部署， 同时比较 torchserver 和 pytorch 的结果。
+
+```shell
+python tools/deployment/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}] [--score-thr ${SCORE_THR}]
+```
+
+例子:
+
+```shell
+python tools/deployment/test_torchserver.py demo/data/kitti/kitti_000008.bin configs/second/hv_second_secfpn_6x8_80e_kitti-3d-car.py checkpoints/hv_second_secfpn_6x8_80e_kitti-3d-car_20200620_230238-393f000c.pth second
+```
+
+
+
+# 模型复杂度
+
+您可以使用 MMDetection 中的 `tools/analysis_tools/get_flops.py` 这个脚本文件，基于 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) 计算一个给定模型的计算量 (FLOPS) 和参数量 (params)。
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+您将会得到如下的结果：
+
+```text
+==============================
+Input shape: (4000, 4)
+Flops: 5.78 GFLOPs
+Params: 953.83 k
+==============================
+```
+
+**注意**：此工具仍然处于试验阶段，我们不能保证数值是绝对正确的。您可以将结果用于简单的比较，但在写技术文档报告或者论文之前您需要再次确认一下。
+
+1. 计算量 (FLOPs) 和输入形状有关，但是参数量 (params) 则和输入形状无关。默认的输入形状为 (1, 40000, 4)。
+2. 一些运算操作不计入计算量 (FLOPs)，比如说像GN和定制的运算操作，详细细节请参考 [`mmcv.cnn.get_model_complexity_info()`](https://github.com/open-mmlab/mmcv/blob/master/mmcv/cnn/utils/flops_counter.py)。
+3. 我们现在仅仅支持单模态输入（点云或者图片）的单阶段模型的计算量 (FLOPs) 计算，我们将会在未来支持两阶段和多模态模型的计算。
+
+
+
+## 模型转换
+
+### RegNet 模型转换到 MMDetection
+
+`tools/model_converters/regnet2mmdet.py` 将 pycls 预训练 RegNet 模型中的键转换为 MMDetection 风格。
+
+```shell
+python tools/model_converters/regnet2mmdet.py ${SRC} ${DST} [-h]
+```
+
+### Detectron ResNet 转换到 Pytorch
+
+MMDetection 中的 `tools/detectron2pytorch.py` 能够把原始的 detectron 中预训练的 ResNet 模型的键转换为 PyTorch 风格。
+
+```shell
+python tools/detectron2pytorch.py ${SRC} ${DST} ${DEPTH} [-h]
+```
+
+### 准备要发布的模型
+
+`tools/model_converters/publish_model.py` 帮助用户准备他们用于发布的模型。
+
+在您上传一个模型到云服务器 (AWS) 之前，您需要做以下几步：
+
+1. 将模型权重转换为 CPU 张量
+2. 删除记录优化器状态 (optimizer states) 的相关信息
+3. 计算检查点 (checkpoint) 文件的哈希编码 (hash id) 并且把哈希编码加到文件名里
+
+```shell
+python tools/model_converters/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+例如，
+
+```shell
+python tools/model_converters/publish_model.py work_dirs/faster_rcnn/latest.pth faster_rcnn_r50_fpn_1x_20190801.pth
+```
+
+最终的输出文件名将会是 `faster_rcnn_r50_fpn_1x_20190801-{hash id}.pth`。
+
+
+
+# 数据集转换
+
+`tools/dataset_converters/` 包含转换数据集为其他格式的一些工具。其中大多数转换数据集为基于 pickle 的信息文件，比如 KITTI，nuscense 和 lyft。Waymo 转换器被用来重新组织 waymo 原始数据为 KITTI 风格。用户能够参考它们了解我们转换数据格式的方法。将它们修改为 nuImages 转换器等脚本也很方便。
+
+为了转换 nuImages 数据集为 COCO 格式，请使用下面的指令：
+
+```shell
+python -u tools/dataset_converters/nuimage_converter.py --data-root ${DATA_ROOT} --version ${VERSIONS} \
+ --out-dir ${OUT_DIR} --nproc ${NUM_WORKERS} --extra-tag ${TAG}
+```
+
+- `--data-root`: 数据集的根目录，默认为 `./data/nuimages`。
+- `--version`: 数据集的版本，默认为 `v1.0-mini`。要获取完整数据集，请使用 `--version v1.0-train v1.0-val v1.0-mini`。
+- `--out-dir`: 注释和语义掩码的输出目录，默认为 `./data/nuimages/annotations/`。
+- `--nproc`: 数据准备的进程数，默认为 `4`。由于图片是并行处理的，更大的进程数目能够减少准备时间。
+- `--extra-tag`: 注释的额外标签，默认为 `nuimages`。这可用于将不同时间处理的不同注释分开以供研究。
+
+更多的数据准备细节参考 [doc](https://mmdetection3d.readthedocs.io/zh_CN/latest/data_preparation.html)，nuImages 数据集的细节参考 [README](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/nuimages/README.md/)。
+
+
+
+# 其他内容
+
+## 打印完整的配置文件
+
+`tools/misc/print_config.py` 逐字打印整个配置文件，展开所有的导入。
+
+```shell
+python tools/misc/print_config.py ${CONFIG} [-h] [--options ${OPTIONS [OPTIONS...]}]
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/vision_det3d.md b/internlm_langchain/knowledge_base/MMDetection3D/content/vision_det3d.md
new file mode 100644
index 00000000..ff5917ca
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/vision_det3d.md
@@ -0,0 +1,114 @@
+# 基于视觉的 3D 检测
+
+基于视觉的 3D 检测是指基于纯视觉输入的 3D 检测方法，例如基于单目、双目和多视图图像的 3D 检测。目前，我们只支持单目和多视图的 3D 检测方法。其他方法也应该与我们的框架兼容，并在将来得到支持。
+
+它期望给定的模型以任意数量的图像作为输入，并为每一个感兴趣的目标预测 3D 框及类别标签。以 nuScenes 数据集 FCOS3D 为例，我们将展示如何准备数据，在标准的 3D 检测基准上训练并测试模型，以及可视化并验证结果。
+
+## 数据准备
+
+首先，我们需要下载原始数据并按照[数据准备文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/data_preparation.html)中提供的标准方式重新组织数据。
+
+由于不同数据集的原始数据有不同的组织方式，我们通常需要用 pkl 或 json 文件收集有用的数据信息。因此，在准备好所有的原始数据之后，我们需要运行 `create_data.py` 中提供的脚本来为不同的数据集生成数据信息。例如，对于 nuScenes，我们需要运行如下命令：
+
+```
+python tools/create_data.py nuscenes --root-path ./data/nuscenes --out-dir ./data/nuscenes --extra-tag nuscenes
+```
+
+随后，相关的目录结构将如下所示：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── nuscenes
+│ │ ├── maps
+│ │ ├── samples
+│ │ ├── sweeps
+│ │ ├── v1.0-test
+| | ├── v1.0-trainval
+│ │ ├── nuscenes_database
+│ │ ├── nuscenes_infos_train.pkl
+│ │ ├── nuscenes_infos_trainval.pkl
+│ │ ├── nuscenes_infos_val.pkl
+│ │ ├── nuscenes_infos_test.pkl
+│ │ ├── nuscenes_dbinfos_train.pkl
+│ │ ├── nuscenes_infos_train_mono3d.coco.json
+│ │ ├── nuscenes_infos_trainval_mono3d.coco.json
+│ │ ├── nuscenes_infos_val_mono3d.coco.json
+│ │ ├── nuscenes_infos_test_mono3d.coco.json
+```
+
+注意，此处的 pkl 文件主要用于使用 LiDAR 数据的方法，json 文件用于 2D 检测/纯视觉的 3D 检测。在 v0.13.0 支持单目 3D 检测之前，json 文件只包含 2D 检测的信息，因此如果你需要最新的信息，请切换到 v0.13.0 之后的分支。
+
+## 训练
+
+接着，我们将使用提供的配置文件训练 FCOS3D。基本的脚本与其他模型一样。当你使用不同的 GPU 设置进行训练时，你基本上可以按照这个[教程](https://mmdetection3d.readthedocs.io/zh_CN/latest/1_exist_data_model.html#inference-with-existing-models)的示例。假设我们在一台具有 8 块 GPU 的机器上使用分布式训练：
+
+```
+./tools/dist_train.sh configs/fcos3d/fcos3d_r101_caffe_fpn_gn-head_dcn_2x8_1x_nus-mono3d.py 8
+```
+
+注意，配置文件名中的 `2x8` 是指训练时用了 8 块 GPU，每块 GPU 上有 2 个数据样本。如果你的自定义设置不同于此，那么有时候你需要相应的调整学习率。基本规则可以参考[此处](https://arxiv.org/abs/1706.02677)。
+
+我们也可以通过运行以下命令微调 FCOS3D，从而达到更好的性能：
+
+```
+./tools/dist_train.sh fcos3d_r101_caffe_fpn_gn-head_dcn_2x8_1x_nus-mono3d_finetune.py 8
+```
+
+通过先前的脚本训练好一个基准模型后，请记得相应的修改[此处](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/fcos3d/fcos3d_r101_caffe_fpn_gn-head_dcn_2x8_1x_nus-mono3d_finetune.py#L8)的路径。
+
+## 定量评估
+
+在训练期间，模型权重文件将会根据配置文件中的 `evaluation = dict(interval=xxx)` 设置被周期性地评估。
+
+我们支持不同数据集的官方评估方案。由于输出格式与基于其他模态的 3D 检测相同，因此评估方法也是一样的。
+
+对于 nuScenes，将使用基于距离的平均精度（mAP）以及 nuScenes 检测分数（NDS）分别对 10 个类别进行评估。评估结果将会被打印到终端中，如下所示：
+
+```
+mAP: 0.3197
+mATE: 0.7595
+mASE: 0.2700
+mAOE: 0.4918
+mAVE: 1.3307
+mAAE: 0.1724
+NDS: 0.3905
+Eval time: 170.8s
+
+Per-class results:
+Object Class AP ATE ASE AOE AVE AAE
+car 0.503 0.577 0.152 0.111 2.096 0.136
+truck 0.223 0.857 0.224 0.220 1.389 0.179
+bus 0.294 0.855 0.204 0.190 2.689 0.283
+trailer 0.081 1.094 0.243 0.553 0.742 0.167
+construction_vehicle 0.058 1.017 0.450 1.019 0.137 0.341
+pedestrian 0.392 0.687 0.284 0.694 0.876 0.158
+motorcycle 0.317 0.737 0.265 0.580 2.033 0.104
+bicycle 0.308 0.704 0.299 0.892 0.683 0.010
+traffic_cone 0.555 0.486 0.309 nan nan nan
+barrier 0.466 0.581 0.269 0.169 nan nan
+```
+
+此外，在训练完成后你也可以评估特定的模型权重文件。你可以简单地执行以下脚本：
+
+```
+./tools/dist_test.sh configs/fcos3d/fcos3d_r101_caffe_fpn_gn-head_dcn_2x8_1x_nus-mono3d.py \
+ work_dirs/fcos3d/latest.pth --eval mAP
+```
+
+## 测试与提交
+
+如果你只想在在线基准上进行推理或测试模型性能，你需要将之前评估脚本中的 `--eval mAP` 替换成 `--format-only`，并在需要的情况下指定 `jsonfile_prefix`，例如，添加选项 `--eval-options jsonfile_prefix=work_dirs/fcos3d/test_submission`。请确保配置文件中的[测试信息](https://github.com/open-mmlab/mmdetection3d/blob/main/configs/_base_/datasets/nus-mono3d.py#L93)由验证集相应地改为测试集。
+
+在生成结果后，你可以压缩文件夹并上传至 nuScenes 3D 检测挑战的 evalAI 评估服务器上。
+
+## 定性评估
+
+MMDetection3D 还提供了通用的可视化工具，以便于我们可以对训练好的模型预测的检测结果有一个直观的感受。你也可以在评估阶段通过设置 `--eval-options 'show=True' 'out_dir=${SHOW_DIR}'` 来在线可视化检测结果，或者使用 `tools/misc/visualize_results.py` 来离线地进行可视化。
+
+此外，我们还提供了脚本 `tools/misc/browse_dataset.py` 用于可视化数据集而不做推理。更多的细节请参考[可视化文档](https://mmdetection3d.readthedocs.io/zh_CN/latest/useful_tools.html#visualization)。
+
+注意，目前我们仅支持纯视觉方法在图像上的可视化。将来我们将集成在前景图以及鸟瞰图（BEV）中的可视化。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/visualization.md b/internlm_langchain/knowledge_base/MMDetection3D/content/visualization.md
new file mode 100644
index 00000000..d09c4571
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/visualization.md
@@ -0,0 +1,202 @@
+# 可视化
+
+MMDetection3D 提供了 `Det3DLocalVisualizer` 用来在训练及测试阶段可视化和存储模型的状态以及结果，其具有以下特性：
+
+1. 支持多模态数据和多任务的基本绘图界面。
+2. 支持多个后端（如 local，TensorBoard），将训练状态（如 `loss`，`lr`）或模型评估指标写入指定的一个或多个后端中。
+3. 支持多模态数据真实标签的可视化，3D 检测结果的跨模态可视化。
+
+## 基本绘制界面
+
+继承自 `DetLocalVisualizer`，`Det3DLocalVisualizer` 提供了在 2D 图像上绘制常见目标的界面，例如绘制检测框、点、文本、线、圆、多边形、二进制掩码等。关于 2D 绘制的更多细节，请参考 MMDetection 中的[可视化文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html)。这里我们介绍 3D 绘制界面。
+
+### 在图像上绘制点云
+
+通过使用 `draw_points_on_image`，我们支持在图像上绘制点云。
+
+```python
+import mmcv
+import numpy as np
+from mmengine import load
+
+from mmdet3d.visualization import Det3DLocalVisualizer
+
+info_file = load('demo/data/kitti/000008.pkl')
+points = np.fromfile('demo/data/kitti/000008.bin', dtype=np.float32)
+points = points.reshape(-1, 4)[:, :3]
+lidar2img = np.array(info_file['data_list'][0]['images']['CAM2']['lidar2img'], dtype=np.float32)
+
+visualizer = Det3DLocalVisualizer()
+img = mmcv.imread('demo/data/kitti/000008.png')
+img = mmcv.imconvert(img, 'bgr', 'rgb')
+visualizer.set_image(img)
+visualizer.draw_points_on_image(points, lidar2img)
+visualizer.show()
+```
+
+
+
+### 在点云上绘制 3D 框
+
+通过使用 `draw_bboxes_3d`，我们支持在点云上绘制 3D 框。
+
+```python
+import torch
+import numpy as np
+
+from mmdet3d.visualization import Det3DLocalVisualizer
+from mmdet3d.structures import LiDARInstance3DBoxes
+
+points = np.fromfile('demo/data/kitti/000008.bin', dtype=np.float32)
+points = points.reshape(-1, 4)
+visualizer = Det3DLocalVisualizer()
+# set point cloud in visualizer
+visualizer.set_points(points)
+bboxes_3d = LiDARInstance3DBoxes(
+ torch.tensor([[8.7314, -1.8559, -1.5997, 4.2000, 3.4800, 1.8900,
+ -1.5808]]))
+# Draw 3D bboxes
+visualizer.draw_bboxes_3d(bboxes_3d)
+visualizer.show()
+```
+
+
+
+### 在图像上绘制投影的 3D 框
+
+通过使用 `draw_proj_bboxes_3d`，我们支持在图像上绘制投影的 3D 框。
+
+```python
+import mmcv
+import numpy as np
+from mmengine import load
+
+from mmdet3d.visualization import Det3DLocalVisualizer
+from mmdet3d.structures import CameraInstance3DBoxes
+
+info_file = load('demo/data/kitti/000008.pkl')
+cam2img = np.array(info_file['data_list'][0]['images']['CAM2']['cam2img'], dtype=np.float32)
+bboxes_3d = []
+for instance in info_file['data_list'][0]['instances']:
+ bboxes_3d.append(instance['bbox_3d'])
+gt_bboxes_3d = np.array(bboxes_3d, dtype=np.float32)
+gt_bboxes_3d = CameraInstance3DBoxes(gt_bboxes_3d)
+input_meta = {'cam2img': cam2img}
+
+visualizer = Det3DLocalVisualizer()
+
+img = mmcv.imread('demo/data/kitti/000008.png')
+img = mmcv.imconvert(img, 'bgr', 'rgb')
+visualizer.set_image(img)
+# project 3D bboxes to image
+visualizer.draw_proj_bboxes_3d(gt_bboxes_3d, input_meta)
+visualizer.show()
+```
+
+### 绘制 BEV 视角的框
+
+通过使用 `draw_bev_bboxes`，我们支持绘制 BEV 视角下的框。
+
+```python
+import numpy as np
+from mmengine import load
+
+from mmdet3d.visualization import Det3DLocalVisualizer
+from mmdet3d.structures import CameraInstance3DBoxes
+
+info_file = load('demo/data/kitti/000008.pkl')
+bboxes_3d = []
+for instance in info_file['data_list'][0]['instances']:
+ bboxes_3d.append(instance['bbox_3d'])
+gt_bboxes_3d = np.array(bboxes_3d, dtype=np.float32)
+gt_bboxes_3d = CameraInstance3DBoxes(gt_bboxes_3d)
+
+visualizer = Det3DLocalVisualizer()
+# set bev image in visualizer
+visualizer.set_bev_image()
+# draw bev bboxes
+visualizer.draw_bev_bboxes(gt_bboxes_3d, edge_colors='orange')
+visualizer.show()
+```
+
+### 绘制 3D 分割掩码
+
+通过使用 `draw_seg_mask`，我们支持通过逐点着色来绘制分割掩码。
+
+```python
+import numpy as np
+
+from mmdet3d.visualization import Det3DLocalVisualizer
+
+points = np.fromfile('demo/data/sunrgbd/000017.bin', dtype=np.float32)
+points = points.reshape(-1, 3)
+visualizer = Det3DLocalVisualizer()
+mask = np.random.rand(points.shape[0], 3)
+points_with_mask = np.concatenate((points, mask), axis=-1)
+# Draw 3D points with mask
+visualizer.set_points(points, pcd_mode=2, vis_mode='add')
+visualizer.draw_seg_mask(points_with_mask)
+visualizer.show()
+```
+
+## 结果
+
+如果想要可视化训练模型的预测结果，你可以运行如下指令：
+
+```bash
+python tools/test.py ${CONFIG_FILE} ${CKPT_PATH} --show --show-dir ${SHOW_DIR}
+```
+
+运行该指令后，绘制的结果（包括输入数据和网络输出在输入上的可视化）将会被保存在 `${SHOW_DIR}` 中。
+
+运行该指令后，你将在 `${SHOW_DIR}` 中获得输入数据，网络输出和真是标签在输入上的可视化（如在多模态检测任务和基于视觉的检测任务中的 `***_gt.png` 和 `***_pred.png`）。当启用 `show` 时，[Open3D](http://www.open3d.org/) 将会用于在线可视化结果。如果你是在没有 GUI 的远程服务器上测试时，在线可视化是不被支持的。你可以从远程服务器中下载 `results.pkl`，并在本地机器上离线可视化预测结果。
+
+使用 `Open3D` 后端离线可视化结果，你可以运行如下指令：
+
+```bash
+python tools/misc/visualize_results.py ${CONFIG_FILE} --result ${RESULTS_PATH} --show-dir ${SHOW_DIR}
+```
+
+
+
+这需要在远程服务器中能够推理并生成结果，然后用户在主机中使用 GUI 打开。
+
+## 数据集
+
+我们也提供了脚本来可视化数据集而无需推理。你可以使用 `tools/misc/browse_dataset.py` 来在线可视化加载的数据的真实标签，并保存在硬盘中。目前我们支持所有数据集的单模态 3D 检测和 3D 分割，KITTI 和 SUN RGB-D 的多模态 3D 检测，以及 nuScenes 的单目 3D 检测。如果想要浏览 KITTI 数据集，你可以运行如下指令：
+
+```shell
+python tools/misc/browse_dataset.py configs/_base_/datasets/kitti-3d-3class.py --task lidar_det --output-dir ${OUTPUT_DIR}
+```
+
+**注意**：一旦指定了 `--output-dir`，当在 open3d 窗口中按下 `_ESC_` 时，用户指定的视图图像将会被保存下来。如果你想要对点云进行缩放操作以观察更多细节， 你可以在命令中指定 `--show-interval=0`。
+
+为了验证数据的一致性和数据增强的效果，你可以加上 `--aug` 来可视化数据增强后的数据，指令如下所示：
+
+```shell
+python tools/misc/browse_dataset.py configs/_base_/datasets/kitti-3d-3class.py --task det --aug --output-dir ${OUTPUT_DIR}
+```
+
+如果你想显示带有投影的 3D 边界框的 2D 图像，你需要一个支持多模态数据加载的配置文件，并将 `--task` 参数改为 `multi-modality_det`。示例如下：
+
+```shell
+python tools/misc/browse_dataset.py configs/mvxnet/mvxnet_fpn_dv_second_secfpn_8xb2-80e_kitti-3d-3class.py --task multi-modality_det --output-dir ${OUTPUT_DIR}
+```
+
+
+
+你可以使用不同的配置浏览不同的数据集，例如在 3D 语义分割任务中可视化 ScanNet 数据集：
+
+```shell
+python tools/misc/browse_dataset.py configs/_base_/datasets/scannet-seg.py --task lidar_seg --output-dir ${OUTPUT_DIR}
+```
+
+
+
+在单目 3D 检测任务中浏览 nuScenes 数据集：
+
+```shell
+python tools/misc/browse_dataset.py configs/_base_/datasets/nus-mono3d.py --task mono_det --output-dir ${OUTPUT_DIR}
+```
+
+
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/waymo.md b/internlm_langchain/knowledge_base/MMDetection3D/content/waymo.md
new file mode 100644
index 00000000..577ec151
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/waymo.md
@@ -0,0 +1,168 @@
+# Waymo 数据集
+
+本文档页包含了关于 MMDetection3D 中 Waymo 数据集用法的教程。
+
+## 数据集准备
+
+在准备 Waymo 数据集之前，如果您之前只安装了 `requirements/build.txt` 和 `requirements/runtime.txt` 中的依赖，请通过运行如下指令额外安装 Waymo 数据集所依赖的官方包：
+
+```
+# tf 2.1.0.
+pip install waymo-open-dataset-tf-2-1-0==1.2.0
+# tf 2.0.0
+# pip install waymo-open-dataset-tf-2-0-0==1.2.0
+# tf 1.15.0
+# pip install waymo-open-dataset-tf-1-15-0==1.2.0
+```
+
+或者
+
+```
+pip install -r requirements/optional.txt
+```
+
+和准备数据集的通用方法一致，我们推荐将数据集根目录软链接至 `$MMDETECTION3D/data`。
+由于原始 Waymo 数据的格式基于 `tfrecord`，我们需要将原始数据进行预处理，以便于训练和测试时使用。我们的方法是将它们转换为 KITTI 格式。
+
+处理之前，文件目录结构组织如下：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── waymo
+│ │ ├── waymo_format
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── testing
+│ │ │ ├── gt.bin
+│ │ ├── kitti_format
+│ │ │ ├── ImageSets
+
+```
+
+您可以在[这里](https://waymo.com/open/download/)下载 1.2 版本的 Waymo 公开数据集，并在[这里](https://drive.google.com/drive/folders/18BVuF_RYJF0NjZpt8SnfzANiakoRMf0o?usp=sharing)下载其训练/验证/测试集拆分文件。接下来，请将 `tfrecord` 文件放入 `data/waymo/waymo_format/` 下的对应文件夹，并将 txt 格式的数据集拆分文件放入 `data/waymo/kitti_format/ImageSets`。在[这里](https://console.cloud.google.com/storage/browser/waymo_open_dataset_v_1_2_0/validation/ground_truth_objects)下载验证集使用的 bin 格式真实标注 (Ground Truth) 文件并放入 `data/waymo/waymo_format/`。小窍门：您可以使用 `gsutil` 来在命令行下载大规模数据集。您可以将该[工具](https://github.com/RalphMao/Waymo-Dataset-Tool) 作为一个例子来查看更多细节。之后，通过运行如下指令准备 Waymo 数据：
+
+```bash
+python tools/create_data.py waymo --root-path ./data/waymo/ --out-dir ./data/waymo/ --workers 128 --extra-tag waymo
+```
+
+请注意，如果您的本地磁盘没有足够空间保存转换后的数据，您可以将 `--out-dir` 改为其他目录；只要在创建文件夹、准备数据并转换格式后，将数据文件链接到 `data/waymo/kitti_format` 即可。
+
+在数据转换后，文件目录结构应组织如下：
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── waymo
+│ │ ├── waymo_format
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── testing
+│ │ │ ├── gt.bin
+│ │ ├── kitti_format
+│ │ │ ├── ImageSets
+│ │ │ ├── training
+│ │ │ │ ├── calib
+│ │ │ │ ├── image_0
+│ │ │ │ ├── image_1
+│ │ │ │ ├── image_2
+│ │ │ │ ├── image_3
+│ │ │ │ ├── image_4
+│ │ │ │ ├── label_0
+│ │ │ │ ├── label_1
+│ │ │ │ ├── label_2
+│ │ │ │ ├── label_3
+│ │ │ │ ├── label_4
+│ │ │ │ ├── label_all
+│ │ │ │ ├── pose
+│ │ │ │ ├── velodyne
+│ │ │ ├── testing
+│ │ │ │ ├── (the same as training)
+│ │ │ ├── waymo_gt_database
+│ │ │ ├── waymo_infos_trainval.pkl
+│ │ │ ├── waymo_infos_train.pkl
+│ │ │ ├── waymo_infos_val.pkl
+│ │ │ ├── waymo_infos_test.pkl
+│ │ │ ├── waymo_dbinfos_train.pkl
+
+```
+
+因为 Waymo 数据的来源包含数个相机，这里我们将每个相机对应的图像和标签文件分别存储，并将相机位姿 (pose) 文件存储下来以供后续处理连续多帧的点云。我们使用 `{a}{bbb}{ccc}` 的名称编码方式为每帧数据命名，其中 `a` 是不同数据拆分的前缀（`0` 指代训练集，`1` 指代验证集，`2` 指代测试集），`bbb` 是分割部分 (segment) 的索引，而 `ccc` 是帧索引。您可以轻而易举地按照如上命名规则定位到所需的帧。我们将训练和验证所需数据按 KITTI 的方式集合在一起，然后将训练集/验证集/测试集的索引存储在 `ImageSet` 下的文件中。
+
+## 训练
+
+考虑到原始数据集中的数据有很多相似的帧，我们基本上可以主要使用一个子集来训练我们的模型。在我们初步的基线中，我们在每五帧图片中加载一帧。得益于我们的超参数设置和数据增强方案，我们得到了比 Waymo [原论文](https://arxiv.org/pdf/1912.04838.pdf)中更好的性能。请移步 `configs/pointpillars/` 下的 README.md 以查看更多配置和性能相关的细节。我们会尽快发布一个更完整的 Waymo 基准榜单 (benchmark)。
+
+## 评估
+
+为了在 Waymo 数据集上进行检测性能评估，请按照[此处指示](https://github.com/waymo-research/waymo-open-dataset/blob/master/docs/quick_start.md)构建用于计算评估指标的二进制文件 `compute_detection_metrics_main`，并将它置于 `mmdet3d/core/evaluation/waymo_utils/` 下。您基本上可以按照下方命令安装 `bazel`，然后构建二进制文件：
+
+```shell
+# download the code and enter the base directory
+git clone https://github.com/waymo-research/waymo-open-dataset.git waymo-od
+# git clone https://github.com/Abyssaledge/waymo-open-dataset-master waymo-od # if you want to use faster multi-thread version.
+cd waymo-od
+git checkout remotes/origin/master
+
+# use the Bazel build system
+sudo apt-get install --assume-yes pkg-config zip g++ zlib1g-dev unzip python3 python3-pip
+BAZEL_VERSION=3.1.0
+wget https://github.com/bazelbuild/bazel/releases/download/${BAZEL_VERSION}/bazel-${BAZEL_VERSION}-installer-linux-x86_64.sh
+sudo bash bazel-${BAZEL_VERSION}-installer-linux-x86_64.sh
+sudo apt install build-essential
+
+# configure .bazelrc
+./configure.sh
+# delete previous bazel outputs and reset internal caches
+bazel clean
+
+bazel build waymo_open_dataset/metrics/tools/compute_detection_metrics_main
+cp bazel-bin/waymo_open_dataset/metrics/tools/compute_detection_metrics_main ../mmdetection3d/mmdet3d/evaluation/functional/waymo_utils/
+```
+
+接下来，您就可以在 Waymo 上评估您的模型了。如下示例是使用 8 个图形处理器 (GPU) 在 Waymo 上用 Waymo 评价指标评估 PointPillars 模型的情景：
+
+```shell
+./tools/dist_test.sh configs/pointpillars/pointpillars_hv_secfpn_sbn-all_16xb2-2x_waymo-3d-car.py checkpoints/hv_pointpillars_secfpn_sbn-2x16_2x_waymo-3d-car_latest.pth
+```
+
+如果需要生成 bin 文件，需要在配置文件的 `test_evaluator` 中指定 `pklfile_prefix`，因此你可以在命令后添加 `--cfg-options "test_evaluator.pklfile_prefix=xxxx"`。
+
+**注意**:
+
+1. 有时用 `bazel` 构建 `compute_detection_metrics_main` 的过程中会出现如下错误：`'round' 不是 'std' 的成员` (`'round' is not a member of 'std'`)。我们只需要移除该文件中，`round` 前的 `std::`。
+
+2. 考虑到 Waymo 上评估一次耗时不短，我们建议只在模型训练结束时进行评估。
+
+3. 为了在 CUDA 9 环境使用 TensorFlow，我们建议通过编译 TensorFlow 源码的方式使用。除了官方教程之外，您还可以参考该[链接](https://github.com/SmileTM/Tensorflow2.X-GPU-CUDA9.0)以寻找可能合适的预编译包以及编译源码的实用攻略。
+
+## 测试并提交到官方服务器
+
+如下是一个使用 8 个图形处理器在 Waymo 上测试 PointPillars，生成 bin 文件并提交结果到官方榜单的例子：
+
+如果你想生成 bin 文件并提交到服务器中，在运行测试指令前你需要在配置文件的 `test_evaluator` 中指定 `submission_prefix`。
+
+在生成 bin 文件后，您可以简单地构建二进制文件 `create_submission`，并按照[指示](https://github.com/waymo-research/waymo-open-dataset/blob/master/docs/quick_start.md/)创建一个提交文件。下面是一些示例：
+
+```shell
+cd ../waymo-od/
+bazel build waymo_open_dataset/metrics/tools/create_submission
+cp bazel-bin/waymo_open_dataset/metrics/tools/create_submission ../mmdetection3d/mmdet3d/core/evaluation/waymo_utils/
+vim waymo_open_dataset/metrics/tools/submission.txtpb # set the metadata information
+cp waymo_open_dataset/metrics/tools/submission.txtpb ../mmdetection3d/mmdet3d/evaluation/functional/waymo_utils/
+
+cd ../mmdetection3d
+# suppose the result bin is in `results/waymo-car/submission`
+mmdet3d/core/evaluation/waymo_utils/create_submission --input_filenames='results/waymo-car/kitti_results_test.bin' --output_filename='results/waymo-car/submission/model' --submission_filename='mmdet3d/evaluation/functional/waymo_utils/submission.txtpb'
+
+tar cvf results/waymo-car/submission/my_model.tar results/waymo-car/submission/my_model/
+gzip results/waymo-car/submission/my_model.tar
+```
+
+如果想用官方评估服务器评估您在验证集上的结果，您可以使用同样的方法生成提交文件，只需确保您在运行如上指令前更改 `submission.txtpb` 中的字段值即可。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMDetection3D/vector_store/index.faiss
new file mode 100644
index 00000000..d7fe9427
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMDetection3D/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/15_minutes.md b/internlm_langchain/knowledge_base/MMEngine/content/15_minutes.md
new file mode 100644
index 00000000..8ca102f5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/15_minutes.md
@@ -0,0 +1,242 @@
+# 15 分钟上手 MMEngine
+
+以在 CIFAR-10 数据集上训练一个 ResNet-50 模型为例，我们将使用 80 行以内的代码，利用 MMEngine 构建一个完整的、
+可配置的训练和验证流程，整个流程包含如下步骤：
+
+1. [构建模型](#构建模型)
+2. [构建数据集和数据加载器](#构建数据集和数据加载器)
+3. [构建评测指标](#构建评测指标)
+4. [构建执行器并执行任务](#构建执行器并执行任务)
+
+## 构建模型
+
+首先，我们需要构建一个**模型**，在 MMEngine 中，我们约定这个模型应当继承 `BaseModel`，并且其 `forward` 方法除了接受来自数据集的若干参数外，还需要接受额外的参数 `mode`：对于训练，我们需要 `mode` 接受字符串 "loss"，并返回一个包含 "loss" 字段的字典；对于验证，我们需要 `mode` 接受字符串 "predict"，并返回同时包含预测信息和真实信息的结果。
+
+```python
+import torch.nn.functional as F
+import torchvision
+from mmengine.model import BaseModel
+
+
+class MMResNet50(BaseModel):
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+
+ def forward(self, imgs, labels, mode):
+ x = self.resnet(imgs)
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+```
+
+## 构建数据集和数据加载器
+
+其次，我们需要构建训练和验证所需要的**数据集 (Dataset)**和**数据加载器 (DataLoader)**。
+对于基础的训练和验证功能，我们可以直接使用符合 PyTorch 标准的数据加载器和数据集。
+
+```python
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+
+norm_cfg = dict(mean=[0.491, 0.482, 0.447], std=[0.202, 0.199, 0.201])
+train_dataloader = DataLoader(batch_size=32,
+ shuffle=True,
+ dataset=torchvision.datasets.CIFAR10(
+ 'data/cifar10',
+ train=True,
+ download=True,
+ transform=transforms.Compose([
+ transforms.RandomCrop(32, padding=4),
+ transforms.RandomHorizontalFlip(),
+ transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)
+ ])))
+
+val_dataloader = DataLoader(batch_size=32,
+ shuffle=False,
+ dataset=torchvision.datasets.CIFAR10(
+ 'data/cifar10',
+ train=False,
+ download=True,
+ transform=transforms.Compose([
+ transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)
+ ])))
+```
+
+## 构建评测指标
+
+为了进行验证和测试，我们需要定义模型推理结果的**评测指标**。我们约定这一评测指标需要继承 `BaseMetric`，并实现 `process` 和 `compute_metrics` 方法。其中 `process` 方法接受数据集的输出和模型 `mode="predict"`
+时的输出，此时的数据为一个批次的数据，对这一批次的数据进行处理后，保存信息至 `self.results` 属性。
+而 `compute_metrics` 接受 `results` 参数，这一参数的输入为 `process` 中保存的所有信息
+（如果是分布式环境，`results` 中为已收集的，包括各个进程 `process` 保存信息的结果），利用这些信息计算并返回保存有评测指标结果的字典。
+
+```python
+from mmengine.evaluator import BaseMetric
+
+class Accuracy(BaseMetric):
+ def process(self, data_batch, data_samples):
+ score, gt = data_samples
+ # 将一个批次的中间结果保存至 `self.results`
+ self.results.append({
+ 'batch_size': len(gt),
+ 'correct': (score.argmax(dim=1) == gt).sum().cpu(),
+ })
+
+ def compute_metrics(self, results):
+ total_correct = sum(item['correct'] for item in results)
+ total_size = sum(item['batch_size'] for item in results)
+ # 返回保存有评测指标结果的字典，其中键为指标名称
+ return dict(accuracy=100 * total_correct / total_size)
+```
+
+## 构建执行器并执行任务
+
+最后，我们利用构建好的**模型**，**数据加载器**，**评测指标**构建一个**执行器 (Runner)**，同时在其中配置
+**优化器**、**工作路径**、**训练与验证配置**等选项，即可通过调用 `train()` 接口启动训练：
+
+```python
+from torch.optim import SGD
+from mmengine.runner import Runner
+
+runner = Runner(
+ # 用以训练和验证的模型，需要满足特定的接口需求
+ model=MMResNet50(),
+ # 工作路径，用以保存训练日志、权重文件信息
+ work_dir='./work_dir',
+ # 训练数据加载器，需要满足 PyTorch 数据加载器协议
+ train_dataloader=train_dataloader,
+ # 优化器包装，用于模型优化，并提供 AMP、梯度累积等附加功能
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ # 训练配置，用于指定训练周期、验证间隔等信息
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ # 验证数据加载器，需要满足 PyTorch 数据加载器协议
+ val_dataloader=val_dataloader,
+ # 验证配置，用于指定验证所需要的额外参数
+ val_cfg=dict(),
+ # 用于验证的评测器，这里使用默认评测器，并评测指标
+ val_evaluator=dict(type=Accuracy),
+)
+
+runner.train()
+```
+
+最后，让我们把以上部分汇总成为一个完整的，利用 MMEngine 执行器进行训练和验证的脚本：
+
+
+
+```python
+import torch.nn.functional as F
+import torchvision
+import torchvision.transforms as transforms
+from torch.optim import SGD
+from torch.utils.data import DataLoader
+
+from mmengine.evaluator import BaseMetric
+from mmengine.model import BaseModel
+from mmengine.runner import Runner
+
+
+class MMResNet50(BaseModel):
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+
+ def forward(self, imgs, labels, mode):
+ x = self.resnet(imgs)
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+
+
+class Accuracy(BaseMetric):
+ def process(self, data_batch, data_samples):
+ score, gt = data_samples
+ self.results.append({
+ 'batch_size': len(gt),
+ 'correct': (score.argmax(dim=1) == gt).sum().cpu(),
+ })
+
+ def compute_metrics(self, results):
+ total_correct = sum(item['correct'] for item in results)
+ total_size = sum(item['batch_size'] for item in results)
+ return dict(accuracy=100 * total_correct / total_size)
+
+
+norm_cfg = dict(mean=[0.491, 0.482, 0.447], std=[0.202, 0.199, 0.201])
+train_dataloader = DataLoader(batch_size=32,
+ shuffle=True,
+ dataset=torchvision.datasets.CIFAR10(
+ 'data/cifar10',
+ train=True,
+ download=True,
+ transform=transforms.Compose([
+ transforms.RandomCrop(32, padding=4),
+ transforms.RandomHorizontalFlip(),
+ transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)
+ ])))
+
+val_dataloader = DataLoader(batch_size=32,
+ shuffle=False,
+ dataset=torchvision.datasets.CIFAR10(
+ 'data/cifar10',
+ train=False,
+ download=True,
+ transform=transforms.Compose([
+ transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)
+ ])))
+
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+)
+runner.train()
+```
+
+输出的训练日志如下：
+
+```
+2022/08/22 15:51:53 - mmengine - INFO -
+------------------------------------------------------------
+System environment:
+ sys.platform: linux
+ Python: 3.8.12 (default, Oct 12 2021, 13:49:34) [GCC 7.5.0]
+ CUDA available: True
+ numpy_random_seed: 1513128759
+ GPU 0: NVIDIA GeForce GTX 1660 SUPER
+ CUDA_HOME: /usr/local/cuda
+...
+
+2022/08/22 15:51:54 - mmengine - INFO - Checkpoints will be saved to /home/mazerun/work_dir by HardDiskBackend.
+2022/08/22 15:51:56 - mmengine - INFO - Epoch(train) [1][10/1563] lr: 1.0000e-03 eta: 0:18:23 time: 0.1414 data_time: 0.0077 memory: 392 loss: 5.3465
+2022/08/22 15:51:56 - mmengine - INFO - Epoch(train) [1][20/1563] lr: 1.0000e-03 eta: 0:11:29 time: 0.0354 data_time: 0.0077 memory: 392 loss: 2.7734
+2022/08/22 15:51:56 - mmengine - INFO - Epoch(train) [1][30/1563] lr: 1.0000e-03 eta: 0:09:10 time: 0.0352 data_time: 0.0076 memory: 392 loss: 2.7789
+2022/08/22 15:51:57 - mmengine - INFO - Epoch(train) [1][40/1563] lr: 1.0000e-03 eta: 0:08:00 time: 0.0353 data_time: 0.0073 memory: 392 loss: 2.5725
+2022/08/22 15:51:57 - mmengine - INFO - Epoch(train) [1][50/1563] lr: 1.0000e-03 eta: 0:07:17 time: 0.0347 data_time: 0.0073 memory: 392 loss: 2.7382
+2022/08/22 15:51:57 - mmengine - INFO - Epoch(train) [1][60/1563] lr: 1.0000e-03 eta: 0:06:49 time: 0.0347 data_time: 0.0072 memory: 392 loss: 2.5956
+2022/08/22 15:51:58 - mmengine - INFO - Epoch(train) [1][70/1563] lr: 1.0000e-03 eta: 0:06:28 time: 0.0348 data_time: 0.0072 memory: 392 loss: 2.7351
+...
+2022/08/22 15:52:50 - mmengine - INFO - Saving checkpoint at 1 epochs
+2022/08/22 15:52:51 - mmengine - INFO - Epoch(val) [1][10/313] eta: 0:00:03 time: 0.0122 data_time: 0.0047 memory: 392
+2022/08/22 15:52:51 - mmengine - INFO - Epoch(val) [1][20/313] eta: 0:00:03 time: 0.0122 data_time: 0.0047 memory: 308
+2022/08/22 15:52:51 - mmengine - INFO - Epoch(val) [1][30/313] eta: 0:00:03 time: 0.0123 data_time: 0.0047 memory: 308
+...
+2022/08/22 15:52:54 - mmengine - INFO - Epoch(val) [1][313/313] accuracy: 35.7000
+```
+
+基于 PyTorch 和基于 MMEngine 的训练流程对比如下：
+
+
+
+除了以上基础组件，你还可以利用**执行器**轻松地组合配置各种训练技巧，如开启混合精度训练和梯度累积（见 [优化器封装（OptimWrapper）](../tutorials/optim_wrapper.md)）、配置学习率衰减曲线（见 [评测指标与评测器（Metrics & Evaluator）](../tutorials/evaluation.md)）等。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/basedataset.md b/internlm_langchain/knowledge_base/MMEngine/content/basedataset.md
new file mode 100644
index 00000000..1e069826
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/basedataset.md
@@ -0,0 +1,501 @@
+# 数据集基类（BaseDataset）
+
+## 基本介绍
+
+算法库中的数据集类负责在训练/测试过程中为模型提供输入数据，OpenMMLab 下各个算法库中的数据集有一些共同的特点和需求，比如需要高效的内部数据存储格式，需要支持数据集拼接、数据集重复采样等功能。
+
+因此 **MMEngine** 实现了一个数据集基类（BaseDataset）并定义了一些基本接口，且基于这套接口实现了一些数据集包装（DatasetWrapper）。OpenMMLab 算法库中的大部分数据集都会满足这套数据集基类定义的接口，并使用统一的数据集包装。
+
+数据集基类的基本功能是加载数据集信息，这里我们将数据集信息分成两类，一种是元信息 (meta information)，代表数据集自身相关的信息，有时需要被模型或其他外部组件获取，比如在图像分类任务中，数据集的元信息一般包含类别信息 `classes`，因为分类模型 `model` 一般需要记录数据集的类别信息；另一种为数据信息 (data information)，在数据信息中，定义了具体样本的文件路径、对应标签等的信息。除此之外，数据集基类的另一个功能为不断地将数据送入数据流水线（data pipeline）中，进行数据预处理。
+
+### 数据标注文件规范
+
+为了统一不同任务的数据集接口，便于多任务的算法模型训练，OpenMMLab 制定了 **OpenMMLab 2.0 数据集格式规范**， 数据集标注文件需符合该规范，数据集基类基于该规范去读取与解析数据标注文件。如果用户提供的数据标注文件不符合规定格式，用户可以选择将其转化为规定格式，并使用 OpenMMLab 的算法库基于该数据标注文件进行算法训练和测试。
+
+OpenMMLab 2.0 数据集格式规范规定，标注文件必须为 `json` 或 `yaml`，`yml` 或 `pickle`，`pkl` 格式；标注文件中存储的字典必须包含 `metainfo` 和 `data_list` 两个字段。其中 `metainfo` 是一个字典，里面包含数据集的元信息；`data_list` 是一个列表，列表中每个元素是一个字典，该字典定义了一个原始数据（raw data），每个原始数据包含一个或若干个训练/测试样本。
+
+以下是一个 JSON 标注文件的例子（该例子中每个原始数据只包含一个训练/测试样本）:
+
+```json
+
+{
+ "metainfo":
+ {
+ "classes": ["cat", "dog"]
+ },
+ "data_list":
+ [
+ {
+ "img_path": "xxx/xxx_0.jpg",
+ "img_label": 0
+ },
+ {
+ "img_path": "xxx/xxx_1.jpg",
+ "img_label": 1
+ }
+ ]
+}
+```
+
+同时假设数据存放路径如下：
+
+```text
+data
+├── annotations
+│ ├── train.json
+├── train
+│ ├── xxx/xxx_0.jpg
+│ ├── xxx/xxx_1.jpg
+│ ├── ...
+```
+
+### 数据集基类的初始化流程
+
+数据集基类的初始化流程如下图所示：
+
+`_.
+
+ # 复制代码
+ # This code was copied from the `ubelt
+ # library`_.
+
+ # 引用论文 & 添加公式
+ class LabelSmoothLoss(nn.Module):
+ r"""Initializer for the label smoothed cross entropy loss.
+
+ Refers to `Rethinking the Inception Architecture for Computer Vision
+ `_.
+
+ This decreases gap between output scores and encourages generalization.
+ Labels provided to forward can be one-hot like vectors (NxC) or class
+ indices (Nx1).
+ And this accepts linear combination of one-hot like labels from mixup or
+ cutmix except multi-label task.
+
+ Args:
+ label_smooth_val (float): The degree of label smoothing.
+ num_classes (int, optional): Number of classes. Defaults to None.
+ mode (str): Refers to notes, Options are "original", "classy_vision",
+ "multi_label". Defaults to "classy_vision".
+ reduction (str): The method used to reduce the loss.
+ Options are "none", "mean" and "sum". Defaults to 'mean'.
+ loss_weight (float): Weight of the loss. Defaults to 1.0.
+
+ Note:
+ if the ``mode`` is "original", this will use the same label smooth
+ method as the original paper as:
+
+ .. math::
+ (1-\epsilon)\delta_{k, y} + \frac{\epsilon}{K}
+
+ where :math:`\epsilon` is the ``label_smooth_val``, :math:`K` is
+ the ``num_classes`` and :math:`\delta_{k,y}` is Dirac delta,
+ which equals 1 for k=y and 0 otherwise.
+
+ if the ``mode`` is "classy_vision", this will use the same label
+ smooth method as the `facebookresearch/ClassyVision
+ `_ repo as:
+
+ .. math::
+ \frac{\delta_{k, y} + \epsilon/K}{1+\epsilon}
+
+ if the ``mode`` is "multi_label", this will accept labels from
+ multi-label task and smoothing them as:
+
+ .. math::
+ (1-2\epsilon)\delta_{k, y} + \epsilon
+ ```
+
+```{note}
+注意 \`\`here\`\`、\`here\`、"here" 三种引号功能是不同。
+
+在 reStructured 语法中，\`\`here\`\` 表示一段代码；\`here\` 表示斜体；"here" 无特殊含义，一般可用来表示字符串。其中 \`here\` 的用法与 Markdown 中不同，需要多加留意。
+另外还有 :obj:\`type\` 这种更规范的表示类的写法，但鉴于长度，不做特别要求，一般仅用于表示非常用类型。
+```
+
+3. 方法（函数）文档
+
+ 函数文档与类文档的结构基本一致，但需要加入返回值文档。对于较为复杂的函数和类，可以使用 Examples 字段加入示例；如果需要对参数加入一些较长的备注，可以加入 Note 字段进行说明。
+
+ 对于使用较为复杂的类或函数，比起看大段大段的说明文字和参数文档，添加合适的示例更能帮助用户迅速了解其用法。需要注意的是，这些示例最好是能够直接在 Python 交互式环境中运行的，并给出一些相对应的结果。如果存在多个示例，可以使用注释简单说明每段示例，也能起到分隔作用。
+
+ ```python
+ def import_modules_from_strings(imports, allow_failed_imports=False):
+ """Import modules from the given list of strings.
+
+ Args:
+ imports (list | str | None): The given module names to be imported.
+ allow_failed_imports (bool): If True, the failed imports will return
+ None. Otherwise, an ImportError is raise. Defaults to False.
+
+ Returns:
+ List[module] | module | None: The imported modules.
+ All these three lines in docstring will be compiled into the same
+ line in readthedocs.
+
+ Examples:
+ >>> osp, sys = import_modules_from_strings(
+ ... ['os.path', 'sys'])
+ >>> import os.path as osp_
+ >>> import sys as sys_
+ >>> assert osp == osp_
+ >>> assert sys == sys_
+ """
+ ...
+ ```
+
+ 如果函数接口在某个版本发生了变化，需要在 docstring 中加入相关的说明，必要时添加 Note 或者 Warning 进行说明，例如：
+
+ ```python
+ class CheckpointHook(Hook):
+ """Save checkpoints periodically.
+
+ Args:
+ out_dir (str, optional): The root directory to save checkpoints. If
+ not specified, ``runner.work_dir`` will be used by default. If
+ specified, the ``out_dir`` will be the concatenation of
+ ``out_dir`` and the last level directory of ``runner.work_dir``.
+ Defaults to None. `Changed in version 1.3.15.`
+ file_client_args (dict, optional): Arguments to instantiate a
+ FileClient. See :class:`mmcv.fileio.FileClient` for details.
+ Defaults to None. `New in version 1.3.15.`
+
+ Warning:
+ Before v1.3.15, the ``out_dir`` argument indicates the path where the
+ checkpoint is stored. However, in v1.3.15 and later, ``out_dir``
+ indicates the root directory and the final path to save checkpoint is
+ the concatenation of out_dir and the last level directory of
+ ``runner.work_dir``. Suppose the value of ``out_dir`` is
+ "/path/of/A" and the value of ``runner.work_dir`` is "/path/of/B",
+ then the final path will be "/path/of/A/B".
+ ```
+
+ 如果参数或返回值里带有需要展开描述字段的 dict，则应该采用如下格式：
+
+ ```python
+ def func(x):
+ r"""
+ Args:
+ x (None): A dict with 2 keys, ``padded_targets``, and ``targets``.
+
+ - ``targets`` (list[Tensor]): A list of tensors.
+ Each tensor has the shape of :math:`(T_i)`. Each
+ element is the index of a character.
+ - ``padded_targets`` (Tensor): A tensor of shape :math:`(N)`.
+ Each item is the length of a word.
+
+ Returns:
+ dict: A dict with 2 keys, ``padded_targets``, and ``targets``.
+
+ - ``targets`` (list[Tensor]): A list of tensors.
+ Each tensor has the shape of :math:`(T_i)`. Each
+ element is the index of a character.
+ - ``padded_targets`` (Tensor): A tensor of shape :math:`(N)`.
+ Each item is the length of a word.
+ """
+ return x
+ ```
+
+```{important}
+为了生成 readthedocs 文档，文档的编写需要按照 ReStructrued 文档格式，否则会产生文档渲染错误，在提交 PR 前，最好生成并预览一下文档效果。
+语法规范参考：
+
+- [reStructuredText Primer - Sphinx documentation](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html#)
+- [Example Google Style Python Docstrings ‒ napoleon 0.7 documentation](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html#example-google)
+```
+
+## 注释规范
+
+### 为什么要写注释
+
+对于一个开源项目，团队合作以及社区之间的合作是必不可少的，因而尤其要重视合理的注释。不写注释的代码，很有可能过几个月自己也难以理解，造成额外的阅读和修改成本。
+
+### 如何写注释
+
+最需要写注释的是代码中那些技巧性的部分。如果你在下次代码审查的时候必须解释一下，那么你应该现在就给它写注释。对于复杂的操作，应该在其操作开始前写上若干行注释。对于不是一目了然的代码，应在其行尾添加注释。
+—— Google 开源项目风格指南
+
+```python
+# We use a weighted dictionary search to find out where i is in
+# the array. We extrapolate position based on the largest num
+# in the array and the array size and then do binary search to
+# get the exact number.
+if i & (i-1) == 0: # True if i is 0 or a power of 2.
+```
+
+为了提高可读性, 注释应该至少离开代码2个空格.
+另一方面, 绝不要描述代码. 假设阅读代码的人比你更懂Python, 他只是不知道你的代码要做什么.
+—— Google 开源项目风格指南
+
+```python
+# Wrong:
+# Now go through the b array and make sure whenever i occurs
+# the next element is i+1
+
+# Wrong:
+if i & (i-1) == 0: # True if i bitwise and i-1 is 0.
+```
+
+在注释中，可以使用 Markdown 语法，因为开发人员通常熟悉 Markdown 语法，这样可以便于交流理解，如可使用单反引号表示代码和变量（注意不要和 docstring 中的 ReStructured 语法混淆）
+
+```python
+# `_reversed_padding_repeated_twice` is the padding to be passed to
+# `F.pad` if needed (e.g., for non-zero padding types that are
+# implemented as two ops: padding + conv). `F.pad` accepts paddings in
+# reverse order than the dimension.
+self._reversed_padding_repeated_twice = _reverse_repeat_tuple(self.padding, 2)
+```
+
+### 注释示例
+
+1. 出自 `mmcv/utils/registry.py`，对于较为复杂的逻辑结构，通过注释，明确了优先级关系。
+
+ ```python
+ # self.build_func will be set with the following priority:
+ # 1. build_func
+ # 2. parent.build_func
+ # 3. build_from_cfg
+ if build_func is None:
+ if parent is not None:
+ self.build_func = parent.build_func
+ else:
+ self.build_func = build_from_cfg
+ else:
+ self.build_func = build_func
+ ```
+
+2. 出自 `mmcv/runner/checkpoint.py`，对于 bug 修复中的一些特殊处理，可以附带相关的 issue 链接，帮助其他人了解 bug 背景。
+
+ ```python
+ def _save_ckpt(checkpoint, file):
+ # The 1.6 release of PyTorch switched torch.save to use a new
+ # zipfile-based file format. It will cause RuntimeError when a
+ # checkpoint was saved in high version (PyTorch version>=1.6.0) but
+ # loaded in low version (PyTorch version<1.6.0). More details at
+ # https://github.com/open-mmlab/mmpose/issues/904
+ if digit_version(TORCH_VERSION) >= digit_version('1.6.0'):
+ torch.save(checkpoint, file, _use_new_zipfile_serialization=False)
+ else:
+ torch.save(checkpoint, file)
+ ```
+
+## 类型注解
+
+### 为什么要写类型注解
+
+类型注解是对函数中变量的类型做限定或提示，为代码的安全性提供保障、增强代码的可读性、避免出现类型相关的错误。
+Python 没有对类型做强制限制，类型注解只起到一个提示作用，通常你的 IDE 会解析这些类型注解，然后在你调用相关代码时对类型做提示。另外也有类型注解检查工具，这些工具会根据类型注解，对代码中可能出现的问题进行检查，减少 bug 的出现。
+需要注意的是，通常我们不需要注释模块中的所有函数：
+
+1. 公共的 API 需要注释
+2. 在代码的安全性，清晰性和灵活性上进行权衡是否注释
+3. 对于容易出现类型相关的错误的代码进行注释
+4. 难以理解的代码请进行注释
+5. 若代码中的类型已经稳定，可以进行注释. 对于一份成熟的代码，多数情况下，即使注释了所有的函数，也不会丧失太多的灵活性.
+
+### 如何写类型注解
+
+1. 函数 / 方法类型注解，通常不对 self 和 cls 注释。
+
+ ```python
+ from typing import Optional, List, Tuple
+
+ # 全部位于一行
+ def my_method(self, first_var: int) -> int:
+ pass
+
+ # 另起一行
+ def my_method(
+ self, first_var: int,
+ second_var: float) -> Tuple[MyLongType1, MyLongType1, MyLongType1]:
+ pass
+
+ # 单独成行（具体的应用场合与行宽有关，建议结合 yapf 自动化格式使用）
+ def my_method(
+ self, first_var: int, second_var: float
+ ) -> Tuple[MyLongType1, MyLongType1, MyLongType1]:
+ pass
+
+ # 引用尚未被定义的类型
+ class MyClass:
+ def __init__(self,
+ stack: List["MyClass"]) -> None:
+ pass
+ ```
+
+ 注：类型注解中的类型可以是 Python 内置类型，也可以是自定义类，还可以使用 Python 提供的 wrapper 类对类型注解进行装饰，一些常见的注解如下：
+
+ ```python
+ # 数值类型
+ from numbers import Number
+
+ # 可选类型，指参数可以为 None
+ from typing import Optional
+ def foo(var: Optional[int] = None):
+ pass
+
+ # 联合类型，指同时接受多种类型
+ from typing import Union
+ def foo(var: Union[float, str]):
+ pass
+
+ from typing import Sequence # 序列类型
+ from typing import Iterable # 可迭代类型
+ from typing import Any # 任意类型
+ from typing import Callable # 可调用类型
+
+ from typing import List, Dict # 列表和字典的泛型类型
+ from typing import Tuple # 元组的特殊格式
+ # 虽然在 Python 3.9 中，list, tuple 和 dict 本身已支持泛型，但为了支持之前的版本
+ # 我们在进行类型注解时还是需要使用 List, Tuple, Dict 类型
+ # 另外，在对参数类型进行注解时，尽量使用 Sequence & Iterable & Mapping
+ # List, Tuple, Dict 主要用于返回值类型注解
+ # 参见 https://docs.python.org/3/library/typing.html#typing.List
+ ```
+
+2. 变量类型注解，一般用于难以直接推断其类型时
+
+ ```python
+ # Recommend: 带类型注解的赋值
+ a: Foo = SomeUndecoratedFunction()
+ a: List[int]: [1, 2, 3] # List 只支持单一类型泛型，可使用 Union
+ b: Tuple[int, int] = (1, 2) # 长度固定为 2
+ c: Tuple[int, ...] = (1, 2, 3) # 变长
+ d: Dict[str, int] = {'a': 1, 'b': 2}
+
+ # Not Recommend：行尾类型注释
+ # 虽然这种方式被写在了 Google 开源指南中，但这是一种为了支持 Python 2.7 版本
+ # 而补充的注释方式，鉴于我们只支持 Python 3, 为了风格统一，不推荐使用这种方式。
+ a = SomeUndecoratedFunction() # type: Foo
+ a = [1, 2, 3] # type: List[int]
+ b = (1, 2, 3) # type: Tuple[int, ...]
+ c = (1, "2", 3.5) # type: Tuple[int, Text, float]
+ ```
+
+3. 泛型
+
+ 上文中我们知道，typing 中提供了 list 和 dict 的泛型类型，那么我们自己是否可以定义类似的泛型呢？
+
+ ```python
+ from typing import TypeVar, Generic
+
+ KT = TypeVar('KT')
+ VT = TypeVar('VT')
+
+ class Mapping(Generic[KT, VT]):
+ def __init__(self, data: Dict[KT, VT]):
+ self._data = data
+
+ def __getitem__(self, key: KT) -> VT:
+ return self._data[key]
+ ```
+
+ 使用上述方法，我们定义了一个拥有泛型能力的映射类，实际用法如下：
+
+ ```python
+ mapping = Mapping[str, float]({'a': 0.5})
+ value: float = example['a']
+ ```
+
+ 另外，我们也可以利用 TypeVar 在函数签名中指定联动的多个类型：
+
+ ```python
+ from typing import TypeVar, List
+
+ T = TypeVar('T') # Can be anything
+ A = TypeVar('A', str, bytes) # Must be str or bytes
+
+
+ def repeat(x: T, n: int) -> List[T]:
+ """Return a list containing n references to x."""
+ return [x]*n
+
+
+ def longest(x: A, y: A) -> A:
+ """Return the longest of two strings."""
+ return x if len(x) >= len(y) else y
+ ```
+
+更多关于类型注解的写法请参考 [typing](https://docs.python.org/3/library/typing.html)。
+
+### 类型注解检查工具
+
+[mypy](https://mypy.readthedocs.io/en/stable/) 是一个 Python 静态类型检查工具。根据你的类型注解，mypy 会检查传参、赋值等操作是否符合类型注解，从而避免可能出现的 bug。
+
+例如如下的一个 Python 脚本文件 test.py:
+
+```python
+def foo(var: int) -> float:
+ return float(var)
+
+a: str = foo('2.0')
+b: int = foo('3.0') # type: ignore
+```
+
+运行 mypy test.py 可以得到如下检查结果，分别指出了第 4 行在函数调用和返回值赋值两处类型错误。而第 5 行同样存在两个类型错误，由于使用了 type: ignore 而被忽略了，只有部分特殊情况可能需要此类忽略。
+
+```
+test.py:4: error: Incompatible types in assignment (expression has type "float", variable has type "int")
+test.py:4: error: Argument 1 to "foo" has incompatible type "str"; expected "int"
+Found 2 errors in 1 file (checked 1 source file)
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/config.md b/internlm_langchain/knowledge_base/MMEngine/content/config.md
new file mode 100644
index 00000000..82302b28
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/config.md
@@ -0,0 +1,1174 @@
+# 配置（Config）
+
+- [配置（Config）](#配置config)
+ - [配置文件读取](#配置文件读取)
+ - [配置文件的使用](#配置文件的使用)
+ - [配置文件的继承](#配置文件的继承)
+ - [继承机制概述](#继承机制概述)
+ - [修改继承字段](#修改继承字段)
+ - [删除字典中的 key](#删除字典中的-key)
+ - [引用被继承文件中的变量](#引用被继承文件中的变量)
+ - [配置文件的导出](#配置文件的导出)
+ - [其他进阶用法](#其他进阶用法)
+ - [预定义字段](#预定义字段)
+ - [命令行修改配置](#命令行修改配置)
+ - [使用环境变量替换配置](#使用环境变量替换配置)
+ - [导入自定义 Python 模块](#导入自定义-python-模块)
+ - [跨项目继承配置文件](#跨项目继承配置文件)
+ - [跨项目获取配置文件](#跨项目获取配置文件)
+ - [纯 Python 风格的配置文件（Beta）](#纯-python-风格的配置文件beta)
+ - [基本语法](#基本语法)
+ - [模块构建](#模块构建)
+ - [继承](#继承)
+ - [配置文件的导出](#配置文件的导出-1)
+ - [什么是 lazy import](#什么是-lazy-import)
+ - [功能限制](#功能限制)
+ - [迁移指南](#迁移指南)
+
+MMEngine 实现了抽象的配置类（Config），为用户提供统一的配置访问接口。配置类能够支持不同格式的配置文件，包括 `python`，`json`，`yaml`，用户可以根据需求选择自己偏好的格式。配置类提供了类似字典或者 Python 对象属性的访问接口，用户可以十分自然地进行配置字段的读取和修改。为了方便算法框架管理配置文件，配置类也实现了一些特性，例如配置文件的字段继承等。
+
+在开始教程之前，我们先将教程中需要用到的配置文件下载到本地（建议在临时目录下执行，方便后续删除示例配置文件）：
+
+```bash
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/config_sgd.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/cross_repo.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/custom_imports.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/demo_train.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/example.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/learn_read_config.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/my_module.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/optimizer_cfg.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/predefined_var.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/refer_base_var.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/replace_data_root.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/replace_num_classes.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50_delete_key.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50_lr0.01.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50_runtime.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/runtime_cfg.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/modify_base_var.py
+```
+
+```{note}
+配置类支持两种风格的配置文件，即纯文本风格的配置文件和纯 Python 风格的配置文件（v0.8.0 的新特性），二者在调用接口统一的前提下各有特色。对于尚且不了解配置类基本用法用户，建议从[配置文件读取](#配置文件读取) 一节开始阅读，以了解配置类的功能和纯文本配置文件的语法。在一些情况下，纯文本风格的配置文件写法更加简洁，语法兼容性更好（`json`、`yaml` 通用）。如果你希望配置文件的写法可以更加灵活，建议阅读并使用[纯 Python 风格的配置文件](#纯-python-风格的配置文件beta)（beta）
+```
+
+## 配置文件读取
+
+配置类提供了统一的接口 `Config.fromfile()`，来读取和解析配置文件。
+
+合法的配置文件应该定义一系列键值对，这里举几个不同格式配置文件的例子。
+
+Python 格式：
+
+```Python
+test_int = 1
+test_list = [1, 2, 3]
+test_dict = dict(key1='value1', key2=0.1)
+```
+
+Json 格式：
+
+```json
+{
+ "test_int": 1,
+ "test_list": [1, 2, 3],
+ "test_dict": {"key1": "value1", "key2": 0.1}
+}
+```
+
+YAML 格式：
+
+```yaml
+test_int: 1
+test_list: [1, 2, 3]
+test_dict:
+ key1: "value1"
+ key2: 0.1
+```
+
+对于以上三种格式的文件，假设文件名分别为 `config.py`，`config.json`，`config.yml`，调用 `Config.fromfile('config.xxx')` 接口加载这三个文件都会得到相同的结果，构造了包含 3 个字段的配置对象。我们以 `config.py` 为例，我们先将示例配置文件下载到本地：
+
+然后通过配置类的 `fromfile` 接口读取配置文件：
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('learn_read_config.py')
+print(cfg)
+```
+
+```
+Config (path: learn_read_config.py): {'test_int': 1, 'test_list': [1, 2, 3], 'test_dict': {'key1': 'value1', 'key2': 0.1}}
+```
+
+## 配置文件的使用
+
+通过读取配置文件来初始化配置对象后，就可以像使用普通字典或者 Python 类一样来使用这个变量了。我们提供了两种访问接口，即类似字典的接口 `cfg['key']` 或者类似 Python 对象属性的接口 `cfg.key`。这两种接口都支持读写。
+
+```python
+print(cfg.test_int)
+print(cfg.test_list)
+print(cfg.test_dict)
+cfg.test_int = 2
+
+print(cfg['test_int'])
+print(cfg['test_list'])
+print(cfg['test_dict'])
+cfg['test_list'][1] = 3
+print(cfg['test_list'])
+```
+
+```
+1
+[1, 2, 3]
+{'key1': 'value1', 'key2': 0.1}
+2
+[1, 2, 3]
+{'key1': 'value1', 'key2': 0.1}
+[1, 3, 3]
+```
+
+注意，配置文件中定义的嵌套字段（即类似字典的字段），在 Config 中会将其转化为 ConfigDict 类，该类继承了 Python 内置字典类型的全部接口，同时也支持以对象属性的方式访问数据。
+
+在算法库中，可以将配置与注册器结合起来使用，达到通过配置文件来控制模块构造的目的。这里举一个在配置文件中定义优化器的例子。
+
+假设我们已经定义了一个优化器的注册器 OPTIMIZERS，包括了各种优化器。那么首先写一个 `config_sgd.py`：
+
+```python
+optimizer = dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.0001)
+```
+
+然后在算法库中可以通过如下代码构造优化器对象。
+
+```python
+from mmengine import Config, optim
+from mmengine.registry import OPTIMIZERS
+
+import torch.nn as nn
+
+cfg = Config.fromfile('config_sgd.py')
+
+model = nn.Conv2d(1, 1, 1)
+cfg.optimizer.params = model.parameters()
+optimizer = OPTIMIZERS.build(cfg.optimizer)
+print(optimizer)
+```
+
+```
+SGD (
+Parameter Group 0
+ dampening: 0
+ foreach: None
+ lr: 0.1
+ maximize: False
+ momentum: 0.9
+ nesterov: False
+ weight_decay: 0.0001
+)
+```
+
+## 配置文件的继承
+
+有时候，两个不同的配置文件之间的差异很小，可能仅仅只改了一个字段，我们就需要将所有内容复制粘贴一次，而且在后续观察的时候，不容易定位到具体差异的字段。又有些情况下，多个配置文件可能都有相同的一批字段，我们不得不在这些配置文件中进行复制粘贴，给后续的修改和维护带来了不便。
+
+为了解决这些问题，我们给配置文件增加了继承的机制，即一个配置文件 A 可以将另一个配置文件 B 作为自己的基础，直接继承了 B 中所有字段，而不必显式复制粘贴。
+
+### 继承机制概述
+
+这里我们举一个例子来说明继承机制。定义如下两个配置文件，
+
+`optimizer_cfg.py`：
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+`resnet50.py`：
+
+```python
+_base_ = ['optimizer_cfg.py']
+model = dict(type='ResNet', depth=50)
+```
+
+虽然我们在 `resnet50.py` 中没有定义 optimizer 字段，但由于我们写了 `_base_ = ['optimizer_cfg.py']`，会使这个配置文件获得 `optimizer_cfg.py` 中的所有字段。
+
+```python
+cfg = Config.fromfile('resnet50.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.02, 'momentum': 0.9, 'weight_decay': 0.0001}
+```
+
+这里 `_base_` 是配置文件的保留字段，指定了该配置文件的继承来源。支持继承多个文件，将同时获得这多个文件中的所有字段，但是要求继承的多个文件中**没有**相同名称的字段，否则会报错。
+
+`runtime_cfg.py`：
+
+```python
+gpu_ids = [0, 1]
+```
+
+`resnet50_runtime.py`：
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+```
+
+这时，读取配置文件 `resnet50_runtime.py` 会获得 3 个字段 `model`，`optimizer`，`gpu_ids`。
+
+```python
+cfg = Config.fromfile('resnet50_runtime.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.02, 'momentum': 0.9, 'weight_decay': 0.0001}
+```
+
+通过这种方式，我们可以将配置文件进行拆分，定义一些通用配置文件，在实际配置文件中继承各种通用配置文件，可以减少具体任务的配置流程。
+
+### 修改继承字段
+
+有时候，我们继承一个配置文件之后，可能需要对其中个别字段进行修改，例如继承了 `optimizer_cfg.py` 之后，想将学习率从 0.02 修改为 0.01。
+
+这时候，只需要在新的配置文件中，重新定义一下需要修改的字段即可。注意由于 optimizer 这个字段是一个字典，我们只需要重新定义这个字典里面需修改的下级字段即可。这个规则也适用于增加一些下级字段。
+
+`resnet50_lr0.01.py`：
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(lr=0.01)
+```
+
+读取这个配置文件之后，就可以得到期望的结果。
+
+```python
+cfg = Config.fromfile('resnet50_lr0.01.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.01, 'momentum': 0.9, 'weight_decay': 0.0001}
+```
+
+对于非字典类型的字段，例如整数，字符串，列表等，重新定义即可完全覆盖，例如下面的写法就将 `gpu_ids` 这个字段的值修改成了 `[0]`。
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+gpu_ids = [0]
+```
+
+### 删除字典中的 key
+
+有时候我们对于继承过来的字典类型字段，不仅仅是想修改其中某些 key，可能还需要删除其中的一些 key。这时候在重新定义这个字典时，需要指定 `_delete_=True`，表示将没有在新定义的字典中出现的 key 全部删除。
+
+`resnet50_delete_key.py`：
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(_delete_=True, type='SGD', lr=0.01)
+```
+
+这时候，`optimizer` 这个字典中就只有 `type` 和 `lr` 这两个 key，`momentum` 和 `weight_decay` 将不再被继承。
+
+```python
+cfg = Config.fromfile('resnet50_delete_key.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.01}
+```
+
+### 引用被继承文件中的变量
+
+有时我们想重复利用 `_base_` 中定义的字段内容，就可以通过 `{{_base_.xxxx}}` 获取来获取对应变量的拷贝。例如：
+
+`refer_base_var.py`
+
+```python
+_base_ = ['resnet50.py']
+a = {{_base_.model}}
+```
+
+解析后发现，`a` 的值变成了 `resnet50.py` 中定义的 `model`
+
+```python
+cfg = Config.fromfile('refer_base_var.py')
+print(cfg.a)
+```
+
+```
+{'type': 'ResNet', 'depth': 50}
+```
+
+我们可以在 `json`、`yaml`、`python` 三种类型的配置文件中，使用这种方式来获取 `_base_` 中定义的变量。
+
+尽管这种获取 `_base_` 中定义变量的方式非常通用，但是在语法上存在一些限制，无法充分利用 `python` 类配置文件的动态特性。比如我们想在 `python` 类配置文件中，修改 `_base_` 中定义的变量：
+
+```python
+_base_ = ['resnet50.py']
+a = {{_base_.model}}
+a['type'] = 'MobileNet'
+```
+
+配置类是无法解析这样的配置文件的（解析时报错）。配置类提供了一种更 `pythonic` 的方式，让我们能够在 `python` 类配置文件中修改 `_base_` 中定义的变量（`python` 类配置文件专属特性，目前不支持在 `json`、`yaml` 配置文件中修改 `_base_` 中定义的变量）。
+
+`modify_base_var.py`：
+
+```python
+_base_ = ['resnet50.py']
+a = _base_.model
+a.type = 'MobileNet'
+```
+
+```python
+cfg = Config.fromfile('modify_base_var.py')
+print(cfg.a)
+```
+
+```
+{'type': 'MobileNet', 'depth': 50}
+```
+
+解析后发现，`a` 的 type 变成了 `MobileNet`。
+
+## 配置文件的导出
+
+在启动训练脚本时，用户可能通过传参的方式来修改配置文件的部分字段，为此我们提供了 `dump` 接口来导出更改后的配置文件。与读取配置文件类似，用户可以通过 `cfg.dump('config.xxx')` 来选择导出文件的格式。`dump` 同样可以导出有继承关系的配置文件，导出的文件可以被独立使用，不再依赖于 `_base_` 中定义的文件。
+
+基于继承一节定义的 `resnet50.py`，我们将其加载后导出：
+
+```python
+cfg = Config.fromfile('resnet50.py')
+cfg.dump('resnet50_dump.py')
+```
+
+`resnet50_dump.py`
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+model = dict(type='ResNet', depth=50)
+```
+
+类似的，我们可以导出 json、yaml 格式的配置文件
+
+`resnet50_dump.yaml`
+
+```yaml
+model:
+ depth: 50
+ type: ResNet
+optimizer:
+ lr: 0.02
+ momentum: 0.9
+ type: SGD
+ weight_decay: 0.0001
+```
+
+`resnet50_dump.json`
+
+```json
+{"optimizer": {"type": "SGD", "lr": 0.02, "momentum": 0.9, "weight_decay": 0.0001}, "model": {"type": "ResNet", "depth": 50}}
+```
+
+此外，`dump` 不仅能导出加载自文件的 `cfg`，还能导出加载自字典的 `cfg`
+
+```python
+cfg = Config(dict(a=1, b=2))
+cfg.dump('dump_dict.py')
+```
+
+`dump_dict.py`
+
+```python
+a=1
+b=2
+```
+
+## 其他进阶用法
+
+这里介绍一下配置类的进阶用法，这些小技巧可能使用户开发和使用算法库更简单方便。
+
+```{note}
+需要注意的是，如果你用的是纯 Python 风格的配置文件，只有“命令行修改配置”一节中提到功能是有效的。
+```
+
+### 预定义字段
+
+```{note}
+该用法仅适用于非 `lazy_import` 模式，具体见纯 Python 风格的配置文件一节
+```
+
+有时候我们希望配置文件中的一些字段和当前路径或者文件名等相关，这里举一个典型使用场景的例子。在训练模型时，我们会在配置文件中定义一个工作目录，存放这组实验配置的模型和日志，那么对于不同的配置文件，我们期望定义不同的工作目录。用户的一种常见选择是，直接使用配置文件名作为工作目录名的一部分，例如对于配置文件 `predefined_var.py`，工作目录就是 `./work_dir/predefined_var`。
+
+使用预定义字段可以方便地实现这种需求，在配置文件 `predefined_var.py` 中可以这样写：
+
+```Python
+work_dir = './work_dir/{{fileBasenameNoExtension}}'
+```
+
+这里 `{{fileBasenameNoExtension}}` 表示该配置文件的文件名（不含拓展名），在配置类读取配置文件的时候，会将这种用双花括号包起来的字符串自动解析为对应的实际值。
+
+```python
+cfg = Config.fromfile('./predefined_var.py')
+print(cfg.work_dir)
+```
+
+```
+./work_dir/predefined_var
+```
+
+目前支持的预定义字段有以下四种，变量名参考自 [VS Code](https://code.visualstudio.com/docs/editor/variables-reference) 中的相关字段：
+
+- `{{fileDirname}}` - 当前文件的目录名，例如 `/home/your-username/your-project/folder`
+- `{{fileBasename}}` - 当前文件的文件名，例如 `file.py`
+- `{{fileBasenameNoExtension}}` - 当前文件不包含扩展名的文件名，例如 `file`
+- `{{fileExtname}}` - 当前文件的扩展名，例如 `.py`
+
+### 命令行修改配置
+
+有时候我们只希望修改部分配置，而不想修改配置文件本身，例如实验过程中想更换学习率，但是又不想重新写一个配置文件，常用的做法是在命令行传入参数来覆盖相关配置。考虑到我们想修改的配置通常是一些内层参数，如优化器的学习率、模型卷积层的通道数等，因此 MMEngine 提供了一套标准的流程，让我们能够在命令行里轻松修改配置文件中任意层级的参数。
+
+1. 使用 `argparse` 解析脚本运行的参数
+2. 使用 `argparse.ArgumentParser.add_argument` 方法时，让 `action` 参数的值为 [DictAction](mmengine.config.DictAction)，用它来进一步解析命令行参数中用于修改配置文件的参数
+3. 使用配置类的 `merge_from_dict` 方法来更新配置
+
+启动脚本示例如下：
+
+`demo_train.py`
+
+```python
+import argparse
+
+from mmengine.config import Config, DictAction
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description='Train a model')
+ parser.add_argument('config', help='train config file path')
+ parser.add_argument(
+ '--cfg-options',
+ nargs='+',
+ action=DictAction,
+ help='override some settings in the used config, the key-value pair '
+ 'in xxx=yyy format will be merged into config file. If the value to '
+ 'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+ 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+ 'Note that the quotation marks are necessary and that no white space '
+ 'is allowed.')
+
+ args = parser.parse_args()
+ return args
+
+
+def main():
+ args = parse_args()
+ cfg = Config.fromfile(args.config)
+ if args.cfg_options is not None:
+ cfg.merge_from_dict(args.cfg_options)
+ print(cfg)
+
+
+if __name__ == '__main__':
+ main()
+```
+
+示例配置文件如下：
+
+`example.py`
+
+```python
+model = dict(type='CustomModel', in_channels=[1, 2, 3])
+optimizer = dict(type='SGD', lr=0.01)
+```
+
+我们在命令行里通过 `.` 的方式来访问配置文件中的深层配置，例如我们想修改学习率，只需要在命令行执行：
+
+```bash
+python demo_train.py ./example.py --cfg-options optimizer.lr=0.1
+```
+
+```
+Config (path: ./example.py): {'model': {'type': 'CustomModel', 'in_channels': [1, 2, 3]}, 'optimizer': {'type': 'SGD', 'lr': 0.1}}
+```
+
+我们成功地把学习率从 0.01 修改成 0.1。如果想改变列表、元组类型的配置，如上例中的 `in_channels`，则需要在命令行赋值时给 `()`，`[]` 外加上双引号：
+
+```bash
+python demo_train.py ./example.py --cfg-options model.in_channels="[1, 1, 1]"
+```
+
+```
+Config (path: ./example.py): {'model': {'type': 'CustomModel', 'in_channels': [1, 1, 1]}, 'optimizer': {'type': 'SGD', 'lr': 0.01}}
+```
+
+`model.in_channels` 已经从 \[1, 2, 3\] 修改成 \[1, 1, 1\]。
+
+```{note}
+上述流程只支持在命令行里修改字符串、整型、浮点型、布尔型、None、列表、元组类型的配置项。对于列表、元组类型的配置，里面每个元素的类型也必须为上述七种类型之一。
+```
+
+:::{note}
+`DictAction` 的行为与 `"extend"` 相似，支持多次传递，并保存在同一个列表中。如
+
+```bash
+python demo_train.py ./example.py --cfg-options optimizer.type="Adam" --cfg-options model.in_channels="[1, 1, 1]"
+```
+
+```
+Config (path: ./example.py): {'model': {'type': 'CustomModel', 'in_channels': [1, 1, 1]}, 'optimizer': {'type': 'Adam', 'lr': 0.01}}
+```
+
+:::
+
+### 使用环境变量替换配置
+
+当要修改的配置嵌套很深时，我们在命令行中需要加上很长的前缀来进行定位。为了更方便地在命令行中修改配置，MMEngine 提供了一套通过环境变量来替换配置的方法。
+
+在解析配置文件之前，MMEngine 会搜索所有的 `{{$ENV_VAR:DEF_VAL}}` 字段，并使用特定的环境变量来替换这一部分。这里 `ENV_VAR` 为替换这一部分所用的环境变量，`DEF_VAL` 为没有设置环境变量时的默认值。
+
+例如，当我们想在命令行中修改数据集路径时，我们可以在配置文件 `replace_data_root.py` 中这样写：
+
+```python
+dataset_type = 'CocoDataset'
+data_root = '{{$DATASET:/data/coco/}}'
+dataset=dict(ann_file= data_root + 'train.json')
+```
+
+当我们运行 `demo_train.py` 来读取这个配置文件时：
+
+```bash
+python demo_train.py replace_data_root.py
+```
+
+```
+Config (path: replace_data_root.py): {'dataset_type': 'CocoDataset', 'data_root': '/data/coco/', 'dataset': {'ann_file': '/data/coco/train.json'}}
+```
+
+这里没有设置环境变量 `DATASET`, 程序直接使用默认值 `/data/coco/` 来替换 `{{$DATASET:/data/coco/}}`。如果在命令行前设置设置环境变量则会有如下结果：
+
+```bash
+DATASET=/new/dataset/path/ python demo_train.py replace_data_root.py
+```
+
+```
+Config (path: replace_data_root.py): {'dataset_type': 'CocoDataset', 'data_root': '/new/dataset/path/', 'dataset': {'ann_file': '/new/dataset/path/train.json'}}
+```
+
+`data_root` 被替换成了环境变量 `DATASET` 的值 `/new/dataset/path/`。
+
+值得注意的是，`--cfg-options` 与 `{{$ENV_VAR:DEF_VAL}}` 都可以在命令行改变配置文件的值，但他们还有一些区别。环境变量的替换发生在配置文件解析之前。如果该配置还参与到其他配置的定义时，环境变量替换也会影响到其他配置，而 `--cfg-options` 只会改变要修改的配置文件的值。
+
+我们以 `demo_train.py` 与 `replace_data_root.py` 为例。 如果我们通过配置 `--cfg-options data_root='/new/dataset/path'` 来修改 `data_root`：
+
+```bash
+python demo_train.py replace_data_root.py --cfg-options data_root='/new/dataset/path/'
+```
+
+```
+Config (path: replace_data_root.py): {'dataset_type': 'CocoDataset', 'data_root': '/new/dataset/path/', 'dataset': {'ann_file': '/data/coco/train.json'}}
+```
+
+从输出结果上看，只有 `data_root` 被修改为新的值。`dataset.ann_file` 依然保持原始值。
+
+作为对比，如果我们通过配置 `DATASET=/new/dataset/path` 来修改 `data_root`:
+
+```bash
+DATASET=/new/dataset/path/ python demo_train.py replace_data_root.py
+```
+
+```
+Config (path: replace_data_root.py): {'dataset_type': 'CocoDataset', 'data_root': '/new/dataset/path/', 'dataset': {'ann_file': '/new/dataset/path/train.json'}}
+```
+
+`data_root` 与 `dataset.ann_file` 同时被修改了。
+
+环境变量也可以用来替换字符串以外的配置，这时可以使用 `{{'$ENV_VAR:DEF_VAL'}}` 或者 `{{"$ENV_VAR:DEF_VAL"}}` 格式。`''` 与 `""` 用来保证配置文件合乎 python 语法。
+
+例如，当我们想替换模型预测的类别数时，可以在配置文件 `replace_num_classes.py` 中这样写：
+
+```
+model=dict(
+ bbox_head=dict(
+ num_classes={{'$NUM_CLASSES:80'}}))
+```
+
+当我们运行 `demo_train.py` 来读取这个配置文件时：
+
+```bash
+python demo_train.py replace_num_classes.py
+```
+
+```
+Config (path: replace_num_classes.py): {'model': {'bbox_head': {'num_classes': 80}}}
+```
+
+当设置 `NUM_CLASSES` 环境变量后：
+
+```bash
+NUM_CLASSES=20 python demo_train.py replace_num_classes.py
+```
+
+```
+Config (path: replace_num_classes.py): {'model': {'bbox_head': {'num_classes': 20}}}
+```
+
+### 导入自定义 Python 模块
+
+将配置与注册器结合起来使用时，如果我们往注册器中注册了一些自定义的类，就可能会遇到一些问题。因为读取配置文件的时候，这部分代码可能还没有被执行到，所以并未完成注册过程，从而导致构建自定义类的时候报错。
+
+例如我们新实现了一种优化器 `CustomOptim`，相应代码在 `my_module.py` 中。
+
+```python
+from mmengine.registry import OPTIMIZERS
+
+@OPTIMIZERS.register_module()
+class CustomOptim:
+ pass
+```
+
+我们为这个优化器的使用写了一个新的配置文件 `custom_imports.py`：
+
+```python
+optimizer = dict(type='CustomOptim')
+```
+
+那么就需要在读取配置文件和构造优化器之前，增加一行 `import my_module` 来保证将自定义的类 `CustomOptim` 注册到 OPTIMIZERS 注册器中：为了解决这个问题，我们给配置文件定义了一个保留字段 `custom_imports`，用于将需要提前导入的 Python 模块，直接写在配置文件中。对于上述例子，就可以将配置文件写成如下：
+
+`custom_imports.py`
+
+```python
+custom_imports = dict(imports=['my_module'], allow_failed_imports=False)
+optimizer = dict(type='CustomOptim')
+```
+
+这样我们就不用在训练代码中增加对应的 import 语句，只需要修改配置文件就可以实现非侵入式导入自定义注册模块。
+
+```python
+cfg = Config.fromfile('custom_imports.py')
+
+from mmengine.registry import OPTIMIZERS
+
+custom_optim = OPTIMIZERS.build(cfg.optimizer)
+print(custom_optim)
+```
+
+```
+
+```
+
+### 跨项目继承配置文件
+
+为了避免基于已有算法库开发新项目时需要复制大量的配置文件，MMEngine 的配置类支持配置文件的跨项目继承。例如我们基于 MMDetection 开发新的算法库，需要使用以下 MMDetection 的配置文件：
+
+```text
+configs/_base_/schedules/schedule_1x.py
+configs/_base_/datasets.coco_instance.py
+configs/_base_/default_runtime.py
+configs/_base_/models/faster-rcnn_r50_fpn.py
+```
+
+如果没有配置文件跨项目继承的功能，我们就需要把 MMDetection 的配置文件拷贝到当前项目，而我们现在只需要安装 MMDetection（如使用 `mim install mmdet`），在新项目的配置文件中按照以下方式继承 MMDetection 的配置文件：
+
+`cross_repo.py`
+
+```python
+_base_ = [
+ 'mmdet::_base_/schedules/schedule_1x.py',
+ 'mmdet::_base_/datasets/coco_instance.py',
+ 'mmdet::_base_/default_runtime.py',
+ 'mmdet::_base_/models/faster-rcnn_r50_fpn.py',
+]
+```
+
+我们可以像加载普通配置文件一样加载 `cross_repo.py`
+
+```python
+cfg = Config.fromfile('cross_repo.py')
+print(cfg.train_cfg)
+```
+
+```
+{'type': 'EpochBasedTrainLoop', 'max_epochs': 12, 'val_interval': 1, '_scope_': 'mmdet'}
+```
+
+通过指定 `mmdet::`，Config 类会去检索 mmdet 包中的配置文件目录，并继承指定的配置文件。实际上，只要算法库的 `setup.py` 文件符合 [MMEngine 安装规范](todo)，在正确安装算法库以后，新的项目就可以使用上述用法去继承已有算法库的配置文件而无需拷贝。
+
+### 跨项目获取配置文件
+
+MMEngine 还提供了 `get_config` 和 `get_model` 两个接口，支持对符合 [MMEngine 安装规范](todo) 的算法库中的模型和配置文件做索引并进行 API 调用。通过 `get_model` 接口可以获得构建好的模型。通过 `get_config` 接口可以获得配置文件。
+
+`get_model` 的使用样例如下所示，使用和跨项目继承配置文件相同的语法，指定 `mmdet::`，即可在 mmdet 包中检索对应的配置文件并构建和初始化相应模型。用户可以通过指定 `pretrained=True` 获得已经加载预训练权重的模型以进行训练或者推理。
+
+```python
+from mmengine.hub import get_model
+
+model = get_model(
+ 'mmdet::faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py', pretrained=True)
+print(type(model))
+```
+
+```
+http loads checkpoint from path: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
+
+```
+
+`get_config` 的使用样例如下所示，使用和跨项目继承配置文件相同的语法，指定 `mmdet::`，即可实现去 mmdet 包中检索并加载对应的配置文件。用户可以基于这样得到的配置文件进行推理修改并自定义自己的算法模型。同时，如果用户指定 `pretrained=True`，得到的配置文件中会新增 `model_path` 字段，指定了对应模型预训练权重的路径。
+
+```python
+from mmengine.hub import get_config
+
+cfg = get_config(
+ 'mmdet::faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py', pretrained=True)
+print(cfg.model_path)
+
+```
+
+```
+https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
+```
+
+## 纯 Python 风格的配置文件（Beta）
+
+在之前的教程里，我们介绍了如何使用配置文件，搭配注册器来构建模块；如何使用 `_base_` 来继承配置文件。这些纯文本风格的配置文件固然能够满足我们平时开发的大部分需求，并且一些模块的 alias 也大大简化了配置文件（例如 `ResNet` 就能指代 `mmcls.models.ResNet`）。但是也存在一些弊端：
+
+1. 配置文件中，type 字段是通过字符串来指定的，在 IDE 中无法直接跳转到对应的类定义处，不利于代码阅读和跳转
+2. 配置文件的继承，也是通过字符串来指定的，IDE 无法直接跳转到被继承的文件中，当配置文件继承结构复杂时，不利于配置文件的阅读和跳转
+3. 继承规则较为隐式，初学者很难理解配置文件是如何对相同字段的变量进行融合，且衍生出 `_delete_` 这类特殊语法，学习成本较高
+4. 用户忘记注册模块时，容易发生 module not found 的 error
+5. 在尚且没有提到的跨库继承中，scope 的引入导致配置文件的继承规则更加复杂，初学者很难理解
+
+综上所述，尽管纯文本风格的配置文件能够为 `python`、`json`、`yaml` 格式的配置提供相同的语法规则，但是当配置文件变得复杂时，纯文本风格的配置文件会显得力不从心。为此，我们提供了纯 Python 风格的配置文件，即 `lazy import` 模式，它能够充分利用 Python 的语法规则，解决上述问题。与此同时，纯 Python 风格的配置文件也支持导出成 `json` 和 `yaml` 格式。
+
+### 基本语法
+
+之前的教程分别介绍了基于纯文本风格配置文件的模块构建、继承和导出，本节将基于这三个方面来介绍纯 Python 风格的配置文件。
+
+#### 模块构建
+
+我们通过一个简单的例子来对比纯 Python 风格和纯文本风格的配置文件：
+
+```{eval-rst}
+.. tabs::
+ .. tabs::
+
+ .. code-tab:: python 纯 Python 风格
+
+ # 无需注册
+
+ .. code-tab:: python 纯文本风格
+
+ # 注册流程
+ from torch.optim import SGD
+ from mmengine.registry import OPTIMIZERS
+
+ OPTIMIZERS.register_module(module=SGD, name='SGD')
+
+ .. tabs::
+
+ .. code-tab:: python 纯 Python 风格
+
+ # 配置文件写法
+ from torch.optim import SGD
+
+
+ optimizer = dict(type=SGD, lr=0.1)
+
+ .. code-tab:: python 纯文本风格
+
+ # 配置文件写法
+ optimizer = dict(type='SGD', lr=0.1)
+
+ .. tabs::
+
+ .. code-tab:: python 纯 Python 风格
+
+ # 构建流程完全一致
+ import torch.nn as nn
+ from mmengine.registry import OPTIMIZERS
+
+
+ cfg = Config.fromfile('optimizer.py')
+ model = nn.Conv2d(1, 1, 1)
+ cfg.optimizer.params = model.parameters()
+ optimizer = OPTIMIZERS.build(cfg.optimizer)
+
+ .. code-tab:: python 纯文本风格
+
+ # 构建流程完全一致
+ import torch.nn as nn
+ from mmengine.registry import OPTIMIZERS
+
+
+ cfg = Config.fromfile('optimizer.py')
+ model = nn.Conv2d(1, 1, 1)
+ cfg.optimizer.params = model.parameters()
+ optimizer = OPTIMIZERS.build(cfg.optimizer)
+```
+
+从上面的例子可以看出，纯 Python 风格的配置文件和纯文本风格的配置文件的区别在于：
+
+1. 纯 Python 风格的配置文件无需注册模块
+2. 纯 Python 风格的配置文件中，type 字段不再是字符串，而是直接指代模块。相应的配置文件需要多出 import 语法
+
+需要注意的是，OpenMMLab 系列算法库在新增模块时仍会保留注册过程，用户基于 MMEngine 构建自己的项目时，如果使用纯 Python 风格的配置文件，则无需注册。看到这你会或许会好奇，这样没有安装 PyTorch 的环境不就没法解析样例配置文件了么，这样的配置文件还叫配置文件么？不要着急，这部分的内容我们会在后面介绍。
+
+#### 继承
+
+纯 Python 风格的配置文件继承语法有所不同：
+
+```{eval-rst}
+.. tabs::
+
+ .. code-tab:: python 纯 Python 风格继承
+
+ from mmengine.config import read_base
+
+
+ with read_base():
+ from .optimizer import *
+
+ .. code-tab:: python 纯文本风格继承
+
+ _base_ = [./optimizer.py]
+
+```
+
+纯 Python 风格的配置文件通过 import 语法来实现继承，这样做的好处是，我们可以直接跳转到被继承的配置文件中，方便阅读和跳转。变量的继承规则（增删改查）完全对齐 Python 语法，例如我想修改 base 配置文件中 optimizer 的学习率：
+
+```python
+from mmengine.config import read_base
+
+
+with read_base():
+ from .optimizer import *
+
+# optimizer 为 base 配置文件定义的变量
+optimizer.update(
+ lr=0.01,
+)
+```
+
+当然了，如果你已经习惯了纯文本风格的继承规则，且该变量在 _base_ 配置文件中为 `dict` 类型，也可以通过 merge 语法来实现和纯文本风格配置文件一致的继承规则：
+
+```python
+from mmengine.config import read_base
+
+
+with read_base():
+ from .optimizer import *
+
+# optimizer 为 base 配置文件定义的变量
+optimizer.merge(
+ _delete_=True,
+ lr=0.01,
+ type='SGD'
+)
+
+# 等价的 python 风格写法如下，与 Python 的 import 规则完全一致
+# optimizer = dict(
+# lr=0.01,
+# type='SGD'
+# )
+```
+
+````{note}
+需要注意的是，纯 Python 风格的配置文件中，字典的 `update` 方法与 `dict.update` 稍有不同。纯 Python 风格的 update 会递归地去更新字典中的内容，例如：
+
+```python
+x = dict(a=1, b=dict(c=2, d=3))
+
+x.update(dict(b=dict(d=4)))
+# 配置文件中的 update 规则：
+# {a: 1, b: {c: 2, d: 4}}
+# 普通 dict 的 update 规则：
+# {a: 1, b: {d: 4}}
+```
+
+可见在配置文件中使用 update 方法会递归地去更新字段，而不是简单的覆盖。
+````
+
+与纯文本风格的配置文件相比，纯 Python 风格的配置文件的继承规则完全对齐 import 语法，更容易理解，且支持配置文件之间的跳转。你或许会好奇既然继承和模块的导入都使用了 import 语法，为什么继承配置文件还需要额外的 `with read_base():` 这个上下文管理器呢？一方面这样可以提升配置文件的可读性，可以让继承的配置文件更加突出，另一方面也是受限于 lazy_import 的规则，这个会在后面讲到。
+
+#### 配置文件的导出
+
+纯 python 风格配置文件也通过 dump 接口导出，使用上没有任何区别，但是导出的内容会有所不同：
+
+```{eval-rst}
+.. tabs::
+
+ .. tabs::
+
+ .. code-tab:: python 纯 Python 风格导出
+
+ optimizer = dict(type='torch.optim.SGD', lr=0.1)
+
+ .. code-tab:: python 纯文本风格导出
+
+ optimizer = dict(type='SGD', lr=0.1)
+
+ .. tabs::
+
+ .. code-tab:: yaml 纯 Python 风格导出
+
+ optimizer:
+ type: torch.optim.SGD
+ lr: 0.1
+
+ .. code-tab:: yaml 纯文本风格导出
+
+ optimizer:
+ type: SGD
+ lr: 0.1
+
+ .. tabs::
+
+ .. code-tab:: json 纯 Python 风格导出
+
+ {"optimizer": "torch.optim.SGD", "lr": 0.1}
+
+ .. code-tab:: json 纯文本风格导出
+
+ {"optimizer": "SGD", "lr": 0.1}
+```
+
+可以看到，纯 Python 风格导出的 type 字段会包含模块的全量信息。导出的配置文件也可以被直接加载，通过注册器来构建实例。
+
+### 什么是 lazy import
+
+看到这你可能会吐槽，这纯 Python 风格的配置文件感觉就像是用纯 Python 语法来组织配置文件嘛。这样我哪还需要配置类，直接用 Python 语法来导入配置文件不就好了。如果你有这样的感受，那真是一件值得庆祝的事，因为这正是我们想要的效果。
+
+正如前面所提到的，解析配置文件需要依赖配置文件中引用的三方库，这其实是一件非常不合理的事。例如我基于 MMagic 训练了一个模型，想使用 MMDeploy 的 onnxruntime 后端部署。由于部署环境中没有 torch，而配置文件解析过程中需要 torch，这就导致了我无法直接使用 MMagic 的配置文件作为部署的配置，这是非常不方便的。为了解决这个问题，我们引入了 lazy_import 的概念。
+
+要聊 lazy_import 的具体实现是一件比较复杂的事，在此我们仅对其功能做简要介绍。lazy_import 的核心思想是，将配置文件中的 import 语句延迟到配置文件被解析时才执行，这样就可以避免配置文件中的 import 语句导致的三方库依赖问题。配置文件解析过程时，Python 解释器实际执行的等效代码如下
+
+```{eval-rst}
+.. tabs::
+ .. code-tab:: python 原始配置文件
+
+ from torch.optim import SGD
+
+
+ optimizer = dict(type=SGD)
+
+ .. code-tab:: python 通过配置类，Python 解释器实际执行的代码
+
+ lazy_obj = LazyObject('torch.optim', 'SGD')
+
+ optimizer = dict(type=lazy_obj)
+```
+
+LazyObject 作为 `Config` 模块的內部类型，无法被用户直接访问。用户在访问 type 字段时，会经过一系列的转换，将 `LazyObject` 转化成真正的 `torch.optim.SGD` 类型。这样一来，配置文件的解析不会触发三方库的导入，而用户使用配置文件时，又可以正常访问三方库的类型。
+
+要想访问 `LazyObject` 的内部类型，可以通过 `Config.to_dict` 接口：
+
+```python
+cfg = Config.fromfile('optimizer.py').to_dict()
+print(type(cfg['optimizer']['type']))
+# mmengine.config.lazy.LazyObject
+```
+
+此时得到的 type 就是 `LazyObject` 类型。
+
+然而对于 base 文件的继承（导入，import），我们不能够采取 lazy import 的策略，这是因为我们希望解析后的配置文件能够包含 base 配置文件定义的字段，需要真正的触发 import。因此我们对 base 文件的导入加了一层限制，即必须在 `with read_base()'` 的上下文中导入。
+
+### 功能限制
+
+1. 不能在配置文件中定义函数、类等
+2. 配置文件名必须符合 Python 模块名的命名规范，即只能包含字母、数字、下划线，且不能以数字开头
+3. 导入 base 配置文件中的变量时，例如 `from ._base_.alpha import beta`，此处的 `alpha` 必须是模块（module）名，即 Python 文件，而不能是含有 `__init__.py` 的包（package）名
+4. 不支持在 absolute import 语句中同时导入多个变量，例如 `import torch, numpy, os`。需要通过多个 import 语句来实现，例如 `import torch; import numpy; import os`
+
+### 迁移指南
+
+从纯文本风格的配置文件迁移到纯 Python 风格的配置文件，需要遵守以下规则：
+
+1. type 从字符串替换成具体的类：
+
+ - 代码不依赖 type 字段是字符串，且没有对 type 字段做特殊处理，则可以将字符串类型的 type 替换成具体的类，并在配置文件的开头导入该类
+ - 代码依赖 type 字段是字符串，则需要修改代码，或保持原有的字符串格式的 type
+
+2. 重命名配置文件，配置文件命名需要符合 Python 模块名的命名规范，即只能包含字母、数字、下划线，且不能以数字开头
+
+3. 删除 scope 相关配置。纯 Python 风格的配置文件不再需要通过 scope 来跨库调用模块，直接通过 import 导入即可。出于兼容性方面的考虑，我们仍然让 Runner 的 default_scope 参数为 `mmengine`，用户需要将其手动设置为 `None`
+
+4. 对于注册器中存在别名的（alias）的模块，将其别名替换成其对应的真实模块即可，以下是常用的别名替换表：
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/contributing.md b/internlm_langchain/knowledge_base/MMEngine/content/contributing.md
new file mode 100644
index 00000000..a5e52fd8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/contributing.md
@@ -0,0 +1,257 @@
+# 贡献代码
+
+欢迎加入 MMEngine 社区，我们致力于打造最前沿的深度学习模型训练的基础库，我们欢迎任何类型的贡献，包括但不限于
+
+**修复错误**
+
+修复代码实现错误的步骤如下：
+
+1. 如果提交的代码改动较大，建议先提交 issue，并正确描述 issue 的现象、原因和复现方式，讨论后确认修复方案。
+2. 修复错误并补充相应的单元测试，提交拉取请求。
+
+**新增功能或组件**
+
+1. 如果新功能或模块涉及较大的代码改动，建议先提交 issue，确认功能的必要性。
+2. 实现新增功能并添单元测试，提交拉取请求。
+
+**文档补充**
+
+修复文档可以直接提交拉取请求
+
+添加文档或将文档翻译成其他语言步骤如下
+
+1. 提交 issue，确认添加文档的必要性。
+2. 添加文档，提交拉取请求。
+
+## 拉取请求工作流
+
+如果你对拉取请求不了解，没关系，接下来的内容将会从零开始，一步一步地指引你如何创建一个拉取请求。如果你想深入了解拉取请求的开发模式，可以参考 github [官方文档](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests)
+
+### 1. 复刻仓库
+
+当你第一次提交拉取请求时，先复刻 OpenMMLab 原代码库，点击 GitHub 页面右上角的 **Fork** 按钮，复刻后的代码库将会出现在你的 GitHub 个人主页下。
+
+
+
+将代码克隆到本地
+
+```shell
+git clone git@github.com:{username}/mmengine.git
+```
+
+添加原代码库为上游代码库
+
+```bash
+git remote add upstream git@github.com:open-mmlab/mmengine
+```
+
+检查 remote 是否添加成功，在终端输入 `git remote -v`
+
+```bash
+origin git@github.com:{username}/mmengine.git (fetch)
+origin git@github.com:{username}/mmengine.git (push)
+upstream git@github.com:open-mmlab/mmengine (fetch)
+upstream git@github.com:open-mmlab/mmengine (push)
+```
+
+```{note}
+这里对 origin 和 upstream 进行一个简单的介绍，当我们使用 git clone 来克隆代码时，会默认创建一个 origin 的 remote，它指向我们克隆的代码库地址，而 upstream 则是我们自己添加的，用来指向原始代码库地址。当然如果你不喜欢他叫 upstream，也可以自己修改，比如叫 open-mmlab。我们通常向 origin 提交代码（即 fork 下来的远程仓库），然后向 upstream 提交一个 pull request。如果提交的代码和最新的代码发生冲突，再从 upstream 拉取最新的代码，和本地分支解决冲突，再提交到 origin。
+```
+
+### 2. 配置 pre-commit
+
+在本地开发环境中，我们使用 [pre-commit](https://pre-commit.com/#intro) 来检查代码风格，以确保代码风格的统一。在提交代码，需要先安装 pre-commit（需要在 mmengine 目录下执行）:
+
+```shell
+pip install -U pre-commit
+pre-commit install
+```
+
+检查 pre-commit 是否配置成功，并安装 `.pre-commit-config.yaml` 中的钩子：
+
+```shell
+pre-commit run --all-files
+```
+
+
+
+
+
+```{note}
+如果你是中国用户，由于网络原因，可能会出现安装失败的情况，这时可以使用国内源
+pre-commit install -c .pre-commit-config-zh-cn.yaml
+pre-commit run --all-files -c .pre-commit-config-zh-cn.yaml
+```
+
+如果安装过程被中断，可以重复执行 `pre-commit run ...` 继续安装。
+
+如果提交的代码不符合代码风格规范，pre-commit 会发出警告，并自动修复部分错误。
+
+
+
+如果我们想临时绕开 pre-commit 的检查提交一次代码，可以在 `git commit` 时加上 `--no-verify`（需要保证最后推送至远程仓库的代码能够通过 pre-commit 检查）。
+
+```shell
+git commit -m "xxx" --no-verify
+```
+
+### 3. 创建开发分支
+
+安装完 pre-commit 之后，我们需要基于 master 创建开发分支，建议的分支命名规则为 `username/pr_name`。
+
+```shell
+git checkout -b yhc/refactor_contributing_doc
+```
+
+在后续的开发中，如果本地仓库的 master 分支落后于 upstream 的 master 分支，我们需要先拉取 upstream 的代码进行同步，再执行上面的命令
+
+```shell
+git pull upstream master
+```
+
+### 4. 提交代码并在本地通过单元测试
+
+- MMEngine 引入了 mypy 来做静态类型检查，以增加代码的鲁棒性。因此我们在提交代码时，需要补充 Type Hints。具体规则可以参考[教程](https://zhuanlan.zhihu.com/p/519335398)。
+
+- 提交的代码同样需要通过单元测试
+
+ ```shell
+ # 通过全量单元测试
+ pytest tests
+
+ # 我们需要保证提交的代码能够通过修改模块的单元测试，以 runner 为例
+ pytest tests/test_runner/test_runner.py
+ ```
+
+ 如果你由于缺少依赖无法运行修改模块的单元测试，可以参考[指引-单元测试](#单元测试)
+
+- 如果修改/添加了文档，参考[指引](#文档渲染)确认文档渲染正常。
+
+### 5. 推送代码到远程
+
+代码通过单元测试和 pre-commit 检查后，将代码推送到远程仓库，如果是第一次推送，可以在 `git push` 后加上 `-u` 参数以关联远程分支
+
+```shell
+git push -u origin {branch_name}
+```
+
+这样下次就可以直接使用 `git push` 命令推送代码了，而无需指定分支和远程仓库。
+
+### 6. 提交拉取请求（PR）
+
+(1) 在 GitHub 的 Pull request 界面创建拉取请求
+
+
+(2) 根据指引修改 PR 描述，以便于其他开发者更好地理解你的修改
+
+
+
+描述规范详见[拉取请求规范](#拉取请求规范)
+
+
+
+**注意事项**
+
+(a) PR 描述应该包含修改理由、修改内容以及修改后带来的影响，并关联相关 Issue（具体方式见[文档](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)）
+
+(b) 如果是第一次为 OpenMMLab 做贡献，需要签署 CLA
+
+
+
+(c) 检查提交的 PR 是否通过 CI（集成测试）
+
+
+
+MMEngine 会在不同的平台（Linux、Window、Mac），基于不同版本的 Python、PyTorch、CUDA 对提交的代码进行单元测试，以保证代码的正确性，如果有任何一个没有通过，我们可点击上图中的 `Details` 来查看具体的测试信息，以便于我们修改代码。
+
+(3) 如果 PR 通过了 CI，那么就可以等待其他开发者的 review，并根据 reviewer 的意见，修改代码，并重复 [4](#4-提交代码并在本地通过单元测试)-[5](#5-推送代码到远程) 步骤，直到 reviewer 同意合入 PR。
+
+
+
+所有 reviewer 同意合入 PR 后，我们会尽快将 PR 合并到主分支。
+
+### 7. 解决冲突
+
+随着时间的推移，我们的代码库会不断更新，这时候，如果你的 PR 与主分支存在冲突，你需要解决冲突，解决冲突的方式有两种：
+
+```shell
+git fetch --all --prune
+git rebase upstream/master
+```
+
+或者
+
+```shell
+git fetch --all --prune
+git merge upstream/master
+```
+
+如果你非常善于处理冲突，那么可以使用 rebase 的方式来解决冲突，因为这能够保证你的 commit log 的整洁。如果你不太熟悉 `rebase` 的使用，那么可以使用 `merge` 的方式来解决冲突。
+
+## 指引
+
+### 单元测试
+
+在提交修复代码错误或新增特性的拉取请求时，我们应该尽可能的让单元测试覆盖所有提交的代码，计算单元测试覆盖率的方法如下
+
+```shell
+python -m coverage run -m pytest /path/to/test_file
+python -m coverage html
+# check file in htmlcov/index.html
+```
+
+### 文档渲染
+
+在提交修复代码错误或新增特性的拉取请求时，可能会需要修改/新增模块的 docstring。我们需要确认渲染后的文档样式是正确的。
+本地生成渲染后的文档的方法如下
+
+```shell
+pip install -r requirements/docs.txt
+cd docs/zh_cn/
+# or docs/en
+make html
+# check file in ./docs/zh_cn/_build/html/index.html
+```
+
+## Python 代码风格
+
+[PEP8](https://www.python.org/dev/peps/pep-0008/) 作为 OpenMMLab 算法库首选的代码规范，我们使用以下工具检查和格式化代码
+
+- [flake8](https://github.com/PyCQA/flake8): Python 官方发布的代码规范检查工具，是多个检查工具的封装
+- [isort](https://github.com/timothycrosley/isort): 自动调整模块导入顺序的工具
+- [yapf](https://github.com/google/yapf): Google 发布的代码规范检查工具
+- [codespell](https://github.com/codespell-project/codespell): 检查单词拼写是否有误
+- [mdformat](https://github.com/executablebooks/mdformat): 检查 markdown 文件的工具
+- [docformatter](https://github.com/myint/docformatter): 格式化 docstring 的工具
+
+yapf 和 isort 的配置可以在 [setup.cfg](https://github.com/open-mmlab/mmengine/blob/main/setup.cfg) 找到
+
+通过配置 [pre-commit hook](https://pre-commit.com/) ，我们可以在提交代码时自动检查和格式化 `flake8`、`yapf`、`isort`、`trailing whitespaces`、`markdown files`，修复 `end-of-files`、`double-quoted-strings`、`python-encoding-pragma`、`mixed-line-ending`，调整 `requirments.txt` 的包顺序。
+pre-commit 钩子的配置可以在 [.pre-commit-config](https://github.com/open-mmlab/mmengine/blob/main/.pre-commit-config-zh-cn.yaml) 找到。
+
+pre-commit 具体的安装使用方式见[拉取请求](#2-配置-pre-commit)。
+
+更具体的规范请参考 [OpenMMLab 代码规范](code_style.md)。
+
+## 拉取请求规范
+
+1. 使用 [pre-commit hook](https://pre-commit.com)，尽量减少代码风格相关问题
+
+2. 一个`拉取请求`对应一个短期分支
+
+3. 粒度要细，一个`拉取请求`只做一件事情，避免超大的`拉取请求`
+
+ - Bad：实现 Faster R-CNN
+ - Acceptable：给 Faster R-CNN 添加一个 box head
+ - Good：给 box head 增加一个参数来支持自定义的 conv 层数
+
+4. 每次 Commit 时需要提供清晰且有意义 commit 信息
+
+5. 提供清晰且有意义的`拉取请求`描述
+
+ - 标题写明白任务名称，一般格式:\[Prefix\] Short description of the pull request (Suffix)
+ - prefix: 新增功能 \[Feature\], 修 bug \[Fix\], 文档相关 \[Docs\], 开发中 \[WIP\] (暂时不会被review)
+ - 描述里介绍`拉取请求`的主要修改内容，结果，以及对其他部分的影响, 参考`拉取请求`模板
+ - 关联相关的`议题` (issue) 和其他`拉取请求`
+
+6. 如果引入了其他三方库，或借鉴了三方库的代码，请确认他们的许可证和 MMEngine 兼容，并在借鉴的代码上补充 `This code is inspired from http://`
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/cross_library.md b/internlm_langchain/knowledge_base/MMEngine/content/cross_library.md
new file mode 100644
index 00000000..a70dc728
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/cross_library.md
@@ -0,0 +1,94 @@
+# 跨库调用模块
+
+通过使用 MMEngine 的[注册器（Registry）](registry.md)和[配置文件（Config）](config.md)，用户可以实现跨软件包的模块构建。
+例如，在 [MMDetection](https://github.com/open-mmlab/mmdetection) 中使用 [MMPretrain](https://github.com/open-mmlab/mmpretrain) 的 Backbone，或者在 [MMRotate](https://github.com/open-mmlab/mmrotate) 中使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 的 Transform，或者在 [MMTracking](https://github.com/open-mmlab/mmtracking) 中使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 的 Detector。
+一般来说，同类模块都可以进行跨库调用，只需要在配置文件的模块类型前加上软件包名的前缀即可。下面举几个常见的例子：
+
+## 跨库调用 Backbone:
+
+以在 MMDetection 中调用 MMPretrain 的 ConvNeXt 为例，首先需要在配置中加入 `custom_imports` 字段将 MMPretrain 的 Backbone 添加进注册器，然后只需要在 Backbone 的配置中的 `type` 加上 MMPretrain 的软件包名 `mmpretrain` 作为前缀，即 `mmpretrain.ConvNeXt` 即可：
+
+```python
+# 使用 custom_imports 将 mmpretrain 的 models 添加进注册器
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+
+model = dict(
+ type='MaskRCNN',
+ data_preprocessor=dict(...),
+ backbone=dict(
+ type='mmpretrain.ConvNeXt', # 添加 mmpretrain 前缀完成跨库调用
+ arch='tiny',
+ out_indices=[0, 1, 2, 3],
+ drop_path_rate=0.4,
+ layer_scale_init_value=1.0,
+ gap_before_final_norm=False,
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint=
+ 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth',
+ prefix='backbone.')),
+ neck=dict(...),
+ rpn_head=dict(...))
+```
+
+## 跨库调用 Transform:
+
+与上文的跨库调用 Backbone 一样，使用 custom_imports 和添加前缀即可实现跨库调用：
+
+```python
+# 使用 custom_imports 将 mmdet 的 transforms 添加进注册器
+custom_imports = dict(imports=['mmdet.datasets.transforms'], allow_failed_imports=False)
+
+# 添加 mmdet 前缀完成跨库调用
+train_pipeline=[
+ dict(type='mmdet.LoadImageFromFile'),
+ dict(type='mmdet.LoadAnnotations', with_bbox=True, box_type='qbox'),
+ dict(type='ConvertBoxType', box_type_mapping=dict(gt_bboxes='rbox')),
+ dict(type='mmdet.Resize', scale=(1024, 2014), keep_ratio=True),
+ dict(type='mmdet.RandomFlip', prob=0.5),
+ dict(type='mmdet.PackDetInputs')
+]
+```
+
+## 跨库调用 Detector:
+
+跨库调用算法是一个比较复杂的例子，一个算法会包含多个子模块，因此每个子模块也需要在`type`中增加前缀，以在 MMTracking 中调用 MMDetection 的 YOLOX 为例：
+
+```python
+# 使用 custom_imports 将 mmdet 的 models 添加进注册器
+custom_imports = dict(imports=['mmdet.models'], allow_failed_imports=False)
+model = dict(
+ type='mmdet.YOLOX',
+ backbone=dict(type='mmdet.CSPDarknet', deepen_factor=1.33, widen_factor=1.25),
+ neck=dict(
+ type='mmdet.YOLOXPAFPN',
+ in_channels=[320, 640, 1280],
+ out_channels=320,
+ num_csp_blocks=4),
+ bbox_head=dict(
+ type='mmdet.YOLOXHead', num_classes=1, in_channels=320, feat_channels=320),
+ train_cfg=dict(assigner=dict(type='mmdet.SimOTAAssigner', center_radius=2.5)))
+```
+
+为了避免给每个子模块手动增加前缀，配置文件中引入了 `_scope_` 关键字，当某一模块的配置中添加了 `_scope_` 关键字后，该模块配置文件下面的所有子模块配置都会从该关键字所对应的软件包内去构建：
+
+```python
+# 使用 custom_imports 将 mmdet 的 models 添加进注册器
+custom_imports = dict(imports=['mmdet.models'], allow_failed_imports=False)
+model = dict(
+ _scope_='mmdet', # 使用 _scope_ 关键字，避免给所有子模块添加前缀
+ type='YOLOX',
+ backbone=dict(type='CSPDarknet', deepen_factor=1.33, widen_factor=1.25),
+ neck=dict(
+ type='YOLOXPAFPN',
+ in_channels=[320, 640, 1280],
+ out_channels=320,
+ num_csp_blocks=4),
+ bbox_head=dict(
+ type='YOLOXHead', num_classes=1, in_channels=320, feat_channels=320),
+ train_cfg=dict(assigner=dict(type='SimOTAAssigner', center_radius=2.5)))
+```
+
+以上这两种写法互相等价。
+
+若希望了解更多关于注册器和配置文件的内容，请参考[配置文件教程](config.md)和[注册器教程](registry.md)
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/data_element.md b/internlm_langchain/knowledge_base/MMEngine/content/data_element.md
new file mode 100644
index 00000000..7574a925
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/data_element.md
@@ -0,0 +1,1098 @@
+# 抽象数据接口
+
+在模型的训练/测试过程中，组件之间往往有大量的数据需要传递，不同的算法需要传递的数据经常是不一样的，例如，训练单阶段检测器需要获得数据集的标注框（ground truth bounding boxes）和标签（ground truth box labels），训练 Mask R-CNN 时还需要实例掩码（instance masks）。
+训练这些模型时的代码如下所示
+
+```python
+for img, img_metas, gt_bboxes, gt_labels in data_loader:
+ loss = retinanet(img, img_metas, gt_bboxes, gt_labels)
+```
+
+```python
+for img, img_metas, gt_bboxes, gt_masks, gt_labels in data_loader:
+ loss = mask_rcnn(img, img_metas, gt_bboxes, gt_masks, gt_labels)
+```
+
+可以发现，在不加封装的情况下，不同算法所需数据的不一致导致了不同算法模块之间接口的不一致，影响了算法库的拓展性，同时一个算法库内的模块为了保持兼容性往往在接口上存在冗余。
+上述弊端在算法库之间会体现地更加明显，导致在实现多任务（同时进行如语义分割、检测、关键点检测等多个任务）感知模型时模块难以复用，接口难以拓展。
+
+为了解决上述问题，MMEngine 定义了一套抽象的数据接口来封装模型运行过程中的各种数据。假设将上述不同的数据封装进 `data_sample` ，不同算法的训练都可以被抽象和统一成如下代码
+
+```python
+for img, data_sample in dataloader:
+ loss = model(img, data_sample)
+```
+
+通过对各种数据提供统一的封装，抽象数据接口统一并简化了算法库中各个模块的接口，可以被用于算法库中 dataset，model，visualizer，和 evaluator 组件之间，或者 model 内各个模块之间的数据传递。
+抽象数据接口实现了基本的增/删/改/查功能，同时支持不同设备之间的迁移，支持类字典和张量的操作，可以充分满足算法库对于这些数据的使用要求。
+基于 MMEngine 的算法库可以继承这套抽象数据接口并实现自己的抽象数据接口来适应不同算法中数据的特点与实际需要，在保持统一接口的同时提高了算法模块的拓展性。
+
+在实际实现过程中，算法库中的各个组件所具备的数据接口，一般为以下两种：
+
+- 一个训练或测试样本（例如一张图像）的所有的标注信息和预测信息的集合，例如数据集的输出、模型以及可视化器的输入一般为单个训练或测试样本的所有信息。MMEngine 将其定义为数据样本（DataSample）
+- 单一类型的预测或标注，一般是算法模型中某个子模块的输出, 例如二阶段检测中RPN的输出、语义分割模型的输出、关键点分支的输出，GAN中生成器的输出等。MMEngine 将其定义为数据元素（XXXData）
+
+下边首先介绍一下数据样本与数据元素的基类 [BaseDataElement](mmengine.structures.BaseDataElement)。
+
+## 数据基类(BaseDataElement)
+
+`BaseDataElement` 中存在两种类型的数据，一种是 `data` 类型，如标注框、框的标签、和实例掩码等；另一种是 `metainfo` 类型，包含数据的元信息以确保数据的完整性，如 `img_shape`, `img_id` 等数据所在图片的一些基本信息，方便可视化等情况下对数据进行恢复和使用。用户在创建 `BaseDataElement` 的过程中需要对这两类属性的数据进行显式地区分和声明。
+
+为了能够更加方便地使用 `BaseDataElement`，`data` 和 `metainfo` 中的数据均为 `BaseDataElement` 的属性。我们可以通过访问类属性的方式直接访问 `data` 和 `metainfo` 中的数据。此外，`BaseDataElement` 还提供了很多方法，方便我们操作 `data` 内的数据：
+
+- 增/删/改/查 `data` 中不同字段的数据
+- 将 `data` 迁移至目标设备
+- 支持像访问字典/张量一样访问 data 内的数据以充分满足算法库对于这些数据的使用要求。
+
+### 1. 数据元素的创建
+
+`BaseDataElement` 的 data 参数可以直接通过 `key=value` 的方式自由添加，metainfo 的字段需要显式通过关键字 `metainfo` 指定。
+
+```python
+import torch
+from mmengine.structures import BaseDataElement
+# 可以声明一个空的 object
+data_element = BaseDataElement()
+
+bboxes = torch.rand((5, 4)) # 假定 bboxes 是一个 Nx4 维的 tensor，N 代表框的个数
+scores = torch.rand((5,)) # 假定框的分数是一个 N 维的 tensor，N 代表框的个数
+img_id = 0 # 图像的 ID
+H = 800 # 图像的高度
+W = 1333 # 图像的宽度
+
+# 直接设置 BaseDataElement 的 data 参数
+data_element = BaseDataElement(bboxes=bboxes, scores=scores)
+
+# 显式声明来设置 BaseDataElement 的参数 metainfo
+data_element = BaseDataElement(
+ bboxes=bboxes,
+ scores=scores,
+ metainfo=dict(img_id=img_id, img_shape=(H, W)))
+```
+
+### 2. `new` 与 `clone` 函数
+
+用户可以使用 `new()` 方法基于已有的 `BaseDataElement` 创建一个具有相同 `data` 和 `metainfo` 的 `BaseDataElement`。用户也可以在调用 `new` 方法时传入新的 `data` 和 `metainfo`，例如 `new(metainfo=xx)` ，此时创建的 `BaseDataElement` 相较于已有的 `BaseDataElement`，`data` 完全一致 ，而 `metainfo` 则为新设置的内容。
+也可以直接使用 `clone()` 来获得一份深拷贝，`clone()` 函数的行为与 PyTorch 中 Tensor 的 `clone()` 参数保持一致。
+
+```python
+data_element = BaseDataElement(
+ bboxes=torch.rand((5, 4)),
+ scores=torch.rand((5,)),
+ metainfo=dict(img_id=1, img_shape=(640, 640)))
+
+# 可以在创建新 `BaseDataElement` 时设置 metainfo 和 data，使得新的 BaseDataElement 有相同未被设置的数据
+data_element1 = data_element.new(metainfo=dict(img_id=2, img_shape=(320, 320)))
+print('bboxes is in data_element1:', 'bboxes' in data_element1) # True
+print('bboxes in data_element1 is same as bbox in data_element', (data_element1.bboxes == data_element.bboxes).all())
+print('img_id in data_element1 is', data_element1.img_id == 2) # True
+
+data_element2 = data_element.new(label=torch.rand(5,))
+print('bboxes is not in data_element2', 'bboxes' not in data_element2) # True
+print('img_id in data_element2 is same as img_id in data_element', data_element2.img_id == data_element.img_id)
+print('label in data_element2 is', 'label' in data_element2)
+
+# 也可以通过 `clone` 构建一个新的 object，新的 object 会拥有和 data_element 相同的 data 和 metainfo 内容以及状态。
+data_element2 = data_element1.clone()
+```
+
+```
+bboxes is in data_element1: True
+bboxes in data_element1 is same as bbox in data_element tensor(True)
+img_id in data_element1 is True
+bboxes is not in data_element2 True
+img_id in data_element2 is same as img_id in data_element True
+label in data_element2 is True
+```
+
+### 3. 属性的增加与查询
+
+对增加属性而言，用户可以像增加类属性那样增加 `data` 内的属性；对 `metainfo` 而言，一般储存的为一些图像的元信息，一般情况下不会修改，如果需要增加，用户应当使用 `set_metainfo` 接口显示地修改。
+
+对查询而言，用户可以可以通过 `keys`，`values`，和 `items` 来访问只存在于 data 中的键值，也可以通过 `metainfo_keys`，`metainfo_values`，和`metainfo_items` 来访问只存在于 metainfo 中的键值。
+用户还能通过 `all_keys`，`all_values`， `all_items` 来访问 `BaseDataElement` 的所有的属性并且不区分他们的类型。
+
+同时为了方便使用，用户可以像访问类属性一样访问 data 与 metainfo 内的数据，或着类字典方式通过 `get()` 接口访问数据。
+
+**注意：**
+
+1. `BaseDataElement` 不支持 metainfo 和 data 属性中有同名的字段，所以用户应当避免 metainfo 和 data 属性中设置相同的字段，否则 `BaseDataElement` 会报错。
+2. 考虑到 `InstanceData` 和 `PixelData` 支持对数据进行切片操作，为了避免 `[]` 用法的不一致，同时减少同种需求的不同方法，`BaseDataElement` 不支持像字典那样访问和设置它的属性，所以类似 `BaseDataElement[name]` 的取值赋值操作是不被支持的。
+
+```python
+data_element = BaseDataElement()
+# 通过 `set_metainfo`设置 data_element 的 metainfo 字段，
+# 同时 img_id 和 img_shape 成为 data_element 的属性
+data_element.set_metainfo(dict(img_id=9, img_shape=(100, 100)))
+# 查看 metainfo 的 key, value 和 item
+print("metainfo'keys are", data_element.metainfo_keys())
+print("metainfo'values are", data_element.metainfo_values())
+for k, v in data_element.metainfo_items():
+ print(f'{k}: {v}')
+
+print("通过类属性查看 img_id 和 img_shape")
+print('img_id:', data_element.img_id)
+print('img_shape:', data_element.img_shape)
+```
+
+```
+metainfo'keys are ['img_id', 'img_shape']
+metainfo'values are [9, (100, 100)]
+img_id: 9
+img_shape: (100, 100)
+通过类属性查看 img_id 和 img_shape
+img_id: 9
+img_shape: (100, 100)
+```
+
+```python
+
+# 通过类属性直接设置 BaseDataElement 中的 data 字段
+data_element.scores = torch.rand((5,))
+data_element.bboxes = torch.rand((5, 4))
+
+print("data's key is:", data_element.keys())
+print("data's value is:", data_element.values())
+for k, v in data_element.items():
+ print(f'{k}: {v}')
+
+print("通过类属性查看 scores 和 bboxes")
+print('scores:', data_element.scores)
+print('bboxes:', data_element.bboxes)
+
+print("通过 get() 查看 scores 和 bboxes")
+print('scores:', data_element.get('scores', None))
+print('bboxes:', data_element.get('bboxes', None))
+print('fake:', data_element.get('fake', 'not exist'))
+```
+
+```
+data's key is: ['scores', 'bboxes']
+data's value is: [tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515]), tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])]
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+通过类属性查看 scores 和 bboxes
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+通过 get() 查看 scores 和 bboxes
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+fake: not exist
+```
+
+```python
+
+print("All key in data_element is:", data_element.all_keys())
+print("The length of values in data_element is", len(data_element.all_values()))
+for k, v in data_element.all_items():
+ print(f'{k}: {v}')
+```
+
+```
+All key in data_element is: ['img_id', 'img_shape', 'scores', 'bboxes']
+The length of values in data_element is 4
+img_id: 9
+img_shape: (100, 100)
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+```
+
+### 4. 属性的删改
+
+用户可以像修改实例属性一样修改 `BaseDataElement` 的 `data`, 对`metainfo` 而言，一般储存的为一些图像的元信息，一般情况下不会修改，如果需要修改，用户应当使用 `set_metainfo` 接口显示的修改。
+
+同时为了操作的便捷性，对 `data` 和 `metainfo` 中的数据可以通过 `del` 直接删除，也支持 `pop` 在访问属性后删除属性。
+
+```python
+data_element = BaseDataElement(
+ bboxes=torch.rand((6, 4)), scores=torch.rand((6,)),
+ metainfo=dict(img_id=0, img_shape=(640, 640))
+)
+for k, v in data_element.all_items():
+ print(f'{k}: {v}')
+```
+
+```
+img_id: 0
+img_shape: (640, 640)
+scores: tensor([0.8445, 0.6678, 0.8172, 0.9125, 0.7186, 0.5462])
+bboxes: tensor([[0.5773, 0.0289, 0.4793, 0.7573],
+ [0.8187, 0.8176, 0.3455, 0.3368],
+ [0.6947, 0.5592, 0.7285, 0.0281],
+ [0.7710, 0.9867, 0.7172, 0.5815],
+ [0.3999, 0.9192, 0.7817, 0.2535],
+ [0.2433, 0.0132, 0.1757, 0.6196]])
+```
+
+```python
+# 对 data 进行修改
+data_element.bboxes = data_element.bboxes * 2
+data_element.scores = data_element.scores * -1
+for k, v in data_element.items():
+ print(f'{k}: {v}')
+
+# 删除 data 中的属性
+del data_element.bboxes
+for k, v in data_element.items():
+ print(f'{k}: {v}')
+
+data_element.pop('scores', None)
+print('The keys in data is', data_element.keys())
+```
+
+```
+scores: tensor([-0.8445, -0.6678, -0.8172, -0.9125, -0.7186, -0.5462])
+bboxes: tensor([[1.1546, 0.0578, 0.9586, 1.5146],
+ [1.6374, 1.6352, 0.6911, 0.6735],
+ [1.3893, 1.1185, 1.4569, 0.0562],
+ [1.5420, 1.9734, 1.4344, 1.1630],
+ [0.7999, 1.8384, 1.5635, 0.5070],
+ [0.4867, 0.0264, 0.3514, 1.2392]])
+scores: tensor([-0.8445, -0.6678, -0.8172, -0.9125, -0.7186, -0.5462])
+The keys in data is []
+```
+
+```python
+# 对 metainfo 进行修改
+data_element.set_metainfo(dict(img_shape = (1280, 1280), img_id=10))
+print(data_element.img_shape) # (1280, 1280)
+for k, v in data_element.metainfo_items():
+ print(f'{k}: {v}')
+
+# 提供了便捷的属性删除和访问操作 pop
+del data_element.img_shape
+for k, v in data_element.metainfo_items():
+ print(f'{k}: {v}')
+
+data_element.pop('img_id')
+print('The keys in metainfo is', data_element.metainfo_keys())
+```
+
+```
+(1280, 1280)
+img_id: 10
+img_shape: (1280, 1280)
+img_id: 10
+The keys in metainfo is []
+```
+
+### 5. 类张量操作
+
+用户可以像 torch.Tensor 那样对 `BaseDataElement` 的 data 进行状态转换，目前支持 `cuda`， `cpu`， `to`， `numpy` 等操作。
+其中，`to` 函数拥有和 `torch.Tensor.to()` 相同的接口，使得用户可以灵活地将被封装的 tensor 进行状态转换。
+**注意：** 这些接口只会处理类型为 np.array，torch.Tensor，或者数字的序列，其他属性的数据（如字符串）会被跳过处理。
+
+```python
+data_element = BaseDataElement(
+ bboxes=torch.rand((6, 4)), scores=torch.rand((6,)),
+ metainfo=dict(img_id=0, img_shape=(640, 640))
+)
+# 将所有 data 转移到 GPU 上
+cuda_element_1 = data_element.cuda()
+print('cuda_element_1 is on the device of', cuda_element_1.bboxes.device) # cuda:0
+cuda_element_2 = data_element.to('cuda:0')
+print('cuda_element_1 is on the device of', cuda_element_2.bboxes.device) # cuda:0
+
+# 将所有 data 转移到 cpu 上
+cpu_element_1 = cuda_element_1.cpu()
+print('cpu_element_1 is on the device of', cpu_element_1.bboxes.device) # cpu
+cpu_element_2 = cuda_element_2.to('cpu')
+print('cpu_element_2 is on the device of', cpu_element_2.bboxes.device) # cpu
+
+# 将所有 data 变成 FP16
+fp16_instances = cuda_element_1.to(
+ device=None, dtype=torch.float16, non_blocking=False, copy=False,
+ memory_format=torch.preserve_format)
+print('The type of bboxes in fp16_instances is', fp16_instances.bboxes.dtype) # torch.float16
+
+# 阻断所有 data 的梯度
+cuda_element_3 = cuda_element_2.detach()
+print('The data in cuda_element_3 requires grad: ', cuda_element_3.bboxes.requires_grad)
+# 转移 data 到 numpy array
+np_instances = cpu_element_1.numpy()
+print('The type of cpu_element_1 is convert to', type(np_instances.bboxes))
+```
+
+```
+cuda_element_1 is on the device of cuda:0
+cuda_element_1 is on the device of cuda:0
+cpu_element_1 is on the device of cpu
+cpu_element_2 is on the device of cpu
+The type of bboxes in fp16_instances is torch.float16
+The data in cuda_element_3 requires grad: False
+The type of cpu_element_1 is convert to
+```
+
+### 6. 属性的展示
+
+`BaseDataElement` 还实现了 `__repr__`，因此，用户可以直接通过 `print` 函数看到其中的所有数据信息。
+同时，为了便捷开发者 debug，`BaseDataElement` 中的属性都会添加进 `__dict__` 中，方便用户在 IDE 界面可以直观看到 `BaseDataElement` 中的内容。
+一个完整的属性展示如下
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = BaseDataElement(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([0, 1, 2, 3])
+instance_data.det_scores = torch.Tensor([0.01, 0.1, 0.2, 0.3])
+print(instance_data)
+```
+
+```
+
+```
+
+## 数据元素(xxxData)
+
+MMEngine 将数据元素情况划分为三个类别：
+
+- 实例数据 (InstanceData) : 主要针对的是上层任务 (high-level) 中，对图像中所有实例相关的数据进行封装，比如检测框 (bounding boxes)，物体类别 (box labels)，实例掩码 (instance masks)，关键点 (key points)，文字边界 (polygons)，跟踪 id (tracking ids) 等。所有实例相关的数据的**长度一致**，均为图像中实例的个数。
+- 像素数据 (PixelData) : 主要针对底层任务 (low-level) 以及需要感知像素级别标签的部分上层任务。像素数据对像素级相关的数据进行封装，比如语义分割中的分割图 (segmentation map), 光流任务中的光流图 (flow map), 全景分割中的全景分割图 (panoptic seg map)；底层任务中生成的各种图像，比如超分辨图，去噪图，以及生成的各种风格图。这些数据的特点是都是三维或四维数组，最后两维度为数据的高度 (height) 和宽度 (width)，且具有相同的 height 和 width
+- 标签数据 (LabelData) : 主要针对标签级别的数据进行封装，比如图像分类，多分类中的类别，图像生成中生成图像的类别内容，或者文字识别中的文本等。
+
+### InstanceData
+
+[`InstanceData`](mmengine.structures.InstanceData) 在 `BaseDataElement` 的基础上对 `data` 存储的数据做了限制，要求存储在 `data` 中的数据的长度一致。比如在目标检测中, 假设一张图像中有 N 个目标 (instance)，可以将图像的所有边界框 (bbox)，类别 (label) 等存储在 `InstanceData` 中, `InstanceData` 的 bbox 和 label 的长度相同。
+MMEngine 对 `InstanceData` 加入了如下支持：
+
+- 对 `InstanceData` 中 data 所存储的数据进行了长度校验
+- data 部分支持类字典访问和设置它的属性
+- 支持基础索引，切片以及高级索引功能
+- 支持具有**相同的 `key`** 但是不同的 `InstanceData` 进行拼接的功能。
+
+这些扩展功能除了支持基础的数据结构， 比如 `torch.tensor`, `numpy.dnarray`, `list`, `str` 和 `tuple`, 也可以是自定义的数据结构，只要自定义数据结构实现了 `__len__`, `__getitem__` 和 `cat` 方法。
+
+#### 数据校验
+
+`InstanceData` 中 data 的数据长度要保持一致，如果传入不同长度的新数据，将会报错。
+
+```python
+from mmengine.structures import InstanceData
+import torch
+import numpy as np
+
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data.det_scores = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print('The length of instance_data is', len(instance_data)) # 2
+
+instance_data.bboxes = torch.rand((3, 4))
+```
+
+```
+The length of instance_data is 2
+AssertionError: the length of values 3 is not consistent with the length of this :obj:`InstanceData` 2
+```
+
+#### 类字典访问和设置属性
+
+`InstanceData` 支持类似字典的操作访问和设置其 **data** 属性。
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data["det_labels"] = torch.LongTensor([2, 3])
+instance_data["det_scores"] = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print(instance_data)
+```
+
+```
+
+```
+
+#### 索引与切片
+
+`InstanceData` 支持 Python 中类似列表的索引与切片，同时也支持类似 numpy 的高级索引操作。
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data.det_scores = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print(instance_data)
+```
+
+```
+
+```
+
+1. 索引
+
+```python
+print(instance_data[1])
+```
+
+```
+
+```
+
+2. 切片
+
+```python
+print(instance_data[0:1])
+```
+
+```
+
+```
+
+3. 高级索引
+
+- 列表索引
+
+```python
+sorted_results = instance_data[instance_data.det_scores.sort().indices]
+print(sorted_results)
+```
+
+```
+
+```
+
+- 布尔索引
+
+```python
+filter_results = instance_data[instance_data.det_scores > 0.75]
+print(filter_results)
+```
+
+```
+
+```
+
+4. 结果为空
+
+```python
+empty_results = instance_data[instance_data.det_scores > 1]
+print(empty_results)
+```
+
+```
+
+```
+
+#### 拼接(cat)
+
+用户可以将两个具有相同 key 的 `InstanceData` 拼接成一个 `InstanceData`。对于长度分别为 N 和 M 的两个 `InstanceData`， 拼接后为长度 N + M 的新的 `InstanceData`
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data.det_scores = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print('The length of instance_data is', len(instance_data))
+cat_results = InstanceData.cat([instance_data, instance_data])
+print('The length of instance_data is', len(cat_results))
+print(cat_results)
+```
+
+```
+The length of instance_data is 2
+The length of instance_data is 4
+
+```
+
+#### 自定义数据结构
+
+对于自定义结构如果想使用上述扩展要求需要实现`__len__`, `__getitem__` 和 `cat`三个接口.
+
+```python
+import itertools
+
+class TmpObject:
+ def __init__(self, tmp) -> None:
+ assert isinstance(tmp, list)
+ self.tmp = tmp
+
+ def __len__(self):
+ return len(self.tmp)
+
+ def __getitem__(self, item):
+ if type(item) == int:
+ if item >= len(self) or item < -len(self): # type:ignore
+ raise IndexError(f'Index {item} out of range!')
+ else:
+ # keep the dimension
+ item = slice(item, None, len(self))
+ return TmpObject(self.tmp[item])
+
+ @staticmethod
+ def cat(tmp_objs):
+ assert all(isinstance(results, TmpObject) for results in tmp_objs)
+ if len(tmp_objs) == 1:
+ return tmp_objs[0]
+ tmp_list = [tmp_obj.tmp for tmp_obj in tmp_objs]
+ tmp_list = list(itertools.chain(*tmp_list))
+ new_data = TmpObject(tmp_list)
+ return new_data
+
+ def __repr__(self):
+ return str(self.tmp)
+```
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data["det_scores"] = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+instance_data.polygons = TmpObject([[1, 2, 3, 4], [5, 6, 7, 8]])
+print(instance_data)
+```
+
+```
+
+```
+
+```python
+# 高级索引
+print(instance_data[instance_data.det_scores > 0.75])
+```
+
+```
+
+```
+
+```python
+# 拼接
+print(InstanceData.cat([instance_data, instance_data]))
+```
+
+```
+
+```
+
+### PixelData
+
+[`PixelData`](mmengine.structures.PixelData) 在 `BaseDataElement` 的基础上，同样对 data 中存储的数据做了限制:
+
+- 所有 data 内的数据均为 3 维，并且顺序为 (通道，高，宽)
+- 所有在 data 内的数据要有相同的长和宽
+
+基于上述假定对 `PixelData`进行了扩展，包括：
+
+- 对 `PixelData` 中 data 所存储的数据进行了尺寸的校验
+- 支持对 data 部分的数据对实例进行空间维度的索引和切片。
+
+#### 数据校验
+
+`PixelData` 会对传入到 data 的数据进行维度与长宽的校验。
+
+```python
+from mmengine.structures import PixelData
+import random
+import torch
+import numpy as np
+metainfo = dict(
+ img_id=random.randint(0, 100),
+ img_shape=(random.randint(400, 600), random.randint(400, 600)))
+image = np.random.randint(0, 255, (4, 20, 40))
+featmap = torch.randint(0, 255, (10, 20, 40))
+pixel_data = PixelData(metainfo=metainfo,
+ image=image,
+ featmap=featmap)
+print('The shape of pixel_data is', pixel_data.shape)
+# set
+pixel_data.map3 = torch.randint(0, 255, (20, 40))
+print('The shape of pixel_data is', pixel_data.map3.shape)
+```
+
+```
+The shape of pixel_data is (20, 40)
+The shape of pixel_data is torch.Size([1, 20, 40])
+```
+
+```python
+pixel_data.map2 = torch.randint(0, 255, (3, 20, 30))
+# AssertionError: the height and width of values (20, 30) is not consistent with the length of this :obj:`PixelData` (20, 40)
+```
+
+```
+AssertionError: the height and width of values (20, 30) is not consistent with the length of this :obj:`PixelData` (20, 40)
+```
+
+```python
+pixel_data.map2 = torch.randint(0, 255, (1, 3, 20, 40))
+# AssertionError: The dim of value must be 2 or 3, but got 4
+```
+
+```
+AssertionError: The dim of value must be 2 or 3, but got 4
+```
+
+#### 空间维度索引
+
+`PixelData` 支持对 data 部分的数据对实例进行空间维度的索引和切片，只需传入长宽的索引即可。
+
+```python
+metainfo = dict(
+ img_id=random.randint(0, 100),
+ img_shape=(random.randint(400, 600), random.randint(400, 600)))
+image = np.random.randint(0, 255, (4, 20, 40))
+featmap = torch.randint(0, 255, (10, 20, 40))
+pixel_data = PixelData(metainfo=metainfo,
+ image=image,
+ featmap=featmap)
+print('The shape of pixel_data is', pixel_data.shape)
+```
+
+```
+The shape of pixel_data is (20, 40)
+```
+
+- 索引
+
+```python
+index_data = pixel_data[10, 20]
+print('The shape of index_data is', index_data.shape)
+```
+
+```
+The shape of index_data is (1, 1)
+```
+
+- 切片
+
+```python
+slice_data = pixel_data[10:20, 20:40]
+print('The shape of slice_data is', slice_data.shape)
+```
+
+```
+The shape of slice_data is (10, 20)
+```
+
+### LabelData
+
+[`LabelData`](mmengine.structures.LabelData) 主要用来封装标签数据，如场景分类标签，文字识别标签等。`LabelData` 没有对 data 做任何限制，只提供了两个额外功能：onehot 与 index 的转换。
+
+```python
+from mmengine.structures import LabelData
+import torch
+
+item = torch.tensor([1], dtype=torch.int64)
+num_classes = 10
+
+```
+
+```python
+onehot = LabelData.label_to_onehot(label=item, num_classes=num_classes)
+print(f'{num_classes} is convert to ', onehot)
+
+index = LabelData.onehot_to_label(onehot=onehot)
+print(f'{onehot} is convert to ', index)
+```
+
+```
+10 is convert to tensor([0, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+tensor([0, 1, 0, 0, 0, 0, 0, 0, 0, 0]) is convert to tensor([1])
+```
+
+## 数据样本(xxxDataSample)
+
+一份样本中可能存在不同类型的标签，例如一张图片里可能同时存在实例级别的标签（Box），像素级别的标签（SegMap），因此在 PixelData、InstanceData、PixelData 之上，还会有一层更加高级封装，用来表示图像级别的标签。OpenMMLab 系列项目将这层封装命名为 `XXDataSample`。以检测任务为例，MMDet 就实现了 DetDataSample。训练过程中所有的标签都会被封装在 XXXDataSample 中，这样能够保证不同的深度学习任务能够保持统一的数据流和统一的数据操作方式。
+
+### 下游库使用
+
+以 MMDet 为例，说明下游库中数据样本的使用，以及数据样本字段的约束和命名。MMDet 中定义了 `DetDataSample`, 同时定义了 7 个字段，分别为：
+
+- 标注信息
+ - gt_instance(InstanceData): 实例标注信息，包括实例的类别、边界框等， 类型约束为 `InstanceData`。
+ - gt_panoptic_seg(PixelData): 全景分割的标注信息，类型约束为 `PixelData`。
+ - gt_semantic_seg(PixelData): 语义分割的标注信息， 类型约束为 `PixelData`。
+- 预测结果
+ - pred_instance(InstanceData): 实例预测结果，包括实例的类别、边界框等， 类型约束为 `InstanceData`。
+ - pred_panoptic_seg(PixelData): 全景分割的预测结果，类型约束为 `PixelData`。
+ - pred_semantic_seg(PixelData): 语义分割的预测结果， 类型约束为 `PixelData`。
+- 中间结果
+ - proposal(InstanceData): 主要为二阶段中 RPN 的预测结果， 类型约束为 `InstanceData`。
+
+```python
+from mmengine.structures import BaseDataElement
+import torch
+
+class DetDataSample(BaseDataElement):
+
+ # 标注
+ @property
+ def gt_instances(self) -> InstanceData:
+ return self._gt_instances
+
+ @gt_instances.setter
+ def gt_instances(self, value: InstanceData):
+ self.set_field(value, '_gt_instances', dtype=InstanceData)
+
+ @gt_instances.deleter
+ def gt_instances(self):
+ del self._gt_instances
+
+ @property
+ def gt_panoptic_seg(self) -> PixelData:
+ return self._gt_panoptic_seg
+
+ @gt_panoptic_seg.setter
+ def gt_panoptic_seg(self, value: PixelData):
+ self.set_field(value, '_gt_panoptic_seg', dtype=PixelData)
+
+ @gt_panoptic_seg.deleter
+ def gt_panoptic_seg(self):
+ del self._gt_panoptic_seg
+
+ @property
+ def gt_sem_seg(self) -> PixelData:
+ return self._gt_sem_seg
+
+ @gt_sem_seg.setter
+ def gt_sem_seg(self, value: PixelData):
+ self.set_field(value, '_gt_sem_seg', dtype=PixelData)
+
+ @gt_sem_seg.deleter
+ def gt_sem_seg(self):
+ del self._gt_sem_seg
+
+ # 预测
+ @property
+ def pred_instances(self) -> InstanceData:
+ return self._pred_instances
+
+ @pred_instances.setter
+ def pred_instances(self, value: InstanceData):
+ self.set_field(value, '_pred_instances', dtype=InstanceData)
+
+ @pred_instances.deleter
+ def pred_instances(self):
+ del self._pred_instances
+
+ @property
+ def pred_panoptic_seg(self) -> PixelData:
+ return self._pred_panoptic_seg
+
+ @pred_panoptic_seg.setter
+ def pred_panoptic_seg(self, value: PixelData):
+ self.set_field(value, '_pred_panoptic_seg', dtype=PixelData)
+
+ @pred_panoptic_seg.deleter
+ def pred_panoptic_seg(self):
+ del self._pred_panoptic_seg
+
+ # 中间结果
+ @property
+ def pred_sem_seg(self) -> PixelData:
+ return self._pred_sem_seg
+
+ @pred_sem_seg.setter
+ def pred_sem_seg(self, value: PixelData):
+ self.set_field(value, '_pred_sem_seg', dtype=PixelData)
+
+ @pred_sem_seg.deleter
+ def pred_sem_seg(self):
+ del self._pred_sem_seg
+
+ @property
+ def proposals(self) -> InstanceData:
+ return self._proposals
+
+ @proposals.setter
+ def proposals(self, value: InstanceData):
+ self.set_field(value, '_proposals', dtype=InstanceData)
+
+ @proposals.deleter
+ def proposals(self):
+ del self._proposals
+
+```
+
+### 类型约束
+
+DetDataSample 的用法如下所示，在数据类型不符合要求的时候(例如用 torch.Tensor 而非 InstanceData 定义 proposals 时)，DetDataSample 就会报错。
+
+```python
+data_sample = DetDataSample()
+
+data_sample.proposals = InstanceData(data=dict(bboxes=torch.rand((5,4))))
+print(data_sample)
+```
+
+```
+
+) at 0x7f9f1c090430>
+```
+
+```python
+data_sample.proposals = torch.rand((5, 4))
+```
+
+```
+AssertionError: tensor([[0.4370, 0.1661, 0.0902, 0.8421],
+ [0.4947, 0.1668, 0.0083, 0.1111],
+ [0.2041, 0.8663, 0.0563, 0.3279],
+ [0.7817, 0.1938, 0.2499, 0.6748],
+ [0.4524, 0.8265, 0.4262, 0.2215]]) should be a but got
+```
+
+## 接口的简化
+
+下面以 MMDetection 为例更具体地说明 OpenMMLab 的算法库将如何迁移使用抽象数据接口，以简化模块和组件接口的。我们假定 MMDetection 和 MMEngine 中实现了 DetDataSample 和 InstanceData。
+
+### 1. 组件接口的简化
+
+检测器的外部接口可以得到显著的简化和统一。MMDet 2.X 中单阶段检测器和单阶段分割算法的接口如下。在训练过程中，`SingleStageDetector` 需要获取
+`img`， `img_metas`， `gt_bboxes`， `gt_labels`， `gt_bboxes_ignore` 作为输入，但是 `SingleStageInstanceSegmentor` 还需要 `gt_masks`，导致 detector 的训练接口不一致，影响了代码的灵活性。
+
+```python
+class SingleStageDetector(BaseDetector):
+ ...
+
+ def forward_train(self,
+ img,
+ img_metas,
+ gt_bboxes,
+ gt_labels,
+ gt_bboxes_ignore=None):
+
+
+class SingleStageInstanceSegmentor(BaseDetector):
+ ...
+
+ def forward_train(self,
+ img,
+ img_metas,
+ gt_masks,
+ gt_labels,
+ gt_bboxes=None,
+ gt_bboxes_ignore=None,
+ **kwargs):
+```
+
+在 MMDet 3.0 中，所有检测器的训练接口都可以使用 DetDataSample 统一简化为 `img` 和 `data_samples`，不同模块可以根据需要去访问 `data_samples` 封装的各种所需要的属性。
+
+```python
+class SingleStageDetector(BaseDetector):
+ ...
+
+ def forward_train(self,
+ img,
+ data_samples):
+
+class SingleStageInstanceSegmentor(BaseDetector):
+ ...
+
+ def forward_train(self,
+ img,
+ data_samples):
+
+```
+
+### 2. 模块接口的简化
+
+MMDet 2.X 中 `HungarianAssigner` 和 `MaskHungarianAssigner` 分别用于在训练过程中将检测框和实例掩码和标注的实例进行匹配。他们内部的匹配逻辑实现是一样的，只是接口和损失函数的计算不同。
+但是，接口的不同使得 `HungarianAssigner` 中的代码无法被复用，`MaskHungarianAssigner` 中重写了很多冗余的逻辑。
+
+```python
+class HungarianAssigner(BaseAssigner):
+
+ def assign(self,
+ bbox_pred,
+ cls_pred,
+ gt_bboxes,
+ gt_labels,
+ img_meta,
+ gt_bboxes_ignore=None,
+ eps=1e-7):
+
+class MaskHungarianAssigner(BaseAssigner):
+
+ def assign(self,
+ cls_pred,
+ mask_pred,
+ gt_labels,
+ gt_mask,
+ img_meta,
+ gt_bboxes_ignore=None,
+ eps=1e-7):
+```
+
+`InstanceData` 可以封装实例的框、分数、和掩码，将 `HungarianAssigner` 的核心参数简化成 `pred_instances`，`gt_instances`，和 `gt_instances_ignore`
+使得 `HungarianAssigner` 和 `MaskHungarianAssigner` 可以合并成一个通用的 `HungarianAssigner`。
+
+```python
+class HungarianAssigner(BaseAssigner):
+
+ def assign(self,
+ pred_instances,
+ gt_instancess,
+ gt_instances_ignore=None,
+ eps=1e-7):
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/data_transform.md b/internlm_langchain/knowledge_base/MMEngine/content/data_transform.md
new file mode 100644
index 00000000..ff6ce852
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/data_transform.md
@@ -0,0 +1,136 @@
+# 数据变换 (Data Transform)
+
+在 OpenMMLab 算法库中，数据集的构建和数据的准备是相互解耦的。通常，数据集的构建只对数据集进行解析，记录每个样本的基本信息；而数据的准备则是通过一系列的数据变换，根据样本的基本信息进行数据加载、预处理、格式化等操作。
+
+## 使用数据变换类
+
+在 MMEngine 中，我们使用各种可调用的数据变换类来进行数据的操作。这些数据变换类可以接受若干配置参数进行实例化，之后通过调用的方式对输入的数据字典进行处理。同时，我们约定所有数据变换都接受一个字典作为输入，并将处理后的数据输出为一个字典。一个简单的例子如下：
+
+```{note}
+MMEngine 中仅约定了数据变换类的规范，常用的数据变换类实现及基类都在 MMCV 中，因此在本篇教程需要提前安装好 MMCV，参见 {external+mmcv:doc}`MMCV 安装教程 `。
+```
+
+```python
+>>> import numpy as np
+>>> from mmcv.transforms import Resize
+>>>
+>>> transform = Resize(scale=(224, 224))
+>>> data_dict = {'img': np.random.rand(256, 256, 3)}
+>>> data_dict = transform(data_dict)
+>>> print(data_dict['img'].shape)
+(224, 224, 3)
+```
+
+## 在配置文件中使用
+
+在配置文件中，我们将一系列数据变换组合成为一个列表，称为数据流水线（Data Pipeline），传给数据集的 `pipeline` 参数。通常数据流水线由以下几个部分组成：
+
+1. 数据加载，通常使用 [`LoadImageFromFile`](mmcv.transforms.LoadImageFromFile)
+2. 标签加载，通常使用 [`LoadAnnotations`](mmcv.transforms.LoadAnnotations)
+3. 数据处理及增强，例如 [`RandomResize`](mmcv.transforms.RandomResize)
+4. 数据格式化，根据任务不同，在各个仓库使用自己的变换操作，通常名为 `PackXXXInputs`，其中 XXX 是任务的名称，如分类任务中的 `PackClsInputs`。
+
+以分类任务为例，我们在下图展示了一个典型的数据流水线。对每个样本，数据集中保存的基本信息是一个如图中最左侧所示的字典，之后每经过一个由蓝色块代表的数据变换操作，数据字典中都会加入新的字段（标记为绿色）或更新现有的字段（标记为橙色）。
+
+
+
+
+
+```{note}
+如果基础配置文件为 train_dataloader 配置了基于 iteration/epoch 采样的 sampler，则需要在当前配置文件中将其更改为指定类型的 sampler，或将其设置为 None。当 dataloader 中的 sampler 为 None，MMEngine 或根据 train_cfg 中的 by_epoch 参数选择 `InfiniteSampler`（False） 或 `DefaultSampler`（True）。
+```
+
+```{note}
+如果基础配置文件在 train_cfg 中指定了 type，那么必须在当前配置文件中将 type 覆盖为（IterBasedTrainLoop 或 EpochBasedTrainLoop），而不能简单的指定 by_epoch 参数。
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/evaluation.md b/internlm_langchain/knowledge_base/MMEngine/content/evaluation.md
new file mode 100644
index 00000000..a3a9ae72
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/evaluation.md
@@ -0,0 +1,88 @@
+# 模型精度评测
+
+## 评测指标与评测器
+
+在模型验证和模型测试中，通常需要对模型精度做定量评测。在 MMEngine 中实现了评测指标（Metric）和评测器（Evaluator）来完成这一功能。
+
+- **评测指标** 用于根据测试数据和模型预测结果，完成特定模型精度指标的计算。在 OpenMMLab 各算法库中提供了对应任务的常用评测指标，如 [MMPretrain](https://github.com/open-mmlab/mmpretrain) 中提供了[Accuracy](https://mmpretrain.readthedocs.io/en/latest/api/generated/mmpretrain.evaluation.Accuracy.html#mmpretrain.evaluation.Accuracy) 用于计算分类模型的 Top-k 分类正确率；[MMDetection](https://github.com/open-mmlab/mmdetection) 中提供了 [COCOMetric](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/evaluation/metrics/coco_metric.py) 用于计算目标检测模型的 AP，AR 等评测指标。评测指标与数据集解耦，如 COCOMetric 也可用于 COCO 以外的目标检测数据集上。
+
+- **评测器** 是评测指标的上层模块，通常包含一个或多个评测指标。评测器的作用是在模型评测时完成必要的数据格式转换，并调用评测指标计算模型精度。评测器通常由[执行器](../tutorials/runner.md)或测试脚本构建，分别用于在线评测和离线评测。
+
+### 评测指标基类 `BaseMetric`
+
+评测指标基类 `BaseMetric` 是一个抽象类，初始化参数如下:
+
+- `collect_device`：在分布式评测中用于同步结果的设备名，如 `'cpu'` 或 `'gpu'`。
+- `prefix`：评测指标名前缀，用以区别多个同名的评测指标。如果该参数未给定，则会尝试使用类属性 `default_prefix` 作为前缀。
+
+```python
+class BaseMetric(metaclass=ABCMeta):
+
+ default_prefix: Optional[str] = None
+
+ def __init__(self,
+ collect_device: str = 'cpu',
+ prefix: Optional[str] = None) -> None:
+ ...
+```
+
+`BaseMetric` 有以下 2 个重要的方法需要在子类中重写：
+
+- **`process()`** 用于处理每个批次的测试数据和模型预测结果。处理结果应存放在 `self.results` 列表中，用于在处理完所有测试数据后计算评测指标。该方法具有以下 2 个参数：
+
+ - `data_batch`：一个批次的测试数据样本，通常直接来自与数据加载器
+ - `data_samples`：对应的模型预测结果
+ 该方法没有返回值。函数接口定义如下：
+
+ ```python
+ @abstractmethod
+ def process(self, data_batch: Any, data_samples: Sequence[dict]) -> None:
+ """Process one batch of data samples and predictions. The processed
+ results should be stored in ``self.results``, which will be used to
+ compute the metrics when all batches have been processed.
+ Args:
+ data_batch (Any): A batch of data from the dataloader.
+ data_samples (Sequence[dict]): A batch of outputs from the model.
+ """
+ ```
+
+- **`compute_metrics()`** 用于计算评测指标，并将所评测指标存放在一个字典中返回。该方法有以下 1 个参数：
+
+ - `results`：列表类型，存放了所有批次测试数据经过 `process()` 方法处理后得到的结果
+ 该方法返回一个字典，里面保存了评测指标的名称和对应的评测值。函数接口定义如下：
+
+ ```python
+ @abstractmethod
+ def compute_metrics(self, results: list) -> dict:
+ """Compute the metrics from processed results.
+
+ Args:
+ results (list): The processed results of each batch.
+
+ Returns:
+ dict: The computed metrics. The keys are the names of the metrics,
+ and the values are corresponding results.
+ """
+ ```
+
+其中，`compute_metrics()` 会在 `evaluate()` 方法中被调用；后者在计算评测指标前，会在分布式测试时收集和汇总不同 rank 的中间处理结果。
+
+需要注意的是，`self.results` 中存放的具体类型取决于评测指标子类的实现。例如，当测试样本或模型输出数据量较大（如语义分割、图像生成等任务），不宜全部存放在内存中时，可以在 `self.results` 中存放每个批次计算得到的指标，并在 `compute_metrics()` 中汇总；或将每个批次的中间结果存储到临时文件中，并在 `self.results` 中存放临时文件路径，最后由 `compute_metrics()` 从文件中读取数据并计算指标。
+
+## 模型精度评测流程
+
+通常，模型精度评测的过程如下图所示。
+
+**在线评测**：测试数据通常会被划分为若干批次（batch）。通过一个循环，依次将每个批次的数据送入模型，得到对应的预测结果，并将测试数据和模型预测结果送入评测器。评测器会调用评测指标的 `process()` 方法对数据和预测结果进行处理。当循环结束后，评测器会调用评测指标的 `evaluate()` 方法，可计算得到对应指标的模型精度。
+
+**离线评测**：与在线评测过程类似，区别是直接读取预先保存的模型预测结果来进行评测。评测器提供了 `offline_evaluate` 接口，用于在离线方式下调用评测指标来计算模型精度。为了避免同时处理大量数据导致内存溢出，离线评测时会将测试数据和预测结果分成若干个块（chunk）进行处理，类似在线评测中的批次。
+
+)
+```
+
+可以看到注册到 Linear 模块的 `forward_hook_fn` 钩子被调用，在该钩子中打印了 Linear 模块的权重、偏置、模块的输入以及输出。更多关于 PyTorch 钩子的用法可以阅读 [nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html)。
+
+## MMEngine 中钩子的设计
+
+在介绍 MMEngine 中钩子的设计之前，先简单介绍使用 PyTorch 实现模型训练的基本步骤（示例代码来自 [PyTorch Tutorials](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py)）：
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import torchvision.transforms as transforms
+from torch.utils.data import Dataset, DataLoader
+
+class CustomDataset(Dataset):
+ pass
+
+class Net(nn.Module):
+ pass
+
+def main():
+ transform = transforms.ToTensor()
+ train_dataset = CustomDataset(transform=transform, ...)
+ val_dataset = CustomDataset(transform=transform, ...)
+ test_dataset = CustomDataset(transform=transform, ...)
+ train_dataloader = DataLoader(train_dataset, ...)
+ val_dataloader = DataLoader(val_dataset, ...)
+ test_dataloader = DataLoader(test_dataset, ...)
+
+ net = Net()
+ criterion = nn.CrossEntropyLoss()
+ optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+ for i in range(max_epochs):
+ for inputs, labels in train_dataloader:
+ optimizer.zero_grad()
+ outputs = net(inputs)
+ loss = criterion(outputs, labels)
+ loss.backward()
+ optimizer.step()
+
+ with torch.no_grad():
+ for inputs, labels in val_dataloader:
+ outputs = net(inputs)
+ loss = criterion(outputs, labels)
+
+ with torch.no_grad():
+ for inputs, labels in test_dataloader:
+ outputs = net(inputs)
+ accuracy = ...
+```
+
+上面的伪代码是训练模型的基本步骤。如果要在上面的代码中加入定制化的逻辑，我们需要不断修改和拓展 `main` 函数。为了提高 `main` 函数的灵活性和拓展性，我们可以在 `main` 方法中插入位点，并在对应位点实现调用 hook 的抽象逻辑。此时只需在这些位点插入 hook 来实现定制化逻辑，即可添加定制化功能，例如加载模型权重、更新模型参数等。
+
+```python
+def main():
+ ...
+ call_hooks('before_run', hooks) # 任务开始前执行的逻辑
+ call_hooks('after_load_checkpoint', hooks) # 加载权重后执行的逻辑
+ call_hooks('before_train', hooks) # 训练开始前执行的逻辑
+ for i in range(max_epochs):
+ call_hooks('before_train_epoch', hooks) # 遍历训练数据集前执行的逻辑
+ for inputs, labels in train_dataloader:
+ call_hooks('before_train_iter', hooks) # 模型前向计算前执行的逻辑
+ outputs = net(inputs)
+ loss = criterion(outputs, labels)
+ call_hooks('after_train_iter', hooks) # 模型前向计算后执行的逻辑
+ loss.backward()
+ optimizer.step()
+ call_hooks('after_train_epoch', hooks) # 遍历完训练数据集后执行的逻辑
+
+ call_hooks('before_val_epoch', hooks) # 遍历验证数据集前执行的逻辑
+ with torch.no_grad():
+ for inputs, labels in val_dataloader:
+ call_hooks('before_val_iter', hooks) # 模型前向计算前执行
+ outputs = net(inputs)
+ loss = criterion(outputs, labels)
+ call_hooks('after_val_iter', hooks) # 模型前向计算后执行
+ call_hooks('after_val_epoch', hooks) # 遍历完验证数据集前执行
+
+ call_hooks('before_save_checkpoint', hooks) # 保存权重前执行的逻辑
+ call_hooks('after_train', hooks) # 训练结束后执行的逻辑
+
+ call_hooks('before_test_epoch', hooks) # 遍历测试数据集前执行的逻辑
+ with torch.no_grad():
+ for inputs, labels in test_dataloader:
+ call_hooks('before_test_iter', hooks) # 模型前向计算后执行的逻辑
+ outputs = net(inputs)
+ accuracy = ...
+ call_hooks('after_test_iter', hooks) # 遍历完成测试数据集后执行的逻辑
+ call_hooks('after_test_epoch', hooks) # 遍历完测试数据集后执行
+
+ call_hooks('after_run', hooks) # 任务结束后执行的逻辑
+```
+
+在 MMEngine 中，我们将训练过程抽象成执行器（Runner），执行器除了完成环境的初始化，另一个功能是在特定的位点调用钩子完成定制化逻辑。更多关于执行器的介绍请阅读[执行器文档](../tutorials/runner.md)。
+
+为了方便管理，MMEngine 将位点定义为方法并集成到[钩子基类（Hook）](mmengine.hooks.Hook)中，我们只需继承钩子基类并根据需求在特定位点实现定制化逻辑，再将钩子注册到执行器中，便可自动调用钩子中相应位点的方法。
+
+钩子中一共有 22 个位点：
+
+- before_run
+- after_run
+- before_train
+- after_train
+- before_train_epoch
+- after_train_epoch
+- before_train_iter
+- after_train_iter
+- before_val
+- after_val
+- before_val_epoch
+- after_val_epoch
+- before_val_iter
+- after_val_iter
+- before_test
+- after_test
+- before_test_epoch
+- after_test_epoch
+- before_test_iter
+- after_test_iter
+- before_save_checkpoint
+- after_load_checkpoint
+
+你可能还想阅读[钩子的用法](../tutorials/hook.md)或者[钩子的 API 文档](../api/hooks)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/infer.md b/internlm_langchain/knowledge_base/MMEngine/content/infer.md
new file mode 100644
index 00000000..ffc1a0b7
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/infer.md
@@ -0,0 +1,244 @@
+# 推理接口
+
+基于 MMEngine 开发时，我们通常会为具体算法定义一个配置文件，根据配置文件去构建[执行器](./runner.md)，执行训练、测试流程，并保存训练好的权重。基于训练好的模型进行推理时，通常需要执行以下步骤：
+
+1. 基于配置文件构建模型
+2. 加载模型权重
+3. 搭建数据预处理流程
+4. 执行模型前向推理
+5. 可视化推理结果
+6. 输出推理结果
+
+对于此类标准的推理流程，MMEngine 提供了统一的推理接口，并且建议用户基于这一套接口规范来开发推理代码。
+
+## 使用样例
+
+### 定义推理器
+
+**基于 `BaseInferencer` 实现自定义的推理器**
+
+```python
+from mmengine.infer import BaseInferencer
+
+class CustomInferencer(BaseInferencer)
+ ...
+```
+
+具体细节参考[开发规范](#推理接口开发规范)
+
+### 构建推理器
+
+**基于配置文件路径构建推理器**
+
+```python
+cfg = 'path/to/config.py'
+weight = 'path/to/weight.pth'
+
+inferencer = CustomInferencer(model=cfg, weight=weight)
+```
+
+**基于配置类实例构建推理器**
+
+```python
+from mmengine import Config
+
+cfg = Config.fromfile('path/to/config.py')
+weight = 'path/to/weight.pth'
+
+inferencer = CustomInferencer(model=cfg, weight=weight)
+```
+
+**基于 model-index 中定义的 model name 构建推理器**，以 MMDetection 中的 [atss 检测器为例](https://github.com/open-mmlab/mmdetection/blob/31c84958f54287a8be2b99cbf87a6dcf12e57753/configs/atss/metafile.yml#L22)，model name 为 `atss_r50_fpn_1x_coco`，由于 model-index 中已经定义了 weight 的路径，因此可以不配置 weight 参数。
+
+```python
+inferencer = CustomInferencer(model='atss_r50_fpn_1x_coco')
+```
+
+### 执行推理
+
+**推理单张图片**
+
+```python
+# 输入为图片路径
+img = 'path/to/img.jpg'
+result = inferencer(img)
+
+# 输入为读取的图片(类型为 np.ndarray)
+img = cv2.imread('path/to/img.jpg')
+result = inferencer(img)
+
+# 输入为 url
+img = 'https://xxx.com/img.jpg'
+result = inferencer(img)
+```
+
+**推理多张图片**
+
+```python
+img_dir = 'path/to/directory'
+result = inferencer(img_dir)
+```
+
+```{note}
+OpenMMLab 系列算法库要求 `inferencer(img)` 输出一个 `dict`，其中包含 `visualization: list` 和 `predictions: list` 两个字段，分别对应可视化结果和预测结果。
+```
+
+## 推理接口开发规范
+
+inferencer 执行推理时，通常会执行以下步骤：
+
+1. preprocess：输入数据预处理，包括数据读取、数据预处理、数据格式转换等
+2. forward: 模型前向推理
+3. visualize：预测结果可视化
+4. postprocess：预测结果后处理，包括结果格式转换、导出预测结果等
+
+为了优化 inferencer 的使用体验，我们不希望使用者在执行推理时，需要为每个过程都配置一遍参数。换句话说，我们希望使用者可以在不感知上述流程的情况下，简单为 `__call__` 接口配置参数，即可完成推理。
+
+`__call__` 接口会按照顺序执行上述步骤，但是本身却不知道使用者传入的参数需要分发给哪个步骤，因此开发者在实现 `CustomInferencer` 时，需要定义 `preprocess_kwargs`，`forward_kwargs`，`visualize_kwargs`，`postprocess_kwargs` 4 个类属性，每个属性均为一个字符集合（`Set[str]`），用于指定 `__call__` 接口中的参数对应哪个步骤：
+
+```python
+class CustomInferencer(BaseInferencer):
+ preprocess_kwargs = {'a'}
+ forward_kwargs = {'b'}
+ visualize_kwargs = {'c'}
+ postprocess_kwargs = {'d'}
+
+ def preprocess(self, inputs, batch_size=1, a=None):
+ pass
+
+ def forward(self, inputs, b=None):
+ pass
+
+ def visualize(self, inputs, preds, show, c=None):
+ pass
+
+ def postprocess(self, preds, visualization, return_datasample=False, d=None):
+ pass
+
+ def __call__(
+ self,
+ inputs,
+ batch_size=1,
+ show=True,
+ return_datasample=False,
+ a=None,
+ b=None,
+ c=None,
+ d=None):
+ return super().__call__(
+ inputs, batch_size, show, return_datasample, a=a, b=b, c=c, d=d)
+```
+
+上述代码中，`preprocess`，`forward`，`visualize`，`postprocess` 四个函数的 `a`，`b`，`c`，`d` 为用户可以传入的额外参数（`inputs`, `preds` 等参数在 `__call__` 的执行过程中会被自动填入），因此开发者需要在类属性 `preprocess_kwargs`，`forward_kwargs`，`visualize_kwargs`，`postprocess_kwargs` 中指定这些参数，这样 `__call__` 阶段用户传入的参数就可以被正确分发给对应的步骤。分发过程由 `BaseInferencer.__call__` 函数实现，开发者无需关心。
+
+此外，我们需要将 `CustomInferencer` 注册到自定义注册器或者 MMEngine 的注册器中
+
+```python
+from mmseg.registry import INFERENCERS
+# 也可以注册到 MMEngine 的注册中
+# from mmengine.registry import INFERENCERS
+
+@INFERENCERS.register_module()
+class CustomInferencer(BaseInferencer):
+ ...
+```
+
+```{note}
+OpenMMLab 系列算法仓库必须将 Inferencer 注册到下游仓库的注册器，而不能注册到 MMEngine 的根注册器（避免重名）。
+```
+
+## 核心接口说明：
+
+### `__init__()`
+
+`BaseInferencer.__init__` 已经实现了[使用样例](#构建推理器)中构建推理器的逻辑，因此通常情况下不需要重写 `__init__` 函数。如果想实现自定义的加载配置文件、权重初始化、pipeline 初始化等逻辑，也可以重写 `__init__` 方法。
+
+### `_init_pipeline()`
+
+```{note}
+抽象方法，子类必须实现
+```
+
+初始化并返回 inferencer 所需的 pipeline。pipeline 用于单张图片，类似于 OpenMMLab 系列算法库中定义的 `train_pipeline`，`test_pipeline`。使用者调用 `__call__` 接口传入的每个 `inputs`，都会经过 pipeline 处理，组成 batch data，然后传入 `forward` 方法。
+
+### `_init_collate()`
+
+初始化并返回 inferencer 所需的 `collate_fn`，其值等价于训练过程中 Dataloader 的 `collate_fn`。`BaseInferencer` 默认会从 `test_dataloader` 的配置中获取 `collate_fn`，因此通常情况下不需要重写 `_init_collate` 函数。
+
+### `_init_visualizer()`
+
+初始化并返回 inferencer 所需的 `visualizer`，其值等价于训练过程中 `visualizer`。`BaseInferencer` 默认会从 `visualizer` 的配置中获取 `visualizer`，因此通常情况下不需要重写 `_init_visualizer` 函数。
+
+### `preprocess()`
+
+入参：
+
+- inputs：输入数据，由 `__call__` 传入，通常为图片路径或者图片数据组成的列表
+- batch_size：batch 大小，由使用者在调用 `__call__` 时传入
+- 其他参数：由用户传入，且在 `preprocess_kwargs` 中指定
+
+返回值：
+
+- 生成器，每次迭代返回一个 batch 的数据。
+
+`preprocess` 默认是一个生成器函数，将 `pipeline` 及 `collate_fn` 应用于输入数据，生成器迭代返回的是组完 batch，预处理后的结果。通常情况下子类无需重写。
+
+### `forward()`
+
+入参：
+
+- inputs：输入数据，由 `preprocess` 处理后的 batch data
+- 其他参数：由用户传入，且在 `forward_kwargs` 中指定
+
+返回值：
+
+- 预测结果，默认类型为 `List[BaseDataElement]`
+
+调用 `model.test_step` 执行前向推理，并返回推理结果。通常情况下子类无需重写。
+
+### `visualize()`
+
+```{note}
+抽象方法，子类必须实现
+```
+
+入参：
+
+- inputs：输入数据，未经过预处理的原始数据。
+- preds：模型的预测结果
+- show：是否可视化
+- 其他参数：由用户传入，且在 `visualize_kwargs` 中指定
+
+返回值：
+
+- 可视化结果，类型通常为 `List[np.ndarray]`，以目标检测任务为例，列表中的每个元素应该是画完检测框后的图像，直接使用 `cv2.imshow` 就能可视化检测结果。不同任务的可视化流程有所不同，`visualize` 应该返回该领域内，适用于常见可视化流程的结果。
+
+### `postprocess()`
+
+```{note}
+抽象方法，子类必须实现
+```
+
+入参：
+
+- preds：模型预测结果，类型为 `list`，列表中的每个元素表示一个数据的预测结果。OpenMMLab 系列算法库中，预测结果中每个元素的类型均为 `BaseDataElement`
+- visualization：可视化结果
+- return_datasample：是否维持 datasample 返回。`False` 时转换成 `dict` 返回
+- 其他参数：由用户传入，且在 `postprocess_kwargs` 中指定
+
+返回值：
+
+- 可视化结果和预测结果，类型为一个字典。OpenMMLab 系列算法库要求返回的字典包含 `predictions` 和 `visualization` 两个 key。
+
+### `__call__()`
+
+入参：
+
+- inputs：输入数据，通常为图片路径、或者图片数据组成的列表。`inputs` 中的每个元素也可以是其他类型的数据，只需要保证数据能够被 [\_init_pipeline](#_init_pipeline) 返回的 `pipeline` 处理即可。当 `inputs` 只含一个推理数据时，它可以不是一个 `list`，`__call__` 会在内部将 `inputs` 包装成列表，以便于后续处理
+- return_datasample：是否将 datasample 转换成 `dict` 返回
+- batch_size：推理的 batch size，会被进一步传给 `preprocess` 函数
+- 其他参数：分发给 `preprocess`、`forward`、`visualize`、`postprocess` 函数的额外参数
+
+返回值：
+
+- `postprocess` 返回的可视化结果和预测结果，类型为一个字典。OpenMMLab 系列算法库要求返回的字典包含 `predictions` 和 `visualization` 两个 key
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/initialize.md b/internlm_langchain/knowledge_base/MMEngine/content/initialize.md
new file mode 100644
index 00000000..f8d8f0a3
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/initialize.md
@@ -0,0 +1,417 @@
+# 权重初始化
+
+基于 Pytorch 构建模型时，我们通常会选择 [nn.Module](https://pytorch.org/docs/stable/nn.html?highlight=nn%20module#module-torch.nn.modules) 作为模型的基类，搭配使用 Pytorch 的初始化模块 [torch.nn.init](https://pytorch.org/docs/stable/nn.init.html?highlight=kaiming#torch.nn.init.kaiming_normal_)，完成模型的初始化。MMEngine 在此基础上抽象出基础模块（BaseModule）,让我们能够通过传参或配置文件来选择模型的初始化方式。此外，`MMEngine` 还提供了一系列模块初始化函数，让我们能够更加方便灵活地初始化模型参数。
+
+## 配置式初始化
+
+为了能够更加灵活地初始化模型权重，`MMEngine` 抽象出了模块基类 `BaseModule`。模块基类继承自 `nn.Module`，在具备 `nn.Module` 基础功能的同时，还支持在构造时接受参数，以此来选择权重初始化方式。继承自 `BaseModule` 的模型可以在实例化阶段接受 `init_cfg` 参数，我们可以通过配置 `init_cfg` 为模型中任意组件灵活地选择初始化方式。目前我们可以在 `init_cfg` 中配置以下初始化器：
+
+
+
+
+
+我们通过几个例子来理解如何在 `init_cfg` 里配置初始化器，来选择模型的初始化方式。
+
+### 使用预训练权重初始化
+
+假设我们定义了模型类 `ToyNet`，它继承自模块基类（`BaseModule`）。此时我们可以在 `ToyNet` 初始化时传入 `init_cfg` 参数来选择模型的初始化方式，实例化后再调用 `init_weights` 方法，完成权重的初始化。以加载预训练权重为例：
+
+```python
+import torch
+import torch.nn as nn
+
+from mmengine.model import BaseModule
+
+
+class ToyNet(BaseModule):
+
+ def __init__(self, init_cfg=None):
+ super().__init__(init_cfg)
+ self.conv1 = nn.Linear(1, 1)
+
+
+# 保存预训练权重
+toy_net = ToyNet()
+torch.save(toy_net.state_dict(), './pretrained.pth')
+pretrained = './pretrained.pth'
+
+# 配置加载预训练权重的初始化方式
+toy_net = ToyNet(init_cfg=dict(type='Pretrained', checkpoint=pretrained))
+# 加载权重
+toy_net.init_weights()
+```
+
+```
+08/19 16:50:24 - mmengine - INFO - load model from: ./pretrained.pth
+08/19 16:50:24 - mmengine - INFO - local loads checkpoint from path: ./pretrained.pth
+```
+
+当 `init_cfg` 是一个字典时，`type` 字段就表示一种初始化器，它需要被注册到 `WEIGHT_INITIALIZERS` [注册器](registry.md)。我们可以通过指定 `init_cfg=dict(type='Pretrained', checkpoint='path/to/ckpt')` 来加载预训练权重，其中 `Pretrained` 为 `PretrainedInit` 初始化器的缩写，这个映射名由 `WEIGHT_INITIALIZERS` 维护；`checkpoint` 是 `PretrainedInit` 的初始化参数，用于指定权重的加载路径，它可以是本地磁盘路径，也可以是 URL。
+
+```{note}
+在所有的初始化器中，`PretrainedInit` 拥有最高的优先级。`init_cfg` 中其他初始化器初始化的权重会被 `PretrainedInit` 加载的预训练权重覆盖。
+```
+
+### 常用的初始化方式
+
+和使用 `PretrainedInit` 初始化器类似，如果我们想对卷积做 `Kaiming` 初始化，需要令 `init_cfg=dict(type='Kaiming', layer='Conv2d')`。这样模型初始化时，就会以 `Kaiming` 初始化的方式来初始化类型为 `Conv2d` 的模块。
+
+有时候我们可能需要用不同的初始化方式去初始化不同类型的模块，例如对卷积使用 `Kaiming` 初始化，对线性层使用 `Xavier`
+初始化。此时我们可以使 `init_cfg` 成为一个列表，其中的每一个元素都表示对某些层使用特定的初始化方式。
+
+```python
+import torch.nn as nn
+
+from mmengine.model import BaseModule
+
+
+class ToyNet(BaseModule):
+
+ def __init__(self, init_cfg=None):
+ super().__init__(init_cfg)
+ self.linear = nn.Linear(1, 1)
+ self.conv = nn.Conv2d(1, 1, 1)
+
+
+# 对卷积做 Kaiming 初始化，线性层做 Xavier 初始化
+toy_net = ToyNet(
+ init_cfg=[
+ dict(type='Kaiming', layer='Conv2d'),
+ dict(type='Xavier', layer='Linear')
+ ], )
+toy_net.init_weights()
+```
+
+```
+08/19 16:50:24 - mmengine - INFO -
+linear.weight - torch.Size([1, 1]):
+XavierInit: gain=1, distribution=normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+linear.bias - torch.Size([1]):
+XavierInit: gain=1, distribution=normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv.weight - torch.Size([1, 1, 1, 1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+```
+
+类似地，`layer` 参数也可以是一个列表，表示列表中的多种不同的 `layer` 均使用 `type` 指定的初始化方式
+
+```python
+# 对卷积和线性层做 Kaiming 初始化
+toy_net = ToyNet(init_cfg=[dict(type='Kaiming', layer=['Conv2d', 'Linear'])], )
+toy_net.init_weights()
+```
+
+```
+08/19 16:50:24 - mmengine - INFO -
+linear.weight - torch.Size([1, 1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+linear.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv.weight - torch.Size([1, 1, 1, 1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+```
+
+### 更细粒度的初始化
+
+有时同一类型的不同模块有不同初始化方式，例如现在有 `conv1` 和 `conv2` 两个模块，他们的类型均为 `Conv2d`
+。我们需要对 conv1 进行 `Kaiming` 初始化，conv2 进行 `Xavier` 初始化，则可以通过配置 `override` 参数来满足这样的需求：
+
+```python
+import torch.nn as nn
+
+from mmengine.model import BaseModule
+
+
+class ToyNet(BaseModule):
+
+ def __init__(self, init_cfg=None):
+ super().__init__(init_cfg)
+ self.conv1 = nn.Conv2d(1, 1, 1)
+ self.conv2 = nn.Conv2d(1, 1, 1)
+
+
+# 对 conv1 做 Kaiming 初始化，对 从 conv2 做 Xavier 初始化
+toy_net = ToyNet(
+ init_cfg=[
+ dict(
+ type='Kaiming',
+ layer=['Conv2d'],
+ override=dict(name='conv2', type='Xavier')),
+ ], )
+toy_net.init_weights()
+```
+
+```
+08/19 16:50:24 - mmengine - INFO -
+conv1.weight - torch.Size([1, 1, 1, 1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv1.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv2.weight - torch.Size([1, 1, 1, 1]):
+XavierInit: gain=1, distribution=normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv2.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+```
+
+`override` 可以理解成一个嵌套的 `init_cfg`， 他同样可以是 `list` 或者 `dict`，也需要通过 `type`
+字段指定初始化方式。不同的是 `override` 必须指定 `name`，`name` 相当于 `override`
+的作用域，如上例中，`override` 的作用域为 `toy_net.conv2`，我们会以 `Xavier` 初始化方式初始化 `toy_net.conv2` 下的所有参数，而不会影响作用域以外的模块。
+
+### 自定义的初始化方式
+
+尽管 `init_cfg` 能够控制各个模块的初始化方式，但是在不扩展 `WEIGHT_INITIALIZERS`
+的情况下，我们是无法初始化一些自定义模块的，例如表格中提到的大多数初始化器，都需要对应的模块有 `weight` 和 `bias` 属性 。对于这种情况，我们建议让自定义模块实现 `init_weights` 方法。模型调用 `init_weights`
+时，会链式地调用所有子模块的 `init_weights`。
+
+假设我们定义了以下模块：
+
+- 继承自 `nn.Module` 的 `ToyConv`，实现了 `init_weights` 方法，让 `custom_weight` 初始化为 1，`custom_bias` 初始化为 0
+
+- 继承自模块基类的模型 `ToyNet`，且含有 `ToyConv` 子模块
+
+我们在调用 `ToyNet` 的 `init_weights` 方法时，会链式的调用的子模块 `ToyConv` 的 `init_weights` 方法，实现自定义模块的初始化。
+
+```python
+import torch
+import torch.nn as nn
+
+from mmengine.model import BaseModule
+
+
+class ToyConv(nn.Module):
+
+ def __init__(self):
+ super().__init__()
+ self.custom_weight = nn.Parameter(torch.empty(1, 1, 1, 1))
+ self.custom_bias = nn.Parameter(torch.empty(1))
+
+ def init_weights(self):
+ with torch.no_grad():
+ self.custom_weight = self.custom_weight.fill_(1)
+ self.custom_bias = self.custom_bias.fill_(0)
+
+
+class ToyNet(BaseModule):
+
+ def __init__(self, init_cfg=None):
+ super().__init__(init_cfg)
+ self.conv1 = nn.Conv2d(1, 1, 1)
+ self.conv2 = nn.Conv2d(1, 1, 1)
+ self.custom_conv = ToyConv()
+
+
+toy_net = ToyNet(
+ init_cfg=[
+ dict(
+ type='Kaiming',
+ layer=['Conv2d'],
+ override=dict(name='conv2', type='Xavier'))
+ ])
+# 链式调用 `ToyConv.init_weights()`，以自定义的方式初始化
+toy_net.init_weights()
+```
+
+```
+08/19 16:50:24 - mmengine - INFO -
+conv1.weight - torch.Size([1, 1, 1, 1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv1.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv2.weight - torch.Size([1, 1, 1, 1]):
+XavierInit: gain=1, distribution=normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+conv2.bias - torch.Size([1]):
+KaimingInit: a=0, mode=fan_out, nonlinearity=relu, distribution =normal, bias=0
+
+08/19 16:50:24 - mmengine - INFO -
+custom_conv.custom_weight - torch.Size([1, 1, 1, 1]):
+Initialized by user-defined `init_weights` in ToyConv
+
+08/19 16:50:24 - mmengine - INFO -
+custom_conv.custom_bias - torch.Size([1]):
+Initialized by user-defined `init_weights` in ToyConv
+```
+
+### 小结
+
+最后我们对 `init_cfg` 和 `init_weights` 两种初始化方式做一些总结：
+
+**1. 配置 `init_cfg` 控制初始化**
+
+- 通常用于初始化一些比较底层的模块，例如卷积、线性层等。如果想通过 `init_cfg` 配置自定义模块的初始化方式，需要将相应的初始化器注册到 `WEIGHT_INITIALIZERS` 里。
+- 动态初始化特性，初始化方式随 `init_cfg` 的值改变。
+
+**2. 实现 `init_weights` 方法**
+
+- 通常用于初始化自定义模块。相比于 `init_cfg` 的自定义初始化，实现 `init_weights` 方法更加简单，无需注册。然而，它的灵活性不及 `init_cfg`，无法动态地指定任意模块的初始化方式。
+
+```{note}
+- init_weights 的优先级比 `init_cfg` 高
+- 执行器会在 train() 函数中调用 init_weights。
+```
+
+## 函数式初始化
+
+在[自定义的初始化方式](#自定义的初始化方式)一节提到，我们可以在 `init_weights` 里实现自定义的参数初始化逻辑。为了能够更加方便地实现参数初始化，MMEngine 在 `torch.nn.init`的基础上，提供了一系列**模块初始化函数**来初始化整个模块。例如我们对卷积层的权重（`weight`）进行正态分布初始化，卷积层的偏置（`bias`）进行常数初始化，基于 `torch.nn.init` 的实现如下：
+
+```python
+from torch.nn.init import normal_, constant_
+import torch.nn as nn
+
+model = nn.Conv2d(1, 1, 1)
+normal_(model.weight, mean=0, std=0.01)
+constant_(model.bias, val=0)
+```
+
+```
+Parameter containing:
+tensor([0.], requires_grad=True)
+```
+
+上述流程实际上是卷积正态分布初始化的标准流程，因此 MMEngine 在此基础上做了进一步地简化，实现了一系列常用的**模块**初始化函数。相比 `torch.nn.init`，MMEngine 提供的初始化函数直接接受卷积模块，一行代码能实现同样的初始化逻辑：
+
+```python
+from mmengine.model import normal_init
+
+normal_init(model, mean=0, std=0.01, bias=0)
+```
+
+类似地，我们也可以用 [Kaiming](http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf) 初始化和 [Xavier](http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf) 初始化：
+
+```python
+from mmengine.model import kaiming_init, xavier_init
+
+kaiming_init(model)
+xavier_init(model)
+```
+
+目前 MMEngine 提供了以下初始化函数：
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/installation.md b/internlm_langchain/knowledge_base/MMEngine/content/installation.md
new file mode 100644
index 00000000..917a2567
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/installation.md
@@ -0,0 +1,75 @@
+# 安装
+
+## 环境依赖
+
+- Python 3.7+
+- PyTorch 1.6+
+- CUDA 9.2+
+- GCC 5.4+
+
+## 准备环境
+
+1. 使用 conda 新建虚拟环境，并进入该虚拟环境；
+
+ ```bash
+ conda create -n open-mmlab python=3.7 -y
+ conda activate open-mmlab
+ ```
+
+2. 安装 PyTorch
+
+ 在安装 MMEngine 之前，请确保 PyTorch 已经成功安装在环境中，可以参考 [PyTorch 官方安装文档](https://pytorch.org/get-started/locally/#start-locally)。使用以下命令验证 PyTorch 是否安装
+
+ ```bash
+ python -c 'import torch;print(torch.__version__)'
+ ```
+
+## 安装 MMEngine
+
+### 使用 mim 安装
+
+[mim](https://github.com/open-mmlab/mim) 是 OpenMMLab 项目的包管理工具，使用它可以很方便地安装 OpenMMLab 项目。
+
+```bash
+pip install -U openmim
+mim install mmengine
+```
+
+### 使用 pip 安装
+
+```bash
+pip install mmengine
+```
+
+### 使用 docker 镜像
+
+1. 构建镜像
+
+ ```bash
+ docker build -t mmengine https://github.com/open-mmlab/mmengine.git#main:docker/release
+ ```
+
+ 更多构建方式请参考 [mmengine/docker](https://github.com/open-mmlab/mmengine/tree/main/docker)。
+
+2. 运行镜像
+
+ ```bash
+ docker run --gpus all --shm-size=8g -it mmengine
+ ```
+
+### 源码安装
+
+```bash
+# 如果克隆代码仓库的速度过慢，可以从 https://gitee.com/open-mmlab/mmengine.git 克隆
+git clone https://github.com/open-mmlab/mmengine.git
+cd mmengine
+pip install -e . -v
+```
+
+## 验证安装
+
+为了验证是否正确安装了 MMEngine 和所需的环境，我们可以运行以下命令
+
+```bash
+python -c 'import mmengine;print(mmengine.__version__)'
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/introduction.md b/internlm_langchain/knowledge_base/MMEngine/content/introduction.md
new file mode 100644
index 00000000..e3958151
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/introduction.md
@@ -0,0 +1,58 @@
+# 介绍
+
+MMEngine 是一个基于 PyTorch 实现的，用于训练深度学习模型的基础库，支持在 Linux、Windows、macOS 上运行。它具有如下三个特性：
+
+1. **通用且强大的执行器**：
+
+ - 支持用少量代码训练不同的任务，例如仅使用 80 行代码就可以训练 ImageNet（原始 PyTorch 示例需要 400 行）。
+ - 轻松兼容流行的算法库（如 TIMM、TorchVision 和 Detectron2）中的模型。
+
+2. **接口统一的开放架构**：
+
+ - 使用统一的接口处理不同的算法任务，例如，实现一个方法并应用于所有的兼容性模型。
+ - 上下游的对接更加统一便捷，在为上层算法库提供统一抽象的同时，支持多种后端设备。目前 MMEngine 支持 Nvidia CUDA、Mac MPS、AMD、MLU 等设备进行模型训练。
+
+3. **可定制的训练流程**：
+
+ - 定义了“乐高”式的训练流程。
+ - 提供了丰富的组件和策略。
+ - 使用不同等级的 API 控制训练过程。
+
+## 架构
+
+
+
+上图展示了 MMEngine 在 OpenMMLab 2.0 中的层次。MMEngine 实现了 OpenMMLab 算法库的新一代训练架构，为 OpenMMLab 中的 30 多个算法库提供了统一的执行基座。其核心组件包含训练引擎、评测引擎和模块管理等。
+
+## 模块介绍
+
+
+
+MMEngine 将训练过程中涉及的组件和它们的关系进行了抽象，如上图所示。不同算法库中的同类型组件具有相同的接口定义。
+
+### 核心模块与相关组件
+
+训练引擎的核心模块是[执行器（Runner）](../tutorials/runner.md)。执行器负责执行训练、测试和推理任务并管理这些过程中所需要的各个组件。在训练、测试、推理任务执行过程中的特定位置，执行器设置了[钩子（Hook）](../tutorials/hook.md)来允许用户拓展、插入和执行自定义逻辑。执行器主要调用如下组件来完成训练和推理过程中的循环：
+
+- [数据集（Dataset）](../tutorials/dataset.md)：负责在训练、测试、推理任务中构建数据集，并将数据送给模型。实际使用过程中会被数据加载器（DataLoader）封装一层，数据加载器会启动多个子进程来加载数据。
+- [模型（Model）](../tutorials/model.md)：在训练过程中接受数据并输出 loss；在测试、推理任务中接受数据，并进行预测。分布式训练等情况下会被模型的封装器（Model Wrapper，如 `MMDistributedDataParallel`）封装一层。
+- [优化器封装（Optimizer）](../tutorials/optim_wrapper.md)：优化器封装负责在训练过程中执行反向传播优化模型，并且以统一的接口支持了混合精度训练和梯度累加。
+- [参数调度器（Parameter Scheduler）](../tutorials/param_scheduler.md)：训练过程中，对学习率、动量等优化器超参数进行动态调整。
+
+在训练间隙或者测试阶段，[评测指标与评测器（Metrics & Evaluator）](../tutorials/evaluation.md)会负责对模型性能进行评测。其中评测器负责基于数据集对模型的预测进行评估。评测器内还有一层抽象是评测指标，负责计算具体的一个或多个评测指标（如召回率、正确率等）。
+
+为了统一接口，OpenMMLab 2.0 中各个算法库的评测器，模型和数据之间交流的接口都使用了[数据元素（Data Element）](../advanced_tutorials/data_element.md)来进行封装。
+
+在训练、推理执行过程中，上述各个组件都可以调用日志管理模块和可视化器进行结构化和非结构化日志的存储与展示。[日志管理（Logging Modules）](../advanced_tutorials/logging.md)：负责管理执行器运行过程中产生的各种日志信息。其中消息枢纽（MessageHub）负责实现组件与组件、执行器与执行器之间的数据共享，日志处理器（Log Processor）负责对日志信息进行处理，处理后的日志会分别发送给执行器的日志器（Logger）和可视化器（Visualizer）进行日志的管理与展示。[可视化器（Visualizer）](../advanced_tutorials/visualization.md)：可视化器负责对模型的特征图、预测结果和训练过程中产生的结构化日志进行可视化，支持 Tensorboard 和 WanDB 等多种可视化后端。
+
+### 公共基础模块
+
+MMEngine 中还实现了各种算法模型执行过程中需要用到的公共基础模块，包括
+
+- [配置类（Config）](../advanced_tutorials/config.md)：在 OpenMMLab 算法库中，用户可以通过编写 config 来配置训练、测试过程以及相关的组件。
+- [注册器（Registry）](../advanced_tutorials/registry.md)：负责管理算法库中具有相同功能的模块。MMEngine 根据对算法库模块的抽象，定义了一套根注册器，算法库中的注册器可以继承自这套根注册器，实现模块的跨算法库调用。
+- [文件读写（File I/O）](../advanced_tutorials/fileio.md)：为各个模块的文件读写提供了统一的接口，以统一的形式支持了多种文件读写后端和多种文件格式，并具备扩展性。
+- [分布式通信原语（Distributed Communication Primitives）](../advanced_tutorials/distributed.md)：负责在程序分布式运行过程中不同进程间的通信。这套接口屏蔽了分布式和非分布式环境的区别，同时也自动处理了数据的设备和通信后端。
+- [其他工具（Utils）](../advanced_tutorials/manager_mixin.md)：还有一些工具性的模块，如 ManagerMixin，它实现了一种全局变量的创建和获取方式，执行器内很多全局可见对象的基类就是 ManagerMixin。
+
+用户可以进一步阅读[教程](../tutorials/runner.md)来了解这些模块的高级用法，也可以参考[设计文档](../design/hook.md) 了解它们的设计思路与细节。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/large_model_training.md b/internlm_langchain/knowledge_base/MMEngine/content/large_model_training.md
new file mode 100644
index 00000000..6539d1a2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/large_model_training.md
@@ -0,0 +1,265 @@
+# 大模型训练
+
+在训练大模型时，需要庞大的资源。单卡显存通常不能满足训练的需要，因此出现了大模型训练技术，其中典型的一种是 [DeepSpeed ZeRO](https://www.deepspeed.ai/tutorials/zero/#zero-overview)。DeepSpedd ZeRO 支持切分优化器、梯度以及参数。
+
+为了更加灵活地支持大模型训练技术，从 MMEngine v0.8.0 开始，我们提供了新的执行器 [FlexibleRunner](mmengine.runner.FlexibleRunner) 和多个抽象策略 [Strategy](../api/strategy)。
+
+```{warning}
+新的执行器 FlexibleRunner 和 Strategy 还处于实验性阶段，在将来的版本中，它们的接口有可能会发生变化。
+```
+
+下面的示例代码摘自 [examples/distributed_training_with_flexible_runner.py](https://github.com/open-mmlab/mmengine/blob/main/examples/distributed_training_with_flexible_runner.py)。
+
+## DeepSpeed
+
+[DeepSpeed](https://github.com/microsoft/DeepSpeed/tree/master) 是微软开源的基于 PyTorch 的分布式框架，其支持了 `ZeRO`, `3D-Parallelism`, `DeepSpeed-MoE`, `ZeRO-Infinity` 等训练策略。
+MMEngine 自 v0.8.0 开始支持使用 DeepSpeed 进行模型的训练。
+
+使用 DeepSpeed 前需安装 deepspeed：
+
+```bash
+pip install deepspeed
+```
+
+安装好 deepspeed 后，需配置 FlexibleRunner 的 strategy 和 optim_wrapper 参数：
+
+- strategy：指定 `type='DeepSpeedStrategy'` 并配置参数。参数的详细介绍可阅读 [DeepSpeedStrategy](mmengine._strategy.DeepSpeedStrategy)。
+- optim_wrapper：指定 `type='DeepSpeedOptimWrapper'` 并配置参数。参数的详细介绍可阅读 [DeepSpeedOptimWrapper](mmengine._strategy.deepspeed.DeepSpeedOptimWrapper)。
+
+下面是 DeepSpeed 相关的配置：
+
+```python
+from mmengine.runner._flexible_runner import FlexibleRunner
+
+# 指定 DeepSpeedStrategy 并配置参数
+strategy = dict(
+ type='DeepSpeedStrategy',
+ fp16=dict(
+ enabled=True,
+ fp16_master_weights_and_grads=False,
+ loss_scale=0,
+ loss_scale_window=500,
+ hysteresis=2,
+ min_loss_scale=1,
+ initial_scale_power=15,
+ ),
+ inputs_to_half=[0],
+ zero_optimization=dict(
+ stage=3,
+ allgather_partitions=True,
+ reduce_scatter=True,
+ allgather_bucket_size=50000000,
+ reduce_bucket_size=50000000,
+ overlap_comm=True,
+ contiguous_gradients=True,
+ cpu_offload=False),
+)
+
+# 指定 DeepSpeedOptimWrapper 并配置参数
+optim_wrapper = dict(
+ type='DeepSpeedOptimWrapper',
+ optimizer=dict(type='AdamW', lr=1e-3))
+
+# 初始化 FlexibleRunner
+runner = FlexibleRunner(
+ model=MMResNet50(),
+ work_dir='./work_dirs',
+ strategy=strategy,
+ train_dataloader=train_dataloader,
+ optim_wrapper=optim_wrapper,
+ param_scheduler=dict(type='LinearLR'),
+ train_cfg=dict(by_epoch=True, max_epochs=10, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy))
+
+# 开始训练
+runner.train()
+```
+
+使用两张卡启动分布式训练：
+
+```bash
+torchrun --nproc-per-node 2 examples/distributed_training_with_flexible_runner.py --use-deepspeed
+```
+
+
+
+
+
+其中 `window_size` 的值可以是：
+
+- 数字：表示统计窗口的大小
+- `global`：统计全局的最大、最小和均值
+- `epoch`：统计一个 epoch 内的最大、最小和均值
+
+当然我们也可以选择自定义的统计方法，详细步骤见[日志设计](../design/logging.md)。
+
+如果我们既想统计窗口为 10 的 `loss1` 的局部均值，又想统计 `loss1` 的全局均值，则需要额外指定 `log_name`：
+
+```python
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)),
+ log_processor=dict(
+ custom_cfg=[
+ # log_name 表示 loss1 重新统计后的日志名
+ dict(data_src='loss1', log_name='loss1_global', method_name='mean', window_size='global')])
+)
+runner.train()
+```
+
+```
+08/21 18:39:32 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0016 data_time: 0.0004 loss1: 0.1512 loss2: 0.3751 loss: 0.5264 loss1_global: 0.1512
+08/21 18:39:32 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0051 data_time: 0.0036 loss1: 0.0113 loss2: 0.0856 loss: 0.0970 loss1_global: 0.0813
+```
+
+类似地，我们也可以统计 `loss1` 的局部最大值和全局最大值：
+
+```python
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)),
+ log_processor=dict(custom_cfg=[
+ # 统计 loss1 的局部最大值，统计窗口为 10，并在日志中重命名为 loss1_local_max
+ dict(data_src='loss1',
+ log_name='loss1_local_max',
+ window_size=10,
+ method_name='max'),
+ # 统计 loss1 的全局最大值，并在日志中重命名为 loss1_local_max
+ dict(
+ data_src='loss1',
+ log_name='loss1_global_max',
+ method_name='max',
+ window_size='global')
+ ]))
+runner.train()
+```
+
+```
+08/21 03:17:26 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0021 data_time: 0.0006 loss1: 1.8495 loss2: 1.3427 loss: 3.1922 loss1_local_max: 2.8872 loss1_global_max: 2.8872
+08/21 03:17:26 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0024 data_time: 0.0010 loss1: 0.5464 loss2: 0.7251 loss: 1.2715 loss1_local_max: 2.8872 loss1_global_max: 2.8872
+```
+
+更多配置规则见[日志处理器文档](mmengine.runner.LogProcessor)
+
+## 自定义统计内容
+
+除了 MMEngine 默认的日志统计类型，如损失、迭代时间、学习率，用户也可以自行添加日志的统计内容。例如我们想统计损失的中间结果，可以这样做：
+
+```python
+from mmengine.logging import MessageHub
+
+
+class ToyModel(BaseModel):
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, mode):
+ feat = self.linear(img)
+ loss_tmp = (feat - label).abs()
+ loss = loss_tmp.pow(2)
+
+ message_hub = MessageHub.get_current_instance()
+ # 在日志中额外统计 `loss_tmp`
+ message_hub.update_scalar('train/loss_tmp', loss_tmp.sum())
+ return dict(loss=loss)
+
+
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)),
+ log_processor=dict(
+ custom_cfg=[
+ # 统计 loss_tmp 的局部均值
+ dict(
+ data_src='loss_tmp',
+ window_size=10,
+ method_name='mean')
+ ]
+ )
+)
+runner.train()
+```
+
+```
+08/21 03:40:31 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0026 data_time: 0.0008 loss_tmp: 0.0097 loss: 0.0000
+08/21 03:40:31 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0028 data_time: 0.0013 loss_tmp: 0.0065 loss: 0.0000
+```
+
+通过调用[消息枢纽](mmengine.logging.MessageHub)的接口实现自定义日志的统计，具体步骤如下：
+
+1. 调用 `get_current_instance` 接口获取执行器的消息枢纽。
+2. 调用 `update_scalar` 接口更新日志内容，其中第一个参数为日志的名称，日志名称以 `train/`，`val/`，`test/` 前缀打头，用于区分训练状态，然后才是实际的日志名，如上例中的 `train/loss_tmp`,这样统计的日志中就会出现 `loss_tmp`。
+3. 配置日志处理器，以均值的方式统计 `loss_tmp`。如果不配置，日志里显示 `loss_tmp` 最近一次更新的值。
+
+## 输出调试日志
+
+初始化执行器（Runner）时，将 `log_level` 设置成 `debug`。这样终端上就会额外输出日志等级为 `debug` 的日志
+
+```python
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ log_level='DEBUG',
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)))
+runner.train()
+```
+
+```
+08/21 18:16:22 - mmengine - DEBUG - Get class `LocalVisBackend` from "vis_backend" registry in "mmengine"
+08/21 18:16:22 - mmengine - DEBUG - An `LocalVisBackend` instance is built from registry, its implementation can be found in mmengine.visualization.vis_backend
+08/21 18:16:22 - mmengine - DEBUG - Get class `RuntimeInfoHook` from "hook" registry in "mmengine"
+08/21 18:16:22 - mmengine - DEBUG - An `RuntimeInfoHook` instance is built from registry, its implementation can be found in mmengine.hooks.runtime_info_hook
+08/21 18:16:22 - mmengine - DEBUG - Get class `IterTimerHook` from "hook" registry in "mmengine"
+...
+```
+
+此外，分布式训练时，`DEBUG` 模式还会分进程存储日志。单机多卡，或者多机多卡但是共享存储的情况下，导出的分布式日志路径如下
+
+```text
+# 共享存储
+./tmp
+├── tmp.log
+├── tmp_rank1.log
+├── tmp_rank2.log
+├── tmp_rank3.log
+├── tmp_rank4.log
+├── tmp_rank5.log
+├── tmp_rank6.log
+└── tmp_rank7.log
+...
+└── tmp_rank63.log
+```
+
+多机多卡，独立存储的情况：
+
+```text
+# 独立存储
+# 设备 0：
+work_dir/
+└── exp_name_logs
+ ├── exp_name.log
+ ├── exp_name_rank1.log
+ ├── exp_name_rank2.log
+ ├── exp_name_rank3.log
+ ...
+ └── exp_name_rank7.log
+
+# 设备 7：
+work_dir/
+└── exp_name_logs
+ ├── exp_name_rank56.log
+ ├── exp_name_rank57.log
+ ├── exp_name_rank58.log
+ ...
+ └── exp_name_rank63.log
+```
+
+如果想要更加深入的了解 MMEngine 的日志系统，可以参考[日志系统设计](../design/logging.md)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/manager_mixin.md b/internlm_langchain/knowledge_base/MMEngine/content/manager_mixin.md
new file mode 100644
index 00000000..4395d84a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/manager_mixin.md
@@ -0,0 +1,55 @@
+# 全局管理器（ManagerMixin）
+
+Runner 在训练过程中，难免会使用全局变量来共享信息，例如我们会在 model 中获取全局的 [logger](mmengine.logging.MMLogger) 来打印初始化信息；在 model 中获取全局的 [Visualizer](./visualization.md) 来可视化预测结果、特征图；在 [Registry](../advanced_tutorials/registry.md) 中获取全局的 [DefaultScope](mmengine.registry.DefaultScope) 来确定注册域。为了管理这些功能相似的模块，MMEngine 设计了管理器 [ManagerMix](mmengine.utils.ManagerMixin) 来统一全局变量的创建和获取方式。
+
+
+
+## 接口介绍
+
+- get_instance(name='', \*\*kwargs)：创建或者返回对应名字的的实例。
+- get_current_instance()：返回最近被创建的实例。
+- instance_name：获取对应实例的 name。
+
+## 使用方法
+
+1. 定义有全局访问需求的类
+
+```python
+from mmengine.utils import ManagerMixin
+
+
+class GlobalClass(ManagerMixin):
+ def __init__(self, name, value):
+ super().__init__(name)
+ self.value = value
+```
+
+注意全局类的构造函数必须带有 name 参数，并在构造函数中调用 `super().__init__(name)`，以确保后续能够根据 name 来获取对应的实例。
+
+2. 在任意位置实例化该对象，以 Hook 为例（要确保访问该实例时，对象已经被创建）：
+
+```python
+from mmengine import Hook
+
+class CustomHook(Hook):
+ def before_run(self, runner):
+ GlobalClass.get_instance('mmengine', value=50)
+ GlobalClass.get_instance(runner.experiment_name, value=100)
+```
+
+当我们调用子类的 `get_instance` 接口时，`ManagerMixin` 会根据名字来判断对应实例是否已经存在，进而创建/获取实例。如上例所示，当我们第一次调用 `GlobalClass.get_instance('mmengine', value=50)` 时，会创建一个名为 "mmengine" 的 `GlobalClass` 实例，其初始 value 为 50。为了方便后续介绍 `get_current_instance` 接口，这里我们创建了两个 `GlobalClass` 实例。
+
+3. 在任意组件中访问该实例
+
+```python
+import torch.nn as nn
+
+
+class CustomModule(nn.Module):
+ def forward(self, x):
+ value = GlobalClass.get_current_instance().value # 最近一次被创建的实例 value 为 100（步骤二中按顺序创建）
+ value = GlobalClass.get_instance('mmengine').value # 名为 mmengine 的实例 value 为 50
+ # value = GlobalClass.get_instance('mmengine', 1000).value # mmengine 已经被创建，不能再接受额外参数
+```
+
+在同一进程里，我们可以在不同组件中访问 `GlobalClass` 实例。例如我们在 `CustomModule` 中，调用 `get_instance` 和 `get_current_instance` 接口来获取对应名字的实例和最近被创建的实例。需要注意的是，由于 "mmengine" 实例已经被创建，再次调用时不能再传入额外参数，否则会报错。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/model.md b/internlm_langchain/knowledge_base/MMEngine/content/model.md
new file mode 100644
index 00000000..1da42c17
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/model.md
@@ -0,0 +1,443 @@
+# 迁移 MMCV 模型到 MMEngine
+
+## 简介
+
+MMCV 早期支持的计算机视觉任务，例如目标检测、物体识别等，都采用了一种典型的模型参数优化流程，可以被归纳为以下四个步骤：
+
+1. 计算损失
+2. 计算梯度
+3. 更新参数
+4. 梯度清零
+
+上述流程的一大特点就是调用位置统一（在训练迭代后调用）、执行步骤统一（依次执行步骤 1->2->3->4），非常契合[钩子（Hook）](../design/hook.md)的设计原则，因此这类任务通常会使用 `Hook`
+来优化模型。MMCV 为此实现了一系列的 `Hook`，例如 `OptimizerHook`（单精度训练）、`Fp16OptimizerHook`（混合精度训练） 和 `GradientCumulativeFp16OptimizerHook`（混合精度训练 + 梯度累加），为这类任务提供各种优化策略。
+
+一些例如生成对抗网络（GAN），自监督（Self-supervision）等领域的算法一般有更加灵活的训练流程，这类流程并不满足调用位置统一、执行步骤统一的原则，难以使用 `Hook` 对参数进行优化。为了支持训练这类任务，MMCV 的执行器会在调用 `model.train_step` 时，额外传入 `optimizer` 参数，让模型在 `train_step` 里实现自定义的优化流程。这样虽然可以支持训练这类任务，但也会导致无法使用各种 `OptimizerHook`，需要算法在 `train_step` 中实现混合精度训练、梯度累加等训练策略。
+
+为了统一深度学习任务的参数优化流程，MMEngine 设计了[优化器封装](mmengine.optim.OptimWrapper)，集成了混合精度训练、梯度累加等训练策略，各类深度学习任务一律在 `model.train_step` 里执行参数优化流程。
+
+## 优化流程的迁移
+
+### 常用的参数更新流程
+
+考虑到目标检测、物体识别一类的深度学习任务参数优化的流程基本一致，我们可以通过继承[模型基类](../tutorials/model.md)来完成迁移。
+
+**基于 MMCV 执行器的模型**
+
+在介绍如何迁移模型之前，我们先来看一个基于 MMCV 执行器训练模型的最简示例：
+
+```python
+import torch
+import torch.nn as nn
+from torch.optim import SGD
+from torch.utils.data import DataLoader
+
+from mmcv.runner import Runner
+from mmcv.utils.logging import get_logger
+
+
+train_dataset = [(torch.ones(1, 1), torch.ones(1, 1))] * 50
+train_dataloader = DataLoader(train_dataset, batch_size=2)
+
+
+class MMCVToyModel(nn.Module):
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, return_loss=False):
+ feat = self.linear(img)
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ loss = (loss1 + loss2).sum()
+ return dict(loss=loss,
+ num_samples=len(img),
+ log_vars=dict(
+ loss1=loss1.sum().item(),
+ loss2=loss2.sum().item()))
+
+ def train_step(self, data, optimizer=None):
+ return self(*data, return_loss=True)
+
+ def val_step(self, data, optimizer=None):
+ return self(*data, return_loss=False)
+
+
+model = MMCVToyModel()
+optimizer = SGD(model.parameters(), lr=0.01)
+logger = get_logger('demo')
+
+lr_config = dict(policy='step', step=[2, 3])
+optimizer_config = dict(grad_clip=None)
+log_config = dict(interval=10, hooks=[dict(type='TextLoggerHook')])
+
+
+runner = Runner(
+ model=model,
+ work_dir='tmp_dir',
+ optimizer=optimizer,
+ logger=logger,
+ max_epochs=5)
+
+runner.register_training_hooks(
+ lr_config=lr_config,
+ optimizer_config=optimizer_config,
+ log_config=log_config)
+runner.run([train_dataloader], [('train', 1)])
+```
+
+基于 MMCV 执行器训练模型时，我们必须实现 `train_step` 接口，并返回一个字典，字典需要包含以下三个字段：
+
+- loss：传给 `OptimizerHook` 计算梯度
+- num_samples：传给 `LogBuffer`，用于计算平滑后的损失
+- log_vars：传给 `LogBuffer` 用于计算平滑后的损失
+
+**基于 MMEngine 执行器的模型**
+
+基于 MMEngine 的执行器，实现同样逻辑的代码：
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+from mmengine.runner import Runner
+from mmengine.model import BaseModel
+
+train_dataset = [(torch.ones(1, 1), torch.ones(1, 1))] * 50
+train_dataloader = DataLoader(train_dataset, batch_size=2)
+
+
+class MMEngineToyModel(BaseModel):
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, mode):
+ feat = self.linear(img)
+ # 被 `train_step` 调用，返回用于更新参数的损失字典
+ if mode == 'loss':
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ return dict(loss1=loss1, loss2=loss2)
+ # 被 `val_step` 调用，返回传给 `evaluator` 的预测结果
+ elif mode == 'predict':
+ return [_feat for _feat in feat]
+ # tensor 模式，功能详见模型教程文档： tutorials/model.md
+ else:
+ pass
+
+
+runner = Runner(
+ model=MMEngineToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=5),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)))
+runner.train()
+```
+
+MMEngine 实现了模型基类，模型基类在 `train_step` 里实现了 `OptimizerHook` 的优化流程。因此上例中，我们无需实现 `train_step`，运行时直接调用基类的 `train_step`。
+
+
+
+
+
+关于等效代码中的[数据处理器（data_preprocessor）](mmengine.model.BaseDataPreprocessor)和[优化器封装（optim_wrapper）](mmengine.optim.OptimWrapper)的说明，详见[模型教程](../tutorials/model.md#数据预处理器datapreprocessor)和[优化器封装教程](../tutorials/optim_wrapper.md)。
+
+模型具体差异如下：
+
+- `MMCVToyModel` 继承自 `nn.Module`，而 `MMEngineToyModel` 继承自 `BaseModel`
+- `MMCVToyModel` 必须实现 `train_step`，且必须返回损失字典，损失字典包含 `loss` 和 `log_vars` 和 `num_samples` 字段。`MMEngineToyModel` 继承自 `BaseModel`，只需要实现 `forward` 接口，并返回损失字典，损失字典的每一个值必须是可微的张量
+- `MMCVToyModel` 和 `MMEngineModel` 的 `forward` 的接口需要匹配 `train_step` 中的调用方式，由于 `MMEngineToyModel` 直接调用基类的 `train_step` 方法，因此 `forward` 需要接受参数 `mode`，具体规则详见[模型教程文档](../tutorials/model.md)
+
+### 自定义的参数更新流程
+
+以训练生成对抗网络为例，生成器和判别器的优化需要交替进行，且优化流程可能会随着迭代次数的增多发生变化，因此很难使用 `OptimizerHook` 来满足这种需求。在基于 MMCV 训练生成对抗网络时，通常会在模型的 `train_step` 接口中传入 `optimizer`，然后在 `train_step` 里实现自定义的参数更新逻辑。这种训练流程和 MMEngine 非常相似，只不过 MMEngine 在 `train_step` 接口中传入[优化器封装](../tutorials/optim_wrapper.md)，能够更加简单地优化模型。
+
+参考[训练生成对抗网络](../examples/train_a_gan.md)，MMCV 和 MMEngine 的对比实现如下：
+
+
+
+
+
+二者的区别主要在于优化器的使用方式。此外，`train_step` 接口返回值的差异和[上一节](#常用的参数更新流程)提到的一致。
+
+## 验证/测试流程的迁移
+
+基于 MMCV 执行器实现的模型通常不需要为验证、测试流程提供独立的 `val_step`、`test_step`（测试流程由 `EvalHook` 实现，这里不做展开）。基于 MMEngine 执行器实现的模型则有所不同，[ValLoop](mmengine.runner.ValLoop)、[TestLoop](mmengine.runner.TestLoop) 会分别调用模型的 `val_step` 和 `test_step` 接口，输出会进一步传给 [Evaluator.process](mmengine.evaluator.Evaluator.process)。因此模型的 `val_step` 和 `test_step` 接口输出需要和 `Evaluator.process` 的入参（第一个参数）对齐，即返回列表（推荐，也可以是其他可迭代类型）类型的结果。列表中的每一个元素代表一个批次（batch）数据中每个样本的预测结果。模型的 `test_step` 和 `val_step` 会调 `forward` 接口（详见[模型教程文档](../tutorials/model.md)），因此在上一节的模型示例中，模型 `forward` 的 `predict` 模式会将 `feat` 切片后，以列表的形式返回预测结果。
+
+```python
+
+class MMEngineToyModel(BaseModel):
+
+ ...
+ def forward(self, img, label, mode):
+ if mode == 'loss':
+ ...
+ elif mode == 'predict':
+ # 把一个 batch 的预测结果切片成列表，每个元素代表一个样本的预测结果
+ return [_feat for _feat in feat]
+ else:
+ ...
+ # tensor 模式，功能详见模型教程文档： tutorials/model.md
+```
+
+## 迁移分布式训练
+
+MMCV 需要在执行器构建之前,使用 `MMDistributedDataParallel` 对模型进行分布式封装。MMEngine 实现了 [MMDistributedDataParallel](mmengine.model.MMDistributedDataParallel) 和 [MMSeparateDistributedDataParallel](mmengine.model.MMSeparateDistributedDataParallel) 两种分布式模型封装，供不同类型的任务选择。执行器会在构建时对模型进行分布式封装。
+
+1. **常用训练流程**
+
+ 对于[简介](#简介)中提到的常用优化流程的训练任务，即一次参数更新可以被拆解成梯度计算、参数优化、梯度清零的任务，使用 Runner 默认的 `MMDistributedDataParallel` 即可满足需求，无需为 runner 其他额外参数。
+
+
+
+
+
+
+
+2. **以自定义流程分模块优化模型的学习任务**
+
+ 同样以训练生成对抗网络为例，生成对抗网络有两个需要分别优化的子模块，即生成器和判别器。因此需要使用 `MMSeparateDistributedDataParallel` 对模型进行封装。我们需要在构建执行器时指定：
+
+ ```python
+ cfg = dict(model_wrapper_cfg='MMSeparateDistributedDataParallel')
+ runner = Runner(
+ model=model,
+ ...,
+ launcher='pytorch',
+ cfg=cfg)
+ ```
+
+ 即可进行分布式训练。
+
+
+
+3. **以自定义流程优化整个模型的深度学习任务**
+
+ 有时候我们需要用自定义的优化流程来优化单个模块，这时候我们就不能复用模型基类的 `train_step`，而需要重新实现，例如我们想用同一批图片对模型优化两次，第一次开启批数据增强，第二次关闭：
+
+ ```python
+ class CustomModel(BaseModel):
+
+ def train_step(self, data, optim_wrapper):
+ data = self.data_preprocessor(data, training=True) # 开启批数据增强
+ loss = self(data, mode='loss')
+ optim_wrapper.update_params(loss)
+ data = self.data_preprocessor(data, training=False) # 关闭批数据增强
+ loss = self(data, mode='loss')
+ optim_wrapper.update_params(loss)
+ ```
+
+ 要想启用分布式训练，我们就需要重载 `MMSeparateDistributedDataParallel`，并在 `train_step` 中实现和 `CustomModel.train_step` 相同的流程（`test_step`、`val_step` 同理）。
+
+ ```python
+ class CustomDistributedDataParallel(MMSeparateDistributedDataParallel):
+
+ def train_step(self, data, optim_wrapper):
+ data = self.data_preprocessor(data, training=True) # 开启批数据增强
+ loss = self(data, mode='loss')
+ optim_wrapper.update_params(loss)
+ data = self.data_preprocessor(data, training=False) # 关闭批数据增强
+ loss = self(data, mode='loss')
+ optim_wrapper.update_params(loss)
+ ```
+
+ 最后在构建 `runner` 时指定：
+
+ ```python
+ # 指定封装类型为 `CustomDistributedDataParallel`，并基于默认参数封装模型。
+ cfg = dict(model_wrapper_cfg=dict(type='CustomDistributedDataParallel'))
+ runner = Runner(
+ model=model,
+ ...,
+ launcher='pytorch',
+ cfg=cfg
+ )
+ ```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/model_analysis.md b/internlm_langchain/knowledge_base/MMEngine/content/model_analysis.md
new file mode 100644
index 00000000..c3867933
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/model_analysis.md
@@ -0,0 +1,184 @@
+# 模型复杂度分析
+
+我们提供了一个工具来帮助分析网络的复杂性。我们借鉴了 [fvcore](https://github.com/facebookresearch/fvcore) 的实现思路来构建这个工具，并计划在未来支持更多的自定义算子。目前的工具提供了用于计算给定模型的浮点运算量（FLOPs）、激活量（Activations）和参数量（Parameters）的接口，并支持以网络结构或表格的形式逐层打印相关信息，同时提供了算子级别（operator）和模块级别（Module）的统计。如果您对统计浮点运算量的实现细节感兴趣，请参考 [Flop Count](https://github.com/facebookresearch/fvcore/blob/main/docs/flop_count.md)。
+
+## 定义
+
+模型复杂度有 3 个指标，分别是浮点运算量（FLOPs）、激活量（Activations）以及参数量（Parameters），它们的定义如下：
+
+- 浮点运算量
+
+ 浮点运算量不是一个定义非常明确的指标，在这里参考 [detectron2](https://detectron2.readthedocs.io/en/latest/modules/fvcore.html#fvcore.nn.FlopCountAnalysis) 的描述，将一组乘加运算定义为 1 个 flop。
+
+- 激活量
+
+ 激活量用于衡量某一层产生的特征数量。
+
+- 参数量
+
+ 模型的参数量。
+
+例如，给定输入尺寸 `inputs = torch.randn((1, 3, 10, 10))`，和一个卷积层 `conv = nn.Conv2d(in_channels=3, out_channels=10, kernel_size=3)`，那么它输出的特征图尺寸为 `(1, 10, 8, 8)`，则它的浮点运算量是 `17280 = 10*8*8*3*3*3`（10*8*8 表示输出的特征图大小、3*3*3 表示每一个输出需要的计算量）、激活量是 `640 = 10*8*8`、参数量是 `280 = 3*10*3*3 + 10`（3*10*3\*3 表示权重的尺寸、10 表示偏置值的尺寸）。
+
+## 用法
+
+### 基于 `nn.Module` 构建的模型
+
+构建模型
+
+```python
+from torch import nn
+
+from mmengine.analysis import get_model_complexity_info
+
+
+# 以字典的形式返回分析结果，包括:
+# ['flops', 'flops_str', 'activations', 'activations_str', 'params', 'params_str', 'out_table', 'out_arch']
+class InnerNet(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(10, 10)
+ self.fc2 = nn.Linear(10, 10)
+
+ def forward(self, x):
+ return self.fc1(self.fc2(x))
+
+
+class TestNet(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(10, 10)
+ self.fc2 = nn.Linear(10, 10)
+ self.inner = InnerNet()
+
+ def forward(self, x):
+ return self.fc1(self.fc2(self.inner(x)))
+
+
+input_shape = (1, 10)
+model = TestNet()
+```
+
+`get_model_complexity_info` 返回的 `analysis_results` 是一个包含 7 个值的字典:
+
+- `flops`: flop 的总数, 例如, 1000, 1000000
+- `flops_str`: 格式化的字符串, 例如, 1.0G, 1.0M
+- `params`: 全部参数的数量, 例如, 1000, 1000000
+- `params_str`: 格式化的字符串, 例如, 1.0K, 1M
+- `activations`: 激活量的总数, 例如, 1000, 1000000
+- `activations_str`: 格式化的字符串, 例如, 1.0G, 1M
+- `out_table`: 以表格形式打印相关信息
+
+打印结果
+
+- 以表格形式打印相关信息
+
+ ```python
+ print(analysis_results['out_table'])
+ ```
+
+ ```text
+ +---------------------+----------------------+--------+--------------+
+ | module | #parameters or shape | #flops | #activations |
+ +---------------------+----------------------+--------+--------------+
+ | model | 0.44K | 0.4K | 40 |
+ | fc1 | 0.11K | 100 | 10 |
+ | fc1.weight | (10, 10) | | |
+ | fc1.bias | (10,) | | |
+ | fc2 | 0.11K | 100 | 10 |
+ | fc2.weight | (10, 10) | | |
+ | fc2.bias | (10,) | | |
+ | inner | 0.22K | 0.2K | 20 |
+ | inner.fc1 | 0.11K | 100 | 10 |
+ | inner.fc1.weight | (10, 10) | | |
+ | inner.fc1.bias | (10,) | | |
+ | inner.fc2 | 0.11K | 100 | 10 |
+ | inner.fc2.weight | (10, 10) | | |
+ | inner.fc2.bias | (10,) | | |
+ +---------------------+----------------------+--------+--------------+
+ ```
+
+- 以网络层级结构打印相关信息
+
+ ```python
+ print(analysis_results['out_arch'])
+ ```
+
+ ```bash
+ TestNet(
+ #params: 0.44K, #flops: 0.4K, #acts: 40
+ (fc1): Linear(
+ in_features=10, out_features=10, bias=True
+ #params: 0.11K, #flops: 100, #acts: 10
+ )
+ (fc2): Linear(
+ in_features=10, out_features=10, bias=True
+ #params: 0.11K, #flops: 100, #acts: 10
+ )
+ (inner): InnerNet(
+ #params: 0.22K, #flops: 0.2K, #acts: 20
+ (fc1): Linear(
+ in_features=10, out_features=10, bias=True
+ #params: 0.11K, #flops: 100, #acts: 10
+ )
+ (fc2): Linear(
+ in_features=10, out_features=10, bias=True
+ #params: 0.11K, #flops: 100, #acts: 10
+ )
+ )
+ )
+ ```
+
+- 以字符串的形式打印结果
+
+ ```python
+ print("Model Flops:{}".format(analysis_results['flops_str']))
+ # Model Flops:0.4K
+ print("Model Parameters:{}".format(analysis_results['params_str']))
+ # Model Parameters:0.44K
+ ```
+
+### 基于 BaseModel（来自 MMEngine）构建的模型
+
+```python
+import torch.nn.functional as F
+import torchvision
+from mmengine.model import BaseModel
+from mmengine.analysis import get_model_complexity_info
+
+
+class MMResNet50(BaseModel):
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+
+ def forward(self, imgs, labels=None, mode='tensor'):
+ x = self.resnet(imgs)
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+ elif mode == 'tensor':
+ return x
+
+
+input_shape = (3, 224, 224)
+model = MMResNet50()
+
+analysis_results = get_model_complexity_info(model, input_shape)
+
+print("Model Flops:{}".format(analysis_results['flops_str']))
+# Model Flops:4.145G
+print("Model Parameters:{}".format(analysis_results['params_str']))
+# Model Parameters:25.557M
+```
+
+## 其他接口
+
+除了上述基本用法，`get_model_complexity_info` 还能接受以下参数，输出定制化的统计结果：
+
+- `model`: (nn.Module) 待分析的模型
+- `input_shape`: (tuple) 输入尺寸，例如 (3, 224, 224)
+- `inputs`: (optional: torch.Tensor), 如果传入该参数, `input_shape` 会被忽略
+- `show_table`: (bool) 是否以表格形式返回统计结果，默认值：True
+- `show_arch`: (bool) 是否以网络结构形式返回统计结果，默认值：True
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/optim_wrapper.md b/internlm_langchain/knowledge_base/MMEngine/content/optim_wrapper.md
new file mode 100644
index 00000000..2c9c7d6b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/optim_wrapper.md
@@ -0,0 +1,502 @@
+# 优化器封装（OptimWrapper）
+
+在[执行器教程](./runner.md)和[模型教程](./model.md)中，我们或多或少地提到了优化器封装（OptimWrapper）的概念，但是却没有介绍为什么我们需要优化器封装，相比于 Pytorch 原生的优化器，优化器封装又有怎样的优势，这些问题会在本教程中得到一一解答。我们将通过对比的方式帮助大家理解，优化器封装的优势，以及如何使用它。
+
+优化器封装顾名思义，是 Pytorch 原生优化器（Optimizer）高级抽象，它在增加了更多功能的同时，提供了一套统一的接口。优化器封装支持不同的训练策略，包括混合精度训练、梯度累加和梯度截断。我们可以根据需求选择合适的训练策略。优化器封装还定义了一套标准的参数更新流程，用户可以基于这一套流程，实现同一套代码，不同训练策略的切换。
+
+## 优化器封装 vs 优化器
+
+这里我们分别基于 Pytorch 内置的优化器和 MMEngine 的优化器封装进行单精度训练、混合精度训练和梯度累加，对比二者实现上的区别。
+
+### 训练模型
+
+**1.1 基于 Pytorch 的 SGD 优化器实现单精度训练**
+
+```python
+import torch
+from torch.optim import SGD
+import torch.nn as nn
+import torch.nn.functional as F
+
+inputs = [torch.zeros(10, 1, 1)] * 10
+targets = [torch.ones(10, 1, 1)] * 10
+model = nn.Linear(1, 1)
+optimizer = SGD(model.parameters(), lr=0.01)
+optimizer.zero_grad()
+
+for input, target in zip(inputs, targets):
+ output = model(input)
+ loss = F.l1_loss(output, target)
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+```
+
+**1.2 使用 MMEngine 的优化器封装实现单精度训练**
+
+```python
+from mmengine.optim import OptimWrapper
+
+optim_wrapper = OptimWrapper(optimizer=optimizer)
+
+for input, target in zip(inputs, targets):
+ output = model(input)
+ loss = F.l1_loss(output, target)
+ optim_wrapper.update_params(loss)
+```
+
+
+
+优化器封装的 `update_params` 实现了标准的梯度计算、参数更新和梯度清零流程，可以直接用来更新模型参数。
+
+**2.1 基于 Pytorch 的 SGD 优化器实现混合精度训练**
+
+```python
+from torch.cuda.amp import autocast
+
+model = model.cuda()
+inputs = [torch.zeros(10, 1, 1, 1)] * 10
+targets = [torch.ones(10, 1, 1, 1)] * 10
+
+for input, target in zip(inputs, targets):
+ with autocast():
+ output = model(input.cuda())
+ loss = F.l1_loss(output, target.cuda())
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+```
+
+**2.2 基于 MMEngine 的 优化器封装实现混合精度训练**
+
+```python
+from mmengine.optim import AmpOptimWrapper
+
+optim_wrapper = AmpOptimWrapper(optimizer=optimizer)
+
+for input, target in zip(inputs, targets):
+ with optim_wrapper.optim_context(model):
+ output = model(input.cuda())
+ loss = F.l1_loss(output, target.cuda())
+ optim_wrapper.update_params(loss)
+```
+
+
+
+开启混合精度训练需要使用 `AmpOptimWrapper`，他的 optim_context 接口类似 `autocast`，会开启混合精度训练的上下文。除此之外他还能加速分布式训练时的梯度累加，这个我们会在下一个示例中介绍。
+
+**3.1 基于 Pytorch 的 SGD 优化器实现混合精度训练和梯度累加**
+
+```python
+for idx, (input, target) in enumerate(zip(inputs, targets)):
+ with autocast():
+ output = model(input.cuda())
+ loss = F.l1_loss(output, target.cuda())
+ loss.backward()
+ if idx % 2 == 0:
+ optimizer.step()
+ optimizer.zero_grad()
+```
+
+**3.2 基于 MMEngine 的优化器封装实现混合精度训练和梯度累加**
+
+```python
+optim_wrapper = AmpOptimWrapper(optimizer=optimizer, accumulative_counts=2)
+
+for input, target in zip(inputs, targets):
+ with optim_wrapper.optim_context(model):
+ output = model(input.cuda())
+ loss = F.l1_loss(output, target.cuda())
+ optim_wrapper.update_params(loss)
+```
+
+
+
+我们只需要配置 `accumulative_counts` 参数，并调用 `update_params` 接口就能实现梯度累加的功能。除此之外，分布式训练情况下，如果我们配置梯度累加的同时开启了 `optim_wrapper` 上下文，可以避免梯度累加阶段不必要的梯度同步。
+
+优化器封装同样提供了更细粒度的接口，方便用户实现一些自定义的参数更新逻辑：
+
+- `backward`：传入损失，用于计算参数梯度。
+- `step`：同 `optimizer.step`，用于更新参数。
+- `zero_grad`：同 `optimizer.zero_grad`，用于参数的梯度。
+
+我们可以使用上述接口实现和 Pytorch 优化器相同的参数更新逻辑：
+
+```python
+for idx, (input, target) in enumerate(zip(inputs, targets)):
+ optimizer.zero_grad()
+ with optim_wrapper.optim_context(model):
+ output = model(input.cuda())
+ loss = F.l1_loss(output, target.cuda())
+ optim_wrapper.backward(loss)
+ if idx % 2 == 0:
+ optim_wrapper.step()
+ optim_wrapper.zero_grad()
+```
+
+我们同样可以为优化器封装配置梯度裁减策略：
+
+```python
+# 基于 torch.nn.utils.clip_grad_norm_ 对梯度进行裁减
+optim_wrapper = AmpOptimWrapper(
+ optimizer=optimizer, clip_grad=dict(max_norm=1))
+
+# 基于 torch.nn.utils.clip_grad_value_ 对梯度进行裁减
+optim_wrapper = AmpOptimWrapper(
+ optimizer=optimizer, clip_grad=dict(clip_value=0.2))
+```
+
+### 获取学习率/动量
+
+优化器封装提供了 `get_lr` 和 `get_momentum` 接口用于获取优化器的一个参数组的学习率：
+
+```python
+import torch.nn as nn
+from torch.optim import SGD
+
+from mmengine.optim import OptimWrapper
+
+model = nn.Linear(1, 1)
+optimizer = SGD(model.parameters(), lr=0.01)
+optim_wrapper = OptimWrapper(optimizer)
+
+print(optimizer.param_groups[0]['lr']) # 0.01
+print(optimizer.param_groups[0]['momentum']) # 0
+print(optim_wrapper.get_lr()) # {'lr': [0.01]}
+print(optim_wrapper.get_momentum()) # {'momentum': [0]}
+```
+
+```
+0.01
+0
+{'lr': [0.01]}
+{'momentum': [0]}
+```
+
+### 导出/加载状态字典
+
+优化器封装和优化器一样，提供了 `state_dict` 和 `load_state_dict` 接口，用于导出/加载优化器状态，对于 `AmpOptimWrapper`，优化器封装还会额外导出混合精度训练相关的参数：
+
+```python
+import torch.nn as nn
+from torch.optim import SGD
+from mmengine.optim import OptimWrapper, AmpOptimWrapper
+
+model = nn.Linear(1, 1)
+optimizer = SGD(model.parameters(), lr=0.01)
+
+optim_wrapper = OptimWrapper(optimizer=optimizer)
+amp_optim_wrapper = AmpOptimWrapper(optimizer=optimizer)
+
+# 导出状态字典
+optim_state_dict = optim_wrapper.state_dict()
+amp_optim_state_dict = amp_optim_wrapper.state_dict()
+
+print(optim_state_dict)
+print(amp_optim_state_dict)
+optim_wrapper_new = OptimWrapper(optimizer=optimizer)
+amp_optim_wrapper_new = AmpOptimWrapper(optimizer=optimizer)
+
+# 加载状态字典
+amp_optim_wrapper_new.load_state_dict(amp_optim_state_dict)
+optim_wrapper_new.load_state_dict(optim_state_dict)
+```
+
+```
+{'state': {}, 'param_groups': [{'lr': 0.01, 'momentum': 0, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'maximize': False, 'foreach': None, 'params': [0, 1]}]}
+{'state': {}, 'param_groups': [{'lr': 0.01, 'momentum': 0, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'maximize': False, 'foreach': None, 'params': [0, 1]}], 'loss_scaler': {'scale': 65536.0, 'growth_factor': 2.0, 'backoff_factor': 0.5, 'growth_interval': 2000, '_growth_tracker': 0}}
+```
+
+### 使用多个优化器
+
+考虑到生成对抗网络之类的算法通常需要使用多个优化器来训练生成器和判别器，因此优化器封装提供了优化器封装的容器类：`OptimWrapperDict` 来管理多个优化器封装。`OptimWrapperDict` 以字典的形式存储优化器封装，并允许用户像字典一样访问、遍历其中的元素，即优化器封装实例。
+
+与普通的优化器封装不同，`OptimWrapperDict` 没有实现 `update_params`、 `optim_context`, `backward`、`step` 等方法，无法被直接用于训练模型。我们建议直接访问 `OptimWrapperDict` 管理的优化器实例，来实现参数更新逻辑。
+
+你或许会好奇，既然 `OptimWrapperDict` 没有训练的功能，那为什么不直接使用 `dict` 来管理多个优化器？事实上，`OptimWrapperDict` 的核心功能是支持批量导出/加载所有优化器封装的状态字典；支持获取多个优化器封装的学习率、动量。如果没有 `OptimWrapperDict`，`MMEngine` 就需要在很多位置对优化器封装的类型做 `if else` 判断，以获取所有优化器封装的状态。
+
+```python
+from torch.optim import SGD
+import torch.nn as nn
+
+from mmengine.optim import OptimWrapper, OptimWrapperDict
+
+gen = nn.Linear(1, 1)
+disc = nn.Linear(1, 1)
+optimizer_gen = SGD(gen.parameters(), lr=0.01)
+optimizer_disc = SGD(disc.parameters(), lr=0.01)
+
+optim_wapper_gen = OptimWrapper(optimizer=optimizer_gen)
+optim_wapper_disc = OptimWrapper(optimizer=optimizer_disc)
+optim_dict = OptimWrapperDict(gen=optim_wapper_gen, disc=optim_wapper_disc)
+
+print(optim_dict.get_lr()) # {'gen.lr': [0.01], 'disc.lr': [0.01]}
+print(optim_dict.get_momentum()) # {'gen.momentum': [0], 'disc.momentum': [0]}
+```
+
+```
+{'gen.lr': [0.01], 'disc.lr': [0.01]}
+{'gen.momentum': [0], 'disc.momentum': [0]}
+```
+
+如上例所示，`OptimWrapperDict` 可以非常方便的导出所有优化器封装的学习率和动量，同样的，优化器封装也能够导出/加载所有优化器封装的状态字典。
+
+### 在[执行器](./runner.md)中配置优化器封装
+
+优化器封装需要接受 `optimizer` 参数，因此我们首先需要为优化器封装配置 `optimizer`。MMEngine 会自动将 PyTorch 中的所有优化器都添加进 `OPTIMIZERS` 注册表中，用户可以用字典的形式来指定优化器，所有支持的优化器见 [PyTorch 优化器列表](https://pytorch.org/docs/stable/optim.html#algorithms)。
+
+以配置一个 SGD 优化器封装为例：
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer)
+```
+
+这样我们就配置好了一个优化器类型为 SGD 的优化器封装，学习率、动量等参数如配置所示。考虑到 `OptimWrapper` 为标准的单精度训练，因此我们也可以不配置 `type` 字段：
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(optimizer=optimizer)
+```
+
+要想开启混合精度训练和梯度累加，需要将 `type` 切换成 `AmpOptimWrapper`，并指定 `accumulative_counts` 参数：
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='AmpOptimWrapper', optimizer=optimizer, accumulative_counts=2)
+```
+
+```{note}
+如果你是第一次阅读 MMEngine 的教程文档，并且尚未了解[配置类](../advanced_tutorials/config.md)、[注册器](../advanced_tutorials/registry.md) 等概念，建议可以先跳过以下进阶教程，先去阅读其他文档。当然了，如果你已经具备了这些储备知识，我们强烈建议阅读进阶教程，在进阶教程中，我们将学会：
+
+1. 如何在配置文件中定制化地在优化器中配置模型参数的学习率、衰减系数等。
+2. 如何自定义一个优化器构造策略，实现真正意义上的“优化器配置自由”。
+
+除了配置类和注册器等前置知识，我们建议在开始进阶教程之前，先深入了解 Pytorch 原生优化器构造时的 params 参数。
+```
+
+## 进阶配置
+
+PyTorch 的优化器支持对模型中的不同参数设置不同的超参数，例如对一个分类模型的骨干（backbone）和分类头（head）设置不同的学习率：
+
+```python
+from torch.optim import SGD
+import torch.nn as nn
+
+model = nn.ModuleDict(dict(backbone=nn.Linear(1, 1), head=nn.Linear(1, 1)))
+optimizer = SGD([{'params': model.backbone.parameters()},
+ {'params': model.head.parameters(), 'lr': 1e-3}],
+ lr=0.01,
+ momentum=0.9)
+```
+
+上面的例子中，模型的骨干部分使用了 0.01 学习率，而模型的头部则使用了 1e-3 学习率。用户可以将模型的不同部分参数和对应的超参组成一个字典的列表传给优化器，来实现对模型优化的细粒度调整。
+
+在 MMEngine 中，我们通过优化器封装构造器（optimizer wrapper constructor），让用户能够直接通过设置优化器封装配置文件中的 `paramwise_cfg` 字段而非修改代码来实现对模型的不同部分设置不同的超参。
+
+### 为不同类型的参数设置不同的超参系数
+
+MMEngine 提供的默认优化器封装构造器支持对模型中不同类型的参数设置不同的超参系数。例如，我们可以在 `paramwise_cfg` 中设置 `norm_decay_mult=0`，从而将正则化层（normalization layer）的权重（weight）和偏置（bias）的权值衰减系数（weight decay）设置为 0，来实现 [Bag of Tricks](https://arxiv.org/abs/1812.01187) 论文中提到的不对正则化层进行权值衰减的技巧。
+
+具体示例如下，我们将 `ToyModel` 中所有正则化层（`head.bn`）的权重衰减系数设置为 0：
+
+```python
+from mmengine.optim import build_optim_wrapper
+from collections import OrderedDict
+
+class ToyModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.backbone = nn.ModuleDict(
+ dict(layer0=nn.Linear(1, 1), layer1=nn.Linear(1, 1)))
+ self.head = nn.Sequential(
+ OrderedDict(
+ linear=nn.Linear(1, 1),
+ bn=nn.BatchNorm1d(1)))
+
+
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001),
+ paramwise_cfg=dict(norm_decay_mult=0))
+optimizer = build_optim_wrapper(ToyModel(), optim_wrapper)
+```
+
+```
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.bias:lr=0.01
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.bias:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.bias:lr=0.01
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.bias:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.bias:lr=0.01
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.bias:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.weight:weight_decay=0.0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.bias:weight_decay=0.0
+```
+
+除了可以对正则化层的权重衰减进行配置外，MMEngine 的默认优化器封装构造器的 `paramwise_cfg` 还支持对更多不同类型的参数设置超参系数，支持的配置如下：
+
+`lr_mult`：所有参数的学习率系数
+
+`decay_mult`：所有参数的衰减系数
+
+`bias_lr_mult`：偏置的学习率系数（不包括正则化层的偏置以及可变形卷积的 offset）
+
+`bias_decay_mult`：偏置的权值衰减系数（不包括正则化层的偏置以及可变形卷积的 offset）
+
+`norm_decay_mult`：正则化层权重和偏置的权值衰减系数
+
+`flat_decay_mult`：一维参数的权值衰减系数
+
+`dwconv_decay_mult`：Depth-wise 卷积的权值衰减系数
+
+`bypass_duplicate`：是否跳过重复的参数，默认为 `False`
+
+`dcn_offset_lr_mult`：可变形卷积（Deformable Convolution）的学习率系数
+
+### 为模型不同部分的参数设置不同的超参系数
+
+此外，与上文 PyTorch 的示例一样，在 MMEngine 中我们也同样可以对模型中的任意模块设置不同的超参，只需要在 `paramwise_cfg` 中设置 `custom_keys` 即可。
+
+例如我们想将 `backbone.layer0` 所有参数的学习率设置为 0，衰减系数设置为 0，`backbone` 其余子模块的学习率设置为 0.01；`head` 所有参数的学习率设置为 0.001，可以这样配置：
+
+```python
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001),
+ paramwise_cfg=dict(
+ custom_keys={
+ 'backbone.layer0': dict(lr_mult=0, decay_mult=0),
+ 'backbone': dict(lr_mult=1),
+ 'head': dict(lr_mult=0.1)
+ }))
+optimizer = build_optim_wrapper(ToyModel(), optim_wrapper)
+```
+
+```
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.weight:lr=0.0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.weight:weight_decay=0.0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.weight:lr_mult=0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.weight:decay_mult=0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.bias:lr=0.0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.bias:weight_decay=0.0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.bias:lr_mult=0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer0.bias:decay_mult=0
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.weight:lr=0.01
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.weight:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.weight:lr_mult=1
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.bias:lr=0.01
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.bias:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- backbone.layer1.bias:lr_mult=1
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.weight:lr=0.001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.weight:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.weight:lr_mult=0.1
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.bias:lr=0.001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.bias:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.linear.bias:lr_mult=0.1
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.weight:lr=0.001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.weight:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.weight:lr_mult=0.1
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.bias:lr=0.001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.bias:weight_decay=0.0001
+08/23 22:02:43 - mmengine - INFO - paramwise_options -- head.bn.bias:lr_mult=0.1
+```
+
+上例中，模型的状态字典的 `key` 如下：
+
+```python
+for name, val in ToyModel().named_parameters():
+ print(name)
+```
+
+```
+backbone.layer0.weight
+backbone.layer0.bias
+backbone.layer1.weight
+backbone.layer1.bias
+head.linear.weight
+head.linear.bias
+head.bn.weight
+head.bn.bias
+```
+
+custom_keys 中每一个字段的含义如下：
+
+1. `'backbone': dict(lr_mult=1)`：将名字前缀为 `backbone` 的参数的学习率系数设置为 1
+2. `'backbone.layer0': dict(lr_mult=0, decay_mult=0)`：将名字前缀为 `backbone.layer0` 的参数学习率系数设置为 0，衰减系数设置为 0，该配置优先级比第一条高
+3. `'head': dict(lr_mult=0.1)`：将名字前缀为 `head` 的参数的学习率系数设置为 0.1
+
+### 自定义优化器构造策略
+
+与 MMEngine 中的其他模块一样，优化器封装构造器也同样由[注册表](../advanced_tutorials/registry.md)管理。我们可以通过实现自定义的优化器封装构造器来实现自定义的超参设置策略。
+
+例如，我们想实现一个叫做 `LayerDecayOptimWrapperConstructor` 的优化器封装构造器，能够对模型不同深度的层自动设置递减的学习率：
+
+```python
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmengine.registry import OPTIM_WRAPPER_CONSTRUCTORS
+from mmengine.logging import print_log
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module(force=True)
+class LayerDecayOptimWrapperConstructor(DefaultOptimWrapperConstructor):
+
+ def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
+ super().__init__(optim_wrapper_cfg, paramwise_cfg=None)
+ self.decay_factor = paramwise_cfg.get('decay_factor', 0.5)
+
+ super().__init__(optim_wrapper_cfg, paramwise_cfg)
+
+ def add_params(self, params, module, prefix='' ,lr=None):
+ if lr is None:
+ lr = self.base_lr
+
+ for name, param in module.named_parameters(recurse=False):
+ param_group = dict()
+ param_group['params'] = [param]
+ param_group['lr'] = lr
+ params.append(param_group)
+ full_name = f'{prefix}.{name}' if prefix else name
+ print_log(f'{full_name} : lr={lr}', logger='current')
+
+ for name, module in module.named_children():
+ chiled_prefix = f'{prefix}.{name}' if prefix else name
+ self.add_params(
+ params, module, chiled_prefix, lr=lr * self.decay_factor)
+
+
+class ToyModel(nn.Module):
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.layer = nn.ModuleDict(dict(linear=nn.Linear(1, 1)))
+ self.linear = nn.Linear(1, 1)
+
+
+model = ToyModel()
+
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001),
+ paramwise_cfg=dict(decay_factor=0.5),
+ constructor='LayerDecayOptimWrapperConstructor')
+
+optimizer = build_optim_wrapper(model, optim_wrapper)
+```
+
+```
+08/23 22:20:26 - mmengine - INFO - layer.linear.weight : lr=0.0025
+08/23 22:20:26 - mmengine - INFO - layer.linear.bias : lr=0.0025
+08/23 22:20:26 - mmengine - INFO - linear.weight : lr=0.005
+08/23 22:20:26 - mmengine - INFO - linear.bias : lr=0.005
+```
+
+`add_params` 被第一次调用时，`params` 参数为空列表（`list`），`module` 为模型（`model`）。详细的重载规则参考[优化器封装构造器文档](mmengine.optim.DefaultOptimWrapperConstructor)。
+
+类似地，如果想构造多个优化器，也需要实现自定义的构造器：
+
+```python
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class MultipleOptimiWrapperConstructor:
+ ...
+```
+
+### 在训练过程中调整超参
+
+优化器中的超参数在构造时只能设置为一个定值，仅仅使用优化器封装，并不能在训练过程中调整学习率等参数。在 MMEngine 中，我们实现了参数调度器（Parameter Scheduler），以便能够在训练过程中调整参数。关于参数调度器的用法请见[优化器参数调整策略](./param_scheduler.md)
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/param_scheduler.md b/internlm_langchain/knowledge_base/MMEngine/content/param_scheduler.md
new file mode 100644
index 00000000..fd9f1842
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/param_scheduler.md
@@ -0,0 +1,563 @@
+# 迁移 MMCV 参数调度器到 MMEngine
+
+MMCV 1.x 版本使用 [LrUpdaterHook](https://mmcv.readthedocs.io/zh_CN/v1.6.0/api.html#mmcv.runner.LrUpdaterHook) 和 [MomentumUpdaterHook](https://mmcv.readthedocs.io/zh_CN/v1.6.0/api.html#mmcv.runner.MomentumUpdaterHook) 来调整学习率和动量。
+但随着深度学习算法训练方式的不断发展，使用 Hook 修改学习率已经难以满足更加丰富的自定义需求，因此 MMEngine 提供了参数调度器（ParamScheduler）。
+一方面，参数调度器的接口与 PyTroch 的学习率调度器（LRScheduler）对齐，另一方面，参数调度器提供了更丰富的功能，详细请参考[参数调度器使用指南](../tutorials/param_scheduler.md)。
+
+## 学习率调度器（LrUpdater）迁移
+
+MMEngine 中使用 LRScheduler 替代 LrUpdaterHook，配置文件中的字段从原本的 `lr_config` 修改为 `param_scheduler`。
+MMCV 中的学习率配置与 MMEngine 中的参数调度器配置对应关系如下：
+
+### 学习率预热（Warmup）迁移
+
+由于 MMEngine 中的学习率调度器在实现时增加了 begin 和 end 参数，指定了调度器的生效区间，所以可以通过调度器组合的方式实现学习率预热。MMCV 中有 3 种学习率预热方式，分别是 `'constant'`, `'linear'`, `'exp'`，在 MMEngine 中对应的配置应修改为:
+
+#### 常数预热(constant)
+
+
+
+
+
+#### 线性预热(linear)
+
+
+
+
+
+#### 指数预热(exp)
+
+
+
+
+
+### fixed 学习率（FixedLrUpdaterHook）迁移
+
+
+
+
+
+### step 学习率（StepLrUpdaterHook）迁移
+
+
+
+
+
+### poly 学习率（PolyLrUpdaterHook）迁移
+
+
+
+
+
+### exp 学习率（ExpLrUpdaterHook）迁移
+
+
+
+
+
+### CosineAnnealing 学习率（CosineAnnealingLrUpdaterHook）迁移
+
+
+
+
+
+### FlatCosineAnnealing 学习率（FlatCosineAnnealingLrUpdaterHook）迁移
+
+像 FlatCosineAnnealing 这种由多个学习率策略拼接而成的学习率，原本需要重写 Hook 来实现，而在 MMEngine 中只需将两个参数调度器组合即可
+
+
+
+
+
+### CosineRestart 学习率（CosineRestartLrUpdaterHook）迁移
+
+
+
+
+
+### OneCycle 学习率（OneCycleLrUpdaterHook）迁移
+
+
+
+
+
+需要注意的是 `by_epoch` 参数 MMCV 默认是 `False`, MMEngine 默认是 `True`
+
+### LinearAnnealing 学习率（LinearAnnealingLrUpdaterHook）迁移
+
+
+
+
+
+## 动量调度器（MomentumUpdater）迁移
+
+MMCV 使用 `momentum_config` 字段和 MomentumUpdateHook 调整动量。 MMEngine 中动量同样由参数调度器控制。用户可以简单将学习率调度器后的 `LR` 修改为 `Momentum`，即可使用同样的策略来调整动量。动量调度器只需要和学习率调度器一样添加进 `param_scheduler` 列表中即可。举一个简单的例子：
+
+
+
+
+
+## 参数更新频率相关配置迁移
+
+如果在使用 epoch-based 训练循环且配置文件中按 epoch 设置生效区间（`begin`，`end`）或周期（`T_max`）等变量的同时希望参数率按 iteration 更新，在 MMCV 中需要将 `by_epoch` 设置为 False。而在 MMEngine 中需要注意，配置中的 `by_epoch` 仍需设置为 True，通过在配置中添加 `convert_to_iter_based=True` 来构建按 iteration 更新的参数调度器，关于此配置详见[参数调度器教程](../tutorials/param_scheduler.md)。
+以迁移CosineAnnealing为例：
+
+
+
+
+
+你可能还想阅读[参数调度器的教程](../tutorials/param_scheduler.md)或者[参数调度器的 API 文档](../api/optim)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/registry.md b/internlm_langchain/knowledge_base/MMEngine/content/registry.md
new file mode 100644
index 00000000..f44b9d53
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/registry.md
@@ -0,0 +1,311 @@
+# 注册器（Registry）
+
+OpenMMLab 的算法库支持了丰富的算法和数据集，因此实现了很多功能相近的模块。例如 ResNet 和 SE-ResNet 的算法实现分别基于 `ResNet` 和 `SEResNet` 类，这些类有相似的功能和接口，都属于算法库中的模型组件。为了管理这些功能相似的模块，MMEngine 实现了 [注册器](mmengine.registry.Registry)。OpenMMLab 大多数算法库均使用注册器来管理它们的代码模块，包括 [MMDetection](https://github.com/open-mmlab/mmdetection)， [MMDetection3D](https://github.com/open-mmlab/mmdetection3d)，[MMPretrain](https://github.com/open-mmlab/mmpretrain) 和 [MMagic](https://github.com/open-mmlab/mmagic) 等。
+
+## 什么是注册器
+
+MMEngine 实现的[注册器](mmengine.registry.Registry)可以看作一个映射表和模块构建方法（build function）的组合。映射表维护了一个字符串到**类或者函数的映射**，使得用户可以借助字符串查找到相应的类或函数，例如维护字符串 `"ResNet"` 到 `ResNet` 类或函数的映射，使得用户可以通过 `"ResNet"` 找到 `ResNet` 类；而模块构建方法则定义了如何根据字符串查找到对应的类或函数以及如何实例化这个类或者调用这个函数，例如，通过字符串 `"bn"` 找到 `nn.BatchNorm2d` 并实例化 `BatchNorm2d` 模块；又或者通过字符串 `"build_batchnorm2d"` 找到 `build_batchnorm2d` 函数并返回该函数的调用结果。MMEngine 中的注册器默认使用 [build_from_cfg](mmengine.registry.build_from_cfg) 函数来查找并实例化字符串对应的类或者函数。
+
+一个注册器管理的类或函数通常有相似的接口和功能，因此该注册器可以被视作这些类或函数的抽象。例如注册器 `MODELS` 可以被视作所有模型的抽象，管理了 `ResNet`，`SEResNet` 和 `RegNetX` 等分类网络的类以及 `build_ResNet`, `build_SEResNet` 和 `build_RegNetX` 等分类网络的构建函数。
+
+## 入门用法
+
+使用注册器管理代码库中的模块，需要以下三个步骤。
+
+1. 创建注册器
+2. 创建一个用于实例化类的构建方法（可选，在大多数情况下可以只使用默认方法）
+3. 将模块加入注册器中
+
+假设我们要实现一系列激活模块并且希望仅修改配置就能够使用不同的激活模块而无需修改代码。
+
+首先创建注册器，
+
+```python
+from mmengine import Registry
+# scope 表示注册器的作用域，如果不设置，默认为包名，例如在 mmdetection 中，它的 scope 为 mmdet
+# locations 表示注册在此注册器的模块所存放的位置，注册器会根据预先定义的位置在构建模块时自动 import
+ACTIVATION = Registry('activation', scope='mmengine', locations=['mmengine.models.activations'])
+```
+
+`locations` 指定的模块 `mmengine.models.activations` 对应了 `mmengine/models/activations.py` 文件。在使用注册器构建模块的时候，ACTIVATION 注册器会自动从该文件中导入实现的模块。因此，我们可以在 `mmengine/models/activations.py` 文件中实现不同的激活函数，例如 `Sigmoid`，`ReLU` 和 `Softmax`。
+
+```python
+import torch.nn as nn
+
+# 使用注册器管理模块
+@ACTIVATION.register_module()
+class Sigmoid(nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ print('call Sigmoid.forward')
+ return x
+
+@ACTIVATION.register_module()
+class ReLU(nn.Module):
+ def __init__(self, inplace=False):
+ super().__init__()
+
+ def forward(self, x):
+ print('call ReLU.forward')
+ return x
+
+@ACTIVATION.register_module()
+class Softmax(nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ print('call Softmax.forward')
+ return x
+```
+
+使用注册器管理模块的关键步骤是，将实现的模块注册到注册表 `ACTIVATION` 中。通过 `@ACTIVATION.register_module()` 装饰所实现的模块，字符串和类或函数之间的映射就可以由 `ACTIVATION` 构建和维护，我们也可以通过 `ACTIVATION.register_module(module=ReLU)` 实现同样的功能。
+
+通过注册，我们就可以通过 `ACTIVATION` 建立字符串与类或函数之间的映射，
+
+```python
+print(ACTIVATION.module_dict)
+# {
+# 'Sigmoid': __main__.Sigmoid,
+# 'ReLU': __main__.ReLU,
+# 'Softmax': __main__.Softmax
+# }
+```
+
+```{note}
+只有模块所在的文件被导入时，注册机制才会被触发，用户可以通过三种方式将模块添加到注册器中：
+
+1. 在 ``locations`` 指向的文件中实现模块。注册器将自动在预先定义的位置导入模块。这种方式是为了简化算法库的使用，以便用户可以直接使用 ``REGISTRY.build(cfg)``。
+
+2. 手动导入文件。常用于用户在算法库之内或之外实现新的模块。
+
+3. 在配置中使用 ``custom_imports`` 字段。 详情请参考[导入自定义Python模块](config.md#导入自定义-python-模块)。
+```
+
+模块成功注册后，我们可以通过配置文件使用这个激活模块。
+
+```python
+import torch
+
+input = torch.randn(2)
+
+act_cfg = dict(type='Sigmoid')
+activation = ACTIVATION.build(act_cfg)
+output = activation(input)
+# call Sigmoid.forward
+print(output)
+```
+
+如果我们想使用 `ReLU`，仅需修改配置。
+
+```python
+act_cfg = dict(type='ReLU', inplace=True)
+activation = ACTIVATION.build(act_cfg)
+output = activation(input)
+# call ReLU.forward
+print(output)
+```
+
+如果我们希望在创建实例前检查输入参数的类型（或者任何其他操作），我们可以实现一个构建方法并将其传递给注册器从而实现自定义构建流程。
+
+创建一个构建方法，
+
+```python
+
+def build_activation(cfg, registry, *args, **kwargs):
+ cfg_ = cfg.copy()
+ act_type = cfg_.pop('type')
+ print(f'build activation: {act_type}')
+ act_cls = registry.get(act_type)
+ act = act_cls(*args, **kwargs, **cfg_)
+ return act
+```
+
+并将 `build_activation` 传递给 `build_func` 参数
+
+```python
+ACTIVATION = Registry('activation', build_func=build_activation, scope='mmengine', locations=['mmengine.models.activations'])
+
+@ACTIVATION.register_module()
+class Tanh(nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ print('call Tanh.forward')
+ return x
+
+act_cfg = dict(type='Tanh')
+activation = ACTIVATION.build(act_cfg)
+output = activation(input)
+# build activation: Tanh
+# call Tanh.forward
+print(output)
+```
+
+```{note}
+在这个例子中，我们演示了如何使用参数 `build_func` 自定义构建类的实例的方法。
+该功能类似于默认的 `build_from_cfg` 方法。在大多数情况下，使用默认的方法就可以了。
+```
+
+MMEngine 的注册器除了可以注册类，也可以注册函数。
+
+```python
+FUNCTION = Registry('function', scope='mmengine')
+
+@FUNCTION.register_module()
+def print_args(**kwargs):
+ print(kwargs)
+
+func_cfg = dict(type='print_args', a=1, b=2)
+func_res = FUNCTION.build(func_cfg)
+```
+
+## 进阶用法
+
+MMEngine 的注册器支持层级注册，利用该功能可实现跨项目调用，即可以在一个项目中使用另一个项目的模块。虽然跨项目调用也有其他方法的可以实现，但 MMEngine 注册器提供了更为简便的方法。
+
+为了方便跨库调用，MMEngine 提供了 22 个根注册器：
+
+- RUNNERS: Runner 的注册器
+- RUNNER_CONSTRUCTORS: Runner 的构造器
+- LOOPS: 管理训练、验证以及测试流程，如 `EpochBasedTrainLoop`
+- HOOKS: 钩子，如 `CheckpointHook`, `ParamSchedulerHook`
+- DATASETS: 数据集
+- DATA_SAMPLERS: `DataLoader` 的 `Sampler`，用于采样数据
+- TRANSFORMS: 各种数据预处理，如 `Resize`, `Reshape`
+- MODELS: 模型的各种模块
+- MODEL_WRAPPERS: 模型的包装器，如 `MMDistributedDataParallel`，用于对分布式数据并行
+- WEIGHT_INITIALIZERS: 权重初始化的工具
+- OPTIMIZERS: 注册了 PyTorch 中所有的 `Optimizer` 以及自定义的 `Optimizer`
+- OPTIM_WRAPPER: 对 Optimizer 相关操作的封装，如 `OptimWrapper`，`AmpOptimWrapper`
+- OPTIM_WRAPPER_CONSTRUCTORS: optimizer wrapper 的构造器
+- PARAM_SCHEDULERS: 各种参数调度器，如 `MultiStepLR`
+- METRICS: 用于计算模型精度的评估指标，如 `Accuracy`
+- EVALUATOR: 用于计算模型精度的一个或多个评估指标
+- TASK_UTILS: 任务强相关的一些组件，如 `AnchorGenerator`, `BboxCoder`
+- VISUALIZERS: 管理绘制模块，如 `DetVisualizer` 可在图片上绘制预测框
+- VISBACKENDS: 存储训练日志的后端，如 `LocalVisBackend`, `TensorboardVisBackend`
+- LOG_PROCESSORS: 控制日志的统计窗口和统计方法，默认使用 `LogProcessor`，如有特殊需求可自定义 `LogProcessor`
+- FUNCTIONS: 注册了各种函数，如 Dataloader 中传入的 `collate_fn`
+- INFERENCERS: 注册了各种任务的推理器，如 `DetInferencer`，负责检测任务的推理
+
+### 调用父节点的模块
+
+`MMEngine` 中定义模块 `RReLU`，并往 `MODELS` 根注册器注册。
+
+```python
+import torch.nn as nn
+from mmengine import Registry, MODELS
+
+@MODELS.register_module()
+class RReLU(nn.Module):
+ def __init__(self, lower=0.125, upper=0.333, inplace=False):
+ super().__init__()
+
+ def forward(self, x):
+ print('call RReLU.forward')
+ return x
+```
+
+假设有个项目叫 `MMAlpha`，它也定义了 `MODELS`，并设置其父节点为 `MMEngine` 的 `MODELS`，这样就建立了层级结构。
+
+```python
+from mmengine import Registry, MODELS as MMENGINE_MODELS
+
+MODELS = Registry('model', parent=MMENGINE_MODELS, scope='mmalpha', locations=['mmalpha.models'])
+```
+
+下图是 `MMEngine` 和 `MMAlpha` 的注册器层级结构。
+
+
+
+运行过程中具体的调用栈如下所示：
+
+
+
+### 数据流
+
+数据经 `TestTimeAug` 增强后，其数据格式为：
+
+```python
+image1 = dict(
+ inputs=[data_1_1, data_1_2],
+ data_sample=[data_sample1_1, data_sample1_2]
+)
+
+image2 = dict(
+ inputs=[data_2_1, data_2_2],
+ data_sample=[data_sample2_1, data_sample2_2]
+)
+
+
+image3 = dict(
+ inputs=[data_3_1, data_3_2],
+ data_sample=[data_sample3_1, data_sample3_2]
+)
+
+```
+
+其中 `data_{i}_{j}` 为增强后的数据，`data_sample_{i}_{j}` 为增强后数据的标签信息。
+数据经过 DataLoader 处理后，格式转变为：
+
+```python
+data_batch = dict(
+ inputs = [
+ (data_1_1, data_2_1, data_3_1),
+ (data_1_2, data_2_2, data_3_2),
+ ]
+ data_samples=[
+ (data_samples1_1, data_samples2_1, data_samples3_1),
+ (data_samples1_2, data_samples2_2, data_samples3_2)
+ ]
+)
+```
+
+为了方便模型推理，BaseTTAModel 会在模型推理前将将数据转换为：
+
+```python
+data_batch_aug1 = dict(
+ inputs = (data_1_1, data_2_1, data_3_1),
+ data_samples=(data_samples1_1, data_samples2_1, data_samples3_1)
+)
+
+data_batch_aug2 = dict(
+ inputs = (data_1_2, data_2_2, data_3_2),
+ data_samples=(data_samples1_2, data_samples2_2, data_samples3_2)
+)
+```
+
+此时每个 `data_batch_aug` 均可以直接传入模型进行推理。模型推理后，`BaseTTAModel` 会将推理结果整理成：
+
+```python
+preds = [
+ [data_samples1_1, data_samples_1_2],
+ [data_samples2_1, data_samples_2_2],
+ [data_samples3_1, data_samples_3_2],
+]
+```
+
+方便用户进行结果融合。了解 TTA 的数据流后，我们就可以根据具体的需求，重载 `BaseTTAModel.test_step()`，以实现更加复杂的融合策略。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/train_a_gan.md b/internlm_langchain/knowledge_base/MMEngine/content/train_a_gan.md
new file mode 100644
index 00000000..9b19331a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/train_a_gan.md
@@ -0,0 +1,308 @@
+# 训练生成对抗网络
+
+生成对抗网络(Generative Adversarial Network, GAN)可以用来生成图像视频等数据。这篇教程将带你一步步用 MMEngine 训练 GAN ！
+
+我们可以通过以下步骤来训练一个生成对抗网络。
+
+- [训练生成对抗网络](#训练生成对抗网络)
+ - [构建数据加载器](#构建数据加载器)
+ - [构建数据集](#构建数据集)
+ - [构建生成器网络和判别器网络](#构建生成器网络和判别器网络)
+ - [构建一个生成对抗网络模型](#构建一个生成对抗网络模型)
+ - [构建优化器](#构建优化器)
+ - [使用执行器进行训练](#使用执行器进行训练)
+
+## 构建数据加载器
+
+### 构建数据集
+
+接下来, 我们为 MNIST 数据集构建一个数据集类 `MNISTDataset`, 继承自数据集基类 [BaseDataset](mmengine.dataset.BaseDataset), 并且重载数据集基类的 `load_data_list` 函数, 保证返回值为 `list[dict]`，其中每个 `dict` 代表一个数据样本。更多关于 MMEngine 中数据集的用法，可以参考[数据集教程](../advanced_tutorials/basedataset.md)。
+
+```python
+import numpy as np
+from mmcv.transforms import to_tensor
+from torch.utils.data import random_split
+from torchvision.datasets import MNIST
+
+from mmengine.dataset import BaseDataset
+
+
+class MNISTDataset(BaseDataset):
+
+ def __init__(self, data_root, pipeline, test_mode=False):
+ # 下载 MNIST 数据集
+ if test_mode:
+ mnist_full = MNIST(data_root, train=True, download=True)
+ self.mnist_dataset, _ = random_split(mnist_full, [55000, 5000])
+ else:
+ self.mnist_dataset = MNIST(data_root, train=False, download=True)
+
+ super().__init__(
+ data_root=data_root, pipeline=pipeline, test_mode=test_mode)
+
+ @staticmethod
+ def totensor(img):
+ if len(img.shape) < 3:
+ img = np.expand_dims(img, -1)
+ img = np.ascontiguousarray(img.transpose(2, 0, 1))
+ return to_tensor(img)
+
+ def load_data_list(self):
+ return [
+ dict(inputs=self.totensor(np.array(x[0]))) for x in self.mnist_dataset
+ ]
+
+
+dataset = MNISTDataset("./data", [])
+
+```
+
+使用 Runner 中的函数 build_dataloader 来构建数据加载器。
+
+```python
+import os
+import torch
+from mmengine.runner import Runner
+
+NUM_WORKERS = int(os.cpu_count() / 2)
+BATCH_SIZE = 256 if torch.cuda.is_available() else 64
+
+train_dataloader = dict(
+ batch_size=BATCH_SIZE,
+ num_workers=NUM_WORKERS,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=dataset)
+train_dataloader = Runner.build_dataloader(train_dataloader)
+```
+
+## 构建生成器网络和判别器网络
+
+下面的代码构建并实例化了一个生成器(Generator)和一个判别器(Discriminator)。
+
+```python
+import torch.nn as nn
+
+class Generator(nn.Module):
+ def __init__(self, noise_size, img_shape):
+ super().__init__()
+ self.img_shape = img_shape
+ self.noise_size = noise_size
+
+ def block(in_feat, out_feat, normalize=True):
+ layers = [nn.Linear(in_feat, out_feat)]
+ if normalize:
+ layers.append(nn.BatchNorm1d(out_feat, 0.8))
+ layers.append(nn.LeakyReLU(0.2, inplace=True))
+ return layers
+
+ self.model = nn.Sequential(
+ *block(noise_size, 128, normalize=False),
+ *block(128, 256),
+ *block(256, 512),
+ *block(512, 1024),
+ nn.Linear(1024, int(np.prod(img_shape))),
+ nn.Tanh(),
+ )
+
+ def forward(self, z):
+ img = self.model(z)
+ img = img.view(img.size(0), *self.img_shape)
+ return img
+```
+
+```python
+class Discriminator(nn.Module):
+ def __init__(self, img_shape):
+ super().__init__()
+
+ self.model = nn.Sequential(
+ nn.Linear(int(np.prod(img_shape)), 512),
+ nn.LeakyReLU(0.2, inplace=True),
+ nn.Linear(512, 256),
+ nn.LeakyReLU(0.2, inplace=True),
+ nn.Linear(256, 1),
+ nn.Sigmoid(),
+ )
+
+ def forward(self, img):
+ img_flat = img.view(img.size(0), -1)
+ validity = self.model(img_flat)
+
+ return validity
+```
+
+```python
+generator = Generator(100, (1, 28, 28))
+discriminator = Discriminator((1, 28, 28))
+```
+
+## 构建一个生成对抗网络模型
+
+在使用 MMEngine 时，我们用 [ImgDataPreprocessor](mmengine.model.ImgDataPreprocessor) 来对数据进行归一化和颜色通道的转换。
+
+```python
+from mmengine.model import ImgDataPreprocessor
+
+data_preprocessor = ImgDataPreprocessor(mean=([127.5]), std=([127.5]))
+```
+
+下面的代码实现了基础 GAN 的算法。使用 MMEngine 实现算法类，需要继承 [BaseModel](mmengine.model.BaseModel) 基类，在 train_step 中实现训练过程。GAN 需要交替训练生成器和判别器，分别由 train_discriminator 和 train_generator 实现，并实现 disc_loss 和 gen_loss 计算判别器损失函数和生成器损失函数。
+关于 BaseModel 的更多信息，请参考[模型教程](../tutorials/model.md).
+
+```python
+import torch.nn.functional as F
+from mmengine.model import BaseModel
+
+class GAN(BaseModel):
+
+ def __init__(self, generator, discriminator, noise_size,
+ data_preprocessor):
+ super().__init__(data_preprocessor=data_preprocessor)
+ assert generator.noise_size == noise_size
+ self.generator = generator
+ self.discriminator = discriminator
+ self.noise_size = noise_size
+
+ def train_step(self, data, optim_wrapper):
+ # 获取数据和数据预处理
+ inputs_dict = self.data_preprocessor(data, True)
+ # 训练判别器
+ disc_optimizer_wrapper = optim_wrapper['discriminator']
+ with disc_optimizer_wrapper.optim_context(self.discriminator):
+ log_vars = self.train_discriminator(inputs_dict,
+ disc_optimizer_wrapper)
+
+ # 训练生成器
+ set_requires_grad(self.discriminator, False)
+ gen_optimizer_wrapper = optim_wrapper['generator']
+ with gen_optimizer_wrapper.optim_context(self.generator):
+ log_vars_gen = self.train_generator(inputs_dict,
+ gen_optimizer_wrapper)
+
+ set_requires_grad(self.discriminator, True)
+ log_vars.update(log_vars_gen)
+
+ return log_vars
+
+ def forward(self, batch_inputs, data_samples=None, mode=None):
+ return self.generator(batch_inputs)
+
+ def disc_loss(self, disc_pred_fake, disc_pred_real):
+ losses_dict = dict()
+ losses_dict['loss_disc_fake'] = F.binary_cross_entropy(
+ disc_pred_fake, 0. * torch.ones_like(disc_pred_fake))
+ losses_dict['loss_disc_real'] = F.binary_cross_entropy(
+ disc_pred_real, 1. * torch.ones_like(disc_pred_real))
+
+ loss, log_var = self.parse_losses(losses_dict)
+ return loss, log_var
+
+ def gen_loss(self, disc_pred_fake):
+ losses_dict = dict()
+ losses_dict['loss_gen'] = F.binary_cross_entropy(
+ disc_pred_fake, 1. * torch.ones_like(disc_pred_fake))
+ loss, log_var = self.parse_losses(losses_dict)
+ return loss, log_var
+
+ def train_discriminator(self, inputs, optimizer_wrapper):
+ real_imgs = inputs['inputs']
+ z = torch.randn(
+ (real_imgs.shape[0], self.noise_size)).type_as(real_imgs)
+ with torch.no_grad():
+ fake_imgs = self.generator(z)
+
+ disc_pred_fake = self.discriminator(fake_imgs)
+ disc_pred_real = self.discriminator(real_imgs)
+
+ parsed_losses, log_vars = self.disc_loss(disc_pred_fake,
+ disc_pred_real)
+ optimizer_wrapper.update_params(parsed_losses)
+ return log_vars
+
+ def train_generator(self, inputs, optimizer_wrapper):
+ real_imgs = inputs['inputs']
+ z = torch.randn(real_imgs.shape[0], self.noise_size).type_as(real_imgs)
+
+ fake_imgs = self.generator(z)
+
+ disc_pred_fake = self.discriminator(fake_imgs)
+ parsed_loss, log_vars = self.gen_loss(disc_pred_fake)
+
+ optimizer_wrapper.update_params(parsed_loss)
+ return log_vars
+```
+
+其中一个函数 set_requires_grad 用来锁定训练生成器时判别器的权重。
+
+```python
+def set_requires_grad(nets, requires_grad=False):
+ """Set requires_grad for all the networks.
+
+ Args:
+ nets (nn.Module | list[nn.Module]): A list of networks or a single
+ network.
+ requires_grad (bool): Whether the networks require gradients or not.
+ """
+ if not isinstance(nets, list):
+ nets = [nets]
+ for net in nets:
+ if net is not None:
+ for param in net.parameters():
+ param.requires_grad = requires_grad
+```
+
+```python
+
+model = GAN(generator, discriminator, 100, data_preprocessor)
+
+```
+
+## 构建优化器
+
+MMEngine 使用 [OptimWrapper](mmengine.optim.OptimWrapper) 来封装优化器，对于多个优化器的情况，使用 [OptimWrapperDict](mmengine.optim.OptimWrapperDict) 对 OptimWrapper 再进行一次封装。
+关于优化器的更多信息，请参考[优化器教程](../tutorials/optim_wrapper.md).
+
+```python
+from mmengine.optim import OptimWrapper, OptimWrapperDict
+
+opt_g = torch.optim.Adam(generator.parameters(), lr=0.0001, betas=(0.5, 0.999))
+opt_g_wrapper = OptimWrapper(opt_g)
+
+opt_d = torch.optim.Adam(
+ discriminator.parameters(), lr=0.0001, betas=(0.5, 0.999))
+opt_d_wrapper = OptimWrapper(opt_d)
+
+opt_wrapper_dict = OptimWrapperDict(
+ generator=opt_g_wrapper, discriminator=opt_d_wrapper)
+
+```
+
+## 使用执行器进行训练
+
+下面的代码演示了如何使用 Runner 进行模型训练。关于 Runner 的更多信息，请参考[执行器教程](../tutorials/runner.md)。
+
+```python
+train_cfg = dict(by_epoch=True, max_epochs=220)
+runner = Runner(
+ model,
+ work_dir='runs/gan/',
+ train_dataloader=train_dataloader,
+ train_cfg=train_cfg,
+ optim_wrapper=opt_wrapper_dict)
+runner.train()
+```
+
+到这里，我们就完成了一个 GAN 的训练，通过下面的代码可以查看刚才训练的 GAN 生成的结果。
+
+```python
+z = torch.randn(64, 100).cuda()
+img = model(z)
+
+from torchvision.utils import save_image
+save_image(img, "result.png", normalize=True)
+```
+
+
+
+如果你想了解更多如何使用 MMEngine 实现 GAN 和生成模型，我们强烈建议你使用同样基于 MMEngine 开发的生成框架 [MMGen](https://github.com/open-mmlab/mmgeneration/tree/dev-1.x)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/train_seg.md b/internlm_langchain/knowledge_base/MMEngine/content/train_seg.md
new file mode 100644
index 00000000..2b125447
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/train_seg.md
@@ -0,0 +1,290 @@
+# 训练语义分割模型
+
+语义分割的样例大体可以分成四个步骤:
+
+- [下载 Camvid 数据集](#下载-camvid-数据集)
+- [实现 Camvid 数据类](#实现-camvid-数据类)
+- [实现语义分割模型](#实现语义分割模型)
+- [使用 Runner 训练模型](#使用-runner-训练模型)
+
+```{note}
+如果你更喜欢 notebook 风格的样例，也可以在[此处](https://colab.research.google.com/github/open-mmlab/mmengine/blob/main/examples/segmentation/train.ipynb) 体验。
+```
+
+## 下载 Camvid 数据集
+
+首先，从 opendatalab 下载 Camvid 数据集:
+
+```bash
+# https://opendatalab.com/CamVid
+# Configure install
+pip install opendatalab
+# Upgraded version
+pip install -U opendatalab
+# Login
+odl login
+# Download this dataset
+mkdir data
+odl get CamVid -d data
+# Preprocess data in Linux. You should extract the files to data manually in
+# Windows
+tar -xzvf data/CamVid/raw/CamVid.tar.gz.00 -C ./data
+```
+
+## 实现 Camvid 数据类
+
+实现继承自 VisionDataset 的 CamVid 数据类。在这个类中，我们重写了`__getitem__`和`__len__`方法，以确保每个索引返回一个包含图像和标签的字典。此外，我们还实现了color_to_class字典，将 mask 的颜色映射到类别索引。
+
+```python
+import os
+import numpy as np
+from torchvision.datasets import VisionDataset
+from PIL import Image
+import csv
+
+
+def create_palette(csv_filepath):
+ color_to_class = {}
+ with open(csv_filepath, newline='') as csvfile:
+ reader = csv.DictReader(csvfile)
+ for idx, row in enumerate(reader):
+ r, g, b = int(row['r']), int(row['g']), int(row['b'])
+ color_to_class[(r, g, b)] = idx
+ return color_to_class
+
+class CamVid(VisionDataset):
+
+ def __init__(self,
+ root,
+ img_folder,
+ mask_folder,
+ transform=None,
+ target_transform=None):
+ super().__init__(
+ root, transform=transform, target_transform=target_transform)
+ self.img_folder = img_folder
+ self.mask_folder = mask_folder
+ self.images = list(
+ sorted(os.listdir(os.path.join(self.root, img_folder))))
+ self.masks = list(
+ sorted(os.listdir(os.path.join(self.root, mask_folder))))
+ self.color_to_class = create_palette(
+ os.path.join(self.root, 'class_dict.csv'))
+
+ def __getitem__(self, index):
+ img_path = os.path.join(self.root, self.img_folder, self.images[index])
+ mask_path = os.path.join(self.root, self.mask_folder,
+ self.masks[index])
+
+ img = Image.open(img_path).convert('RGB')
+ mask = Image.open(mask_path).convert('RGB') # Convert to RGB
+
+ if self.transform is not None:
+ img = self.transform(img)
+
+ # Convert the RGB values to class indices
+ mask = np.array(mask)
+ mask = mask[:, :, 0] * 65536 + mask[:, :, 1] * 256 + mask[:, :, 2]
+ labels = np.zeros_like(mask, dtype=np.int64)
+ for color, class_index in self.color_to_class.items():
+ rgb = color[0] * 65536 + color[1] * 256 + color[2]
+ labels[mask == rgb] = class_index
+
+ if self.target_transform is not None:
+ labels = self.target_transform(labels)
+ data_samples = dict(
+ labels=labels, img_path=img_path, mask_path=mask_path)
+ return img, data_samples
+
+ def __len__(self):
+ return len(self.images)
+
+```
+
+基于 CamVid 数据类，选择相应的数据增强方式，构建 train_dataloader 和 val_dataloader，供后续 runner 使用
+
+```python
+import torch
+import torchvision.transforms as transforms
+
+norm_cfg = dict(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+transform = transforms.Compose(
+ [transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)])
+
+target_transform = transforms.Lambda(
+ lambda x: torch.tensor(np.array(x), dtype=torch.long))
+
+train_set = CamVid(
+ 'data/CamVid',
+ img_folder='train',
+ mask_folder='train_labels',
+ transform=transform,
+ target_transform=target_transform)
+
+valid_set = CamVid(
+ 'data/CamVid',
+ img_folder='val',
+ mask_folder='val_labels',
+ transform=transform,
+ target_transform=target_transform)
+
+train_dataloader = dict(
+ batch_size=3,
+ dataset=train_set,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ collate_fn=dict(type='default_collate'))
+
+val_dataloader = dict(
+ batch_size=3,
+ dataset=valid_set,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ collate_fn=dict(type='default_collate'))
+```
+
+## 实现语义分割模型
+
+定义一个名为`MMDeeplabV3`的模型类。该类继承自`BaseModel`，并集成了DeepLabV3架构的分割模型。`MMDeeplabV3` 重写了`forward`方法，以处理输入图像和标签，并支持在训练和预测模式下计算损失和返回预测结果。
+
+关于`BaseModel`的更多信息，请参考[模型教程](../tutorials/model.md)。
+
+```python
+from mmengine.model import BaseModel
+from torchvision.models.segmentation import deeplabv3_resnet50
+import torch.nn.functional as F
+
+
+class MMDeeplabV3(BaseModel):
+
+ def __init__(self, num_classes):
+ super().__init__()
+ self.deeplab = deeplabv3_resnet50()
+ self.deeplab.classifier[4] = torch.nn.Conv2d(
+ 256, num_classes, kernel_size=(1, 1), stride=(1, 1))
+
+ def forward(self, imgs, data_samples=None, mode='tensor'):
+ x = self.deeplab(imgs)['out']
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, data_samples['labels'])}
+ elif mode == 'predict':
+ return x, data_samples
+```
+
+## 使用 Runner 训练模型
+
+在使用 Runner 进行训练之前，我们需要实现 IoU（交并比）指标来评估模型的性能。
+
+```python
+from mmengine.evaluator import BaseMetric
+
+class IoU(BaseMetric):
+
+ def process(self, data_batch, data_samples):
+ preds, labels = data_samples[0], data_samples[1]['labels']
+ preds = torch.argmax(preds, dim=1)
+ intersect = (labels == preds).sum()
+ union = (torch.logical_or(preds, labels)).sum()
+ iou = (intersect / union).cpu()
+ self.results.append(
+ dict(batch_size=len(labels), iou=iou * len(labels)))
+
+ def compute_metrics(self, results):
+ total_iou = sum(result['iou'] for result in self.results)
+ num_samples = sum(result['batch_size'] for result in self.results)
+ return dict(iou=total_iou / num_samples)
+```
+
+实现可视化钩子（Hook）也很重要，它可以便于更轻松地比较模型预测的好坏。
+
+```python
+from mmengine.hooks import Hook
+import shutil
+import cv2
+import os.path as osp
+
+
+class SegVisHook(Hook):
+
+ def __init__(self, data_root, vis_num=1) -> None:
+ super().__init__()
+ self.vis_num = vis_num
+ self.palette = create_palette(osp.join(data_root, 'class_dict.csv'))
+
+ def after_val_iter(self,
+ runner,
+ batch_idx: int,
+ data_batch=None,
+ outputs=None) -> None:
+ if batch_idx > self.vis_num:
+ return
+ preds, data_samples = outputs
+ img_paths = data_samples['img_path']
+ mask_paths = data_samples['mask_path']
+ _, C, H, W = preds.shape
+ preds = torch.argmax(preds, dim=1)
+ for idx, (pred, img_path,
+ mask_path) in enumerate(zip(preds, img_paths, mask_paths)):
+ pred_mask = np.zeros((H, W, 3), dtype=np.uint8)
+ runner.visualizer.set_image(pred_mask)
+ for color, class_id in self.palette.items():
+ runner.visualizer.draw_binary_masks(
+ pred == class_id,
+ colors=[color],
+ alphas=1.0,
+ )
+ # Convert RGB to BGR
+ pred_mask = runner.visualizer.get_image()[..., ::-1]
+ saved_dir = osp.join(runner.log_dir, 'vis_data', str(idx))
+ os.makedirs(saved_dir, exist_ok=True)
+
+ shutil.copyfile(img_path,
+ osp.join(saved_dir, osp.basename(img_path)))
+ shutil.copyfile(mask_path,
+ osp.join(saved_dir, osp.basename(mask_path)))
+ cv2.imwrite(
+ osp.join(saved_dir, f'pred_{osp.basename(img_path)}'),
+ pred_mask)
+```
+
+准备完毕，让我们用 Runner 开始训练吧！
+
+```python
+from torch.optim import AdamW
+from mmengine.optim import AmpOptimWrapper
+from mmengine.runner import Runner
+
+
+num_classes = 32 # Modify to actual number of categories.
+
+runner = Runner(
+ model=MMDeeplabV3(num_classes),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(
+ type=AmpOptimWrapper, optimizer=dict(type=AdamW, lr=2e-4)),
+ train_cfg=dict(by_epoch=True, max_epochs=10, val_interval=10),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=IoU),
+ custom_hooks=[SegVisHook('data/CamVid')],
+ default_hooks=dict(checkpoint=dict(type='CheckpointHook', interval=1)),
+)
+runner.train()
+```
+
+训练完成后，你可以在 `./work_dir/{timestamp}/vis_data` 文件夹中找到可视化结果，如下图所示：
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/transform.md b/internlm_langchain/knowledge_base/MMEngine/content/transform.md
new file mode 100644
index 00000000..c98ce710
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/transform.md
@@ -0,0 +1,151 @@
+# 数据变换类的迁移
+
+## 简介
+
+在 TorchVision 的数据变换类接口约定中，数据变换类需要实现 `__call__` 方法，而在 OpenMMLab 1.0 的接口约定中，进一步要求
+`__call__` 方法的输出应当是一个字典，在各种数据变换中对这个字典进行增删查改。在 OpenMMLab 2.0 中，为了提升后续的可扩展性，我们将原先的 `__call__` 方法迁移为 `transform` 方法，并要求数据变换类应当继承
+[mmcv.transforms.BaseTransform](mmcv.transforms.BaseTransform)。具体如何实现一个数据变换类，可以参见[文档](../advanced_tutorials/data_transform.md)。
+
+由于在此次更新中，我们将部分共用的数据变换类统一迁移至 MMCV 中，因此本文将会对比这些数据变换在旧版本（[MMClassification v0.23.2](https://github.com/open-mmlab/mmclassification/tree/v0.23.2)、[MMDetection v2.25.1](https://github.com/open-mmlab/mmdetection/tree/v2.25.1)）和新版本（[MMCV v2.0.0rc0](https://github.com/open-mmlab/mmcv/tree/2.x)）中的功能、用法和实现上的差异。
+
+## 功能差异
+
+
+
+
+
+## 实现差异
+
+以 `RandomFlip` 为例，MMCV 的 [RandomFlip](https://github.com/open-mmlab/mmcv/blob/5947178e855c23eea6103b1d70e1f8027f7b2ca8/mmcv/transforms/processing.py#L985) 相比旧版 MMDetection 的 [RandomFlip](https://github.com/open-mmlab/mmdetection/blob/3b72b12fe9b14de906d1363982b9fba05e7d47c1/mmdet/datasets/pipelines/transforms.py#L333)，需要继承 `BaseTransfrom`，将功能实现放在 `transforms` 方法，并将生成随机结果的部分放在单独的方法中，用 `cache_randomness` 包装。有关随机方法的包装相关功能，参见[相关文档](TODO)。
+
+- MMDetection (旧）
+
+```python
+class RandomFlip:
+ def __call__(self, results):
+ """调用时进行随机翻转"""
+ ...
+ # 随机选择翻转方向
+ cur_dir = np.random.choice(direction_list, p=flip_ratio_list)
+ ...
+ return results
+```
+
+- MMCV
+
+```python
+class RandomFlip(BaseTransfrom):
+ def transform(self, results):
+ """调用时进行随机翻转"""
+ ...
+ cur_dir = self._random_direction()
+ ...
+ return results
+
+ @cache_randomness
+ def _random_direction(self):
+ """随机选择翻转方向"""
+ ...
+ return np.random.choice(direction_list, p=flip_ratio_list)
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/visualization.md b/internlm_langchain/knowledge_base/MMEngine/content/visualization.md
new file mode 100644
index 00000000..ecc8dbf1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/visualization.md
@@ -0,0 +1,417 @@
+# 可视化
+
+可视化可以给深度学习的模型训练和测试过程提供直观解释。
+
+MMEngine 提供了 `Visualizer` 可视化器用以可视化和存储模型训练和测试过程中的状态以及中间结果，具备如下功能：
+
+- 支持基础绘图接口以及特征图可视化
+- 支持本地、TensorBoard 以及 WandB 等多种后端，可以将训练状态例如 loss 、lr 或者性能评估指标以及可视化的结果写入指定的单一或多个后端
+- 允许在代码库任意位置调用，对任意位置的特征、图像和状态等进行可视化和存储。
+
+## 基础绘制接口
+
+可视化器提供了常用对象的绘制接口，例如绘制**检测框、点、文本、线、圆、多边形和二值掩码**。这些基础 API 支持以下特性：
+
+- 可以多次调用，实现叠加绘制需求
+- 均支持多输入，除了要求文本输入的绘制接口外，其余接口同时支持 Tensor 以及 Numpy array 的输入
+
+常见用法如下：
+
+(1) 绘制检测框、掩码和文本等
+
+```python
+import torch
+import mmcv
+from mmengine.visualization import Visualizer
+
+# https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/zh_cn/_static/image/cat_and_dog.png
+image = mmcv.imread('docs/en/_static/image/cat_and_dog.png',
+ channel_order='rgb')
+visualizer = Visualizer(image=image)
+# 绘制单个检测框, xyxy 格式
+visualizer.draw_bboxes(torch.tensor([72, 13, 179, 147]))
+# 绘制多个检测框
+visualizer.draw_bboxes(torch.tensor([[33, 120, 209, 220], [72, 13, 179, 147]]))
+visualizer.show()
+```
+
+
+```
+
+Notes:
+1. The order of bbox labels accords with the order of entry names;
+2. In bbox location, "x_1" and "y_1" represent the upper left point coordinate of bounding box, "x_2" and "y_2" represent the lower right point coordinate of bounding box. Bounding box locations are listed in the order of [x_1, y_1, x_2, y_2].
+
+
+## LANDMARK LABELS
+
+list_landmarks_consumer2shop.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: [ , ... ]
+```
+
+Notes:
+1. The order of landmark labels accords with the order of entry names;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes. Upper-body clothes possess six fahsion landmarks, lower-body clothes possess four fashion landmarks, full-body clothes possess eight fashion landmarks;
+3. In variation type, "1" represents normal pose, "2" represents medium pose, "3" represents large pose, "4" represents medium zoom-in, "5" represents large zoom-in;
+4. In landmark visibility state, "0" represents visible, "1" represents invisible/occluded, "2" represents truncated/cut-off;
+5. For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left hem", "right hem"]; For lower-body clothes, landmark annotations are listed in the order of ["left waistline", "right waistline", "left hem", "right hem"]; For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left waistline", "right waistline", "left hem", "right hem"].
+
+
+## CATEGORY LABELS
+
+list_category_cloth.txt
+
+```sh
+First Row: number of categories
+Second Row: entry names
+Rest of the Rows:
+```
+
+list_category_img.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. In category type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes;
+2. The order of category labels accords with the order of category names;
+3. In category labels, the number represents the category id in category names;
+4. For the clothing categories, "Cape", "Nightdress", "Shirtdress" and "Sundress" have been merged into "Dress";
+5. Category prediction is treated as a 1-of-K classification problem.
+
+
+## ATTRIBUTE LABELS
+
+list_attr_cloth.txt
+
+```sh
+First Row: number of attributes
+Second Row: entry names
+Rest of the Rows:
+```
+
+list_attr_img.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. In attribute type, "1" represents texture-related attributes, "2" represents fabric-related attributes, "3" represents shape-related attributes, "4" represents part-related attributes, "5" represents style-related attributes;
+2. The order of attribute labels accords with the order of attribute names;
+3. In attribute labels, "1" represents positive while "-1" represents negative, '0' represents unknown;
+4. Attribute prediction is treated as a multi-label tagging problem.
+
+
+## EVALUATION PARTITIONS
+
+list_eval_partition.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. In evaluation status, "train" represents training image, "val" represents validation image, "test" represents testing image;
+2. Please refer to the paper "DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations" for more details.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/CONSUMER_TO_SHOP_DATASET.md b/internlm_langchain/knowledge_base/MMFashion/content/CONSUMER_TO_SHOP_DATASET.md
new file mode 100644
index 00000000..b59e52aa
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/CONSUMER_TO_SHOP_DATASET.md
@@ -0,0 +1,134 @@
+# ConsumerToShopDataset
+
+- Annotations (Anno/)
+
+ - Attribute Annotations (list_attr_cloth.txt & list_attr_type.txt & list_attr_items.txt)
+
+ clothing attribute labels. See ATTRIBUTE LABELS section below for more info.
+
+ - Bounding Box Annotations (list_bbox_consumer2shop.txt)
+
+ bounding box labels. See BBOX LABELS section below for more info.
+
+ - Item Annotations (list_item_consumer2shop.txt)
+
+ item labels. See ITEM LABELS section below for more info.
+
+ - Fashion Landmark Annotations (list_landmarks_consumer2shop.txt)
+
+ fashion landmark labels. See LANDMARK LABELS section below for more info.
+
+- Images (Img/)
+
+ consumer-to-shop clothes images. See IMAGE section below for more info.
+
+- Evaluation Partitions (Eval/list_eval_partition.txt)
+
+ image pair names for training, validation and testing set respectively. See EVALUATION PARTITIONS section below for more info.
+
+
+## IMAGE
+
+*.jpg
+
+format: JPG
+
+Notes:
+1. The long side of images are resized to 300;
+2. The aspect ratios of original images are kept unchanged.
+
+
+## BBOX LABELS
+
+list_bbox_consumer2shop.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. The order of bbox labels accords with the order of entry names;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes;
+3. In source type, "1" represents shop image, "2" represents consumer image;
+4. In bbox location, "x_1" and "y_1" represent the upper left point coordinate of bounding box, "x_2" and "y_2" represent the lower right point coordinate of bounding box. Bounding box locations are listed in the order of [x_1, y_1, x_2, y_2].
+
+
+## LANDMARK LABELS
+
+list_landmarks_consumer2shop.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: [ , ... ]
+```
+
+Notes:
+1. The order of landmark labels accords with the order of entry names;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes. Upper-body clothes possess six fahsion landmarks, lower-body clothes possess four fashion landmarks, full-body clothes possess eight fashion landmarks;
+3. In variation type, "1" represents normal pose, "2" represents medium pose, "3" represents large pose, "4" represents medium zoom-in, "5" represents large zoom-in;
+4. In landmark visibility state, "0" represents visible, "1" represents invisible/occluded, "2" represents truncated/cut-off;
+5. For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left hem", "right hem"]; For lower-body clothes, landmark annotations are listed in the order of ["left waistline", "right waistline", "left hem", "right hem"]; For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left waistline", "right waistline", "left hem", "right hem"].
+
+
+## ITEM LABELS
+
+list_items_consumer2shop.txt
+
+First Row: number of items
+
+Rest of the Rows: -
+
+Notes:
+1. Please refer to the paper "DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations" for more details.
+
+
+## ATTRIBUTE LABELS
+
+list_attr_cloth.txt
+
+```sh
+First Row: number of attributes
+Second Row: entry names
+Rest of the Rows:
+```
+
+list_attr_type.txt
+
+```sh
+First Row: number of attribute types
+Second Row: entry names
+Rest of the Rows:
+```
+
+list_attr_items.txt
+
+```sh
+First Row: number of items
+Second Row: entry names
+Rest of the Rows: -
+```
+
+Notes:
+1. The order of attribute labels accords with the order of attribute names;
+2. In attribute labels, "1" represents positive while "-1" represents negative, '0' represents unknown;
+3. Attribute prediction is treated as a multi-label tagging problem.
+
+
+## EVALUATION PARTITIONS
+
+list_eval_partition.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: -
+```
+
+Notes:
+1. In evaluation status, "train" represents training image, "val" represents validation image, "test" represents testing image;
+2. The gallery set here are all the shop images in "val + test" set;
+3. Items of clothes images are NOT overlapped within this dataset partition;
+4. Please refer to the paper "DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations" for more details.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/CONTRIBUTING.md b/internlm_langchain/knowledge_base/MMFashion/content/CONTRIBUTING.md
new file mode 100644
index 00000000..8ce4d8e0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing to mmfashion
+
+All kinds of contributions are welcome, including but not limited to the following.
+
+- Fixes (typo, bugs)
+- New features and components
+
+## Workflow
+
+1. fork and pull the latest mmfashion
+2. checkout a new branch (do not use master branch for PRs)
+3. commit your changes
+4. create a PR
+
+Note
+- If you plan to add some new features that involve large changes, it is encouraged to open an [issue](https://github.com/open-mmlab/mmfashion/issues) for discussion first.
+
+## Code style
+
+### Python
+
+We adopt [PEP8](https://www.python.org/dev/peps/pep-0008/) as the preferred code style.
+
+We use the following tools for linting and formatting:
+- [flake8](http://flake8.pycqa.org/en/latest/): linter
+- [yapf](https://github.com/google/yapf): formatter
+- [isort](https://github.com/timothycrosley/isort): sort imports
+
+Style configurations of yapf and isort can be found in [.style.yapf](.style.yapf) and [.isort.cfg](.isort.cfg).
+
+>Before you create a PR, make sure that your code lints and is formatted by yapf.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/DATA_PREPARATION.md b/internlm_langchain/knowledge_base/MMFashion/content/DATA_PREPARATION.md
new file mode 100644
index 00000000..d718d687
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/DATA_PREPARATION.md
@@ -0,0 +1,227 @@
+# Data Preparation
+
+1. [DeepFashion - Category and Attribute Prediction Benchmark](http://mmlab.ie.cuhk.edu.hk/projects/DeepFashion/AttributePrediction.html)
+
+2. [DeepFashion - In-Shop Clothes Retrieval Benchmark](http://mmlab.ie.cuhk.edu.hk/projects/DeepFashion/InShopRetrieval.html)
+
+4. [DeepFashion - Consumer-to-Shop Clothes Retrieval Benchmark](http://mmlab.ie.cuhk.edu.hk/projects/DeepFashion/Consumer2ShopRetrieval.html)
+
+4. [DeepFashion - Fashion Landmark Detection Benchmark](http://mmlab.ie.cuhk.edu.hk/projects/DeepFashion/LandmarkDetection.html)
+
+5. [Polyvore Outfits](https://drive.google.com/file/d/13-J4fAPZahauaGycw3j_YvbAHO7tOTW5/view?usp=sharing)
+
+6. [VTON](https://drive.google.com/file/d/1MxCUvKxejnwWnoZ-KoCyMCXo3TLhRuTo/view)
+
+To use the DeepFashion dataset you need to first download it to 'data/' , then follow these steps to re-organize the dataset.
+
+```sh
+cd data/
+mv Category\ and\ Attribute\ Prediction\ Benchmark Attr_Predict
+mv In-shop\ Clothes\ Retrieval\ Benchmark In-shop
+mv Consumer-to-shop\ Clothes\ Retrieval\ Benchmark Consumer_to_shop
+mv Fashion\ Landmark\ Detection\ Benchmark/ Landmark_Detect
+python prepare_attr_pred.py
+python prepare_in_shop.py
+python prepare_consumer_to_shop.py
+python prepare_landmark_detect.py
+```
+
+The directory should be like this:
+
+```sh
+mmfashion
+├── mmfashion
+├── tools
+├── configs
+├── data
+│ ├── Attr_Predict
+│ │ ├── Anno_coarse
+│ │ │ ├── train.txt
+│ │ │ ├── test.txt
+│ │ │ ├── val.txt
+│ │ │ ├── train_attr.txt
+│ │ │ ├── ...
+│ │ ├── Anno_fine
+│ │ │ ├── train.txt
+│ │ │ ├── test.txt
+│ │ │ ├── val.txt
+│ │ │ ├── ...
+│ │ ├── Img
+│ │ │ ├── img
+│ │ ├── Eval
+│ │ │ ├── ...
+│ ├── In-shop
+│ │ ├── train.txt
+│ │ ├── query.txt
+│ │ ├── gallery.txt
+│ │ ├── train_labels.txt
+│ │ │ ├── ...
+```
+
+## Prepare an AttrDataset
+
+**Updated**: We re-labeled a more accurate attribute prediction dataset, please [download](https://drive.google.com/drive/folders/19J-FY5NY7s91SiHpQQBo2ad3xjIB42iN?usp=sharing) them.
+
+The file tree should be like this:
+
+```sh
+Attr_Predict
+├── Anno_fine
+│ ├── list_attr_cloth.txt
+│ ├── list_attr_img.txt
+│ ├── list_bbox.txt
+│ ├── list_category_cloth.txt
+│ ├── list_category_img.txt
+│ ├── list_landmarks.txt
+│ ├── ...
+├── Anno_coarse
+├── Eval
+│ └── list_eval_partition.txt
+└── Img
+ ├── XXX.jpg
+ └── ...
+```
+
+Note that if you use "Anno_fine" that contains 26 better-labeled attributes, nothing else need to be done.
+
+If you use run "Anno_coarse" that contains 1000 roughly labeled attributes,
+ first run the following script to re-organize them.
+ `python prepare_attr_pred.py`
+
+Please refer to [dataset/ATTR_DATASET.md](dataset/ATTR_DATASET.md) for more info.
+
+
+## Prepare an InShopDataset
+We add segmentation annotations for "Fashion Parsing and Segmentation" task. Please download the updated data.
+The file tree should be like this:
+
+```sh
+In-shop
+├── Anno
+│ ├── segmentation
+│ | ├── DeepFashion_segmentation_train.json
+│ | ├── DeepFashion_segmentation_query.json
+│ | ├── DeepFashion_segmentation_gallery.json
+│ ├── list_bbox_inshop.txt
+│ ├── list_description_inshop.json
+│ ├── list_item_inshop.txt
+│ └── list_landmarks_inshop.txt
+├── Eval
+│ └── list_eval_partition.txt
+└── Img
+ ├── img
+ | ├──XXX.jpg
+ ├── img_highres
+ └── ├──XXX.jpg
+
+```
+
+Then run `python prepare_in_shop.py` to re-organize the dataset.
+
+Please refer to [dataset/IN_SHOP_DATASET.md](dataset/IN_SHOP_DATASET.md) for more info.
+
+
+## Prepare a ConsumerToShopDataset
+
+The file tree should be like this:
+
+```sh
+Consumer_to_shop
+├── Anno
+│ ├── list_attr_cloth.txt
+│ ├── list_attr_items.txt
+│ ├── list_attr_type.txt
+│ ├── list_bbox_consumer2shop.txt
+│ ├── list_item_consumer2shop.txt
+│ └── list_landmarks_consumer2shop.txt
+├── Eval
+│ └── list_eval_partition.txt
+└── Img
+ ├── XXX.jpg
+ └── ...
+```
+
+Then run `python prepare_consumer_to_shop.py` to re-organize the dataset.
+
+Please refer to [dataset/CONSUMER_TO_SHOP_DATASET.md](dataset/CONSUMER_TO_SHOP_DATASET.md) for more info.
+
+
+## Prepare a LandmarkDetectDataset
+
+The file tree should be like this:
+
+```sh
+Landmark_Detect
+├── Anno
+│ ├── list_bbox.txt
+│ ├── list_joints.txt
+│ └── list_landmarks.txt
+├── Eval
+│ └── list_eval_partition.txt
+└── Img
+ ├── XXX.jpg
+ └── ...
+```
+
+Then run `python prepare_landmark_detect.py` to re-organize the dataset.
+
+Please refer to [dataset/LANDMARK_DETECT_DATASET.md](dataset/LANDMARK_DETECT_DATASET.md) for more info.
+
+
+## Prepare Polyvore-Outfit dataset
+Polyvore dataset is widely used for learning fashion compatibility, containing rich multimodel information like
+images and descriptions of fashion items, number of likes of the outfit, etc.
+It is firstly collected by [Maryland](https://arxiv.org/pdf/1707.05691.pdf).
+Here we use a better sorted and grouped version from [UIUC](https://arxiv.org/pdf/1803.09196.pdf).
+
+Download [Polyvore](https://drive.google.com/file/d/13-J4fAPZahauaGycw3j_YvbAHO7tOTW5/view?usp=sharing)
+and put it in the `data/`
+
+The file tree should be like this:
+
+```sh
+Polyvore
+├── disjoint
+│ ├── compatibility_test.txt
+│ ├── compatibility_train.txt
+│ ├── fill_in_blank_test.json
+| └── ...
+├── nondisjoint
+│ └── ...
+└── images
+│ ├── XXX.jpg
+├── categories.csv
+├── polyvore_item_metadata.json
+├── polyvore_outfit_titles.json
+```
+
+
+## Prepare VTON dataset
+
+VTON dataset is used for virtual try-on task.
+It is first collected by [Han](https://arxiv.org/abs/1711.08447), containing around 19,000 front-view woman and top clothing image pairs.
+Here, we use a better sorted and grouped version from [Wang](https://arxiv.org/abs/1807.07688).
+
+Download [VTON](https://drive.google.com/file/d/1MxCUvKxejnwWnoZ-KoCyMCXo3TLhRuTo/view)
+and put it in the `data/`
+
+The file tree should be like this:
+
+```sh
+VTON
+├── vton_resize
+│ ├── train
+│ | ├── cloth
+| | ├── cloth-mask
+| | ├── image
+| | ├── image-parse
+| | ├── pose
+| | ├── train-pairs.txt
+└── ├── test
+ ├── cloth
+ ├── cloth-mask
+ ├── image
+ ├── image-parse
+ ├── pose
+ └── test_pairs.txt
+```
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/FASHION_COMPATIBILITY_DATASET.md b/internlm_langchain/knowledge_base/MMFashion/content/FASHION_COMPATIBILITY_DATASET.md
new file mode 100644
index 00000000..e54f1fd0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/FASHION_COMPATIBILITY_DATASET.md
@@ -0,0 +1,53 @@
+#PolyvoreOutfitDataset
+
+Polyvore Dataset is widely used for learning fashion compatibility.
+There are several different split versions of this dataset. We deployed [Learning Type Aware Embeddings for Fashion Compatibility](https://arxiv.org/pdf/1803.09196.pdf) here.
+
+- Polyvore Outfits(Nondisjoint)
+
+ Outfits are split at random. The training dataset and testing dataset may have overlapped items(garments).
+
+- Polyvore Outfits(Disjoint)
+
+ The training set and testing/validation set have no overlapped items.
+
+## Annotations
+
+- train/test/valid.json
+
+ A list of outfits, their item_id and their ordering(index).
+
+- typespaces.p
+
+ A list of tuples(t1, t2), each of which identifies a type- specific embedding that compares items of type t1 to items of type t2.
+
+- train_hglmm_pca6000.txt
+
+ Each row contains 6001 comma separated values, where the first element is the label, the remaining 6000 dimensions are the PCA-reduced HGLMM fisher vectors (note: the "label" may also contain a comma).
+
+- compatibility_train/test/valid.txt
+
+ Fashion compatibility experiment data, where each row is an outfit sample. The first element of the outfit sample is the label (1/0 for positive/negative) and the remaining elements are item identifiers in that sample.
+
+- fill_in_blank_train/test/valid.json
+
+ Fill-in-the-blank experiment data, contains an array of dictionaries. These dictionaries contain the question/answer pairs, and also identifies the "index" of the item in the outfit in
+"blank_position". Since the set_id is used in the item identifiers, the correct answer can be determined by matching the set_id in the question
+elements with the set_id in the answers.
+
+
+##Images
+Images are stored by their item_id, which are organized in lists of outfits for each each version of the dataset.
+
+##Meta-Data
+- polyvore_item_metadata.json
+
+ It contains a dictionary where each key is an item_id, and the values are its associated meta-data labels.
+
+- polyvore_outfit_titles.json
+
+ It contains a dictionary where each key is a set_id and the values are its associated meta-data labels.
+
+- categories.csv
+
+ Each row contains three items: category_id, fine_grained category, semantic categroy.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/GETTING_STARTED.md b/internlm_langchain/knowledge_base/MMFashion/content/GETTING_STARTED.md
new file mode 100644
index 00000000..b830693f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/GETTING_STARTED.md
@@ -0,0 +1,229 @@
+# Getting Started
+
+This page provides basic tutorials about the usage of `MMFashion`.
+
+
+## Inference with pretrained models
+
+We provide testing scripts to evaluate a whole dataset (Category and Attribute Prediction Benchmark, In-Shop Clothes Retrieval Benchmark, Fashion Landmark Detection Benchmark etc.),
+and also some high-level apis for easier integration to other projects.
+
+### Test an image
+
+You can use the following commands to test an image.
+
+```sh
+python demo/test_*.py --input ${INPUT_IMAGE_FILE}
+```
+
+Examples:
+
+Assume that you have already downloaded the checkpoints to `checkpoints/`.
+
+1. Test an attribute predictor(coarse prediction).
+
+ ```sh
+ # Prepare `Anno/list_attr_cloth.txt` which is specified in `configs/attribute_predict/global_predictor_vgg_attr.py`
+ python demo/test_attr_predictor.py \
+ --input demo/imgs/attr_pred_demo1.jpg
+ ```
+
+ Test a category and attribute predictor(**more accurate** prediction).
+
+ ```sh
+ # Prepare `Anno/list_attr_cloth.txt` which is specified in `configs/category_attribute_predict/global_predictor_vgg_attr.py`
+ python demo/test_cate_attr_predictor.py \
+ --input demo/imgs/attr_pred_demo1.jpg
+ ```
+
+2. Test an in-shop / Consumer-to_shop clothes retriever.
+
+ ```sh
+ # Prepare the gallery data which is specified in `configs/retriever_in_shop/global_retriever_vgg_loss_id.py`
+ python demo/test_retriever.py \
+ --input demo/imgs/retrieve_demo1.jpg
+ ```
+
+3. Test a landmark detector.
+
+ ```sh
+ python demo/test_landmark_detector.py \
+ --input demo/imgs/04_1_front.jpg
+ ```
+
+4. Test a fashion-compatibility predictor.
+
+ ```sh
+ python demo/test_fashion_recommender.py \
+ --input_dir demo/imgs/fashion_compatibility/set2
+ ```
+
+
+### Test a dataset
+
+You can use the following commands to test a dataset.
+
+```sh
+python tools/test_*.py --config ${CONFIG_FILE} --checkpoint ${CHECKPOINT_FILE}
+```
+
+Examples:
+
+Assume that you have already downloaded the checkpoints to `checkpoints/` and prepared the dataset in `data/`.
+
+1. Test an attribute predictor.
+
+ ```sh
+ python tools/test_predictor.py \
+ --config configs/attribute_predict/roi_predictor_vgg_attr.py \
+ --checkpoint checkpoint/Predict/vgg/roi/latest.pth
+ ```
+
+ Test a category and attribute predictor.
+
+ ```
+ python test tools/test_cate_attr_predictor.py \
+ --config configs/category_attribute_predict/roi_predictor_vgg.py \
+ --checkpoint checkpoint/CateAttrPredict/vgg/roi/latest.pth
+ ```
+
+2. Test an in-shop / Consumer-to_shop clothes retriever.
+
+ ```sh
+ python tools/test_retriever.py \
+ --config configs/retriever_in_shop/roi_retriever_vgg.py \
+ --checkpoint checkpoint/Retrieve_in_shop/vgg/latest.pth
+ ```
+
+ ```sh
+ python tools/test_retriever.py \
+ --config configs/retriever_consumer_to_shop/roi_retriever_vgg.py \
+ --checkpoint checkpoint/Retrieve_consumer_to_shop/vgg/latest.pth
+ ```
+
+3. Test a landmark detector.
+
+ ```sh
+ python tools/test_landmark_detector.py \
+ --config configs/landmark_detect/landmark_detect_vgg.py
+ --checkpoint checkpoint/LandmarkDetect/vgg/latest.pth
+ ```
+
+4. Test a fashion-compatibility predictor.
+
+ ```sh
+ python tools/test_fashion_recommender.py \
+ --config configs/fashion_recommendation/type_aware_recommendation_polyvore_disjoint.py
+ --checkpoint checkpoint/FashionRecommend/TypeAware/latest.pth
+ ```
+
+
+6. Test a virtual try-on module.
+
+ Step 1, use the geometric matching module(GMM) to generate warp-cloth and warp-mask,
+ ```sh
+ python tools/test_virtual_tryon.py \
+ --config configs/virtual_tryon/cp_vton.py \
+ --stage GMM
+ ```
+
+ Step 2, use the tryon module(TOM) to generate the results.
+ The default result directory is `data/VTON/result`, you can modify the path in config file(line 103).
+ ```sh
+ python tools/test_virtual_tryon.py \
+ --config configs/virtual_tryon/cp_vton.py \
+ --stage TOM
+ ```
+
+
+
+## Train a model
+
+You can use the following commands to train a model.
+
+```sh
+python tools/train_*.py --config ${CONFIG_FILE}
+```
+
+Examples:
+
+1. Train an attribute predictor.
+
+ ```sh
+ python tools/train_predictor.py \
+ --config configs/attribute_predict/roi_predictor_vgg_attr.py
+ ```
+
+2. Train an in-shop clothes / Consumer-to-shop retriever.
+
+ ```sh
+ python tools/train_retriever.py \
+ --config configs/retriever_in_shop/roi_retriever_vgg.py
+ ```
+
+ ```sh
+ python tools/train_retriever.py \
+ --config configs/retriever_consumer_to_shop/roi_retriever_vgg.py
+ ```
+
+3. Train a landmark detector.
+
+ ```sh
+ python tools/train_landmark_detector.py \
+ --config configs/landmark_detect/landmark_detect_vgg.py
+ ```
+
+4. Train a fashion-compatibility predictor.
+
+ ```sh
+ python tools/train_fashion_recommender.py \
+ --config configs/fashion_recommendation/type_aware_recommendation_polyvore_disjoint.py
+ ```
+
+5. Train a fashion detector.
+
+ ```sh
+ python mmdetection/tools/train.py \
+ configs/fashion_parsing_segmentation/mask_rcnn_r50_fpn_1x.py
+ ```
+
+6. Train a virtual try-on module.
+
+ Step 1, train a geometric matching module(GMM)
+ ```sh
+ python tools/train_virtual_tryon.py \
+ --config configs/virtual_tryon/cp_vton.py \
+ --stage GMM
+ ```
+
+ After training GMM, you need to generate the training images which are required by Step 2.
+
+ **Note** that you need to modify the config file `configs/virtual_tryon/cp_vton.py` as follows,
+
+ Line 87 should be `datamode='train'`,
+
+ Line 89 should be `data_list='test_pairs.txt'`,
+
+ Line 93 should be `save_dir=os.path.join(data_root, 'vton_resize', 'train')`
+
+ Then,
+ ```sh
+ python tools/test_virtual_tryon.py \
+ --config configs/virtual_tryon/cp_vton.py \
+ --stage GMM
+ ```
+
+ Step 2, train a tryon module(TOM),
+ ```sh
+ python tools/train_virtual_tryon.py \
+ --config configs/virtual_tryon/cp_vton.py \
+ --stage TOM
+ ```
+
+
+
+## Use custom datasets
+
+The simplest way is to prepare your dataset to existing dataset formats (AttrDataset, InShopDataset, ConsumerToShopDataset or LandmarkDetectDataset).
+
+Please refer to [DATA_PREPARATION.md](DATA_PREPARATION.md) for the dataset specifics.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/IN_SHOP_DATASET.md b/internlm_langchain/knowledge_base/MMFashion/content/IN_SHOP_DATASET.md
new file mode 100644
index 00000000..2c3f0583
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/IN_SHOP_DATASET.md
@@ -0,0 +1,167 @@
+# InShopDataset
+
+- Annotations (Anno/)
+ - segmentation/
+ clothing semgentaion and detection annotations
+
+ - Attribute Annotations (list_attr_cloth.txt & list_attr_items.txt)
+
+ clothing attribute labels. See ATTRIBUTE LABELS section below for more info.
+
+ - Bounding Box Annotations (list_bbox_inshop.txt)
+
+ bounding box labels. See BBOX LABELS section below for more info.
+
+ - Description Annotations (list_description_inshop.json)
+
+ item descriptions. See DESCRIPTION LABELS section below for more info.
+
+ - Item Annotations (list_item_inshop.txt)
+
+ item labels. See ITEM LABELS section below for more info.
+
+ - Fashion Landmark Annotations (list_landmarks_inshop.txt)
+
+ fashion landmark labels. See LANDMARK LABELS section below for more info.
+
+- Images (Img/)
+
+ in-shop clothes images. See IMAGE section below for more info.
+
+- Evaluation Partitions (Eval/list_eval_partition.txt)
+
+ image names for training, validation and testing set respectively. See EVALUATION PARTITIONS section below for more info.
+
+
+## IMAGE
+
+For Fashion Retrieval task, use "img.zip"; for fashion parsing and segmentation task, use "img_highres.zip".
+*.jpg
+
+format: JPG
+
+Notes:
+1. Images are centered and resized to 256*256;
+2. The aspect ratios of original images are kept unchanged.
+
+
+## BBOX LABELS
+
+list_bbox_inshop.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. The order of bbox labels accords with the order of entry names;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes;
+3. In pose type, "1" represents frontal view, "2" represents side view, "3" represents back view, "4" represents zoom-out view, "5" represents zoom-in view, "6" represents stand-alone view;
+4. In bbox location, "x_1" and "y_1" represent the upper left point coordinate of bounding box, "x_2" and "y_2" represent the lower right point coordinate of bounding box. Bounding box locations are listed in the order of [x_1, y_1, x_2, y_2].
+
+
+
+## LANDMARK LABELS
+
+list_landmarks_inshop.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: [ , ... ]
+```
+
+Notes:
+1. The order of landmark labels accords with the order of entry names;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes. Upper-body clothes possess six fahsion landmarks, lower-body clothes possess four fashion landmarks, full-body clothes possess eight fashion landmarks;
+3. In variation type, "1" represents normal pose, "2" represents medium pose, "3" represents large pose, "4" represents medium zoom-in, "5" represents large zoom-in;
+4. In landmark visibility state, "0" represents visible, "1" represents invisible/occluded, "2" represents truncated/cut-off;
+5. For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left hem", "right hem"]; For lower-body clothes, landmark annotations are listed in the order of ["left waistline", "right waistline", "left hem", "right hem"]; For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left waistline", "right waistline", "left hem", "right hem"].
+
+
+## COLOR MAPPING LABELS
+segmentation/img_highres_seg
+
+| Color(R-G-B) | Label |
+| :-------------------: | :-------------: |
+| 0-0-0 | background |
+| 255-250-250 | top |
+| 250-235-215 | skirt |
+| 70-130-180 | leggings |
+| 16-78-139 | dress |
+| 255-250-205 | outer |
+| 255-140-0 | pants |
+| 50-205-50 | bag |
+| 220-220-220 | neckwear |
+| 255-0-0 | headwear |
+| 127-255-212 | eyeglass |
+| 0-100-0 | belt |
+| 255-255-0 | footwear |
+| 211-211-211 | hair |
+| 144-238-144 | skin |
+| 245-222-179 | face |
+
+
+
+## ITEM LABELS
+
+list_item_inshop.txt
+
+First Row: number of items
+
+Rest of the Rows: -
+
+Notes:
+1. Please refer to the paper "DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations" for more details.
+
+
+## DESCRIPTION LABELS
+
+list_description_inshop.json
+
+Each Row:
-
-
-
+
+Notes:
+1. Please refer to the paper "DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations" for more details.
+
+
+## ATTRIBUTE LABELS
+
+list_attr_cloth.txt
+
+```sh
+First Row: number of attributes
+Second Row: entry names
+Rest of the Rows:
+```
+
+list_attr_items.txt
+
+```sh
+First Row: number of items
+Second Row: entry names
+Rest of the Rows: -
+```
+
+Notes:
+1. The order of attribute labels accords with the order of attribute names;
+2. In attribute labels, "1" represents positive while "-1" represents negative, '0' represents unknown;
+3. Attribute prediction is treated as a multi-label tagging problem.
+
+
+## EVALUATION PARTITIONS
+
+list_eval_partition.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: -
+```
+
+Notes:
+1. In evaluation status, "train" represents training image, "query" represents query image, "gallery" represents gallery image;
+2. Items of clothes images are NOT overlapped within this dataset partition;
+3. Please refer to the paper "DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations" for more details.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/LANDMARK_DETECT_DATASET.md b/internlm_langchain/knowledge_base/MMFashion/content/LANDMARK_DETECT_DATASET.md
new file mode 100644
index 00000000..87c91d9b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/LANDMARK_DETECT_DATASET.md
@@ -0,0 +1,99 @@
+# LandmarkDetectDataset
+
+- Annotations (Anno/)
+
+ - Bounding Box Annotations (list_bbox.txt)
+
+ bounding box labels. See BBOX LABELS section below for more info.
+
+ - Human Joint Annotations (list_joints.txt)
+
+ human joint labels. See JOINT LABELS section below for more info.
+
+ - Fashion Landmark Annotations (list_landmarks.txt)
+
+ fashion landmark labels. See LANDMARK LABELS section below for more info.
+
+- Images (Img/)
+
+ clothes images. See IMAGE section below for more info.
+
+- Evaluation Partitions (Eval/list_eval_partition.txt)
+
+ image names for training, validation and testing set respectively. See EVALUATION PARTITIONS section below for more info.
+
+
+## IMAGE
+
+*.jpg
+
+format: JPG
+
+Notes:
+1. The long side of images are resized to 512;
+2. The aspect ratios of original images are kept unchanged.
+
+
+## BBOX LABELS
+
+list_bbox.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. The order of bbox labels accords with the order of entry names;
+2. In bbox location, "x_1" and "y_1" represent the upper left point coordinate of bounding box, "x_2" and "y_2" represent the lower right point coordinate of bounding box. Bounding box locations are listed in the order of [x_1, y_1, x_2, y_2].
+
+
+## LANDMARK LABELS
+
+list_landmarks.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: [ , ... ]
+```
+
+Notes:
+1. The order of landmark labels accords with the order of entry names;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes. Upper-body clothes possess six fashion landmarks, lower-body clothes possess four fashion landmarks, full-body clothes possess eight fashion landmarks;
+3. In variation type, "1" represents normal pose, "2" represents medium pose, "3" represents large pose, "4" represents medium zoom-in, "5" represents large zoom-in;
+4. In landmark visibility state, "0" represents visible, "1" represents invisible/occluded, "2" represents truncated/cut-off;
+5. For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left hem", "right hem"]; For lower-body clothes, landmark annotations are listed in the order of ["left waistline", "right waistline", "left hem", "right hem"]; For upper-body clothes, landmark annotations are listed in the order of ["left collar", "right collar", "left sleeve", "right sleeve", "left waistline", "right waistline", "left hem", "right hem"].
+
+
+## JOINT LABELS
+
+list_joints.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows: [ , ... ]
+```
+
+Notes:
+1. The order of joint labels accords with the order of entry names. Overall there are fourteen human joints;
+2. In clothes type, "1" represents upper-body clothes, "2" represents lower-body clothes, "3" represents full-body clothes;
+3. In variation type, "1" represents normal pose, "2" represents medium pose, "3" represents large pose, "4" represents medium zoom-in, "5" represents large zoom-in;
+4. In landmark visibility state, "0" represents visible, "1" represents invisible.
+
+
+## EVALUATION PARTITIONS
+
+list_eval_partition.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
+```
+
+Notes:
+1. In evaluation status, "train" represents training image, "val" represents validation image, "test" represents testing image;
+2. Please refer to the paper "Fashion Landmark Detection in the Wild" for more details.
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/MODEL_ZOO.md b/internlm_langchain/knowledge_base/MMFashion/content/MODEL_ZOO.md
new file mode 100644
index 00000000..742b6bb8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/MODEL_ZOO.md
@@ -0,0 +1,73 @@
+# Model Zoo
+
+More models with different backbones will be added to the model zoo.
+
+## Init models
+
+| Backbone | Download |
+| :---------: | :----------------: |
+| VGG-16 | [vgg16.pth](https://download.pytorch.org/models/vgg16-397923af.pth) |
+
+
+## Attribute Prediction(Coarse)
+
+| Backbone | Pooling | Loss | Top-5 Recall | Top-5 Acc. | Download (Google) | Download (Baidu) |
+| :---------: | :--------------: | :-----------: | :----------: | :--------: | :----------------: | :----------------: |
+| VGG-16 | Global Pooling | Cross-Entropy | 13.70 | 99.81 | [model](https://drive.google.com/open?id=1lJlUtEQUxeWCDLj1nIhUBw8QtgaYtuqe) | [model](https://pan.baidu.com/s/1QB_10Yx9hU1xqjoZSuZsaQ), passwd: j9qd |
+| VGG-16 | Landmark Pooling | Cross-Entropy | 14.79 | 99.27 | [model](https://drive.google.com/open?id=18ZWz9Tr6vsAW5Lxq81ps6GddCJPJ0gMx) | - |
+| ResNet-50 | Global Pooling | Cross-Entropy | 23.52 | 99.29 | [model](https://drive.google.com/open?id=1LmC4aKiOY3qmm9qo6RNDU5v_o-xDCAdT) | - |
+| ResNet-50 | Landmark Pooling | Cross-Entropy | 30.84 | 99.30 | [model](https://drive.google.com/open?id=1bOL4GhLyBEcXgATiVcZ-g3RD8xhKsj5f) | - |
+
+
+## Category and Attribute Prediction(Fine)
+| Backbone | Pooling | Loss | Top-5 Cate. Recall | Top-5 Attr. Recall. | Download (Google) | Download (Baidu) |
+| :---------: | :--------------: | :-----------: | :----------------: | :-----------------: | :----------------: | :----------------: |
+| VGG-16 | Global Pooling | Cross-Entropy | 35.91 | 25.44 | [model](https://drive.google.com/file/d/10SZ3Lw4U0F9OKAuHWc-tBbvLS6yfE_x8/view?usp=sharing) | - |
+| VGG-16 | Landmark Pooling | Cross-Entropy | 37.71 | 26.69 | [model](https://drive.google.com/file/d/17XlihpZS9iY__i7rPxqlzpenHHRSbLGa/view?usp=sharing) | - |
+| ResNet-50 | Global Pooling | Cross-Entropy | 42.87 | 29.37 | [model](https://drive.google.com/file/d/1zsgxJAkdumpw4uDkapb1Ulq-aG1Hwz45/view?usp=sharing) | - |
+| ResNet-50 | Landmark Pooling | Cross-Entropy | 48.25 | 32.57 | [model](https://drive.google.com/file/d/1zsgxJAkdumpw4uDkapb1Ulq-aG1Hwz45/view?usp=sharing) | - |
+
+
+## In-Shop Clothes Retrieval
+
+| Backbone | Pooling | Loss | Top-5 Acc. | Download (Google) | Download (Baidu) |
+| :---------: | :--------------: | :-----------: | :--------: | :----------------: | :----------------: |
+| VGG-16 | Global Pooling | Cross-Entropy | 38.76 | [model](https://drive.google.com/open?id=1J3FmP5iVE-arwQZKP2QVrOwDTtTvlzJZ) | [model](https://pan.baidu.com/s/1n8BnYBUm4Dug4aREFfYfpQ), passwd: wz69 |
+| VGG-16 | Landmark Pooling | Cross-Entropy | 46.29 | [model](https://drive.google.com/open?id=1BQxjEqDF4ZQV4X57SiT28qCzIttUAZc-) | - |
+| ResNet-50 | Global Pooling | Cross-Entropy | 41.81 | [model](https://drive.google.com/open?id=1UYaIaDhuCwMQiQIcOEzYlPh0M1RFfdw-) | - |
+| ResNet-50 | Landmark Pooling | Cross-Entropy | 48.82 | [model](https://drive.google.com/open?id=1HZ13jijnjXxQ4nnsiss-UZ7bxHLN0kjw) | - |
+
+
+## Consumer-to-Shop Clothes Retrieval
+
+| Backbone | Pooling | Loss | Top-5 Acc. | Download (Google) | Download (Baidu) |
+| :---------: | :--------------: | :-----------: | :--------: | :----------------: | :----------------: |
+| VGG-16 | Landmark Pooling | Cross-Entropy | 7.18 | [model](https://drive.google.com/open?id=1I5_VBDKmjqNtG0-H0e9rvGXhhrz_-lDy) | [model](https://pan.baidu.com/s/1WUOihnZzav_8vl6pfHSy1A), passwd: grfx |
+
+
+## Fashion Landmark Detection
+
+| Backbone | Loss | Normalized Error | % of Det. Landmarks | Download (Google) | Download (Baidu) |
+| :---------: | :-----: | :--------------: | :-----------------: | :----------------: | :----------------: |
+| VGG-16 | L2 Loss | 0.0813 | 55.35 | [model](https://drive.google.com/open?id=1LWhPnkT9AbbldvteFn8u_s21PCQ-h00h) | [model](https://pan.baidu.com/s/1tzVGeV5P5Sed3diXEr1UPg), passwd: 4ebx |
+| ResNet-50 | L2 Loss | 0.0758 | 56.32 | [model](https://drive.google.com/open?id=1VGbOgkqBOgs2MaZ6qvLplopqqt7vKAM1) |
+
+
+## Fashion Compatibility Predictor
+| Backbone | Dataset | Embedding Projection | Loss | Fill-in-blank Acc | Compatibility AUC | Download (Google) |
+| :---------: | :---------: | :-------------------: | :---------------------------------------------------------: | :----------------:| :----------------:| :-------------------------: |
+| ResNet-18 | Disjoint | fully-connected layer | Triplet loss, Type-specific loss, Similarity loss, VSE loss | 50.4 | 0.80 | [model](https://drive.google.com/open?id=1T-9BLWbuZhEHpX8xV6f1ZoGUpcjV3efc) |
+| ResNet-18 | Disjoint | learned metric | Triplet loss, Type-specific loss, Similarity loss, VSE loss | 55.6 | 0.84 | [model](https://drive.google.com/open?id=1sYF0vqfI2z1riBvF9O643IH6mDikER7n) |
+| ResNet-18 | Nondisjoint | fully-connected layer | Triplet loss, Type-specific loss, Similarity loss, VSE loss | 53.5 | 0.85 | [model](https://drive.google.com/open?id=177W9T7Szl7Z--mF2Zjv89q6u7nUQG2Lq) |
+
+
+## Fashion Segmentation
+| Backbone | Model type | Dataset | bbox detection Average Precision | segmentation Average Precision | Download (Google) |
+| :---------: | :----------: | :-----------------: | :--------------------------------: | :----------------------------: | :-------------------------: |
+| Resnet50 | Mask RCNN | DeepFashion-In-shop | 0.599 | 0.584 | [model](https://drive.google.com/open?id=1q6zF7J6Gb-FFgM87oIORIt6uBozaXp5r) |
+
+
+## Fashion Virual Try-on
+| Model type | Dataset | Download (Google) |
+| :-----------: | :-----------: | :-------------------------: |
+| CP-VTON | VTON | [GMM](https://drive.google.com/file/d/1-nfMaN40WOofvfv9pCbqrbq0xQT3Tnnx/view?usp=sharing) [TOM](https://drive.google.com/file/d/1zZRBQDJZbDCr5bdoAnIm0UyOiWXB5dvO/view?usp=sharing) |
diff --git a/internlm_langchain/knowledge_base/MMFashion/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMFashion/vector_store/index.faiss
new file mode 100644
index 00000000..96b20ddf
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMFashion/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/customize_config.md b/internlm_langchain/knowledge_base/MMFewShot/content/customize_config.md
new file mode 100644
index 00000000..1e0586b9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/customize_config.md
@@ -0,0 +1,295 @@
+# Tutorial 1: Learn about Configs
+
+We incorporate modular and inheritance design into our config system, which is convenient to conduct various experiments.
+If you wish to inspect the config file, you may run `python tools/misc/print_config.py /PATH/TO/CONFIG` to see the complete config.
+The classification part of mmfewshot is built upon the [mmcls](https://github.com/open-mmlab/mmclassification),
+thus it is highly recommended learning the basic of mmcls.
+
+## Modify config through script arguments
+
+When submitting jobs using "tools/classification/train.py" or "tools/classification/test.py", you may specify `--cfg-options` to in-place modify the config.
+
+- Update config keys of dict chains.
+
+ The config options can be specified following the order of the dict keys in the original config.
+ For example, `--cfg-options model.backbone.norm_eval=False` changes the all BN modules in model backbones to `train` mode.
+
+- Update keys inside a list of configs.
+
+ Some config dicts are composed as a list in your config. For example, the training pipeline `data.train.pipeline` is normally a list
+ e.g. `[dict(type='LoadImageFromFile'), ...]`. If you want to change `'LoadImageFromFile'` to `'LoadImageFromWebcam'` in the pipeline,
+ you may specify `--cfg-options data.train.pipeline.0.type=LoadImageFromWebcam`.
+
+- Update values of list/tuples.
+
+ If the value to be updated is a list or a tuple. For example, the config file normally sets `workflow=[('train', 1)]`. If you want to
+ change this key, you may specify `--cfg-options workflow="[(train,1),(val,1)]"`. Note that the quotation mark " is necessary to
+ support list/tuple data types, and that **NO** white space is allowed inside the quotation marks in the specified value.
+
+## Config Name Style
+
+We follow the below style to name config files. Contributors are advised to follow the same style.
+
+```
+{algorithm}_[algorithm setting]_{backbone}_{gpu x batch_per_gpu}_[misc]_{dataset}_{meta test setting}.py
+```
+
+`{xxx}` is required field and `[yyy]` is optional.
+
+- `{algorithm}`: model type like `faster_rcnn`, `mask_rcnn`, etc.
+- `[algorithm setting]`: specific setting for some model, like `without_semantic` for `htc`, `moment` for `reppoints`, etc.
+- `{backbone}`: backbone type like `conv4`, `resnet12`.
+- `[norm_setting]`: `bn` (Batch Normalization) is used unless specified, other norm layer type could be `gn` (Group Normalization), `syncbn` (Synchronized Batch Normalization).
+ `gn-head`/`gn-neck` indicates GN is applied in head/neck only, while `gn-all` means GN is applied in the entire model, e.g. backbone, neck, head.
+- `[gpu x batch_per_gpu]`: GPUs and samples per GPU. For episodic training methods we use the total number of images in one episode, i.e. n classes x (support images+query images).
+- `[misc]`: miscellaneous setting/plugins of model.
+- `{dataset}`: dataset like `cub`, `mini-imagenet` and `tiered-imagenet`.
+- `{meta test setting}`: n way k shot setting like `5way_1shot` or `5way_5shot`.
+
+## An Example of Baseline
+
+To help the users have a basic idea of a complete config and the modules in a modern classification system,
+we make brief comments on the config of Baseline for MiniImageNet in 5 way 1 shot setting as the following.
+For more detailed usage and the corresponding alternative for each module, please refer to the API documentation.
+
+```python
+# config of model
+model = dict(
+ # classifier name
+ type='Baseline',
+ # config of backbone
+ backbone=dict(type='Conv4'),
+ # config of classifier head
+ head=dict(type='LinearHead', num_classes=64, in_channels=1600),
+ # config of classifier head used in meta test
+ meta_test_head=dict(type='LinearHead', num_classes=5, in_channels=1600))
+
+# data pipeline for training
+train_pipeline = [
+ # first pipeline to load images from file path
+ dict(type='LoadImageFromFile'),
+ # random resize crop
+ dict(type='RandomResizedCrop', size=84),
+ # random flip
+ dict(type='RandomFlip', flip_prob=0.5, direction='horizontal'),
+ # color jitter
+ dict(type='ColorJitter', brightness=0.4, contrast=0.4, saturation=0.4),
+ dict(type='Normalize', # normalization
+ # mean values used to normalization
+ mean=[123.675, 116.28, 103.53],
+ # standard variance used to normalization
+ std=[58.395, 57.12, 57.375],
+ # whether to invert the color channel, rgb2bgr or bgr2rgb
+ to_rgb=True),
+ # convert img into torch.Tensor
+ dict(type='ImageToTensor', keys=['img']),
+ # convert gt_label into torch.Tensor
+ dict(type='ToTensor', keys=['gt_label']),
+ # pipeline that decides which keys in the data should be passed to the runner
+ dict(type='Collect', keys=['img', 'gt_label'])
+]
+
+# data pipeline for testing
+test_pipeline = [
+ # first pipeline to load images from file path
+ dict(type='LoadImageFromFile'),
+ # resize image
+ dict(type='Resize', size=(96, -1)),
+ # center crop
+ dict(type='CenterCrop', crop_size=84),
+ dict(type='Normalize', # normalization
+ # mean values used to normalization
+ mean=[123.675, 116.28, 103.53],
+ # standard variance used to normalization
+ std=[58.395, 57.12, 57.375],
+ # whether to invert the color channel, rgb2bgr or bgr2rgb
+ to_rgb=True),
+ # convert img into torch.Tensor
+ dict(type='ImageToTensor', keys=['img']),
+ # pipeline that decides which keys in the data should be passed to the runner
+ dict(type='Collect', keys=['img', 'gt_label'])
+]
+
+# config of fine-tuning using support set in Meta Test
+meta_finetune_cfg = dict(
+ # number of iterations in fine-tuning
+ num_steps=150,
+ # optimizer config in fine-tuning
+ optimizer=dict(
+ type='SGD', # optimizer name
+ lr=0.01, # learning rate
+ momentum=0.9, # momentum
+ dampening=0.9, # dampening
+ weight_decay=0.001)), # weight decay
+
+data = dict(
+ # batch size of a single GPU
+ samples_per_gpu=64,
+ # worker to pre-fetch data for each single GPU
+ workers_per_gpu=4,
+ # config of training set
+ train=dict(
+ # name of dataset
+ type='MiniImageNetDataset',
+ # prefix of image
+ data_prefix='data/mini_imagenet',
+ # subset of dataset
+ subset='train',
+ # train pipeline
+ pipeline=train_pipeline),
+ # config of validation set
+ val=dict(
+ # dataset wrapper for Meta Test
+ type='MetaTestDataset',
+ # total number of test tasks
+ num_episodes=100,
+ num_ways=5, # number of class in each task
+ num_shots=1, # number of support images in each task
+ num_queries=15, # number of query images in each task
+ dataset=dict( # config of dataset
+ type='MiniImageNetDataset', # dataset name
+ subset='val', # subset of dataset
+ data_prefix='data/mini_imagenet', # prefix of images
+ pipeline=test_pipeline),
+ meta_test_cfg=dict( # config of Meta Test
+ num_episodes=100, # total number of test tasks
+ num_ways=5, # number of class in each task
+ # whether to pre-compute features from backbone for acceleration
+ fast_test=True,
+ # dataloader setting for feature extraction of fast test
+ test_set=dict(batch_size=16, num_workers=2),
+ support=dict( # support set setting in meta test
+ batch_size=4, # batch size for fine-tuning
+ num_workers=0, # number of worker set 0 since the only 5 images
+ drop_last=True, # drop last
+ train=dict( # config of fine-tuning
+ num_steps=150, # number of steps in fine-tuning
+ optimizer=dict( # optimizer config in fine-tuning
+ type='SGD', # optimizer name
+ lr=0.01, # learning rate
+ momentum=0.9, # momentum
+ dampening=0.9, # dampening
+ weight_decay=0.001))), # weight decay
+ # query set setting predict 75 images
+ query=dict(batch_size=75, num_workers=0))),
+ test=dict( # used for model validation in Meta Test fashion
+ type='MetaTestDataset', # dataset wrapper for Meta Test
+ num_episodes=2000, # total number of test tasks
+ num_ways=5, # number of class in each task
+ num_shots=1, # number of support images in each task
+ num_queries=15, # number of query images in each task
+ dataset=dict( # config of dataset
+ type='MiniImageNetDataset', # dataset name
+ subset='test', # subset of dataset
+ data_prefix='data/mini_imagenet', # prefix of images
+ pipeline=test_pipeline),
+ meta_test_cfg=dict( # config of Meta Test
+ num_episodes=2000, # total number of test tasks
+ num_ways=5, # number of class in each task
+ # whether to pre-compute features from backbone for acceleration
+ fast_test=True,
+ # dataloader setting for feature extraction of fast test
+ test_set=dict(batch_size=16, num_workers=2),
+ support=dict( # support set setting in meta test
+ batch_size=4, # batch size for fine-tuning
+ num_workers=0, # number of worker set 0 since the only 5 images
+ drop_last=True, # drop last
+ train=dict( # config of fine-tuning
+ num_steps=150, # number of steps in fine-tuning
+ optimizer=dict( # optimizer config in fine-tuning
+ type='SGD', # optimizer name
+ lr=0.01, # learning rate
+ momentum=0.9, # momentum
+ dampening=0.9, # dampening
+ weight_decay=0.001))), # weight decay
+ # query set setting predict 75 images
+ query=dict(batch_size=75, num_workers=0))))
+log_config = dict(
+ interval=50, # interval to print the log
+ hooks=[dict(type='TextLoggerHook')])
+checkpoint_config = dict(interval=20) # interval to save a checkpoint
+evaluation = dict(
+ by_epoch=True, # eval model by epoch
+ metric='accuracy', # Metrics used during evaluation
+ interval=5) # interval to eval model
+# parameters to setup distributed training, the port can also be set.
+dist_params = dict(backend='nccl')
+log_level = 'INFO' # the output level of the log.
+load_from = None # load a pre-train checkpoints
+# resume checkpoints from a given path, the training will be resumed from
+# the epoch when the checkpoint's is saved.
+resume_from = None
+# workflow for runner. [('train', 1)] means there is only one workflow and
+# the workflow named 'train' is executed once.
+workflow = [('train', 1)]
+pin_memory = True # whether to use pin memory
+# whether to use infinite sampler; infinite sampler can accelerate training efficient
+use_infinite_sampler = True
+seed = 0 # random seed
+runner = dict(type='EpochBasedRunner', max_epochs=200) # runner type and epochs of training
+optimizer = dict( # the configuration file used to build the optimizer, support all optimizers in PyTorch.
+ type='SGD', # optimizer type
+ lr=0.05, # learning rat
+ momentum=0.9, # momentum
+ weight_decay=0.0001) # weight decay of SGD
+optimizer_config = dict(grad_clip=None) # most of the methods do not use gradient clip
+lr_config = dict(
+ # the policy of scheduler, also support CosineAnnealing, Cyclic, etc. Refer to details of supported LrUpdater
+ # from https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/lr_updater.py#L9.
+ policy='step',
+ warmup='linear', # warmup type
+ warmup_iters=3000, # warmup iterations
+ warmup_ratio=0.25, # warmup ratio
+ step=[60, 120]) # Steps to decay the learning rate
+```
+
+## FAQ
+
+### Use intermediate variables in configs
+
+Some intermediate variables are used in the configuration file. The intermediate variables make the configuration file clearer and easier to modify.
+
+For example, `train_pipeline` / `test_pipeline` is the intermediate variable of the data pipeline. We first need to define `train_pipeline` / `test_pipeline`, and then pass them to `data`. If you want to modify the size of the input image during training and testing, you need to modify the intermediate variables of `train_pipeline` / `test_pipeline`.
+
+```python
+img_norm_cfg = dict(
+ mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='RandomResizedCrop', size=384, backend='pillow',),
+ dict(type='RandomFlip', flip_prob=0.5, direction='horizontal'),
+ dict(type='Normalize', **img_norm_cfg),
+ dict(type='ImageToTensor', keys=['img']),
+ dict(type='ToTensor', keys=['gt_label']),
+ dict(type='Collect', keys=['img', 'gt_label'])
+]
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize', size=384, backend='pillow'),
+ dict(type='Normalize', **img_norm_cfg),
+ dict(type='ImageToTensor', keys=['img']),
+ dict(type='Collect', keys=['img'])
+]
+data = dict(
+ train=dict(pipeline=train_pipeline),
+ val=dict(pipeline=test_pipeline),
+ test=dict(pipeline=test_pipeline))
+```
+
+### Ignore some fields in the base configs
+
+Sometimes, you need to set `_delete_=True` to ignore some domain content in the basic configuration file. You can refer to [mmcv](https://mmcv.readthedocs.io/en/latest/understand_mmcv/config.html#inherit-from-base-config-with-ignored-fields) for more instructions.
+
+The following is an example. If you want to use cosine schedule, just using inheritance and directly modify it will report `get unexcepected keyword'step'` error, because the `'step'` field of the basic config in `lr_config` domain information is reserved, and you need to add `_delete_ =True` to ignore the content of `lr_config` related fields in the basic configuration file:
+
+```python
+lr_config = dict(
+ _delete_=True,
+ policy='CosineAnnealing',
+ min_lr=0,
+ warmup='linear',
+ by_epoch=True,
+ warmup_iters=5,
+ warmup_ratio=0.1
+)
+```
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/customize_dataset.md b/internlm_langchain/knowledge_base/MMFewShot/content/customize_dataset.md
new file mode 100644
index 00000000..be00b6f2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/customize_dataset.md
@@ -0,0 +1,224 @@
+# Tutorial 2: Adding New Dataset
+
+## Customize datasets by reorganizing data
+
+### Customize loading annotations
+
+You can write a new Dataset class inherited from `BaseFewShotDataset`, and overwrite `load_annotations(self)`,
+like [CUB](https://github.com/open-mmlab/mmfewshot/blob/main/mmfewshot/classification/datasets/cub.py) and [MiniImageNet](https://github.com/open-mmlab/mmfewshot/blob/main/mmfewshot/classification/datasets/mini_imagenet.py).
+Typically, this function returns a list, where each sample is a dict, containing necessary data information, e.g., `img` and `gt_label`.
+
+Assume we are going to implement a `Filelist` dataset, which takes filelists for both training and testing. The format of annotation list is as follows:
+
+```
+000001.jpg 0
+000002.jpg 1
+```
+
+We can create a new dataset in `mmfewshot/classification/datasets/filelist.py` to load the data.
+
+```python
+import mmcv
+import numpy as np
+
+from mmcls.datasets.builder import DATASETS
+from .base import BaseFewShotDataset
+
+
+@DATASETS.register_module()
+class Filelist(BaseFewShotDataset):
+
+ def load_annotations(self):
+ assert isinstance(self.ann_file, str)
+
+ data_infos = []
+ with open(self.ann_file) as f:
+ samples = [x.strip().split(' ') for x in f.readlines()]
+ for filename, gt_label in samples:
+ info = {'img_prefix': self.data_prefix}
+ info['img_info'] = {'filename': filename}
+ info['gt_label'] = np.array(gt_label, dtype=np.int64)
+ data_infos.append(info)
+ return data_infos
+
+```
+
+And add this dataset class in `mmcls/datasets/__init__.py`
+
+```python
+from .base_dataset import BaseDataset
+...
+from .filelist import Filelist
+
+__all__ = [
+ 'BaseDataset', ... ,'Filelist'
+]
+```
+
+Then in the config, to use `Filelist` you can modify the config as the following
+
+```python
+train = dict(
+ type='Filelist',
+ ann_file = 'image_list.txt',
+ pipeline=train_pipeline
+)
+```
+
+### Customize different subsets
+
+To support different subset, we first predefine the classes of different subsets.
+Then we modify `get_classes` to handle different classes of subset.
+
+```python
+import mmcv
+import numpy as np
+
+from mmcls.datasets.builder import DATASETS
+from .base import BaseFewShotDataset
+
+@DATASETS.register_module()
+class Filelist(BaseFewShotDataset):
+
+ TRAIN_CLASSES = ['train_a', ...]
+ VAL_CLASSES = ['val_a', ...]
+ TEST_CLASSES = ['test_a', ...]
+
+ def __init__(self, subset, *args, **kwargs):
+ ...
+ self.subset = subset
+ super().__init__(*args, **kwargs)
+
+ def get_classes(self):
+ if self.subset == 'train':
+ class_names = self.TRAIN_CLASSES
+ ...
+ return class_names
+```
+
+## Customize datasets sampling
+
+### EpisodicDataset
+
+We use `EpisodicDataset` as wrapper to perform N way K shot sampling.
+For example, suppose the original dataset is Dataset_A, the config looks like the following
+
+```python
+dataset_A_train = dict(
+ type='EpisodicDataset',
+ num_episodes=100000, # number of total episodes = length of dataset wrapper
+ # each call of `__getitem__` will return
+ # {'support_data': [(num_ways * num_shots) images],
+ # 'query_data': [(num_ways * num_queries) images]}
+ num_ways=5, # number of way (different classes)
+ num_shots=5, # number of support shots of each class
+ num_queries=5, # number of query shots of each class
+ dataset=dict( # This is the original config of Dataset_A
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+ )
+```
+
+### Customize sampling logic
+
+An example of customizing data sampling logic for training:
+
+#### Create a new dataset wrapper
+
+We can create a new dataset wrapper in mmfewshot/classification/datasets/dataset_wrappers.py to customize sampling logic.
+
+```python
+class MyDatasetWrapper:
+ def __init__(self, dataset, args_a, args_b, ...):
+ self.dataset = dataset
+ ...
+ self.episode_idxes = self.generate_episodic_idxes()
+
+ def generate_episodic_idxes(self):
+ episode_idxes = []
+ # sampling each episode
+ for _ in range(self.num_episodes):
+ episodic_a_idx, episodic_b_idx, episodic_c_idx= [], [], []
+ # customize sampling logic
+ # select the index of data_infos from original dataset
+ ...
+ episode_idxes.append({
+ 'a': episodic_a_idx,
+ 'b': episodic_b_idx,
+ 'c': episodic_c_idx,
+ })
+ return episode_idxes
+
+ def __getitem__(self, idx):
+ # the key can be any value, but it needs to modify the code
+ # in the forward function of model.
+ return {
+ 'a_data' : [self.dataset[i] for i in self.episode_idxes[idx]['a']],
+ 'b_data' : [self.dataset[i] for i in self.episode_idxes[idx]['b']],
+ 'c_data' : [self.dataset[i] for i in self.episode_idxes[idx]['c']]
+ }
+
+```
+
+#### Update dataset builder
+
+We need to add the build code in mmfewshot/classification/datasets/builder.py
+for our customize dataset wrapper.
+
+```python
+def build_dataset(cfg, default_args=None):
+ if isinstance(cfg, (list, tuple)):
+ dataset = ConcatDataset([build_dataset(c, default_args) for c in cfg])
+ ...
+ elif cfg['type'] == 'MyDatasetWrapper':
+ dataset = MyDatasetWrapper(
+ build_dataset(cfg['dataset'], default_args),
+ # pass customize arguments
+ args_a=cfg['args_a'],
+ args_b=cfg['args_b'],
+ ...)
+ else:
+ dataset = build_from_cfg(cfg, DATASETS, default_args)
+
+ return dataset
+```
+
+#### Update the arguments in model
+
+The argument names in forward function need to be consistent with the customize dataset wrapper.
+
+```python
+class MyClassifier(BaseFewShotClassifier):
+ ...
+ def forward(self, a_data=None, b_data=None, c_data=None, ...):
+ # pass the modified arguments name.
+ if mode == 'train':
+ return self.forward_train(a_data=a_data, b_data=b_data, c_data=None, **kwargs)
+ elif mode == 'query':
+ return self.forward_query(img=img, **kwargs)
+ elif mode == 'support':
+ return self.forward_support(img=img, **kwargs)
+ elif mode == 'extract_feat':
+ return self.extract_feat(img=img)
+ else:
+ raise ValueError()
+```
+
+#### using customize dataset wrapper in config
+
+Then in the config, to use `MyDatasetWrapper` you can modify the config as the following,
+
+```python
+dataset_A_train = dict(
+ type='MyDatasetWrapper',
+ args_a=None,
+ args_b=None,
+ dataset=dict( # This is the original config of Dataset_A
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+ )
+```
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/customize_models.md b/internlm_langchain/knowledge_base/MMFewShot/content/customize_models.md
new file mode 100644
index 00000000..fadcd565
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/customize_models.md
@@ -0,0 +1,265 @@
+# Tutorial 3: Customize Models
+
+### Add a new classifier
+
+Here we show how to develop a new classifier with an example as follows
+
+#### 1. Define a new classifier
+
+Create a new file `mmfewshot/classification/models/classifiers/my_classifier.py`.
+
+```python
+from mmcls.models.builder import CLASSIFIERS
+from .base import BaseFewShotClassifier
+
+@CLASSIFIERS.register_module()
+class MyClassifier(BaseFewShotClassifier):
+
+ def __init__(self, arg1, arg2):
+ pass
+
+ # customize input for different mode
+ # the input should keep consistent with the dataset
+ def forward(self, img, mode='train',**kwargs):
+ if mode == 'train':
+ return self.forward_train(img=img, **kwargs)
+ elif mode == 'query':
+ return self.forward_query(img=img, **kwargs)
+ elif mode == 'support':
+ return self.forward_support(img=img, **kwargs)
+ elif mode == 'extract_feat':
+ assert img is not None
+ return self.extract_feat(img=img)
+ else:
+ raise ValueError()
+
+ # customize forward function for training data
+ def forward_train(self, img, gt_label, **kwargs):
+ pass
+
+ # customize forward function for meta testing support data
+ def forward_support(self, img, gt_label, **kwargs):
+ pass
+
+ # customize forward function for meta testing query data
+ def forward_query(self, img):
+ pass
+
+ # prepare meta testing
+ def before_meta_test(self, meta_test_cfg, **kwargs):
+ pass
+
+ # prepare forward meta testing query images
+ def before_forward_support(self, **kwargs):
+ pass
+
+ # prepare forward meta testing support images
+ def before_forward_query(self, **kwargs):
+ pass
+```
+
+#### 2. Import the module
+
+You can either add the following line to `mmfewshot/classification/models/heads/__init__.py`
+
+```python
+from .my_classifier import MyClassifier
+```
+
+or alternatively add
+
+```python
+custom_imports = dict(
+ imports=['mmfewshot.classification.models.classifier.my_classifier'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+#### 3. Use the classifier in your config file
+
+```python
+model = dict(
+ type="MyClassifier",
+ ...
+)
+```
+
+### Add a new backbone
+
+Here we show how to develop a new backbone with an example as follows
+
+#### 1. Define a new backbone
+
+Create a new file `mmfewshot/classification/models/backbones/mynet.py`.
+
+```python
+import torch.nn as nn
+
+from mmcls.models.builder import BACKBONES
+
+@BACKBONES.register_module()
+class MyNet(nn.Module):
+
+ def __init__(self, arg1, arg2):
+ pass
+
+ def forward(self, x): # should return a tensor
+ pass
+```
+
+#### 2. Import the module
+
+You can either add the following line to `mmfewshot/classification/models/backbones/__init__.py`
+
+```python
+from .mynet import MyNet
+```
+
+or alternatively add
+
+```python
+custom_imports = dict(
+ imports=['mmfewshot.classification.models.backbones.mynet'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+#### 3. Use the backbone in your config file
+
+```python
+model = dict(
+ ...
+ backbone=dict(
+ type='MyNet',
+ arg1=xxx,
+ arg2=xxx),
+ ...
+```
+
+### Add new heads
+
+Here we show how to develop a new head with an example as follows
+
+#### 1. Define a new head
+
+Create a new file `mmfewshot/classification/models/heads/myhead.py`.
+
+```python
+from mmcls.models.builder import HEADS
+from .base_head import BaseFewShotHead
+
+@HEADS.register_module()
+class MyHead(BaseFewShotHead):
+
+ def __init__(self, arg1, arg2) -> None:
+ pass
+
+ def forward_train(self, x, gt_label, **kwargs):
+ pass
+
+ def forward_support(self, x, gt_label, **kwargs):
+ pass
+
+ def forward_query(self, x, **kwargs):
+ pass
+
+ def before_forward_support(self) -> None:
+ pass
+
+ def before_forward_query(self) -> None:
+ pass
+```
+
+#### 2. Import the module
+
+You can either add the following line to `mmfewshot/classification/models/heads/__init__.py`
+
+```python
+from .myhead import MyHead
+```
+
+or alternatively add
+
+```python
+custom_imports = dict(
+ imports=['mmfewshot.classification.models.backbones.myhead'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+#### 3. Use the head in your config file
+
+```python
+model = dict(
+ ...
+ head=dict(
+ type='MyHead',
+ arg1=xxx,
+ arg2=xxx),
+ ...
+```
+
+### Add new loss
+
+To add a new loss function, the users need implement it in `mmfewshot/classification/models/losses/my_loss.py`.
+The decorator `weighted_loss` enable the loss to be weighted for each element.
+
+```python
+import torch
+import torch.nn as nn
+
+from ..builder import LOSSES
+from .utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+ assert pred.size() == target.size() and target.numel() > 0
+ loss = torch.abs(pred - target)
+ return loss
+
+@LOSSES.register_module()
+class MyLoss(nn.Module):
+
+ def __init__(self, reduction='mean', loss_weight=1.0):
+ super(MyLoss, self).__init__()
+ self.reduction = reduction
+ self.loss_weight = loss_weight
+
+ def forward(self,
+ pred,
+ target,
+ weight=None,
+ avg_factor=None,
+ reduction_override=None):
+ assert reduction_override in (None, 'none', 'mean', 'sum')
+ reduction = (
+ reduction_override if reduction_override else self.reduction)
+ loss_bbox = self.loss_weight * my_loss(
+ pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+ return loss_bbox
+```
+
+Then the users need to add it in the `mmfewshot/classification/models/losses/__init__.py`.
+
+```python
+from .my_loss import MyLoss, my_loss
+```
+
+Alternatively, you can add
+
+```python
+custom_imports=dict(
+ imports=['mmfewshot.classification.models.losses.my_loss'])
+```
+
+to the config file and achieve the same goal.
+
+To use it, modify the `loss_xxx` field.
+Since MyLoss is for regression, you need to modify the `loss_bbox` field in the head.
+
+```python
+loss_bbox=dict(type='MyLoss', loss_weight=1.0))
+```
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/customize_runtime.md b/internlm_langchain/knowledge_base/MMFewShot/content/customize_runtime.md
new file mode 100644
index 00000000..035930b1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/customize_runtime.md
@@ -0,0 +1,395 @@
+# Tutorial 4: Customize Runtime Settings
+
+## Customize optimization settings
+
+### Customize optimizer supported by Pytorch
+
+We already support to use all the optimizers implemented by PyTorch, and the only modification is to change the `optimizer` field of config files.
+For example, if you want to use `ADAM` (note that the performance could drop a lot), the modification could be as the following.
+
+```python
+optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
+```
+
+To modify the learning rate of the model, the users only need to modify the `lr` in the config of optimizer. The users can directly set arguments following the [API doc](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim) of PyTorch.
+
+### Customize self-implemented optimizer
+
+#### 1. Define a new optimizer
+
+A customized optimizer could be defined as following.
+
+Assume you want to add a optimizer named `MyOptimizer`, which has arguments `a`, `b`, and `c`.
+You need to create a new directory named `mmfewshot/classification/core/optimizer`.
+And then implement the new optimizer in a file, e.g., in `mmfewshot/classification/core/optimizer/my_optimizer.py`:
+
+```python
+from .registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+ def __init__(self, a, b, c)
+
+```
+
+#### 2. Add the optimizer to registry
+
+To find the above module defined above, this module should be imported into the main namespace at first. There are two options to achieve it.
+
+- Modify `mmfewshot/classification/core/optimizer/__init__.py` to import it.
+
+ The newly defined module should be imported in `mmfewshot/classification/core/optimizer/__init__.py` so that the registry will
+ find the new module and add it:
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- Use `custom_imports` in the config to manually import it
+
+```python
+custom_imports = dict(imports=['mmfewshot.classification.core.optimizer.my_optimizer'], allow_failed_imports=False)
+```
+
+The module `mmfewshot.classification.core.optimizer.my_optimizer` will be imported at the beginning of the program and the class `MyOptimizer` is then automatically registered.
+Note that only the package containing the class `MyOptimizer` should be imported.
+`mmfewshot.classification.core.optimizer.my_optimizer.MyOptimizer` **cannot** be imported directly.
+
+Actually users can use a totally different file directory structure using this importing method, as long as the module root can be located in `PYTHONPATH`.
+
+#### 3. Specify the optimizer in the config file
+
+Then you can use `MyOptimizer` in `optimizer` field of config files.
+In the configs, the optimizers are defined by the field `optimizer` like the following:
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+To use your own optimizer, the field can be changed to
+
+```python
+optimizer = dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value)
+```
+
+### Customize optimizer constructor
+
+Some models may have some parameter-specific settings for optimization, e.g. weight decay for BatchNorm layers.
+The users can do those fine-grained parameter tuning through customizing optimizer constructor.
+
+```python
+from mmcv.utils import build_from_cfg
+
+from mmcv.runner.optimizer import OPTIMIZER_BUILDERS, OPTIMIZERS
+from mmfewshot.utils import get_root_logger
+from .my_optimizer import MyOptimizer
+
+
+@OPTIMIZER_BUILDERS.register_module()
+class MyOptimizerConstructor(object):
+
+ def __init__(self, optimizer_cfg, paramwise_cfg=None):
+
+ def __call__(self, model):
+
+ return my_optimizer
+
+```
+
+The default optimizer constructor is implemented [here](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/optimizer/default_constructor.py#L11), which could also serve as a template for new optimizer constructor.
+
+### Additional settings
+
+Tricks not implemented by the optimizer should be implemented through optimizer constructor (e.g., set parameter-wise learning rates) or hooks. We list some common settings that could stabilize the training or accelerate the training. Feel free to create PR, issue for more settings.
+
+- __Use gradient clip to stabilize training__:
+ Some models need gradient clip to clip the gradients to stabilize the training process. An example is as below:
+
+ ```python
+ optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2))
+ ```
+
+- __Use momentum schedule to accelerate model convergence__:
+ We support momentum scheduler to modify model's momentum according to learning rate, which could make the model converge in a faster way.
+ Momentum scheduler is usually used with LR scheduler, for example, the following config is used in 3D detection to accelerate convergence.
+ For more details, please refer to the implementation of [CyclicLrUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L327) and [CyclicMomentumUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/momentum_updater.py#L130).
+
+ ```python
+ lr_config = dict(
+ policy='cyclic',
+ target_ratio=(10, 1e-4),
+ cyclic_times=1,
+ step_ratio_up=0.4,
+ )
+ momentum_config = dict(
+ policy='cyclic',
+ target_ratio=(0.85 / 0.95, 1),
+ cyclic_times=1,
+ step_ratio_up=0.4,
+ )
+ ```
+
+## Customize training schedules
+
+By default we use step learning rate with 1x schedule, this calls [`StepLRHook`](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L153) in MMCV.
+We support many other learning rate schedule [here](https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/lr_updater.py), such as `CosineAnnealing` and `Poly` schedule. Here are some examples
+
+- Poly schedule:
+
+ ```python
+ lr_config = dict(policy='poly', power=0.9, min_lr=1e-4, by_epoch=False)
+ ```
+
+- ConsineAnnealing schedule:
+
+ ```python
+ lr_config = dict(
+ policy='CosineAnnealing',
+ warmup='linear',
+ warmup_iters=1000,
+ warmup_ratio=1.0 / 10,
+ min_lr_ratio=1e-5)
+ ```
+
+## Customize workflow
+
+Workflow is a list of (phase, epochs) to specify the running order and epochs.
+By default it is set to be
+
+```python
+workflow = [('train', 1)]
+```
+
+which means running 1 epoch for training.
+Sometimes user may want to check some metrics (e.g. loss, accuracy) about the model on the validate set.
+In such case, we can set the workflow as
+
+```python
+[('train', 1), ('val', 1)]
+```
+
+so that 1 epoch for training and 1 epoch for validation will be run iteratively.
+
+**Note**:
+
+1. The parameters of model will not be updated during val epoch.
+2. Keyword `total_epochs` in the config only controls the number of training epochs and will not affect the validation workflow.
+3. Workflows `[('train', 1), ('val', 1)]` and `[('train', 1)]` will not change the behavior of `EvalHook` because `EvalHook` is called by `after_train_epoch` and validation workflow only affect hooks that are called through `after_val_epoch`. Therefore, the only difference between `[('train', 1), ('val', 1)]` and `[('train', 1)]` is that the runner will calculate losses on validation set after each training epoch.
+
+## Customize hooks
+
+### Customize self-implemented hooks
+
+#### 1. Implement a new hook
+
+Here we give an example of creating a new hook in MMFewShot and using it in training.
+
+```python
+from mmcv.runner import HOOKS, Hook
+
+
+@HOOKS.register_module()
+class MyHook(Hook):
+
+ def __init__(self, a, b):
+ pass
+
+ def before_run(self, runner):
+ pass
+
+ def after_run(self, runner):
+ pass
+
+ def before_epoch(self, runner):
+ pass
+
+ def after_epoch(self, runner):
+ pass
+
+ def before_iter(self, runner):
+ pass
+
+ def after_iter(self, runner):
+ pass
+```
+
+Depending on the functionality of the hook, the users need to specify what the hook will do at each stage of the training in `before_run`, `after_run`, `before_epoch`, `after_epoch`, `before_iter`, and `after_iter`.
+
+#### 2. Register the new hook
+
+Then we need to make `MyHook` imported. Assuming the file is in `mmfewshot/classification/core/utils/my_hook.py` there are two ways to do that:
+
+- Modify `mmfewshot/core/utils/__init__.py` to import it.
+
+ The newly defined module should be imported in `mmfewshot/classification/core/utils/__init__.py` so that the registry will
+ find the new module and add it:
+
+```python
+from .my_hook import MyHook
+```
+
+- Use `custom_imports` in the config to manually import it
+
+```python
+custom_imports = dict(imports=['mmfewshot.classification.core.utils.my_hook'], allow_failed_imports=False)
+```
+
+#### 3. Modify the config
+
+```python
+custom_hooks = [
+ dict(type='MyHook', a=a_value, b=b_value)
+]
+```
+
+You can also set the priority of the hook by adding key `priority` to `'NORMAL'` or `'HIGHEST'` as below
+
+```python
+custom_hooks = [
+ dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+By default the hook's priority is set as `NORMAL` during registration.
+
+### Use hooks implemented in MMCV
+
+If the hook is already implemented in MMCV, you can directly modify the config to use the hook as below
+
+```python
+custom_hooks = [
+ dict(type='MMCVHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+### Customize self-implemented eval hooks with a dataset
+
+Here we give an example of creating a new hook in MMFewShot and using it to evaluate a dataset.
+To achieve this, we can add following code in `mmfewshot/classification/apis/test.py`.
+
+```python
+if validate:
+ ...
+ # build dataset and dataloader
+ my_eval_dataset = build_dataset(cfg.data.my_eval)
+ my_eval_data_loader = build_dataloader(my_eval_dataset)
+ runner.register_hook(eval_hook(my_eval_data_loader), priority='LOW')
+```
+
+The arguments used in `test_my_single_task` can be defined in `meta_test_cfg`, for example:
+
+```python
+data = dict(
+ test=dict(
+ type='MetaTestDataset',
+ ...,
+ dataset=dict(...),
+ meta_test_cfg=dict(
+ ...,
+ test_my_single_task=dict(arg1=...)
+ )
+ )
+)
+```
+
+Then we can replace the `test_single_task` with customized `test_my_single_task` in `single_gpu_meta_test` and `multiple_gpu_meta_test`
+
+### Modify default runtime hooks
+
+There are some common hooks that are not registered through `custom_hooks`, they are
+
+- log_config
+- checkpoint_config
+- evaluation
+- lr_config
+- optimizer_config
+- momentum_config
+
+In those hooks, only the logger hook has the `VERY_LOW` priority, others' priority are `NORMAL`.
+The above-mentioned tutorials already covers how to modify `optimizer_config`, `momentum_config`, and `lr_config`.
+Here we reveals how what we can do with `log_config`, `checkpoint_config`, and `evaluation`.
+
+#### Checkpoint config
+
+The MMCV runner will use `checkpoint_config` to initialize [`CheckpointHook`](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/hooks/checkpoint.py#L9).
+
+```python
+checkpoint_config = dict(interval=1)
+```
+
+The users could set `max_keep_ckpts` to only save only small number of checkpoints or decide whether to store state dict of optimizer by `save_optimizer`. More details of the arguments are [here](https://mmcv.readthedocs.io/en/latest/api.html#mmcv.runner.CheckpointHook)
+
+#### Log config
+
+The `log_config` wraps multiple logger hooks and enables to set intervals. Now MMCV supports `WandbLoggerHook`, `MlflowLoggerHook`, and `TensorboardLoggerHook`.
+The detail usages can be found in the [doc](https://mmcv.readthedocs.io/en/latest/api.html#mmcv.runner.LoggerHook).
+
+```python
+log_config = dict(
+ interval=50,
+ hooks=[
+ dict(type='TextLoggerHook'),
+ dict(type='TensorboardLoggerHook')
+ ])
+```
+
+#### Evaluation config
+
+The config of `evaluation` will be used to initialize the `EvalHook`.
+Except the key `interval`, other arguments such as `metric` will be passed to the `dataset.evaluate()`
+
+```python
+evaluation = dict(interval=1, metric='bbox')
+```
+
+## Customize Meta Testing
+
+We already support two ways to handle the support data, fine-tuning and straight forwarding.
+To customize the code for a meta test task, we need to add a new function `test_my_single_task`
+in the `mmfewshot/classification/apis/test.py`.
+
+```python
+def test_my_single_task(model: MetaTestParallel,
+ support_dataloader: DataLoader,
+ query_dataloader: DataLoader,
+ meta_test_cfg: Dict):
+ # use copy of model for each task
+ model = copy.deepcopy(model)
+ ...
+ # forward support set
+ model.before_forward_support()
+ # customize code for support data
+ ...
+
+ # forward query set
+ model.before_forward_query()
+ ...
+ results_list, gt_label_list = [], []
+ # customize code for query data
+ ...
+
+ # return predict results and gt labels for evaluation
+ return results_list, gt_labels
+
+```
+
+The arguments used in `test_my_single_task` can be defined in `meta_test_cfg`, for example:
+
+```python
+data = dict(
+ test=dict(
+ type='MetaTestDataset',
+ ...,
+ dataset=dict(...),
+ meta_test_cfg=dict(
+ ...,
+ test_my_single_task=dict(arg1=...)
+ )
+ )
+)
+```
+
+Then we can replace the `test_single_task` with customized `test_my_single_task` in `single_gpu_meta_test` and `multiple_gpu_meta_test`
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/faq.md b/internlm_langchain/knowledge_base/MMFewShot/content/faq.md
new file mode 100644
index 00000000..3b015f20
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/faq.md
@@ -0,0 +1,95 @@
+# Frequently Asked Questions
+
+We list some common troubles faced by many users and their corresponding solutions here. Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them. If the contents here do not cover your issue, please create an issue using the [provided templates](https://github.com/open-mmlab/mmdetection/blob/master/.github/ISSUE_TEMPLATE/error-report.md/) and make sure you fill in all required information in the template.
+
+## MMCV Installation
+
+- Compatibility issue between MMCV and MMDetection; "ConvWS is already registered in conv layer"; "AssertionError: MMCV==xxx is used but incompatible. Please install mmcv>=xxx, \<=xxx."
+
+ Please install the correct version of MMCV for the version of your MMDetection following the [installation instruction](https://mmdetection.readthedocs.io/en/latest/get_started.html#installation).
+
+- "No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'".
+
+ 1. Uninstall existing mmcv in the environment using `pip uninstall mmcv`.
+ 2. Install mmcv-full following the [installation instruction](https://mmcv.readthedocs.io/en/latest/#installation).
+
+## PyTorch/CUDA Environment
+
+- "RTX 30 series card fails when building MMCV or MMDet"
+
+ 1. Temporary work-around: do `MMCV_WITH_OPS=1 MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80' pip install -e .`.
+ The common issue is `nvcc fatal : Unsupported gpu architecture 'compute_86'`. This means that the compiler should optimize for sm_86, i.e., nvidia 30 series card, but such optimizations have not been supported by CUDA toolkit 11.0.
+ This work-around modifies the compile flag by adding `MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80'`, which tells `nvcc` to optimize for **sm_80**, i.e., Nvidia A100. Although A100 is different from the 30 series card, they use similar ampere architecture. This may hurt the performance but it works.
+ 2. PyTorch developers have updated that the default compiler flags should be fixed by [pytorch/pytorch#47585](https://github.com/pytorch/pytorch/pull/47585). So using PyTorch-nightly may also be able to solve the problem, though we have not tested it yet.
+
+- "invalid device function" or "no kernel image is available for execution".
+
+ 1. Check if your cuda runtime version (under `/usr/local/`), `nvcc --version` and `conda list cudatoolkit` version match.
+ 2. Run `python mmdet/utils/collect_env.py` to check whether PyTorch, torchvision, and MMCV are built for the correct GPU architecture.
+ You may need to set `TORCH_CUDA_ARCH_LIST` to reinstall MMCV.
+ The GPU arch table could be found [here](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list),
+ i.e. run `TORCH_CUDA_ARCH_LIST=7.0 pip install mmcv-full` to build MMCV for Volta GPUs.
+ The compatibility issue could happen when using old GPUS, e.g., Tesla K80 (3.7) on colab.
+ 3. Check whether the running environment is the same as that when mmcv/mmdet has compiled.
+ For example, you may compile mmcv using CUDA 10.0 but run it on CUDA 9.0 environments.
+
+- "undefined symbol" or "cannot open xxx.so".
+
+ 1. If those symbols are CUDA/C++ symbols (e.g., libcudart.so or GLIBCXX), check whether the CUDA/GCC runtimes are the same as those used for compiling mmcv,
+ i.e. run `python mmdet/utils/collect_env.py` to see if `"MMCV Compiler"`/`"MMCV CUDA Compiler"` is the same as `"GCC"`/`"CUDA_HOME"`.
+ 2. If those symbols are PyTorch symbols (e.g., symbols containing caffe, aten, and TH), check whether the PyTorch version is the same as that used for compiling mmcv.
+ 3. Run `python mmdet/utils/collect_env.py` to check whether PyTorch, torchvision, and MMCV are built by and running on the same environment.
+
+- setuptools.sandbox.UnpickleableException: DistutilsSetupError("each element of 'ext_modules' option must be an Extension instance or 2-tuple")
+
+ 1. If you are using miniconda rather than anaconda, check whether Cython is installed as indicated in [#3379](https://github.com/open-mmlab/mmdetection/issues/3379).
+ You need to manually install Cython first and then run command `pip install -r requirements.txt`.
+ 2. You may also need to check the compatibility between the `setuptools`, `Cython`, and `PyTorch` in your environment.
+
+- "Segmentation fault".
+
+ 1. Check you GCC version and use GCC 5.4. This usually caused by the incompatibility between PyTorch and the environment (e.g., GCC \< 4.9 for PyTorch). We also recommend the users to avoid using GCC 5.5 because many feedbacks report that GCC 5.5 will cause "segmentation fault" and simply changing it to GCC 5.4 could solve the problem.
+
+ 2. Check whether PyTorch is correctly installed and could use CUDA op, e.g. type the following command in your terminal.
+
+ ```shell
+ python -c 'import torch; print(torch.cuda.is_available())'
+ ```
+
+ And see whether they could correctly output results.
+
+ 3. If Pytorch is correctly installed, check whether MMCV is correctly installed.
+
+ ```shell
+ python -c 'import mmcv; import mmcv.ops'
+ ```
+
+ If MMCV is correctly installed, then there will be no issue of the above two commands.
+
+ 4. If MMCV and Pytorch is correctly installed, you man use `ipdb`, `pdb` to set breakpoints or directly add 'print' in mmdetection code and see which part leads the segmentation fault.
+
+## Training
+
+- "Loss goes Nan"
+
+ 1. Check if the dataset annotations are valid: zero-size bounding boxes will cause the regression loss to be Nan due to the commonly used transformation for box regression. Some small size (width or height are smaller than 1) boxes will also cause this problem after data augmentation (e.g., instaboost). So check the data and try to filter out those zero-size boxes and skip some risky augmentations on the small-size boxes when you face the problem.
+ 2. Reduce the learning rate: the learning rate might be too large due to some reasons, e.g., change of batch size. You can rescale them to the value that could stably train the model.
+ 3. Extend the warmup iterations: some models are sensitive to the learning rate at the start of the training. You can extend the warmup iterations, e.g., change the `warmup_iters` from 500 to 1000 or 2000.
+ 4. Add gradient clipping: some models requires gradient clipping to stabilize the training process. The default of `grad_clip` is `None`, you can add gradient clippint to avoid gradients that are too large, i.e., set `optimizer_config=dict(_delete_=True, grad_clip=dict(max_norm=35, norm_type=2))` in your config file. If your config does not inherits from any basic config that contains `optimizer_config=dict(grad_clip=None)`, you can simply add `optimizer_config=dict(grad_clip=dict(max_norm=35, norm_type=2))`.
+
+- ’GPU out of memory"
+
+ 1. There are some scenarios when there are large amounts of ground truth boxes, which may cause OOM during target assignment. You can set `gpu_assign_thr=N` in the config of assigner thus the assigner will calculate box overlaps through CPU when there are more than N GT boxes.
+ 2. Set `with_cp=True` in the backbone. This uses the sublinear strategy in PyTorch to reduce GPU memory cost in the backbone.
+ 3. Try mixed precision training using following the examples in `config/fp16`. The `loss_scale` might need further tuning for different models.
+
+- "RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one"
+
+ 1. This error indicates that your module has parameters that were not used in producing loss. This phenomenon may be caused by running different branches in your code in DDP mode.
+ 2. You can set ` find_unused_parameters = True` in the config to solve the above problems or find those unused parameters manually.
+
+## Evaluation
+
+- COCO Dataset, AP or AR = -1
+ 1. According to the definition of COCO dataset, the small and medium areas in an image are less than 1024 (32\*32), 9216 (96\*96), respectively.
+ 2. If the corresponding area has no object, the result of AP and AR will set to -1.
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/get_started.md b/internlm_langchain/knowledge_base/MMFewShot/content/get_started.md
new file mode 100644
index 00000000..231f75f4
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/get_started.md
@@ -0,0 +1,143 @@
+## Test a model
+
+- single GPU
+- CPU
+- single node multiple GPU
+- multiple node
+
+You can use the following commands to infer a dataset.
+
+```shell
+# single-gpu
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
+
+# CPU: disable GPUs and run single-gpu testing script
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
+
+# multi-gpu
+sh ./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [optional arguments]
+
+# multi-node in slurm environment
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments] --launcher slurm
+```
+
+Examples:
+
+For classification, inference Baseline on CUB under 5way 1shot setting.
+
+```shell
+python ./tools/classification/test.py \
+ configs/classification/baseline/cub/baseline_conv4_1xb64_cub_5way-1shot.py \
+ checkpoints/SOME_CHECKPOINT.pth
+```
+
+For detection, inference TFA on VOC split1 1shot setting.
+
+```shell
+python ./tools/detection/test.py \
+ configs/detection/tfa/voc/split1/tfa_r101_fpn_voc-split1_1shot-fine-tuning.py \
+ checkpoints/SOME_CHECKPOINT.pth --eval mAP
+```
+
+## Train a model
+
+### Train with a single GPU
+
+```shell
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+If you want to specify the working directory in the command, you can add an argument `--work_dir ${YOUR_WORK_DIR}`.
+
+### Train on CPU
+
+The process of training on the CPU is consistent with single GPU training. We just need to disable GPUs before the training process.
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+**Note**:
+
+We do not recommend users to use CPU for training because it is too slow. We support this feature to allow users to debug on machines without GPU for convenience.
+
+### Train with multiple GPUs
+
+```shell
+sh ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+Optional arguments are:
+
+- `--no-validate` (**not suggested**): By default, the codebase will perform evaluation during the training. To disable this behavior, use `--no-validate`.
+- `--work-dir ${WORK_DIR}`: Override the working directory specified in the config file.
+- `--resume-from ${CHECKPOINT_FILE}`: Resume from a previous checkpoint file.
+
+Difference between `resume-from` and `load-from`:
+`resume-from` loads both the model weights and optimizer status, and the epoch is also inherited from the specified checkpoint. It is usually used for resuming the training process that is interrupted accidentally.
+`load-from` only loads the model weights and the training epoch starts from 0. It is usually used for finetuning.
+
+### Train with multiple machines
+
+If you launch with multiple machines simply connected with ethernet, you can simply run following commands:
+
+On the first machine:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+On the second machine:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+Usually it is slow if you do not have high speed networking like InfiniBand.
+
+If you run MMClassification on a cluster managed with [slurm](https://slurm.schedmd.com/), you can use the script `slurm_train.sh`. (This script also supports single machine training.)
+
+```shell
+[GPUS=${GPUS}] sh ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
+```
+
+You can check [slurm_train.sh](https://github.com/open-mmlab/mmclassification/blob/master/tools/slurm_train.sh) for full arguments and environment variables.
+
+If you have just multiple machines connected with ethernet, you can refer to
+PyTorch [launch utility](https://pytorch.org/docs/stable/distributed_deprecated.html#launch-utility).
+Usually it is slow if you do not have high speed networking like InfiniBand.
+
+### Launch multiple jobs on a single machine
+
+If you launch multiple jobs on a single machine, e.g., 2 jobs of 4-GPU training on a machine with 8 GPUs,
+you need to specify different ports (29500 by default) for each job to avoid communication conflict.
+
+If you use `dist_train.sh` to launch training jobs, you can set the port in commands.
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+If you use launch training jobs with Slurm, you need to modify the config files (usually the 6th line from the bottom in config files) to set different communication ports.
+
+In `config1.py`,
+
+```python
+dist_params = dict(backend='nccl', port=29500)
+```
+
+In `config2.py`,
+
+```python
+dist_params = dict(backend='nccl', port=29501)
+```
+
+Then you can launch two jobs with `config1.py` ang `config2.py`.
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+```
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/install.md b/internlm_langchain/knowledge_base/MMFewShot/content/install.md
new file mode 100644
index 00000000..113a3fc9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/install.md
@@ -0,0 +1,157 @@
+## 依赖
+
+- Linux | Windows | macOS
+- Python 3.7+
+- PyTorch 1.5+
+- CUDA 9.2+
+- GCC 5+
+- [mmcv](https://mmcv.readthedocs.io/en/latest/#installation) 1.3.12+
+- [mmdet](https://mmdetection.readthedocs.io/en/latest/#installation) 2.16.0+
+- [mmcls](https://mmclassification.readthedocs.io/en/latest/#installation) 0.15.0+
+
+MMFewShot 和 MMCV, MMCls, MMDet 版本兼容性如下所示，需要安装正确的版本以避免安装出现问题。
+
+| MMFewShot 版本 | MMCV 版本 | MMClassification 版本 | MMDetection 版本 |
+| :------------: | :---------------: | :-------------------: | :--------------: |
+| master | mmcv-full>=1.3.12 | mmdet >= 2.16.0 | mmcls >=0.15.0 |
+
+\*\*注意：\*\*如果已经安装了 mmcv，首先需要使用 `pip uninstall mmcv` 卸载已安装的 mmcv，如果同时安装了 mmcv 和 mmcv-full，将会报 `ModuleNotFoundError` 错误。
+
+## 安装流程
+
+### 从零开始设置脚本
+
+假设当前已经成功安装 CUDA 10.1，这里提供了一个完整的基于 conda 安装 MMFewShot 的脚本。您可以参考下一节中的分步安装说明。
+
+```shell
+conda create -n openmmlab python=3.7 -y
+conda activate openmmlab
+
+conda install pytorch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0 cudatoolkit=10.1 -c pytorch
+
+pip install openmim
+mim install mmcv-full
+
+# install mmclassification mmdetection
+mim install mmcls
+mim install mmdet
+
+# install mmfewshot
+git clone https://github.com/open-mmlab/mmfewshot.git
+cd mmfewshot
+pip install -r requirements/build.txt
+pip install -v -e . # or "python setup.py develop"
+```
+
+### 准备环境
+
+1. 使用 conda 新建虚拟环境，并进入该虚拟环境；
+
+ ```shell
+ conda create -n openmmlab python=3.7 -y
+ conda activate openmmlab
+ ```
+
+2. 基于 [PyTorch 官网](https://pytorch.org/)安装 PyTorch 和 torchvision，例如：
+
+ ```shell
+ conda install pytorch torchvision -c pytorch
+ ```
+
+ **注意**：需要确保 CUDA 的编译版本和运行版本匹配。可以在 [PyTorch 官网](https://pytorch.org/)查看预编译包所支持的 CUDA 版本。
+
+ `例 1` 例如在 `/usr/local/cuda` 下安装了 CUDA 10.1， 并想安装 PyTorch 1.7，则需要安装支持 CUDA 10.1 的预构建 PyTorch：
+
+ ```shell
+ conda install pytorch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0 cudatoolkit=10.1 -c pytorch
+ ```
+
+### 安装 MMFewShot
+
+我们建议使用 [MIM](https://github.com/open-mmlab/mim) 来安装 MMFewShot：
+
+```shell
+pip install openmim
+mim install mmfewshot
+```
+
+MIM 能够自动地安装 OpenMMLab 的项目以及对应的依赖包。
+
+或者，可以手动安装 MMFewShot：
+
+1. 安装 mmcv-full，我们建议使用预构建包来安装：
+
+ ```shell
+ # pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/{cu_version}/{torch_version}/index.html
+ pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.10.0/index.html
+ ```
+
+ PyTorch 在 1.x.0 和 1.x.1 之间通常是兼容的，故 mmcv-full 只提供 1.x.0 的编译包。如果你的 PyTorch 版本是 1.x.1，你可以放心地安装在 1.x.0 版本编译的 mmcv-full。
+
+ ```
+ # 我们可以忽略 PyTorch 的小版本号
+ pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.10/index.html
+ ```
+
+ 请参阅 [MMCV](https://github.com/open-mmlab/mmcv#install-with-pip) 了解不同版本的 MMCV 与不同版本的 PyTorch 和 CUDA 的兼容情况。同时，您可以使用以下命令从源码编译 MMCV：
+
+2. 安装 MMClassification 和 MMDetection.
+
+ 你可以直接通过如下命令从 pip 安装使用 mmclassification 和 mmdetection：
+
+ ```shell
+ pip install mmcls mmdet
+ ```
+
+3. 安装 MMFewShot.
+
+ 你可以直接通过如下命令从 pip 安装使用 mmfewshot：
+
+ ```shell
+ pip install mmfewshot
+ ```
+
+ 或者从 git 仓库编译源码：
+
+ ```shell
+ git clone https://github.com/open-mmlab/mmfewshot.git
+ cd mmfewshot
+ pip install -r requirements/build.txt
+ pip install -v -e . # or "python setup.py develop"
+
+ ```
+
+**Note:**
+
+(1) 按照上述说明，MMDetection 安装在 `dev` 模式下，因此在本地对代码做的任何修改都会生效，无需重新安装；
+
+(2) 如果希望使用 `opencv-python-headless` 而不是 `opencv-python`， 可以在安装 MMCV 之前安装；
+
+(3) 一些安装依赖是可以选择的。例如只需要安装最低运行要求的版本，则可以使用 `pip install -v -e .` 命令。如果希望使用可选择的像 `albumentations` 和 `imagecorruptions` 这种依赖项，可以使用 `pip install -r requirements/optional.txt ` 进行手动安装，或者在使用 `pip` 时指定所需的附加功能（例如 `pip install -v -e .[optional]`），支持附加功能的有效键值包括 `all`、`tests`、`build` 以及 `optional` 。
+
+### 另一种选择： Docker 镜像
+
+我们提供了 [Dockerfile](https://github.com/open-mmlab/mmfewshot/blob/master/docker/Dockerfile) to build an image. Ensure that you are using [docker version](https://docs.docker.com/engine/install/) >=19.03.
+
+```shell
+# 基于 PyTorch 1.6, CUDA 10.1 生成镜像
+docker build -t mmfewshot docker/
+```
+
+运行命令：
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmfewshot/data mmfewshot
+```
+
+## 验证
+
+为了验证是否正确安装了 MMFewShot 和所需的环境，我们可以运行示例的 Python 代码在示例图像进行推理：
+
+具体的细节可以参考 [few shot classification demo](https://github.com/open-mmlab/mmfewshot/tree/main/demo#few-shot-classification-demo)
+以及 [few shot detection demo](https://github.com/open-mmlab/mmfewshot/tree/main/demo#few-shot-detection-demo) 。
+如果成功安装 MMFewShot，则上面的代码可以完整地运行。
+
+## 准备数据集
+
+具体的细节可以参考 [准备数据](https://github.com/open-mmlab/mmfewshot/tree/main/tools/data) 下载并组织数据集。
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/model_zoo.md b/internlm_langchain/knowledge_base/MMFewShot/content/model_zoo.md
new file mode 100644
index 00000000..39745c1a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/model_zoo.md
@@ -0,0 +1,61 @@
+# Model Zoo
+
+## Few Shot Classification Model Zoo
+
+#### Baseline
+
+Please refer to [Baseline](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/baseline) for details.
+
+#### Baseline++
+
+Please refer to [Baseline++](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/baseline_plus) for details.
+
+#### ProtoNet
+
+Please refer to [ProtoNet](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/proto_net) for details.
+
+#### RelationNet
+
+Please refer to [RelationNet](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/relation_net) for details.
+
+#### MatchingNet
+
+Please refer to [MatchingNet](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/matching_net) for details.
+
+#### MAML
+
+Please refer to [MAML](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/maml) for details.
+
+#### NegMargin
+
+Please refer to [NegMargin](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/neg_margin) for details.
+
+#### Meta Baseline
+
+Please refer to [Meta Baseline](https://github.com/open-mmlab/mmfewshot/tree/main/configs/classification/meta_baseline) for details.
+
+## Few Shot Detection Model Zoo
+
+#### TFA
+
+Please refer to [TFA](https://github.com/open-mmlab/mmfewshot/tree/main/configs/detection/tfa) for details.
+
+#### FSCE
+
+Please refer to [FSCE](https://github.com/open-mmlab/mmfewshot/tree/main/configs/detection/fsce) for details.
+
+#### Meta RCNN
+
+Please refer to [Meta RCNN](https://github.com/open-mmlab/mmfewshot/tree/main/configs/detection/meta_rcnn) for details.
+
+#### FSDetView
+
+Please refer to [FSDetView](https://github.com/open-mmlab/mmfewshot/tree/main/configs/detection/fsdetview) for details.
+
+#### Attention RPN
+
+Please refer to [Attention RPN](https://github.com/open-mmlab/mmfewshot/tree/main/configs/detection/attention_rpn) for details.
+
+#### MPSR
+
+Please refer to [MPSR](https://github.com/open-mmlab/mmfewshot/tree/main/configs/detection/mpsr) for details.
diff --git a/internlm_langchain/knowledge_base/MMFewShot/content/overview.md b/internlm_langchain/knowledge_base/MMFewShot/content/overview.md
new file mode 100644
index 00000000..fb95a0f9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFewShot/content/overview.md
@@ -0,0 +1,121 @@
+# Tutorial 0: Overview of MMFewShot Classification
+
+The main difference between general classification task and few shot classification task
+is the data usage.
+Therefore, the design of MMFewShot target at data sampling, meta test and models apis for few shot setting based on [mmcls](https://github.com/open-mmlab/mmclassification).
+Additionally, the modules in [mmcls](https://github.com/open-mmlab/mmclassification) can be imported and reused in the code or config.
+
+## Design of Data Sampling
+
+In MMFewShot, we suggest customizing the data pipeline using a dataset wrapper and modify the arguments in forward
+function when returning the dict with customize keys.
+
+```python
+class CustomizeDataset:
+
+ def __init__(self, dataset, ...):
+ self.dataset = dataset
+ self.customize_list = generate_function(dataset)
+
+ def generate_function(self, dataset):
+ pass
+
+ def __getitem__(self, idx):
+ return {
+ 'support_data': [self.dataset[i] for i in self.customize_list],
+ 'query_data': [self.dataset[i] for i in self.customize_list]
+ }
+```
+
+More details can refer to [Tutorial 2: Adding New Dataset](https://mmfewshot.readthedocs.io/en/latest/classification/customize_dataset.html)
+
+## Design of Models API
+
+Each model in MMFewShot should implement following functions to support meta testing.
+More details can refer to [Tutorial 3: Customize Models](https://mmfewshot.readthedocs.io/en/latest/classification/customize_models.html)
+
+```python
+@CLASSIFIERS.register_module()
+class BaseFewShotClassifier(BaseModule):
+
+ def forward(self, mode, ...):
+ if mode == 'train':
+ return self.forward_train(...)
+ elif mode == 'query':
+ return self.forward_query(...)
+ elif mode == 'support':
+ return self.forward_support(...)
+ ...
+
+ def forward_train(self, **kwargs):
+ pass
+
+ # --------- for meta testing ----------
+ def forward_support(self, **kwargs):
+ pass
+
+ def forward_query(self, **kwargs):
+ pass
+
+ def before_meta_test(self, meta_test_cfg, **kwargs):
+ pass
+
+ def before_forward_support(self, **kwargs):
+ pass
+
+ def before_forward_query(self, **kwargs):
+ pass
+
+```
+
+## Design of Meta Testing
+
+Meta testing performs prediction on random sampled tasks multiple times.
+Each task contains support and query data.
+More details can refer to `mmfewshot/classification/apis/test.py`.
+Here is the basic pipeline for meta testing:
+
+```text
+# the model may from training phase and may generate or fine-tine weights
+1. Copy model
+# prepare for the meta test (generate or freeze weights)
+2. Call model.before_meta_test()
+# some methods with fixed backbone can pre-compute the features for acceleration
+3. Extracting features of all images for acceleration(optional)
+# test different random sampled tasks
+4. Test tasks (loop)
+ # make sure all the task share the same initial weight
+ a. Copy model
+ # prepare model for support data
+ b. Call model.before_forward_support()
+ # fine-tune or none fine-tune models with given support data
+ c. Forward support data: model(*data, mode='support')
+ # prepare model for query data
+ d. Call model.before_forward_query()
+ # predict results of query data
+ e. Forward query data: model(*data, mode='query')
+```
+
+### meta testing on multiple gpus
+
+In MMFewShot, we also support multi-gpu meta testing during
+validation or testing phase.
+In multi-gpu meta testing, the model will be copied and wrapped with `MetaTestParallel`, which will
+send data to the device of model.
+Thus, the original model will not be affected by the operations in Meta Testing.
+More details can refer to `mmfewshot/classification/utils/meta_test_parallel.py`
+Specifically, each gpu will be assigned with (num_test_tasks / world_size) task.
+Here is the distributed logic for multi gpu meta testing:
+
+```python
+sub_num_test_tasks = num_test_tasks // world_size
+sub_num_test_tasks += 1 if num_test_tasks % world_size != 0 else 0
+for i in range(sub_num_test_tasks):
+ task_id = (i * world_size + rank)
+ if task_id >= num_test_tasks:
+ continue
+ # test task with task_id
+ ...
+```
+
+If user want to customize the way to test a task, more details can refer to [Tutorial 4: Customize Runtime Settings](https://mmfewshot.readthedocs.io/en/latest/classification/customize_runtime.html)
diff --git a/internlm_langchain/knowledge_base/MMFewShot/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMFewShot/vector_store/index.faiss
new file mode 100644
index 00000000..c104c926
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMFewShot/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/0_config_.md b/internlm_langchain/knowledge_base/MMFlow/content/0_config_.md
new file mode 100644
index 00000000..ae8ebb2d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/0_config_.md
@@ -0,0 +1,261 @@
+# 教程0: 如何使用 Configs
+
+我们的配置文件 (configs) 中支持了模块化和继承设计，这便于进行各种实验。如果需要检查配置文件，可以通过运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置文件。
+
+## 配置文件结构
+
+在目录 `config/_base_` 下有四种基本模块类型，即数据集 (datasets) 、模型 (models) 、训练计划 (schedules) 以及默认运行配置 (default_runtime)。很多模型可以很容易地参考其中一种方法 (如 PWC-Net )来构建。这些由 `_base_` 中的模块构成的配置文件被称为 *原始配置 (primitive configs)*。
+
+对于同一文件夹下的所有配置，建议只有**1个**原始配置。所有其他配置都应该从原始配置继承。这样，最大继承级别 (inheritance level) 为 3。
+
+简单来说，我们建议贡献者去继承现有模型的配置文件。例如，如果在 PWC-Net 的基础上做了一些改动，可以首先通过在配置文件中指定原始配置 `_base_ = ../pwcnet/pwcnet_slong_8x1_flyingchairs_384x448.py` 来继承基本的 PWC-Net 结构，然后再根据需要修改配置文件中的指定字段 (fields)。
+
+如果需要搭建不能与现有模型共享任何结构的全新的模型，您可以在 `configs` 下创建一个新文件夹 `xxx`。
+
+您也可以参考 [mmcv](https://mmcv.readthedocs.io/en/latest/understand_mmcv/config.html) 文档中的更多细节。
+
+## 配置文件命名规则
+
+我们按照下面的风格来命名配置文件。建议贡献者使用相同的风格。
+
+```text
+{model}_{schedule}_[gpu x batch_per_gpu]_{training datasets}_[input_size].py
+```
+
+`{xxx}` 表示必填字段，而 `[yyy]` 表示可选字段。
+
+- `{model}`: 模型类型，如 `pwcnet`, `flownets` 等等。
+- `{schedule}`: 训练计划。按照 FlowNet2 中的约定，我们使用 `slong`、 `sfine` 和 `sshort`，或者像 `150k` 表示150k(iterations) 这样指定迭代次数。
+- `[gpu x batch_per_gpu]`: GPU 数量以及每个 GPU上分配的样本数， 如 `8x1`。
+- `{training datasets}`: 训练数据集，如 `flyingchairs`， `flyingthings3d_subset` 或 `flyingthings3d`。
+- `[input_size]`: 训练时图片大小。
+
+## 配置文件结构
+
+为了帮助用户对完整的配置和 MMFlow 中的模块有一个基本的了解，我们以在 `flyingchairs` 上使用 `slong` 训练的 PWC-Net 的配置为例进行简单的讲解。有关每个模块的更详细的用法和相应的替代方案，请参阅 API 文档和 [MMDetection 教程](https://github.com/open-mmlab/mmdetection/blob/master/docs/tutorials/config.md)。
+
+```python
+_base_ = [
+ '../_base_/models/pwcnet.py', '../_base_/datasets/flyingchairs_384x448.py',
+ '../_base_/schedules/schedule_s_long.py', '../_base_/default_runtime.py'
+]# 新增配置文件依赖的基本配置文件
+```
+
+`_base_/models/pwc_net.py` 是 PWC-Net 模型的基本配置文件。
+
+```python
+model = dict(
+ type='PWCNet', # 算法名称
+ encoder=dict( # 编码器 (Encoder) 模块配置
+ type='PWCNetEncoder', # PWC-Net 编码器名称
+ in_channels=3, # 输入通道数
+ # 子卷积模块的类型: 如果 net_type 为 Basic，各尺度的卷积层数量为3；如果 net_type 为
+ # Small，各尺度的卷积层数量为 2
+ net_type='Basic',
+ pyramid_levels=[
+ 'level1', 'level2', 'level3', 'level4', 'level5', 'level6'
+ ], # 特征金字塔尺度，同时也是编码器输出字典 (dict) 的键值 (keys)
+ out_channels=(16, 32, 64, 96, 128, 196), # 各金字塔尺度 (pyramid level) 的输出通道数列表
+ strides=(2, 2, 2, 2, 2, 2), # 各金字塔尺度 (pyramid level) 的步长 (stride) 列表
+ dilations=(1, 1, 1, 1, 1, 1), # 各金字塔尺度 (pyramid level) 的膨胀率 (dilation) 列表
+ act_cfg=dict(type='LeakyReLU', negative_slope=0.1)), # 针对编码器内 ConvModule 模块的激活函数配置
+ decoder=dict( # 解码器 (Decoder) 模块配置
+ type='PWCNetDecoder', # 光流估计解码器 (Decoder) 名称
+ in_channels=dict(
+ level6=81, level5=213, level4=181, level3=149, level2=117), # PWC-Net 的 basic dense block 的输入通道数
+ flow_div=20., # 用于缩放真实值 (Ground Truth) 的常数除数
+ corr_cfg=dict(type='Correlation', max_displacement=4, padding=0),
+ warp_cfg=dict(type='Warp'),
+ act_cfg=dict(type='LeakyReLU', negative_slope=0.1),
+ scaled=False, # 是否使用按参与相关性 (correlation) 计算的元素数量缩放相关性计算结果
+ post_processor=dict(type='ContextNet', in_channels=565), # 后处理网络配置
+ flow_loss=dict( # 损失函数配置
+ type='MultiLevelEPE',
+ p=2,
+ reduction='sum',
+ weights={ # 不同尺度下的光流损失加权权重
+ 'level2': 0.005,
+ 'level3': 0.01,
+ 'level4': 0.02,
+ 'level5': 0.08,
+ 'level6': 0.32
+ }),
+ ),
+ # 模型训练测试配置。
+ train_cfg=dict(),
+ test_cfg=dict(),
+ init_cfg=dict(
+ type='Kaiming',
+ nonlinearity='leaky_relu',
+ layer=['Conv2d', 'ConvTranspose2d'],
+ mode='fan_in',
+ bias=0))
+```
+
+原始配置文件 `_base_/datasets/flyingchairs_384x448.py` 中是:
+
+```python
+dataset_type = 'FlyingChairs' # 数据集名称
+data_root = 'data/FlyingChairs/data' # 数据集根目录
+
+img_norm_cfg = dict(mean=[0., 0., 0.], std=[255., 255., 255], to_rgb=False) # 输入图像标准化所需要的均值、标准差信息
+
+train_pipeline = [ # 训练图片处理管道 (Pipeline)
+ dict(type='LoadImageFromFile'), # 加载图片
+ dict(type='LoadAnnotations'), # 加载光流数据
+ dict(type='ColorJitter', # 随机改变输入图片亮度、对比度、饱和度以及色调
+ brightness=0.5, # 亮度调整范围
+ contrast=0.5, # 对比度调整范围
+ saturation=0.5, # 饱和度调整范围
+ hue=0.5), # 色调调整范围
+ dict(type='RandomGamma', gamma_range=(0.7, 1.5)), # 随机伽马校正配置
+ dict(type='Normalize', **img_norm_cfg), # 图像标准化配置，具体数值来自 img_norm_cfg
+ dict(type='GaussianNoise', sigma_range=(0, 0.04), clamp_range=(0., 1.)), # 增加高斯噪声，高斯噪声的标准差采样自 [0, 0.04] 区间
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'), # 随机水平翻转配置
+ dict(type='RandomFlip', prob=0.5, direction='vertical'), # 随机竖直翻转配置
+ # 随机仿射变换配置
+ # global_transform 和 relative_transform 的键值应该是下列其中之一:
+ # ('translates', 'zoom', 'shear', 'rotate')。同时，每个键值和对应的数
+ # 值需要满足下面的规则:
+ # - 平移: 沿图像坐标系 x 轴、y 轴的平移比率。默认为 (0., 0.)。
+ # - 缩放: 最小、最大的图片缩放比。默认为 (1.0, 1.0)。
+ # - 剪切: 最小、最大的图片剪切比。 默认为 (1.0, 1.0)。
+ # - 旋转: 最小、最大的旋转角度。 默认为 (0., 0.)。
+ dict(type='RandomAffine',
+ global_transform=dict(
+ translates=(0.05, 0.05),
+ zoom=(1.0, 1.5),
+ shear=(0.86, 1.16),
+ rotate=(-10., 10.)
+ ),
+ relative_transform=dict(
+ translates=(0.00375, 0.00375),
+ zoom=(0.985, 1.015),
+ shear=(1.0, 1.0),
+ rotate=(-1.0, 1.0)
+ )),
+ dict(type='RandomCrop', crop_size=(384, 448)), # 随即裁剪输入图像与光流到 (384, 448) 大小
+ dict(type='DefaultFormatBundle'), # 它提供了格式化常用输入字段的简化接口，支持 'img1'、'img2' 和 'flow_gt' 字段
+ dict(
+ type='Collect', # 从加载器 (loader) 收集与特定任务相关的数据
+ keys=['imgs', 'flow_gt'],
+ meta_keys=('img_fields', 'ann_fields', 'filename1', 'filename2',
+ 'ori_filename1', 'ori_filename2', 'filename_flow',
+ 'ori_filename_flow', 'ori_shape', 'img_shape',
+ 'img_norm_cfg')),
+]
+
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ dict(type='InputResize', exponent=4),
+ dict(type='Normalize', **img_norm_cfg),
+ dict(type='TestFormatBundle'), # 它提供了格式化常用输入字段的简化接口，支持 'img1'、'img2' 和 'flow_gt' 字段
+ dict(
+ type='Collect',
+ keys=['imgs'], # 从加载器 (loader) 收集与特定任务相关的数据
+ meta_keys=('flow_gt', 'filename1', 'filename2', 'ori_filename1',
+ 'ori_filename2', 'ori_shape', 'img_shape', 'img_norm_cfg',
+ 'scale_factor', 'pad_shape')) # meta_keys 中的 'flow_gt' 是用于在线模型评估 (online evaluation) 的字段
+]
+
+data = dict(
+ train_dataloader=dict(
+ samples_per_gpu=1, # 单一 GPU 上的样本数
+ workers_per_gpu=5, # 每个 GPU 上预取数据的线程数
+ drop_last=True), # 是否删除最后一个非完整的批次 (batch)
+
+ val_dataloader=dict(
+ samples_per_gpu=1, # 单一 GPU 上的样本数
+ workers_per_gpu=2, # 每个 GPU 上预取数据的线程数
+ shuffle=False), # 是否删除最后一个非完整的批次 (batch)
+
+ test_dataloader=dict(
+ samples_per_gpu=1, # 单一 GPU 上的样本数
+ workers_per_gpu=2, # 每个 GPU 上预取数据的线程数
+ shuffle=False), # 是否打乱输入顺序
+
+ train=dict( # 训练数据集配置
+ type=dataset_type,
+ pipeline=train_pipeline,
+ data_root=data_root,
+ split_file='data/FlyingChairs_release/FlyingChairs_train_val.txt', # 训练、验证子集
+ ),
+
+ val=dict(
+ type=dataset_type,
+ pipeline=test_pipeline,
+ data_root=data_root,
+ test_mode=True),
+
+ test=dict(
+ type=dataset_type,
+ pipeline=test_pipeline,
+ data_root=data_root,
+ test_mode=True)
+)
+```
+
+原始配置文件 `_base_/schedules/schedule_s_long.py` 中是:
+
+```python
+# optimizer
+optimizer = dict(
+ type='Adam', lr=0.0001, weight_decay=0.0004, betas=(0.9, 0.999))
+optimizer_config = dict(grad_clip=None)
+# learning policy
+lr_config = dict(
+ policy='step',
+ by_epoch=False,
+ gamma=0.5,
+ step=[400000, 600000, 800000, 1000000])
+runner = dict(type='IterBasedRunner', max_iters=1200000)
+checkpoint_config = dict(by_epoch=False, interval=100000)
+evaluation = dict(interval=100000, metric='EPE')
+```
+
+原始配置文件 `_base_/default_runtime.py` 中是:
+
+```python
+log_config = dict( # 配置注册记录器钩子
+ interval=50, # 打印训练日志信息的频率
+ hooks=[
+ dict(type='TextLoggerHook'),
+ dict(type='TensorboardLoggerHook')
+ ]) # 记录训练过程的记录器配置
+dist_params = dict(backend='nccl') # 设置分布式训练的参数，端口 (port) 也可以在这里配置
+log_level = 'INFO' # 日志信息等级
+load_from = None # 从给定路径加载模型作为预训练模型，这不同于恢复训练 (resume training)
+workflow = [('train', 1)] # 运行期的工作流设置。 [('train', 1)] 是指只有一个工作流 'train'，且它只执行一次
+```
+
+## 通过脚本参数来修改配置
+
+在使用 `tools/train.py` 或 `tools/test.py` 时，可以通过指定 `--cfg-options` 来就地 (in-place) 修改配置。
+
+- 更新配置字典链 (dict chains) 中的键 (keys)。
+
+ 可以按照原始配置中字典键的顺序指定配置选项。
+ 例如， `--cfg-option model.encoder.in_channels=6`。
+
+- 更新配置列表中的键 (keys)。
+
+ 一些配置字典在配置文件中组成一个列表。例如，训练数据处理管道 (pipeline) `data.train.pipeline` 往往是一个像 `[dict(type='LoadImageFromFile'), ...]` 一样的列表。 如果希望将其中的 `'LoadImageFromFile'` 替换为 `'LoadImageFromWebcam'`，可以通过指定 `--cfg-option data.train.pipeline.0.type='LoadImageFromWebcam'` 来实现。
+
+- 更新列表或元组的值。
+
+ 如果需要更新的值是一个元组或是列表。例如，配置文件中通常设置训练工作流为 `workflow=[('train', 1)]`。如果希望修改这个键值，可以通过指定 `--cfg-options workflow="[(train,1),(val,1)]"` 来实现。 注意，引号 " 对于列表、元组数据类型是必需的，且在指定值的引号内**不允许**有空格。
+
+## 常见问题 (FAQ)
+
+### 忽略原始配置中的部分字段
+
+如果需要，你可以通过设置 `_delete_=True` 来忽略原始配置文件中的部分字段。
+可以参考 [mmcv](https://mmcv.readthedocs.io/en/latest/utils.html#inherit-from-base-config-with-ignored-fields) 中的简单说明。
+
+请仔细阅读 [config 教程](https://github.com/open-mmlab/mmdetection/blob/master/docs/tutorials/config.md) 以更好地了解这一方法。
+
+### 使用配置文件中的中间变量
+
+配置文件中使用了一些中间变量，例如数据集配置中的 `train_pipeline`/`test_pipeline`。
+值得注意的是，在修改子配置文件中的中间变量时，用户需要再次将中间变量传递到相应的字段中。更为直观的例子参见 [config 教程](https://github.com/open-mmlab/mmdetection/blob/master/docs/tutorials/config.md)。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/1_inference.md b/internlm_langchain/knowledge_base/MMFlow/content/1_inference.md
new file mode 100644
index 00000000..09ee328d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/1_inference.md
@@ -0,0 +1,3 @@
+# 教程1 模型推理
+
+欢迎有兴趣的朋友一起翻译 MMFlow 文档。如有兴趣，请在 [MMFlow issue](<>) 提 issue 确定翻译的文档。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/2_finetune.md b/internlm_langchain/knowledge_base/MMFlow/content/2_finetune.md
new file mode 100644
index 00000000..718d25f0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/2_finetune.md
@@ -0,0 +1,3 @@
+# 教程2 模型微调
+
+欢迎有兴趣的朋友一起翻译 MMFlow 文档。如有兴趣，请在 [MMFlow issue](<>) 提 issue 确定翻译的文档。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/3_data_pipeline.md b/internlm_langchain/knowledge_base/MMFlow/content/3_data_pipeline.md
new file mode 100644
index 00000000..fec140ed
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/3_data_pipeline.md
@@ -0,0 +1,3 @@
+# 教程3 数据预处理
+
+欢迎有兴趣的朋友一起翻译 MMFlow 文档。如有兴趣，请在 [MMFlow issue](<>) 提 issue 确定翻译的文档。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/4_new_modules.md b/internlm_langchain/knowledge_base/MMFlow/content/4_new_modules.md
new file mode 100644
index 00000000..6dfd2690
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/4_new_modules.md
@@ -0,0 +1,3 @@
+# 教程4 添加新模块
+
+欢迎有兴趣的朋友一起翻译 MMFlow 文档。如有兴趣，请在 [MMFlow issue](<>) 提 issue 确定翻译的文档。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/5_customize_runtime.md b/internlm_langchain/knowledge_base/MMFlow/content/5_customize_runtime.md
new file mode 100644
index 00000000..a1509818
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/5_customize_runtime.md
@@ -0,0 +1,3 @@
+# 教程5 自定义模型运行参数
+
+欢迎有兴趣的朋友一起翻译 MMFlow 文档。如有兴趣，请在 [MMFlow issue](<>) 提 issue 确定翻译的文档。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/README.md b/internlm_langchain/knowledge_base/MMFlow/content/README.md
new file mode 100644
index 00000000..de11dc67
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/README.md
@@ -0,0 +1,35 @@
+# 准备 ChairsSDHom 数据集
+
+
+
+```bibtex
+@InProceedings{IMKDB17,
+ author = "E. Ilg and N. Mayer and T. Saikia and M. Keuper and A. Dosovitskiy and T. Brox",
+ title = "FlowNet 2.0: Evolution of Optical Flow Estimation with Deep Networks",
+ booktitle = "IEEE Conference on Computer Vision and Pattern Recognition (CVPR)",
+ month = "Jul",
+ year = "2017",
+ url = "http://lmb.informatik.uni-freiburg.de//Publications/2017/IMKDB17"
+}
+```
+
+```text
+ChairsSDHom
+| | ├── data
+| | | ├── train
+| | | | |── flow
+| | | | | |── xxxxx.pfm
+| | | | |── t0
+| | | | | |── xxxxx.png
+| | | | |── t1
+| | | | | |── xxxxx.png
+| | | ├── test
+| | | | |── flow
+| | | | | |── xxxxx.pfm
+| | | | |── t0
+| | | | | |── xxxxx.png
+| | | | |── t1
+| | | | | |── xxxxx.png
+```
+
+从数据集[官网](https://lmb.informatik.uni-freiburg.de/data/FlowNet2/ChairsSDHom/ChairsSDHom.tar.gz)下载文件压缩包后，解压文件并对照上方目录检查解压后的数据集目录。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/getting_started.md b/internlm_langchain/knowledge_base/MMFlow/content/getting_started.md
new file mode 100644
index 00000000..2542988f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/getting_started.md
@@ -0,0 +1,145 @@
+# 快速入门
+
+本文介绍 MMFlow 的基本使用，安装指引请参看[安装文档](install.md)
+
+
+
+- [快速入门](#%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8)
+ - [准备数据集](#%E5%87%86%E5%A4%87%E6%95%B0%E6%8D%AE%E9%9B%86)
+ - [模型推理](#%E6%A8%A1%E5%9E%8B%E6%8E%A8%E7%90%86)
+ - [演示样例](#%E6%BC%94%E7%A4%BA%E6%A0%B7%E4%BE%8B)
+ - [数据集上测试](#%E6%95%B0%E6%8D%AE%E9%9B%86%E4%B8%8A%E6%B5%8B%E8%AF%95)
+ - [模型训练](#%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83)
+ - [其他教程](#%E5%85%B6%E4%BB%96%E6%95%99%E7%A8%8B)
+
+
+
+## 准备数据集
+
+我们推荐用将目录 `$MMFlow/data` 指向（symlink）存放目录的地址。请根据以下指引准备训练数据集。
+
+- [FlyingChairs](../en/data_prepare/FlyingChairs/README.md)
+- [FlyingThings3d_subset](../en/data_prepare/FlyingThings3d_subset/README.md)
+- [FlyingThings3d](../en/data_prepare/FlyingThings3d/README.md)
+- [Sintel](../en/data_prepare/Sintel/README.md)
+- [KITTI2015](../en/data_prepare/KITTI2015/README.md)
+- [KITTI2012](../en/data_prepare/KITTI2012/README.md)
+- [FlyingChairsOcc](../en/data_prepare/FlyingChairsOcc/README.md)
+- [ChairsSDHom](../en/data_prepare/ChairsSDHom/README.md)
+- [HD1K](../en/data_prepare/hd1k/README.md)
+
+## 模型推理
+
+我们提供了测试脚本，可以在标准的数据集 Sintel, KITTI 等上进行测试，也提供可直接对图像或者视频进行推理的 API 和 脚本。
+
+### 演示样例
+
+我们提供了样例脚本可以之间来推理两帧之间的光流
+
+1. [图像推理样例](../demo/image_demo.py)
+
+ ```shell
+ python demo/image_demo.py ${IMAGE1} ${IMAGE2} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${OUTPUT_DIR} \
+ [--out_prefix] ${OUTPUT_PREFIX} [--device] ${DEVICE}
+ ```
+
+ 可选参数：
+
+ - `--out_prefix`: 输出结果的前缀，包括光流文件和可视化后的光流图片。
+ - `--device`: 用于推理的设备
+
+ 例子：
+
+ 假设您已经将 checkpoints 下载到目录中 `checkpoints/`, 并将输出的结果存在 `raft_demo`
+
+ ```shell
+ python demo/image_demo.py demo/frame_0001.png demo/frame_0002.png \
+ configs/raft/raft_8x2_100k_mixed_368x768.pth \
+ checkpoints/raft_8x2_100k_TSKH_368x768.pth raft_demo
+ ```
+
+2. [视频推理样例](../demo/video_demo.py)
+
+ ```shell
+ python demo/video_demo.py ${VIDEO} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${OUTPUT_FILE} \
+ [--gt] ${GROUND_TRUTH} [--device] ${DEVICE}
+ ```
+
+ 可选参数：
+
+ - `--gt`: 输入视频的 ground truth 视频文件。如果指定，可视化结果将会把 ground truth
+ 与预测结果连接在一起输出作为比较。
+ - `--device`: 用于推理的设备
+
+ 例子：
+
+ 假设您已经将 checkpoints 下载到目录中 `checkpoints/`, 并将输出的结果存为 `raft_demo.mp4`
+
+ ```shell
+ python demo/video_demo.py demo/demo.mp4 \
+ configs/raft/raft_8x2_100k_mixed_368x768.py \
+ checkpoints/raft_8x2_100k_mixed_368x768.pth \
+ raft_demo.mp4 --gt demo/demo_gt.mp4
+ ```
+
+### 数据集上测试
+
+可以利用以下命令来测试模型在数据集上的精度，更多细节可以查看 [tutorials/1_inference](../en/tutorials/1_inference.md)。
+
+```shell
+# single-gpu testing
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
+```
+
+可选参数：
+
+- `--out_dir`: 输出文件保存目录，被指定后，模型输出的光流将以 '.flo' 文件的形式会保存在该目录。
+- `--fuse-conv-bn`: 是否将 conv 和 bn 融合，如果定义为 True, 这项操作会对推理轻微加速。
+- `--show_dir`: 可视化光流图的保存目录，被指定后，模型输出的光流可视化后将以图片的形式保存在该目录。
+- `--eval`: 评估的指标，例如：EPE。
+- `--cfg-option`: 键值 xxx=yyy 将被合并到配置文件中。例如：'--cfg-option model.encoder.in_channels=6'
+
+例子：
+
+假设您已经将 checkpoints 下载到目录中 `checkpoints/`。
+测试 PWC-Net 在 Sintel 数据集的 clean 和 final 两个子数据集上的 EPE 指标，但不保存预测结果。
+
+```shell
+python tools/test.py configs/pwcnet_8x1_sfine_sintel_384x768.py \
+ checkpoints/pwcnet_8x1_sfine_sintel_384x768.pth --eval EPE
+
+```
+
+## 模型训练
+
+你可以使用[训练脚本](../tools/train.py)直接来启动一个单卡训练任务，更多信息请查看 [tutorials/2_finetune](../en/tutorials/2_finetune.md)
+
+```shell
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+可选参数：
+
+- `--work-dir`: 工作目录，如果指定会覆盖配置文件中的工作目录参数。
+- `--load-from`: 将要加载的 checkpoint 文件参数。
+- `--resume-from`: 从之前的 checkpoint 文件恢复训练。
+- `--no-validate`: 是否在训练过程不对模型做评估。
+- `--seed`: Python, Numpy 和 Pytorch 中生成随机数的随机种子。
+- `--deterministic`: 如果指定，它将为 CUDNN 后端设置确定性选项。
+- `--cfg-options`: 键值 xxx=yyy 将被合并到配置文件中。例如：'--cfg-option model.encoder.in_channels=6'
+
+`resume-from` 和 `load-from` 的不同：
+
+`resume-from` 同时加载模型参数、优化器状态以及当前 epoch/iter。通常用于恢复被意外中断的训练过程。
+`load-from` 只加载模型的参数,训练将会从头开始。通常用于模型微调。
+
+## 其他教程
+
+我们为用户提供了一些教程文档:
+
+- [learn about configs](../en/tutorials/0_config.md)
+- [inference model](../en/tutorials/1_inference.md)
+- [finetune model](../en/tutorials/2_finetune.md)
+- [customize data pipelines](../en/tutorials/3_data_pipeline.md)
+- [add new modules](../en/tutorials/4_new_modules.md)
+- [customize runtime settings](../en/tutorials/5_customize_runtime.md).
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/install.md b/internlm_langchain/knowledge_base/MMFlow/content/install.md
new file mode 100644
index 00000000..80be8ddb
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/install.md
@@ -0,0 +1,140 @@
+# 安装
+
+
+
+- [安装](#%E5%AE%89%E8%A3%85)
+ - [依赖](#%E4%BE%9D%E8%B5%96)
+ - [准备环境](#%E5%87%86%E5%A4%87%E7%8E%AF%E5%A2%83)
+ - [安装 MMFlow](#%E5%AE%89%E8%A3%85-mmflow)
+ - [从零开始安装](#%E4%BB%8E%E9%9B%B6%E5%BC%80%E5%A7%8B%E5%AE%89%E8%A3%85)
+ - [安装验证](#%E5%AE%89%E8%A3%85%E9%AA%8C%E8%AF%81)
+
+
+
+## 依赖
+
+- Linux
+- Python 3.6+
+- PyTorch 1.5 或更高
+- CUDA 9.0 或更高
+- NCCL 2
+- GCC 5.4 或更高
+- [mmcv](https://github.com/open-mmlab/mmcv) 1.3.15 或更高
+
+## 准备环境
+
+a. 创建并激活 conda 虚拟环境
+
+```shell
+conda create -n openmmlab python=3.7 -y
+conda activate openmmlab
+```
+
+b. 按照 [PyTorch 官方文档](https://pytorch.org/) 安装 PyTorch 和 torchvision
+
+注：确保 CUDA 编译版本和 CUDA 运行版本相匹配。 用户可以参照 [PyTorch 官网](https://pytorch.org/) 对预编译包所支持的 CUDA 版本进行核对。
+
+`例1`：如果 `/usr/local/cuda` 文件夹下已安装了 CUDA 10.2 版本，并需要安装最新版本的 PyTorch。
+
+```shell
+conda install pytorch torchvision torchaudio cudatoolkit=10.2 -c pytorch
+```
+
+`例2`：如果 `/usr/local/cuda` 文件夹下已安装了 CUDA 9.2 版本，并需要安装 PyTorch 1.7.0。
+
+```shell
+conda install pytorch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0 cudatoolkit=9.2 -c pytorch
+```
+
+如果你从源码编译 PyTorch 而不是安装的预编译版本的话，你可以使用更多 CUDA 版本（例如9.0）。
+
+c. 安装 MMCV，我们推荐按照如下方式安装预编译的 MMCV
+
+```shell
+pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/{cu_version}/{torch_version}/index.html
+```
+
+请按照 CUDA 和 Pytorch 的版本 替换链接中的 `{cu_version}` and `{torch_version}`， 例如，当环境中已安装 CUDA 10.2 和 PyTorch 1.10.0 时安装最新版本的 `mmcv-full`，可以使用以下命令：
+
+```shell
+pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.10.0/index.html
+```
+
+[这里](https://github.com/open-mmlab/mmcv#installation) 可以查看不同 MMCV 的安装方式。
+
+或者，也可以按以下命令从源码编译 MMCV
+
+```shell
+git clone https://github.com/open-mmlab/mmcv.git
+cd mmcv
+MMCV_WITH_OPS=1 pip install -e . # 这种方式可以安装包含 CUDA op 的 mmcv-full
+# pip install -e . # 或者安装不包含 CUDA op 的 mmcv
+cd ..
+```
+
+**重要** 如果之前安装了 `mmcv`，在安装 `mmcv` 之前需要先卸载 `pip uninstall mmcv`。因为同时安装了 `mmcv` 和 `mmcv-full`，
+会遇到 `ModuleNotFoundError` 的错误。
+
+## 安装 MMFlow
+
+a. 克隆 MMFlow 代码库
+
+```shell
+git clone https://github.com/open-mmlab/mmflow.git
+cd mmflow
+```
+
+b. 安装相关依赖和 MMFlow
+
+```shell
+pip install -r requirements/build.txt
+pip install -v -e . # or "python setup.py develop"
+```
+
+注：
+
+1. git commit 的 id 将会被写到版本号中，如 0.6.0+2e7045c。这个版本号也会被保存到训练好的模型中。
+
+2. 根据上述步骤， MMFlow 就会以 `dev` 模式被安装，任何本地的代码修改都会立刻生效，不需要再重新安装一遍（除非用户提交了 commits，并且想更新版本号）。
+
+3. 如果用户想使用 `opencv-python-headless` 而不是 `opencv-python`，可在安装 `MMCV` 前安装 `opencv-python-headless`。
+
+## 从零开始安装
+
+假设已安装了 10.1 版本的 CUDA，以下是完整的安装 MMFlow 的命令。
+
+```shell
+conda create -n open-mmlab python=3.7 -y
+conda activate open-mmlab
+
+conda install pytorch==1.6.0 torchvision==0.7.0 cudatoolkit=10.1 -c pytorch -y
+
+# install latest mmcv
+pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.6.0/index.html
+
+# install mmflow
+git clone https://github.com/open-mmlab/mmflow.git
+cd mmflow
+pip install -r requirements/build.txt
+pip install -v -e .
+```
+
+## 安装验证
+
+我们可以利用以下步骤初始化模型并对图像做推理，来检查 MMFlow 是否正确安装。
+
+```python
+from mmflow.apis import inference_model, init_model
+
+config_file = 'configs/pwcnet/pwcnet_ft_4x1_300k_sintel_final_384x768.py'
+# download the checkpoint from model zoo and put it in `checkpoints/`
+# url: https://download.openmmlab.com/mmflow/pwcnet/pwcnet_ft_4x1_300k_sintel_final_384x768.pth
+checkpoint_file = 'checkpoints/pwcnet_ft_4x1_300k_sintel_final_384x768.pth'
+device = 'cuda:0'
+# init a model
+model = init_model(config_file, checkpoint_file, device=device)
+# inference the demo image
+inference_model(model, 'demo/frame_0001.png', 'demo/frame_0002.png')
+```
+
+上述命令应该在完成安装后成功运行。
diff --git a/internlm_langchain/knowledge_base/MMFlow/content/model_zoo.md b/internlm_langchain/knowledge_base/MMFlow/content/model_zoo.md
new file mode 100644
index 00000000..6ecec0b3
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFlow/content/model_zoo.md
@@ -0,0 +1,15 @@
+# 模型库统计
+
+- 论文数量: 9
+
+- 模型数量: 62 ckpts
+
+ - [FlowNet: Learning Optical Flow with Convolutional Networks](../../configs/flownet) (5 ckpts)
+ - [FlowNet 2.0: Evolution of Optical Flow Estimation with Deep Networks](../../configs/flownet2) (7 ckpts)
+ - [PWC-Net: CNNs for Optical Flow Using Pyramid, Warping, and Cost Volume](../../configs/_base_/pwcnet) (6 ckpts)
+ - [LiteFlowNet: A Lightweight Convolutional Neural Network for Optical Flow Estimation](../../configs/liteflownet) (9 ckpts)
+ - [A Lightweight Optical Flow CNN-Revisiting Data Fidelity and Regularization](../../configs/liteflownet2) (8 ckpts)
+ - [Iterative Residual Refinement for Joint Optical Flow and Occlusion Estimation](../../configs/irr) (5 ckpts)
+ - [MaskFlownet: Asymmetric Feature Matching with Learnable Occlusion Mask](../../configs/maskflownet) (4 ckpts)
+ - [RAFT: Recurrent All-Pairs Field Transforms for Optical Flow](../../configs/raft) (5 ckpts)
+ - [GMA: Learning to Estimate Hidden Motions with Global Motion Aggregation](../../configs/gma) (13 ckpts)
diff --git a/internlm_langchain/knowledge_base/MMFlow/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMFlow/vector_store/index.faiss
new file mode 100644
index 00000000..5114b2e3
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMFlow/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/cameras.md b/internlm_langchain/knowledge_base/MMHuman3D/content/cameras.md
new file mode 100644
index 00000000..14504db5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/cameras.md
@@ -0,0 +1,304 @@
+# 相机
+
+## 相机初始化
+
+MMHuman3D遵循 `PyTorch3D` 中的相机规范：其外参矩阵定义为从相机坐标系到世界坐标系的变化。外参矩阵使用右乘，内参矩阵使用左乘。我们还提供了`OpenCV`中的相机规范，如果您更熟悉`OpenCV`，您也可以选择`OpenCV`规范来进行操作。
+
+- **相机切片:**
+
+ MMHuman3D中，推荐的相机初始化的方式为直接传递`K`, `R`, `T`矩阵。
+ 可以按索引对相机进行切片，也可以在batch维度进行拼接。
+
+ ```python
+ from mmhuman3d.core.cameras import PerspectiveCameras
+ import torch
+ K = torch.eye(4, 4)[None]
+ R = torch.eye(3, 3)[None]
+ T = torch.zeros(100, 3)
+ # K, R, T的Batch大小应该相同，或者为1。如果不同，最终的batch大小会是三者中最大的那一个。
+ cam = PerspectiveCameras(K=K, R=R, T=T)
+ assert cam.R.shape == (100, 3, 3)
+ assert cam.K.shape == (100, 4, 4)
+ assert cam.T.shape == (100, 3)
+ assert (cam[:10].K == cam.K[:10]).all()
+ ```
+- **构建相机:**
+
+ 封装在mmcv.Registry中。
+
+ MMHuman3D中，推荐的初始化相机的方式为直接传递`K`, `R`, `T`矩阵, 但是也可以传递`focal_length` 和 `principle_point` 作为输入。
+
+ 以常用的`PerspectiveCameras`为例。如果`K`, `R`, `T`没有被确定，`K`将会使用`compute_default_projection_matrix`中默认的，`principal_point` 和 `R` 将会被设置为单位矩阵，`T`将会被设置为零矩阵。您也可以通过重写`compute_default_projection_matrix`来指定具体的数值。
+
+ ```python
+ from mmhuman3d.core.cameras import build_cameras
+
+ # 使用给定的K, R, T矩阵初始化相机(PerspectiveCameras)。
+ # K, R, T的batch大小应该相同，或者为1。
+ K = torch.eye(4, 4)[None]
+ R = torch.eye(3, 3)[None]
+ T = torch.zeros(10, 3)
+
+ height, width = 1000
+ cam1 = build_cameras(
+ dict(
+ type='PerspectiveCameras',
+ K=K,
+ R=R,
+ T=T,
+ in_ndc=True,
+ image_size=(height, width),
+ convention='opencv',
+ ))
+
+ # This is the same as:
+ cam2 = PerspectiveCameras(
+ K=K,
+ R=R,
+ T=T,
+ in_ndc=True,
+ image_size=1000, # 图像尺度指定为单数时，表示正方形图像。
+ convention='opencv',
+ )
+ assert cam1.K.shape == cam2.K.shape == (10, 4, 4)
+ assert cam1.R.shape == cam2.R.shape == (10, 3, 3)
+ assert cam1.T.shape == cam2.T.shape == (10, 3)
+
+ # 使用给定的`image_size`, `principal_points`, `focal_length`初始化相机(PerspectiveCameras)。
+ # `in_ndc = False` 意味着内参矩阵 `K` 在screen space中被定义。 `K`中的`focal_length`和`principal_point`被定义为像素个数。 下例中， `principal_points` 为 (500, 500) 像素， `focal_length` 为 1000 像素。
+ cam = build_cameras(
+ dict(
+ type='PerspectiveCameras',
+ in_ndc=False,
+ image_size=(1000, 1000),
+ principal_points=(500, 500),
+ focal_length=1000,
+ convention='opencv',
+ ))
+
+ assert (cam.K[0] == torch.Tensor([[1000., 0., 500., 0.],
+ [0., 1000., 500., 0.],
+ [0., 0., 0., 1.],
+ [0., 0., 1., 0.]]).view(4, 4)).all()
+
+ # 使用给定的K, R, T初始化相机(WeakPerspectiveCameras)。Weakperspective Camera 只支持`in_ndc = True`(默认)。
+ cam = build_cameras(
+ dict(
+ type='WeakPerspectiveCameras',
+ K=K,
+ R=R,
+ T=T,
+ image_size=(1000, 1000)
+ ))
+
+ # 如果`K`, `R`, `T`矩阵没有给定，将会使用默认矩阵初始化`in_ndc`的相机(PerspectiveCameras)。
+ cam = build_cameras(
+ dict(
+ type='PerspectiveCameras',
+ in_ndc=True,
+ image_size=(1000, 1000),
+ ))
+ # Then convert it to screen. This operation requires `image_size`.
+ cam.to_screen_()
+ ```
+
+## 相机重投影矩阵
+- **Perspective:**
+
+ 内参矩阵的格式:
+ fx, fy 是焦距, px, py 是像主点。
+ ```python
+ K = [
+ [fx, 0, px, 0],
+ [0, fy, py, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ ]
+ ```
+ 更多信息请参考[Pytorch3D](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/renderer/cameras.py#L895)。
+
+- **WeakPerspective:**
+
+ 内参矩阵的格式:
+ ```python
+ K = [
+ [sx*r, 0, 0, tx*sx*r],
+ [0, sy, 0, ty*sy],
+ [0, 0, 1, 0],
+ [0, 0, 0, 1],
+ ]
+ ```
+ `WeakPerspectiveCameras` 事实上是正交投影, 主要用于 SMPL(x) 模型的重投影。
+ 更多信息请参考[mmhuman3d cameras](mmhuman3d/core/cameras/cameras.py#L40)。
+ 可以通过SMPL预测的相机参数进行转换:
+ ```python
+ from mmhuman3d.core.cameras import WeakPerspectiveCameras
+ K = WeakPerspectiveCameras.convert_orig_cam_to_matrix(orig_cam)
+ ```
+ `pred_cam`是一个由[scale_x, scale_y, transl_x, transl_y]组成的array/tensor, 其维度为(frame, 4)。更多信息请参考[VIBE](https://github.com/mkocabas/VIBE/blob/master/lib/utils/renderer.py#L40-L47).
+
+- **FoVPerspective:**
+
+ 内参矩阵的格式:
+ ```python
+ K = [
+ [s1, 0, w1, 0],
+ [0, s2, h1, 0],
+ [0, 0, f1, f2],
+ [0, 0, 1, 0],
+ ]
+ ```
+ s1, s2, w1, h1, f1, f2 由 FoV parameters (`fov`, `znear`, `zfar`, 等)定义, 更多信息请参考[Pytorch3D](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/renderer/cameras.py).
+
+- **Orthographics:**
+
+ 内参矩阵的格式:
+ ```python
+ K = [
+ [fx, 0, 0, px],
+ [0, fy, 0, py],
+ [0, 0, 1, 0],
+ [0, 0, 0, 1],
+ ]
+ ```
+ 更多信息请参考[Pytorch3D](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/renderer/cameras.py).
+
+- **FoVOrthographics:**
+ ```python
+ K = [
+ [scale_x, 0, 0, -mid_x],
+ [0, scale_y, 0, -mix_y],
+ [0, 0, -scale_z, -mid_z],
+ [0, 0, 0, 1],
+ ]
+ ```
+ scale_x, scale_y, scale_z, mid_x, mid_y, mid_z 由 FoV parameters(`min_x`, `min_y`, `max_x`, `max_y`, `znear`, `zfar`, 等)定义, 更多信息请参考[Pytorch3D](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/renderer/cameras.py).
+
+## 相机规范
+- **在不同相机之间进行转换:**
+
+ 我们命名内参矩阵为`K`, 旋转矩阵为`R` 平移矩阵为`T`。
+ 不同的相机规范有着不同的轴向, 有些使用矩阵左乘，有些使用矩阵右乘。 内参矩阵和外参矩阵应该使用相同的矩阵乘法规范，但是`PyTorch3D`在计算过程中使用矩阵右乘，在相机初始化的时候传递左乘矩阵`K`(这主要是为了便于理解)。
+ `NDC`和`screen`之间的转换也会影响内参矩阵, 这与相机规范无关。
+ 如果要使用现有的规范，请指定`['opengl', 'opencv', 'pytorch3d', 'pyrender', 'open3d']`中的一个。
+ 例如, 可以进行如下的操作，将使用`OpenCV`标定的相机转化为`PyTorch3D NDC`定义的相机以进行渲染:
+ ```python
+ from mmhuman3d.core.conventions.cameras import convert_cameras
+ import torch
+
+ K = torch.eye(4, 4)[None]
+ R = torch.eye(3, 3)[None]
+ T = torch.zeros(10, 3)
+ height, width = 1080, 1920
+ K, R, T = convert_cameras(
+ K=K,
+ R=R,
+ T=T,
+ in_ndc_src=False,
+ in_ndc_dst=True,
+ resolution_src=(height, width),
+ convention_src='opencv',
+ convention_dst='pytorch3d')
+ ```
+ 输入 `K` 可以为 None, 或者维度为(batch_size, 3, 3) `array`/`tensor`，维度也可以为(batch_size, 4, 4)。
+
+ 输入 `R` 可以为 None, 或者维度为(batch_size, 3, 3) `array`/`tensor`。
+
+ 输入 `T` 可以为 None, 或者维度为(batch_size, 3) `array`/`tensor`。
+
+ 如果原始的 `K` 为 `None`, 将会一直保持为 `None`。如果原始的 `R` 为 `None`, 将会设置为单位矩阵。 如果原始的 `T` 为 `None`, 将会设置为零矩阵。
+
+ 更多关于`NDC`和`screen`相机空间的信息，请参考[Pytorch3D](https://github.com/facebookresearch/pytorch3d/blob/main/docs/notes/cameras.md)。
+
+- **定义个人的相机规范:**
+
+ 如果使用新的相机规范, 请在[CAMERA_CONVENTION_FACTORY](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/conventions/cameras/__init__.py)中, 按照向右, 向上, 和远离屏幕的顺序进行定义。例如, 下方第一个`PyRender`的顺序应该为'+x+y+z'。第二个`OpenCV`的顺序应该为'+x-y-z'。 第三个`Pytorch3D`的顺序为'-xyz'。
+ ```
+ OpenGL(PyRender) OpenCV Pytorch3D
+ y z y
+ | / |
+ | / |
+ |_______x /________x x________ |
+ / | /
+ / | /
+ z / y | z /
+ ```
+
+## 部分转换函数
+转换函数定义在`conventions.cameras`中。
+- **NDC & screen:**
+
+ ```python
+ from mmhuman3d.core.conventions.cameras import (convert_ndc_to_screen,
+ convert_screen_to_ndc)
+
+ K = convert_ndc_to_screen(K, resolution=(1080, 1920), is_perspective=True)
+ K = convert_screen_to_ndc(K, resolution=(1080, 1920), is_perspective=True)
+ ```
+
+- **3x3 & 4x4 内参矩阵**
+
+ ```python
+ from mmhuman3d.core.conventions.cameras import (convert_K_3x3_to_4x4,
+ convert_K_4x4_to_3x3)
+
+ K = convert_K_3x3_to_4x4(K, is_perspective=True)
+ K = convert_K_4x4_to_3x3(K, is_perspective=True)
+ ```
+
+- **world & view:**
+
+ 在世界坐标和视图坐标中转换。
+
+ ```python
+ from mmhuman3d.core.conventions.cameras import convert_world_view
+ R, T = convert_world_view(R, T)
+ ```
+- **weakperspective & perspective:**
+
+ 在weakperspective 和 perspective中进行转换, `zmean` 参数是必须的。
+
+
+
+ ```python
+ from mmhuman3d.core.conventions.cameras import (
+ convert_perspective_to_weakperspective,
+ convert_weakperspective_to_perspective)
+
+ K = convert_perspective_to_weakperspective(
+ K, zmean, in_ndc=False, resolution, convention='opencv')
+ K = convert_weakperspective_to_perspective(
+ K, zmean, in_ndc=False, resolution, convention='pytorch3d')
+ ```
+
+## 部分计算函数
+
+- **将3D坐标投影至平面:**
+
+ ```python
+ points_xydepth = cameras.transform_points_screen(points)
+ points_xy = points_xydepth[..., :2]
+ ```
+
+- **计算点的深度:**
+
+ 可以简单地将点转化为视图坐标，并且得到深度z。
+ 更多的用例请参考[DepthRenderer](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/renderer/torch3d_renderer/depth_renderer.py).
+ ```python
+ points_depth = cameras.compute_depth_of_points(points)
+ ```
+
+- **获取mesh的法线:**
+
+ 使用`Pytorch3D`计算mesh的法线。
+ 更多的用例请参考[NormalRenderer](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/renderer/torch3d_renderer/normal_renderer.py).
+ ```python
+ normals = cameras.compute_normal_of_meshes(meshes)
+ ```
+
+- **获取相机平面的法线:**
+
+ 获取从相机中心指向相机平面法线的归一化张量。
+ ```python
+ normals = cameras.get_camera_plane_normals()
+ ```
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/contribute_dataset.md b/internlm_langchain/knowledge_base/MMHuman3D/content/contribute_dataset.md
new file mode 100644
index 00000000..76a90f5a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/contribute_dataset.md
@@ -0,0 +1,153 @@
+## 向mmhuman3d中添加数据转换
+
+### 总览
+
+所有的数据集在加载之前，需要先使用不同的转换脚本，将其预处理为相同的结构。该文档描述了如何给新的数据集编写转换工具。
+
+### 1. 首先给转换工具创建python脚本
+
+在下面的例子中, 我们给LSP数据集创建转换脚本`mmhuman3d/data/data_converters/lsp.py`。
+
+我们继承了两种类型的转换工具:
+
+(1) BaseConverter (详情见`mmhuman3d/data/data_converters/coco.py`)
+
+CocoConverter 使用 `convert` 函数输出处理过后的单个`.npz`文件。
+```
+@DATA_CONVERTERS.register_module()
+class CocoConverter(BaseConverter):
+
+ def convert(self, dataset_path: str, out_path: str) -> dict:
+ """
+ 参数:
+ dataset_path (str): 存放原始图像和标注的文件夹路径。
+ out_path (str): 保存处理过的`.npz`文件的路径
+
+ 返回值:
+ dict:
+ 一个基于HumanData()结构的字典，包含了
+ image_path, bbox_xywh, keypoints2d,
+ keypoints2d_mask等关键字。
+ """
+```
+
+(2) BaseModeConverter (详情见`mmhuman3d/data/data_converters/lsp.py`)
+
+如果需要对训练集和测试集进行不同的操作，您可以继承`BaseModeConverter`。 例如，`LspConverter`通过`convert_by_mode`函数输出多个定义在`ACCEPTED_MODES`中, 经过处理的`.npz`文件。
+```
+@DATA_CONVERTERS.register_module()
+class LspConverter(BaseModeConverter):
+
+ """
+ Args:
+ modes (list): 'test' 或者 'train'
+ """
+ ACCEPTED_MODES = ['test', 'train']
+
+ def __init__(self, modes: List = []) -> None:
+ super(LspConverter, self).__init__(modes)
+
+ def convert_by_mode(self, dataset_path: str, out_path: str,
+ mode: str) -> dict:
+
+```
+
+请参考[keypoints conventions](https://github.com/open-mmlab/mmhuman3d/blob/main/docs/keypoints_convention.md)查看您的数据集是否已经拥有现成的convention。没有的话, 您可以按照[customize_keypoints_convention](https://github.com/open-mmlab/mmhuman3d/blob/main/docs/customize_keypoints_convention.md)的指导定义一个新的convention。
+
+```
+# 根据给定的convention储存关键点
+keypoints2d_, mask = convert_kps(keypoints2d_, 'lsp', 'human_data')
+
+```
+
+MMHuman3D使用 `HumanData` 结构来储存和加载数据。 您可以在[human_data](https://github.com/open-mmlab/mmhuman3d/blob/main/docs/human_data.md)中找到对其功能进一步的描述。
+
+```
+ # 使用 HumanData 储存数据
+ human_data = HumanData()
+
+ ...
+
+ # 存储必要的关键字，例如: image path, bbox, keypoints2d, keypoints2d_mask, keypoints3d, keypoints3d_mask
+ human_data['image_path'] = image_path_
+ human_data['bbox_xywh'] = bbox_xywh_
+ human_data['keypoints2d_mask'] = mask
+ human_data['keypoints2d'] = keypoints2d_
+ human_data['config'] = 'lsp'
+ human_data.compress_keypoints_by_mask()
+
+ # 储存数据结构
+ if not os.path.isdir(out_path):
+ os.makedirs(out_path)
+
+ out_file = os.path.join(out_path, 'lsp_{}.npz'.format(mode))
+ human_data.dump(out_file)
+```
+
+### 2. 在`mmhuman3d/data/data_converters/__init__.py`中初始化转换工具
+
+将您的转换工具注册在data_converters中:
+
+```python
+# 引用您的转换工具
+from .lsp import LspConverter
+
+# 将您的转换工具添加在如下列表中
+__all__ = [
+ 'build_data_converter', 'AgoraConverter', 'MpiiConverter', 'H36mConverter', ...
+ 'LspConverter'
+]
+```
+
+
+### 3. 将您的数据集的配置文件添加在`mmhuman3d/tools/convert_datasets.py`的`DATASET-CONFIGS`中
+
+现有数据集的配置文件罗列在[convert_datasets.py](https://github.com/open-mmlab/mmhuman3d/tree/main/tools/convert_datasets.py)中。
+
+例如:
+```
+DATASET_CONFIGS = dict(
+ ...
+ lsp=dict(type='LspConverter', modes=['train', 'test'], prefix='lsp')
+)
+```
+
+其中 `lsp` 是 `dataset-name`的一个实例。 可使用的模式包括 `train` 和 `test`, `prefix` 指定了数据集文件夹的名称。 在该例中, `prefix = 'lsp'` 是存放了原始标注和图像的文件夹(文件夹的具体结构可以参考[preprocess_dataset](https://github.com/open-mmlab/mmhuman3d/blob/main/docs/preprocess_dataset.md#lsp)).
+
+
+### 4. 将您的数据集的license和相应的文件夹结构添加到`preprocess_dataset.md`中
+
+`lsp.py`中引用数据集的例子:
+- https://github.com/open-mmlab/mmhuman3d/blob/9ec38db89cb896c318ff830c12ec007f60c447ad/mmhuman3d/data/data_converters/lsp.py#L15-L22
+
+下载链接和文件夹结构放置在 `preprocess_dataset.md`
+- https://github.com/open-mmlab/mmhuman3d/blob/main/docs/preprocess_dataset.md#lsp
+
+
+### 5. 检查转换工具是否正常工作
+
+
+运行如下脚本进行检查
+
+```bash
+python tools/convert_datasets.py \
+ --datasets lsp \ # 定义在`DATASET_CONFIGS`中的数据集名称
+ --root_path data/datasets \
+ --output_path data/preprocessed_datasets
+```
+
+获得放置在 `data/preprocessed_datasets` 下的`.npz`文件:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── datasets
+ └── preprocessed_datasets
+ ├── lsp_train.npz
+ └── lsp_test.npz
+```
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/customize_keypoints_convention.md b/internlm_langchain/knowledge_base/MMHuman3D/content/customize_keypoints_convention.md
new file mode 100644
index 00000000..91f78afb
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/customize_keypoints_convention.md
@@ -0,0 +1,96 @@
+## 客制化关键点类型
+
+### 总览
+
+如果使用的数据集在MMHuman3D中不受支持，您可以根据这个文档，添加一个新的关键点类型。
+
+下列是MMHuman3D中支持的关键点类型:
+ - agora
+ - coco
+ - coco_wholebody
+ - crowdpose
+ - h36m
+ - human_data
+ - hybrik
+ - lsp
+ - mpi_inf_3dhp
+ - mpii
+ - openpose
+ - penn_action
+ - posetrack
+ - pw3d
+ - smpl
+ - smplx
+
+
+**1. 创建新的关键点类型**
+
+请根据
+[`mmhuman3d/core/conventions/keypoints_mapping/human_data.py`](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/conventions/keypoints_mapping/human_data.py) , 创建一个名为 `NEW_CONVENTION.py` 的新文件。
+该文件中, `NEW_KEYPOINTS` 是一个包含关键点名字和具体顺序的列表。
+
+例如, 想要为`AGORA`数据集创建一个新的关键点类型, `agora.py` 文件应该包含以下项目:
+```
+AGORA_KEYPOINTS = [
+ 'pelvis',
+ 'left_hip',
+ 'right_hip'
+ ...
+]
+```
+
+**2. 寻找`human_data`中的关键点名字**
+
+在MMHuman3D中，不同数据集中具有相同名字的关键点应该对应相同的人体部件。`human_data`类型已经整合了支持的数据集中不同名字的关键点和对应关系。
+
+对于`NEW_KEYPOINTS`中的每一个关键点, 需要进行如下检查:
+
+(1)关健点名称是否存在于[`mmhuman3d/core/conventions/keypoints_mapping/human_data.py`](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/conventions/keypoints_mapping/human_data.py);
+
+(2)关键点是否有相对于`human_data`中相同位置关键点的映射关系。
+
+如果两个条件都满足, 请在`NEW_CONVENTION.py`中保留关键点的名字。
+
+
+**3. 寻找`human_data`中关键点的对应关系**
+
+如果`NEW_KEYPOINTS`中的关键点与`human_data`中不同名字的关键点有相同的对应关系, 例如`NEW_KEYPOINTS`中的`head`对应于`human_data`中的`head_extra`, 将`NEW_KEYPOINTS`中的关键点按照`human_data`的规范重命名, 例如`head` -> `head_extra`。
+
+**4. 在`human_data`中添加新的关键点**
+
+如果新的关键点与`human_data`中的关键点没有对应关系，就需要将其罗列出来，并且在原始名称上加上前缀以作区分，例如`spine_3dhp`。
+
+如有需要的话，我们会对`human_data`进行拓展以匹配新的关键点，但这必须在检查新的关键点没有对应关系，且没有命名冲突的情况下完成。
+
+**5. 初始化新的关键点类型集合**
+
+在[`mmhuman3d/core/conventions/keypoints_mapping/__init__.py`](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/conventions/keypoints_mapping/__init__.py#L8-25)中添加`NEW_CONVENTION.py`的`import`, 并在[KEYPOINTS_FACTORY](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/conventions/keypoints_mapping/__init__.py#L27-52)的字典中添加标识符。
+
+例如, 我们所添加的新的关键点类型为`agora`:
+```
+# 添加 import
+from mmhuman3d.core.conventions.keypoints_mapping import (
+ agora,
+ ...
+)
+
+# 添加到 factory
+KEYPOINTS_FACTORY = {
+ 'agora': agora.AGORA_KEYPOINTS,
+ ...
+}
+```
+
+**6. 将新的关键点类型用于关键点转换**
+
+想要将现有的关键点类型转换为新的类型，可以使用[`mmhuman3d/core/conventions/keypoints_mapping/__init__.py`](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/core/conventions/keypoints_mapping/__init__.py)中的`convert_kps`函数。该函数会产生一个由0,1构成的mask，指示是否应该滤除或者保留。
+
+将`coco`关键点转换为新的关键点:
+```
+ new_kps, mask = convert_kps(smplx_keypoints, src='coco', dst='NEW_CONVENTION')
+```
+
+将新的关键点转换为`human_data`:
+```
+ new_kps, mask = convert_kps(smplx_keypoints, src='NEW_CONVENTION', dst='human_data')
+```
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/getting_started.md b/internlm_langchain/knowledge_base/MMHuman3D/content/getting_started.md
new file mode 100644
index 00000000..c43c636a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/getting_started.md
@@ -0,0 +1,214 @@
+# 开始使用
+
+- [开始](#getting-started)
+ - [安装](#安装)
+ - [数据预处理](#数据预处理)
+ - [人体模型](#人体模型)
+ - [推理 / 演示](#推理-/-演示)
+ - [离线Demo](#离线Demo)
+ - [在线Demo](#在线Demo)
+ - [测试](#测试)
+ - [使用单（多）个GPU进行测试](#使用单（多）个GPU进行测试)
+ - [使用slurm进行测试](#使用slurm进行测试)
+ - [训练](#训练)
+ - [使用单（多）个GPU进行训练](#使用单（多）个GPU进行训练)
+ - [通过slurm进行训练](#通过slurm进行训练)
+ - [更多教程](#更多教程)
+
+## 安装
+
+安装请参考 [install.md](../docs_zh-CN/install.md).
+
+## 数据预处理
+
+数据预处理请参考 [data_preparation.md](../docs_zh-CN/preprocess_dataset.md).
+
+## 人体模型
+
+- 主要使用[SMPL](https://smpl.is.tue.mpg.de/) v1.0.
+ - 可以在[SMPLify](https://smplify.is.tue.mpg.de/)下载neutral model.
+ - 所有的人体模型需要重命名为 `SMPL_{GENDER}.pkl` 格式。
+ 例如, `SMPL_NEUTRAL.pkl` `SMPL_MALE.pkl` `SMPL_FEMALE.pkl` +- [J_regressor_extra.npy](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/J_regressor_extra.npy?versionId=CAEQHhiBgIDD6c3V6xciIGIwZDEzYWI5NTBlOTRkODU4OTE1M2Y4YTI0NTVlZGM1) +- [J_regressor_h36m.npy](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/J_regressor_h36m.npy?versionId=CAEQHhiBgIDE6c3V6xciIDdjYzE3MzQ4MmU4MzQyNmRiZDA5YTg2YTI5YWFkNjRi) +- [smpl_mean_params.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/smpl_mean_params.npz?versionId=CAEQHhiBgICN6M3V6xciIDU1MzUzNjZjZGNiOTQ3OWJiZTJmNThiZmY4NmMxMTM4) + +下载上述所有文件，并按如下结构安排文件夹: + +```text +mmhuman3d +├── mmhuman3d +├── docs +├── tests +├── tools +├── configs +└── data + └── body_models + ├── J_regressor_extra.npy + ├── J_regressor_h36m.npy + ├── smpl_mean_params.npz + └── smpl + ├── SMPL_FEMALE.pkl + ├── SMPL_MALE.pkl + └── SMPL_NEUTRAL.pkl +``` + +## 推理 / 演示 +### 离线Demo +我们提供了用于从图像或视频中估计单人或多人`SMPL`模型参数的演示脚本，运行该脚本可能会用到`MMDetection`和`MMTracking`。通过该脚本进行演示，您只需要从模型库中选择用到的预训练模型(我们目前只支持[HMR](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/hmr/)、 [SPIN](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/spin/)、[VIBE](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/vibe/) 和[PARE](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/pare/), 未来会加入更多的SOTA方法)，并指定少量的参数。 + +以下是一些参数的释义: + +- 如果指定`--output` 和 `--show_path`, 演示脚本会将结果储存在`human_data`中，并且渲染得到的人体mesh。 +- 如果指定`--smooth_type`, 演示脚本会使用特定的方法进行平滑。目前可以选择的平滑方法包括`gaus1d`、`oneeuro`和 `savgol`。 +- 如果指定`--speed_up_type`, 演示脚本会使用特定的方法进行加速处理。目前支持基于学习的方法`deciwatch`, 更多的信息请参考[DeciWatch](../configs/_base_/post_processing/README.md)。 + +对于单人 + +```shell +python demo/estimate_smpl.py \ + ${MMHUMAN3D_CONFIG_FILE} \ + ${MMHUMAN3D_CHECKPOINT_FILE} \ + --single_person_demo \ + --det_config ${MMDET_CONFIG_FILE} \ + --det_checkpoint ${MMDET_CHECKPOINT_FILE} \ + --input_path ${VIDEO_PATH_OR_IMG_PATH} \ + [--show_path ${VIS_OUT_PATH}] \ + [--output ${RESULT_OUT_PATH}] \ + [--smooth_type ${SMOOTH_TYPE}] \ + [--speed_up_type ${SPEED_UP_TYPE}] \ + [--draw_bbox] \ +``` + +例如: +```shell +python demo/estimate_smpl.py \ + configs/hmr/resnet50_hmr_pw3d.py \ + data/checkpoints/resnet50_hmr_pw3d.pth \ + --single_person_demo \ + --det_config demo/mmdetection_cfg/faster_rcnn_r50_fpn_coco.py \ + --det_checkpoint https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \ + --input_path demo/resources/single_person_demo.mp4 \ + --show_path vis_results/single_person_demo.mp4 \ + --output demo_result \ + --smooth_type savgol \ + --speed_up_type deciwatch \ + --draw_bbox +``` + +对于多人 + + +```shell +python demo/estimate_smpl.py \ + ${MMHUMAN3D_CONFIG_FILE} \ + ${MMHUMAN3D_CHECKPOINT_FILE} \ + --multi_person_demo \ + --tracking_config ${MMTRACKING_CONFIG_FILE} \ + --input_path ${VIDEO_PATH_OR_IMG_PATH} \ + [--show_path ${VIS_OUT_PATH}] \ + [--output ${RESULT_OUT_PATH}] \ + [--smooth_type ${SMOOTH_TYPE}] \ + [--speed_up_type ${SPEED_UP_TYPE}] \ + [--draw_bbox] +``` + +例如: +```shell +python demo/estimate_smpl_image.py \ + configs/hmr/resnet50_hmr_pw3d.py \ + data/checkpoints/resnet50_hmr_pw3d.pth \ + --multi_person_demo \ + --tracking_config demo/mmtracking_cfg/deepsort_faster-rcnn_fpn_4e_mot17-private-half.py \ + --input_path demo/resources/multi_person_demo.mp4 \ + --show_path vis_results/multi_person_demo.mp4 \ + --smooth_type savgol \ + --speed_up_type deciwatch \ + [--draw_bbox] + +``` +MMHuman3D的checkpoints文件可以从[model zoo](../docs_zh-CN/model_zoo.md)下载。 +这里我们使用HMR (resnet50_hmr_pw3d.pth)作为示例。 + +### 在线Demo +我们提供一个从相机或者一个指定的视频文件估计SMPL参数的webcam演示脚本。你可以简单的运行下面的命令： +```shell +python demo/webcam_demo.py +``` +以下是一些参数的释义: +- 如果指定`--output`, 演示脚本会将可视化结果储存到对应的文件中。这可能会降低帧率。 +- 如果指定`--synchronous`, 视频的 I/O 和模型的推理在时序上将会对齐. 注意这会降低帧率. +- 如果你想以离线的方式在视频文件上运行webcam演示, 你应该指定`--cam-id=VIDEO_FILE_PATH`. 注意`--synchronous` 在这种情形下应该被设置为 `True`. +- 视频的I/O和模型的推理是异步的运行，而且后者往往需要更多的时间. 为了缓解延时，你可以: + + - 根据显示在左上角的推理延时设置`--display-delay=MILLISECONDS` 来延时视频流. 或者, + + - 设置 `--synchronous=True` 强制视频流和推理结果对齐. 这可能降低视频的帧率。 + + +## 测试 + +我们提供的预训练模型可以参见 [config](https://github.com/open-mmlab/mmhuman3d/tree/main/configs). + +### 使用单（多）个GPU进行测试 + +```shell +python tools/test.py ${CONFIG} --work-dir=${WORK_DIR} ${CHECKPOINT} --metrics=${METRICS} +``` +例如: +```shell +python tools/test.py configs/hmr/resnet50_hmr_pw3d.py --work-dir=work_dirs/hmr work_dirs/hmr/latest.pth --metrics pa-mpjpe mpjpe +``` + +### 使用slurm进行测试 + +如果通过[slurm](https://slurm.schedmd.com/)在集群上使用MMHuman3D, 您可以使用脚本 `slurm_test.sh`进行测试。 + +```shell +./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} ${CONFIG} ${WORK_DIR} ${CHECKPOINT} --metrics ${METRICS} +``` +例如: +```shell +./tools/slurm_test.sh my_partition test_hmr configs/hmr/resnet50_hmr_pw3d.py work_dirs/hmr work_dirs/hmr/latest.pth 8 --metrics pa-mpjpe mpjpe +``` + + +## 训练 + +### 使用单（多）个GPU进行训练 + +```shell +python tools/train.py ${CONFIG_FILE} ${WORK_DIR} --no-validate +``` +例如: 使用单个GPU训练HMR. +```shell +python tools/train.py ${CONFIG_FILE} ${WORK_DIR} --gpus 1 --no-validate +``` + +### 使用slurm进行训练 + +如果通过[slurm](https://slurm.schedmd.com/)在集群上使用MMHuman3D, 您可以使用脚本 `slurm_train.sh`进行训练。 + +```shell +./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR} ${GPU_NUM} --no-validate +``` + +可选参数包括: +- `--resume-from ${CHECKPOINT_FILE}`: 继承之前的权重继续训练。 +- `--no-validate`: 在训练时是否进行测试。 + +例如: 在集群上使用8卡训练HMR。 +```shell +./tools/slurm_train.sh my_partition my_job configs/hmr/resnet50_hmr_pw3d.py work_dirs/hmr 8 --no-validate +``` + +详情请见[slurm_train.sh](https://github.com/open-mmlab/mmhuman3d/tree/main/tools/slurm_train.sh)。 + +## 更多教程 + +- [Camera conventions](../docs_zh-CN/cameras.md) +- [Keypoint conventions](../docs_zh-CN/keypoints_convention.md) +- [Custom keypoint conventions](../docs_zh-CN/customize_keypoints_convention.md) +- [HumanData](../docs_zh-CN/human_data.md) +- [Keypoint visualization](../docs_zh-CN/visualize_keypoints.md) +- [Mesh visualization](../docs_zh-CN/visualize_smpl.md) diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/human_data.md b/internlm_langchain/knowledge_base/MMHuman3D/content/human_data.md new file mode 100644 index 00000000..a866f453 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMHuman3D/content/human_data.md @@ -0,0 +1,287 @@ +## HumanData数据格式 + +### 总览 + +`HumanData`是Python内置字典的子类，主要用于存放包含人体的单视角图像的信息。它具有通用的基础结构，也兼容具有新特性的客制化数据。 +原生的`HumanData`包含`numpy.ndarray`或其他的Python内置的数据结构，但不包含`torch.Tensor`的数据。可以使用`human_data.to()`将其转换为`torch.Tensor`(支持CPU和GPU)。 + +### `Key/Value`的定义：如下是对`HumanData`支持的`Key`和`Value`的描述. + +#### 路径: + +通常包含图片路径，如果数据集有提供额外的深度或者分割图，也可以记录下来。 +- image_path: (N, ), 字符串组成的列表, 每一个元素是图像相对于根目录的路径。 +- segmantation_path (可选): (N, ), 字符串组成的列表, 每一个元素是图像分割图相对于根目录的路径。 +- depth_path (可选): (N, ), 字符串组成的列表, 每一个元素是图像深度图相对于根目录的路径。 + +#### 关键点： + +以下关键点keys如果适用，则应包含在HumanData中。任何一个关键点的key，应存在一个mask，表示其中哪些关键点有效。如`keypoints3d_original`应对应`keypoints3d_original_mask`。 +`HumanData` 中的关键点存储格式为`HUMAN_DATA`, 包含190个关键点。MMHuman3d中提供了很多常用关键点格式的转换（2d及3d均支持）, 详见 [keypoints_convention](../docs_zh-CN/keypoints_convention.md). +- keypoints3d_smpl / keypoints3d_smplx: (N, 190, 4), numpy array, `smplx / smplx`模型的3d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- keypoints3d_original: (N, 190, 4), numpy array, 由数据集本身提供的3d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- keypoints2d_smpl / keypoints2d_smplx: (N, 190, 3), numpy array, `smpl / smplx`模型的2d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- keypoints2d_original: (N, 190, 3), numpy array, 由数据集本身提供的2d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- （mask示例） keypoints2d_smpl_mask: (190, ), numpy array, 表示`keypoints2d_smpl`中关键点是否有效的掩膜。 0表示该位置的关键点在原始数据集中无法找到。 + +#### 检测框： + +身体（smpl），手脸（smplx）的检测框，标注为`[x_min, y_min, width, height, confidence]`，且不应超出图片。 +- bbox_xywh: (N, 5), numpy array, 边界框的置信度, 边界框左下角点的坐标x和y, 边界框的宽w和高h, 置信度得分放置在最后。 +- face_bbox_xywh, lhand_bbox_xywh, rhand_bbox_xywh（可选）： (N, 5), numpy array, 如果数据标注中含有`smplx`, 则应包括这三个key，由smplx2d关键点得出，格式同上。 + +#### 人体模型参数： + +通常以smpl/smplx格式存储。 +- smpl: (1, ), 字典, `keys` 分别为 ['body_pose': numpy array, (N, 23, 3), 'global_orient': numpy array, (N, 3), 'betas': numpy array, (N, 10), 'transl': numpy array, (N, 3)]. +- smplx: (1, ), 字典, `keys` 分别为 ['body_pose': numpy array, (N, 21, 3),'global_orient': numpy array, (N, 3), 'betas': numpy array, (N, 10), 'transl': numpy array, (N, 3), 'left_hand_pose': numpy array, (N, 15, 3), 'right_hand_pose': numpy array, (N, 15, 3), 'expression': numpy array (N, 10), 'leye_pose': numpy array (N, 3), 'reye_pose': (N, 3), 'jaw_pose': numpy array (N, 3)]. + +#### 其它keys + +- config: (), 字符串, 单个数据集的配置的标志。 +- meta: (1, ), 字典, `keys`为数据集中的各种元数据。 +- misc: (1, ), 字典, `keys`为数据集中各种独特设定，也可以由用户自定义。`misc`占用的空间（可以通过`sys.getsizeof(misc)`获取）不能超过6MB。 + +#### `HumanData['misc']`中建议（可能）包含的内容: +Miscellaneous部分中包含了每个数据集的独特设定，包括相机种类，关键点标注来源，检测框来源，是否包含smpl/smplx标注等等，用于便利数据读取。 +`HumanData['misc']`中包含一个dictionary，建议包含的key如下所示： +- kps3d_root_aligned： Bool 描述keypoints3d是否经过root align，建议不进行root_alignment，如果不包含这个key，则默认没有进行过root_aligenment +- flat_hand_mean：Bool 对于smplx标注的数据，应该存在此项，大多数数据集中`flat_hand_mean=False` +- bbox_source：描述检测框的来源，`bbox_soruce='keypoints2d_smpl' or 'keypoints2d_smplx' or 'keypoints2d_original'`，描述检测框是由哪种关键点得出的，或者`bbox_source='provide_by_dataset'`表示检测框由数据集直接给出（比如用其自带检测器生成而不是由关键点推导得出） +- bbox_body_scale: 如果检测框由关键点推导得出，则应包含此项，描述由smpl/smplx/2d_gt关键点推导出的身体检测框的放大比例，建议`bbox_body_scale=1.2` +- bbox_hand_scale, bbox_face_scale: 如果检测框由关键点推导得出，则应包含这两项，描述由smpl/smplx/2d_gt关键点推导出的身体检测框的放大比例，建议`bbox_hand_scale=1.0, bbox_face_scale=1.0` +- smpl_source / smplx_source: 描述smpl/smplx的来源，`'original', 'nerual_annot', 'eft', 'osx_annot', 'cliff_annot'`, 来描述smpl/smnplx是来源于数据集提供，或者其它标注来源 +- cam_param_type: 描述相机参数的种类，`cam_param_type='prespective' or 'predicted_camera' or 'eft_camera'` +- principal_point, focal_length: (1, 2), numpy array，如果数据集中相机参数恒定，则应包含这两项，通常适用于生成数据集。 +- image_shape: (1, 2), numpy array，如果数据集中图片大小恒定，则应包含此项。 + +#### `HumanData['meta']`中建议（可能）包含的内容: +- gender: (N, )， 字符串组成的列表, 每一个元素是smplx模型的性别（中性则不必标注） +- height（width）：(N, )， 字符串组成的列表, 每一个元素是图片的高（或宽），这里不推荐使用`image_shape=(width, height): (N, 2)`，因为有时需要按反顺序读取图片格式。（数据集图片分辨率一致则应标注在`HumanData['misc']`中） +- 其它有标识性的key，若数据集中该key不一致，且会影响keypoints or smpl/smplx，则建议标注，如focal_length与principal_point, focal_length = (N, 2), principal_point = (N, 2) + +#### 关于HumanData的一些说明 + +- 所有数据标注均已从世界坐标转移到opencv相机空间，进行smpl/smplx的相机空间转换可以用 + +```from mmhuman3d.models.body_models.utils import transform_to_camera_frame, batch_transform_to_camera_frame``` + +#### 检查`HumanData`中的`key`. + +在默认的`HumanData`中，只能包含之前描述过`key`。如果无法避免这个问题，还有一个方法。 通过指定`__key_strict__ == False`构建一个`HumanData`实例。 + +```python +human_data = HumanData.new(key_strict=False) +human_data['video_path'] = 'test.mp4' +``` +返回的`HumanData`允许任何客制化的`key`，并在第一次接受新`key`时log一个警告。如果正在使用客制化的`key`，请忽略该警告，在程序结束前它不会再出现。 + +如果您已经构建了一个`HumanData`, 并且想改变`strict`模式, 可以使用`set_key_strict`: + +```python +human_data = HumanData.fromfile('human_data.npz') +key_strict = human_data.get_key_strict() +human_data.set_key_strict(not key_strict) +``` + + + +#### 检查`HumanData`中的`value`. + +只有指定`human_data[key] == value`时，才会检查之前提到过的`value`，相关规范在`HumanData.SUPPORTED_KEYS`中定义。 + +对于每个`value`, 必须在其`key`下指定数据类型: + +```python +'smpl': { + 'type': dict, +}, +``` + +对于类型为`numpy.ndarray`的`value`, 需要指定`shape`和`dim`参数: + +```python +'keypoints3d': { + 'type': np.ndarray, + 'shape': (-1, -1, 4), + # value.ndim==3 value.shape[2]==4 + # value.shape[0:2] is arbitrary. + 'dim': 0 + # dimension 0 marks time(frame index, or second) +}, +``` + +对于不随帧变化的`value`，指定其`dim=-1`以跳过帧检查: + +```python +'keypoints3d_mask': { + 'type': np.ndarray, + 'shape': (-1, ), + 'dim': -1 +}, +``` + +### 数据压缩 + +#### 压缩`mask` + +由于`HUMAN_DATA`的关键点定义整合自不同的数据集，部分关键点缺失是很常见的。使用如下的方式，可以通过`mask`滤除缺失的关键点: + +```python +# keypoints2d_agora 是一个形状为[frame_num, 127, 3]的numpy数组. +# Agora中定义了127个关键点. +keypoints2d_human_data, mask = convert_kps(keypoints2d_agora, 'agora', 'human_data') +# keypoints2d_human_data 是一个形状为[frame_num, 190, 3]的numpy数组. +# mask 是一个形状为[190, ]的numpy数组, 内含了127个1和63个0. +``` + +指定`keypoints2d_mask` 和 `keypoints2d`, 很明显`keypoints2d`中有很多冗余的0: + +```python +human_data = HumanData() +human_data['keypoints2d_mask'] = mask +human_data['keypoints2d'] = keypoints2d_human_data +``` + +调用`compress_keypoints_by_mask()`去掉冗余的0。 该方法会检查所有包含`keypoints`的`key`是否具有相应的`mask`，如果同时存在，就进行压缩: + +```python +human_data.compress_keypoints_by_mask() +``` + +调用`get_raw_value()`获得储存在`HumanData`实例中压缩过的`value`. 当通过`[]`获得`item`时, 将返回用0填充后的关键点: + +```python +keypoints2d_human_data = human_data.get_raw_value('keypoints2d') +print(keypoints2d_human_data.shape) # [frame_num, 127, 3] +keypoints2d_human_data = human_data['keypoints2d'] +print(keypoints2d_human_data.shape) # [frame_num, 190, 3] +``` + +在`keypoints_compressed`模式中, 可以对关键点进行编辑。有两种不同的方式，设置填充数据或直接指定压缩数据: + +```python +padded_keypoints2d = np.zeros(shape=[100, 190, 3]) +human_data['keypoints2d'] = padded_keypoints2d # [frame_num, 190, 3] +compressed_keypoints2d = np.zeros(shape=[100, 127, 3]) +human_data.set_raw_value('keypoints2d', compressed_keypoints2d) # [frame_num, 127, 3] +``` + +当`HumanData`实例处于`keypoints_compressed`模式, 所有关键点的`masks`会被锁定。当您尝试进行修改时, 会log一个警告并且`value`不会被修改。如果需要修改`mask`，使用`decompress_keypoints()`进行解压缩: + +```python +human_data.decompress_keypoints() +``` + +上述特性也适用于其他类似于`keypoints*`和`keypoints*_mask`的`key-value`对。 + +#### 压缩文件 + +调用`dump()` 将`HumanData`压缩成`.npz`文件。 + +`dump`后的`.npz`文件可以使用`load()`进行加载: + +```python +# 保存 +human_data.dump('./dumped_human_data.npz') +# 加载 +another_human_data = HumanData() +another_human_data.load('./dumped_human_data.npz') +``` + +有时`HumanData`太长了，直接进行`dump`会报错。这种情况下，可以调用`dump_by_pickle`和`load_by_pickle`将`HumanData`压缩成`.pkl`文件。 + +#### 压缩`key` + +如果`HumanData`实例不处于`key_strict`模式, 其可能会包含不受支持的项目。调用`pop_unsupported_items()`清除这些项目，以节省空间: + +```python +human_data = HumanData.fromfile('human_data_not_strict.npz') +human_data.pop_unsupported_items() +human_data.set_key_strict(True) +``` + +### 数据选择 + +#### 通过形状进行选择 + +假定`keypoints2d` 是一个`array`，其形状为[200, 190, 3], 只需要最开始的10帧: + +```python +first_ten_frames = human_data.get_value_in_shape('keypoints2d', shape=[10, -1, -1]) +``` + +在一些情况下, 我们需要将`array`扩充成特定的形状: + +```python +# 通过填0将其形状从[200, 190, 3]扩充成[200, 300, 3] +padded_keypoints2d = human_data.get_value_in_shape('keypoints2d', shape=[200, 300, -1]) +# 填充的数值可以被修改 +padded_keypoints2d = human_data.get_value_in_shape('keypoints2d', shape=[200, 300, -1], padding_constant=1) +``` + +#### 通过时间切片进行选择 + +假设在一个`HumanData`实例中有200帧, 只需要中间10至20帧: + +```python +# 所有支持的`value`都会被切片 +sub_human_data = human_data.get_slice(10, 21) +``` + +也可以进行下采样,下面的例子描述了一种选择其33%数据的方法: + +```python +# 选择 [0, 3, 6, 9,..., 198] +sub_human_data = human_data.get_slice(0, 200, 3) +``` + +### 转换为`torch.Tensor` + +之前提到，原生的`HumanData`中包含`numpy.ndarray`或python内置类型的`value`，但`numpy.ndarray`可以轻松转换为`torch.Tensor`: + +```python +# ndarray会被转换成cpu上的Tensor. +# 其他类型的value不会发生变化. +# 返回一个形如HumanData的字典. +dict_of_tensor = human_data.to() +# 也可以转换为GPU上的Tensor +gpu0_device = torch.device('cuda:0') +dict_of_gpu_tensor = human_data.to(gpu0_device) +``` +## MultiHumanData + +MulitHumanData 被设计来支持多人重建。它继承于HumanData。在HumanData中，因为图片和数据是一一对应的，所以我们可以直接索引数据。然而，在MultiHumanData中数据和图像是多对一的关系。 + +MultiHumanData在HumanData的基础上添加一个新的key叫做`frame_range`,它定义如下： + +```python +'frame_range': { + 'type': np.ndarray, + 'shape': (-1, 2), + 'dim': 0 + } +``` + +`frame_range`是和图像一一对应的。 `frame_range`中的每个元素是两个指针，它们指向一个数据区域。 + +假设我们有一个MultiHumanData的实例，我们想索引第i张图像对应的数据。 首先我们用主索引索引`frame_range`，它会返回两个指针，用这两个指针我们就可以索引第i张图像对应的所有数据。 + +``` +image_0 ----> human_0 <--- frame_range[0][0] + - . + - . + --> human_(n-1) <--- frame_range[0][0] + (n-1) + -> human_n <--- frame_range[0][1] + . + . + . + + +image_n ----> human_0 <--- frame_range[n][0] + - . + - . + --> human_(n-1) <--- frame_range[n][0] + (n-1) + -> human_n <--- frame_range[n][1] + +``` diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/install.md b/internlm_langchain/knowledge_base/MMHuman3D/content/install.md new file mode 100644 index 00000000..4464b640 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMHuman3D/content/install.md @@ -0,0 +1,227 @@ +# 安装 + +- [安装](#安装) +- [依赖](#依赖) +- [准备环境](#准备环境) +- [安装 MMHuman3D](#安装-mmhuman3d) +- [从头开始安装的脚本](#从头开始安装的脚本) + +## 依赖 + +- Linux +- ffmpeg +- Python 3.7+ +- PyTorch 1.6.0, 1.7.0, 1.7.1, 1.8.0, 1.8.1, 1.9.0 或 1.9.1. +- CUDA 9.2+ +- GCC 5+ +- PyTorch3D 0.4+ +- [MMCV](https://github.com/open-mmlab/mmcv) (请安装用于GPU的mmcv-full, 要求版本>=1.3.17,<1.6.0) + +Optional: +- [MMPose](https://github.com/open-mmlab/mmpose) (只用于演示) +- [MMDetection](https://github.com/open-mmlab/mmdetection) (只用于演示) +- [MMTracking](https://github.com/open-mmlab/mmtracking) (只用于多人的演示。请安装 mmcls<0.23.1, mmcv-full>=1.3.17,<1.6.0) + +## 准备环境 + +a. 创建conda虚拟环境并激活. + +```shell +conda create -n open-mmlab python=3.8 -y +conda activate open-mmlab +``` + +b. 安装 ffmpeg + +直接使用conda安装ffmpeg + +```shell +conda install ffmpeg +``` + +c. 根据 [官方指导](https://pytorch.org/) ，安装PyTorch和torchvision . +```shell +conda install pytorch={torch_version} torchvision cudatoolkit={cu_version} -c pytorch +``` + +以安装 PyTorch 1.8.0 和 CUDA 10.2为例. +```shell +conda install pytorch=1.8.0 torchvision cudatoolkit=10.2 -c pytorch +``` + +**注意:** 请确保compilation CUDA version和runtime CUDA version相匹配。 +另外， 对于RTX 30系列的显卡， 需要cudatoolkit>=11.0. + +d. 在Linux或者Windows上安装PyTorch3D. + +对于Linux： + +```shell +conda install -c fvcore -c iopath -c conda-forge fvcore iopath -y +conda install -c bottler nvidiacub -y + +conda install pytorch3d -c pytorch3d +``` + +用户也可以参考 [PyTorch3D-install](https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md) 的更多细节。 +然而我们近期的测试显示使用 conda 安装会遇到依赖冲突的问题。 +因此，用户也可选择按照下列步骤从源码安装Pytorch3D。 + +```shell +git clone https://github.com/facebookresearch/pytorch3d.git +cd pytorch3d +pip install . +cd .. +``` + +对于Windows： + +请参考 [官方安装文档](https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md) 。 这里我们提供一个 [例子](https://github.com/open-mmlab/mmhuman3d/pull/199#issue-1274739041) 供用户参考。 +**注意:** 这部分是针对想在Windows平台安装MMHuman3D的用户。 + +运行如下命令测试PyTorch3D是否安装成功: + +```shell +echo "import pytorch3d;print(pytorch3d.__version__); \ + from pytorch3d.renderer import MeshRenderer;print(MeshRenderer);\ + from pytorch3d.structures import Meshes;print(Meshes);\ + from pytorch3d.renderer import cameras;print(cameras);\ + from pytorch3d.transforms import Transform3d;print(Transform3d);"|python + +echo "import torch;device=torch.device('cuda');\ + from pytorch3d.utils import torus;\ + Torus = torus(r=10, R=20, sides=100, rings=100, device=device);\ + print(Torus.verts_padded());"|python +``` + +## 安装 MMHuman3D + +a. 安装 mmcv-full 、 mmpose 、 mmdet 和 mmtrack + +- mmcv-full + +推荐使用如下命令安装mmcv-full. + +对于 CPU: +```shell +pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cpu/{torch_version}/index.html +``` +使用您的pytorch版本号替换`{torch_version}` + +对于 GPU: + ```shell + pip install "mmcv-full>=1.3.17,<=1.5.3" -f https://download.openmmlab.com/mmcv/dist/{cu_version}/{torch_version}/index.html + ``` +使用您的cuda版本号和pytorch版本号替换`{cu_version}`和`{torch_version}` + +以在CUDA 10.2和PyTorch 1.8.0的环境下, 安装mmcv-full为例: +```shell +pip install "mmcv-full>=1.3.17,<=1.5.3" -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html +``` +您可以从 [这里](https://mmcv.readthedocs.io/en/latest/get_started/installation.html) 查看适配于不同CUDA版本和PyTorch版本的MMCV. +更多版本的下载信息，请参考 [openmmlab-download](https://download.openmmlab.com/mmcv/dist/index.html) 。 + +您也可以使用如下命令，从源码编译mmcv + +```shell +git clone https://github.com/open-mmlab/mmcv.git -b v1.5.3 +cd mmcv +MMCV_WITH_OPS=1 pip install -e . # 执行此步骤会安装包含cuda算子的mmcv-full +# 或者运行 pip install -e . # 执行此步骤会安装不包含cuda算子的mmcv +cd .. +``` + +**注意** 如果已经安装了mmcv，您需要先运行`pip uninstall mmcv`。 同时安装了mmcv和mmcv-full，可能会出现`ModuleNotFoundError`。 + +- mmdetection (可选) + +```shell +pip install "mmdet<=2.25.1" +``` + +如果想要修改mmdet的代码，您也可以使用如下命令，从源码构建mmdet： +```shell +git clone https://github.com/open-mmlab/mmdetection.git -b v2.25.1 +cd mmdetection +pip install -r requirements/build.txt +pip install -v -e . +``` + +- mmpose (可选) +```shell +pip install "mmpose<=0.28.1" +``` + +如果您想要修改mmdet的代码，您也可以使用如下命令，从源码构建mmpose： + +```shell +git clone https://github.com/open-mmlab/mmpose.git -b v0.28.1 +cd mmpose +pip install -r requirements.txt +pip install -v -e . +``` + +- mmtracking (可选) + +```shell +pip install "mmcls<=0.23.2" "mmtrack<=0.13.0" +``` + +如果您想要修改mmdet的代码，您也可以使用如下命令，从源码构建mmtracking： + +```shell +git clone https://github.com/open-mmlab/mmtracking.git -b v0.13.0 +cd mmtracking +pip install -r requirements/build.txt +pip install -v -e . # 或者 "python setup.py develop" +``` +b. 克隆mmhuman3d仓库. + +```shell +git clone https://github.com/open-mmlab/mmhuman3d.git +cd mmhuman3d +``` + + +c. 安装依赖项并安装mmhuman3d. + +```shell +pip install -v -e . # 或者 "python setup.py develop" +``` + +## 从头开始安装的脚本 + +```shell +# 安装 conda 环境 +conda create -n open-mmlab python=3.8 -y +conda activate open-mmlab + +# 安装 ffmpeg +conda install ffmpeg + +# 安装 PyTorch +conda install pytorch==1.8.0 torchvision cudatoolkit=10.2 -c pytorch -y + +# 安装 PyTorch3D +conda install -c fvcore -c iopath -c conda-forge fvcore iopath -y +conda install -c bottler nvidiacub -y +conda install pytorch3d -c pytorch3d -y +# 在遇到依赖冲突的情况下也可使用从源码中安装 +# git clone https://github.com/facebookresearch/pytorch3d.git +# cd pytorch3d +# pip install . +# cd .. + +# 安装 mmcv-full +pip install "mmcv-full>=1.3.17,<1.6.0" -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html + +# 可选: 安装 mmdetection，mmpose 及 mmtracking +pip install "mmdet<=2.25.1" +pip install "mmpose<=0.28.1" +pip install "mmcls<=0.23.2" "mmtrack<=0.13.0" + +# 安装 mmhuman3d +git clone https://github.com/open-mmlab/mmhuman3d.git +cd mmhuman3d +pip install -v -e . +``` diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/keypoints_convention.md b/internlm_langchain/knowledge_base/MMHuman3D/content/keypoints_convention.md new file mode 100644 index 00000000..141f0fee --- /dev/null +++ b/internlm_langchain/knowledge_base/MMHuman3D/content/keypoints_convention.md @@ -0,0 +1,377 @@ +# 关键点类型 + +## 总览 + +MMHuamn3D中的关键点类型整合了各种常用数据集中不同关键点的定义。由于标注数据的过程不尽相同，不同数据集中具有相同名字的关键点可能会对应不同的身体部位。相对的，拥有不同名字的关键点可能对应相同的身体部位。 +为了统一不同数据集中不同关键点的对应关系，我们采用`human_data`结构作为转换和存储关键点的基本类型。 + +## 使用方法 + +### 不同类型之间的转换 + +使用 `convert_kps` 函数可以转换不同数据集中的关键点。 + +为了将`human_data`转换为`coco`的格式，需要指定源类型和目标类型。 + + +```python +from mmhuman3d.core.conventions.keypoints_mapping import convert_kps + +keypoints_human_data = np.zeros((100, 190, 3)) +keypoints_coco, mask = convert_kps(keypoints_human_data, src='human_data', dst='coco') +assert mask.all()==1 +``` + +如果目标类型是源类型的子集合，输出的`mask`应该全为1。没有对应关系的关键点的置信度会被设置为0, 可以使用`mask`作为关键点的置信度。 + +### 通过置信度进行转换 + +如果获得了关键点的置信度，可以使用原始`mask`对其进行标记，然后将信息更新为返回的`mask`。例如，想要将`smpl`的关键点转换为`coco`的关键点，并且已知`left_shoulder`被遮挡。想要在转换过程中继承该信息，可以像如下这样设置原始`mask`并且转换为`coco`类型: + +```python +import numpy as np +from mmhuman3d.core.conventions.keypoints_mapping import KEYPOINTS_FACTORY, convert_kps + +keypoints = np.zeros((1, len(KEYPOINTS_FACTORY['smpl']), 3)) +confidence = np.ones((len(KEYPOINTS_FACTORY['smpl']))) + +# 假设 'left_shoulder' 是无效的. +confidence[KEYPOINTS_FACTORY['smpl'].index('left_shoulder')] = 0 + +_, conf_coco = convert_kps( + keypoints=keypoints, confidence=confidence, src='smpl', dst='coco') +_, conf_coco_full = convert_kps( + keypoints=keypoints, src='smpl', dst='coco') + +assert conf_coco[KEYPOINTS_FACTORY['coco'].index('left_shoulder')] == 0 +conf_coco[KEYPOINTS_FACTORY['coco'].index('left_shoulder')] = 1 +assert (conf_coco == conf_coco_full).all() +``` + +`mask`表示有效信息，其`dtype`为`uint8`，同时关键点的置信度范围为0到1。 +例如，想要将`smpl`的关键点转换为`coco`的关键点, 并且已知`left_shoulder`被遮挡。 + +```python +confidence = np.ones((len(KEYPOINTS_FACTORY['smpl']))) +confidence[KEYPOINTS_FACTORY['smpl'].index('left_shoulder')] = 0.5 +kp_smpl = np.concatenate([kp_smpl, confidence], -1) +kp_smpl_converted, mask = convert_kps(kp_smpl, src='smpl', dst='coco') +new_confidence = kp_smpl_converted[..., 2:] +assert new_confidence[KEYPOINTS_FACTORY['smpl'].index('left_shoulder')] == 0.5 +``` + +## 支持的种类 + + +以下是支持的关键点种类: + - [AGORA](#agora) + - [COCO](#coco) + - [COCO-WHOLEBODY](#coco-wholebody) + - [CrowdPose](#crowdpose) + - [GTA-Human](#gta-human) + - [Human3.6M](#human36m) + - human_data + - [HybrIK](#hybrik) + - [LSP](#lsp) + - [MPI-INF-3DHP](#mpi-inf-3dhp) + - [MPII](#mpii) + - openpose + - [PennAction](#pennaction) + - [PoseTrack18](#posetrack18) + - [PW3D](#pw3d) + - [SMPL](#smpl) + - [SMPL-X](#smplx) + + +### HUMANDATA + +`HumanData` 中的前 144 个关键点对应于 `SMPL-X` 中的关键点。后缀为`_extra`的关键点是指从`Jregressor_extra`获得的关键点。 后缀为`_openpose`的关键点是指从`OpenPose`预测中获得的关键点。 + +`MPI-INF-3DHP`、`Human3.6M` 和 `Posetrack` 中有几个关键点具有相同的名称，但在含义上与 `SMPL-X` 中的关键点不同。 因此，我们添加了一个额外的后缀`head_h36m`来区分这些关键点。 + +### AGORA + + \
+ --root_path data/datasets \
+ --output_path data/preprocessed_datasets
+```
+
+使用时，请指定具体的`dataset-name`.
+
+训练HMR算法，需要如下的数据集
+ - [COCO](#coco)
+ - [Human3.6M](#human36m)
+ - [Human3.6M Mosh](#human36m-mosh)
+ - [MPI-INF-3DHP](#mpi-inf-3dhp)
+ - [MPII](#mpii)
+ - [LSP](#lsp)
+ - [LSPET](#lspet)
+ - [PW3D](#pw3d)
+
+使用如下的数据集名称替换`dataset-names`进行数据转换:
+```
+coco, pw3d, mpii, mpi_inf_3dhp, lsp_original, lsp_extended, h36m
+```
+
+**或者**, 您可以下载处理好的.npz文件:
+- [cmu_mosh.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/cmu_mosh.npz?versionId=CAEQHhiBgIDoof_37BciIDU0OGU0MGNhMjAxMjRiZWI5YzdkMWEzMzc3YzBiZDM2)
+- [coco_2014_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/coco_2014_train.npz?versionId=CAEQHhiBgICUrvbS6xciIDFmZmFhMDk5OGQ3YzQ5ZDE5NzJkMGQxNzdmMmQzZDdi)
+- [h36m_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/h36m_train.npz?versionId=CAEQHhiBgMDrrfbS6xciIGY2NjMxMjgwMWQzNjRkNWJhYTNkZTYyYWUxNWQ4ZTE5)
+- [lsp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/lsp_train.npz?versionId=CAEQHhiBgICnq_bS6xciIDU4ZTRhMDIwZTBkZjQ1YTliYTY0NGFmMDVmOGVhZjMy)
+- [lspet_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/lspet_train.npz?versionId=CAEQHhiBgICXrPbS6xciIDVkZGNmYWZjODlmMzQ2YjNhMjhlNmJmMzU2MjM4Yzg4)
+- [mpi_inf_3dhp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/mpi_inf_3dhp_train.npz?versionId=CAEQHhiBgMD3q_bS6xciIGQwYjc4NTRjYTllMzRkODU5NTNiZDQyOTBlYmRhODg5)
+- [mpii_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/mpii_train.npz?versionId=CAEQHhiBgIDhq_bS6xciIDEwMmE0ZDc0NWI1NjQ2NWZhYTA5ZjEyODBiNWFmODg1)
+- [pw3d_test.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/pw3d_test.npz?versionId=CAEQHhiBgMDaq_bS6xciIGVjY2YzZGJkNjNmMjQ2NGU4OTZkYjMwMjhhYWM1Y2I0)
+
+由于许可证的限制，我们无法上传`h36m_mosh_train.npz`。但是我们提供了相关的转换工具, 如果您拥有原始的`mosh`数据, 您可以参考[Human3.6M Mosh](#human36m-mosh)。
+
+处理好的数据集应该具有如下的结构:
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── datasets
+ └── preprocessed_datasets
+ ├── coco_2014_train.npz
+ ├── h36m_train.npz (h36m_mosh_train.npz)
+ ├── lspet_train.npz
+ ├── lsp_train.npz
+ ├── mpi_inf_3dhp_train.npz
+ ├── mpii_train.npz
+ └── pw3d_test.npz
+```
+
+训练SPIN算法, 需要如下的数据集:
+ - [COCO](#coco)
+ - [Human3.6M](#human36m)
+ - [Human3.6M Mosh](#human36m-mosh)
+ - [MPI-INF-3DHP](#mpi-inf-3dhp)
+ - [MPII](#mpii)
+ - [LSP](#lsp)
+ - [LSPET](#lspet)
+ - [PW3D](#pw3d)
+ - [SPIN](#spin)
+
+
+使用如下的数据集名称替换`dataset-names`进行数据转换:
+```
+spin, h36m
+```
+
+**或者**, 您可以先下载处理好的.npz文件:
+- [spin_coco_2014_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/spin_coco_2014_train.npz?versionId=CAEQHhiBgICb6bfT6xciIGM2NmNmZDYyNDMxMDRiNTVhNDk3YzY1N2Y2ODdlMTAy)
+- [h36m_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/h36m_train.npz?versionId=CAEQHhiBgMDrrfbS6xciIGY2NjMxMjgwMWQzNjRkNWJhYTNkZTYyYWUxNWQ4ZTE5)
+- [spin_lsp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/spin_lsp_train.npz?versionId=CAEQHhiBgIDu57fT6xciIDQ0ODAzNjUyNjJkMzQyNzQ5Y2IzNGNhOTZmZGI2NzBm)
+- [spin_lspet_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/spin_lspet_train.npz?versionId=CAEQHhiBgMCe6LfT6xciIDc3NzZiYzA1ZGJkYzQwNzRhYjg3ZDMwYTdjZDZmNTAw)
+- [spin_mpi_inf_3dhp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/spin_mpi_inf_3dhp_train.npz?versionId=CAEQHhiBgMCV6LfT6xciIDliYTJhM2FkNDkyYjRiOWFiYTUwOTk0MGRlNThlZWRk)
+- [spin_mpii_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/spin_mpii_train.npz?versionId=CAEQHhiBgMDz57fT6xciIGJjMzAwMDdlYTBmMTQ0MDg4ZGE4YjhiZGNkNWQwZmM1)
+- [spin_pw3d_test.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/spin_pw3d_test.npz?versionId=CAEQHhiBgMCL6LfT6xciIGUxNjY3OTBiODU5ZDQxODliYTQ4NzU0OGVjMzJkYmRm)
+
+由于许可证的限制，我们无法上传`h36m_mosh_train.npz`。但是我们提供了相关的转换工具, 如果您拥有原始的`mosh`数据, 您可以参考[Human3.6M Mosh](#human36m-mosh)。
+
+处理好的数据集应该具有如下的结构:
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── datasets
+ └── preprocessed_datasets
+ ├── spin_coco_2014_train.npz
+ ├── h36m_train.npz (h36m_mosh_train.npz)
+ ├── spin_lsp_train.npz
+ ├── spin_lspet_train.npz
+ ├── spin_mpi_inf_3dhp_train.npz
+ ├── spin_mpii_train.npz
+ └── spin_pw3d_test.npz
+```
+
+训练VIBE算法, 需要如下的数据集:
+ - [MPI-INF-3DHP](#mpi-inf-3dhp)
+ - [PW3D](#pw3d)
+
+数据转换暂时不可用.
+
+**或者**, 您可以先下载处理好的.npz文件:
+- [vibe_insta_variety.npz](https://pjlab-my.sharepoint.cn/:u:/g/personal/openmmlab_pjlab_org_cn/EYnlkp-69NBNlXDH-5ELZikBXDbSg8SZHqmdSX_3hK4EYg?e=QUl5nI)
+- [vibe_mpi_inf_3dhp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/vibe_mpi_inf_3dhp_train.npz?versionId=CAEQHhiBgICTnq3U6xciIGUwMTc5YWQ2MjNhZDQ3NGE5MmYxOWJhMGQxMTcwNTll)
+- [vibe_pw3d_test.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/vibe_pw3d_test.npz?versionId=CAEQHhiBgMD5na3U6xciIGQ4MmU0MjczYTYzODQ1NDQ5M2JiNzY1N2E5MTNlOWY5)
+
+
+处理好的数据集应该具有如下的结构:
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── datasets
+ └── preprocessed_datasets
+ ├── vibe_insta_variety.npz
+ ├── vibe_mpi_inf_3dhp_train.npz
+ └── vibe_pw3d_test.npz
+```
+
+训练HybrIK算法, 需要如下的数据集:
+ - [HybrIK](#hybrik)
+ - [COCO](#coco)
+ - [Human3.6M](#human36m)
+ - [MPI-INF-3DHP](#mpi-inf-3dhp)
+ - [PW3D](#pw3d)
+
+使用如下的数据集名称替换`dataset-names`进行数据转换:
+```
+h36m_hybrik, pw3d_hybrik, mpi_inf_3dhp_hybrik, coco_hybrik
+```
+
+**或者**, 您可以先下载处理好的.npz文件:
+- [hybriK_coco_2017_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/hybrik_coco_2017_train.npz?versionId=CAEQHhiBgMDA6rjT6xciIDE3N2FiZDkxYTkyZDRjN2ZiYjc1ODQ2YTc5NjY0ZmFl)
+- [hybrik_h36m_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/hybrik_h36m_train.npz?versionId=CAEQHhiBgIC_iLjT6xciIGE4NmQ5YzUxMzY0ZjQ0Y2U5MWFkOTkwNmIwMGI4NTNm)
+- [hybrik_mpi_inf_3dhp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/hybrik_mpi_inf_3dhp_train.npz?versionId=CAEQHhiBgICogLjT6xciIDQwYzRlYTVlOTE0YTQ4ZDRhYTljOGRkZDc1MDhjNDgy)
+- [hybrik_pw3d_test.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/hybrik_pw3d_test.npz?versionId=CAEQHhiBgMCO8LfT6xciIDhjMDFhOTFmZjY4MDQ4MWI4MzVmODYyYTc1NTYwNjA1)
+
+
+处理好的数据集应该具有如下的结构:
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── datasets
+ └── preprocessed_datasets
+ ├── hybriK_coco_2017_train.npz
+ ├── hybrik_h36m_train.npz
+ ├── hybrik_mpi_inf_3dhp_train.npz
+ └── hybrik_pw3d_test.npz
+```
+
+训练PARE算法, 需要如下的数据集:
+ - [Human3.6M](#human36m)
+ - [Human3.6M Mosh](#human36m-mosh)
+ - [MPI-INF-3DHP](#mpi-inf-3dhp)
+ - [EFT-COCO](#EFT)
+ - [EFT-MPII](#EFT)
+ - [EFT-LSPET](#EFT)
+ - [PW3D](#pw3d)
+
+
+使用如下的数据集名称替换`dataset-names`进行数据转换:
+```
+h36m, coco, mpii, lspet, mpi-inf-3dhp, pw3d
+```
+
+**或者**, 您可以先下载处理好的.npz文件:
+- [h36m_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/h36m_train.npz?versionId=CAEQHhiBgMDrrfbS6xciIGY2NjMxMjgwMWQzNjRkNWJhYTNkZTYyYWUxNWQ4ZTE5)
+- [mpi_inf_3dhp_train.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/mpi_inf_3dhp_train.npz?versionId=CAEQHhiBgMD3q_bS6xciIGQwYjc4NTRjYTllMzRkODU5NTNiZDQyOTBlYmRhODg5)
+- [eft_mpii.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/eft_mpii.npz?versionId=CAEQOhiBgMCXlty_gxgiIDYxNDc5YTIzZjBjMDRhMGM5ZjBiZmYzYjFjMTU1ZTRm)
+- [eft_lspet.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/eft_lspet.npz?versionId=CAEQOhiBgMC339u_gxgiIDZlNzk1YjMxMWRmMzRkNWJiNjg1OTI2Mjg5OTA1YzJh
+)
+- [eft_coco_all.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/eft_coco_all.npz?versionId=CAEQOhiBgID3iuS_gxgiIDgwYzU4NTc3ZWRkNDQyNGJiYzU4MGViYTFhYTFmMmUx)
+- [pw3d_test.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/pw3d_test.npz?versionId=CAEQHhiBgMDaq_bS6xciIGVjY2YzZGJkNjNmMjQ2NGU4OTZkYjMwMjhhYWM1Y2I0)
+
+
+处理好的数据集应该具有如下的结构:
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── datasets
+ └── preprocessed_datasets
+ ├── h36m_mosh_train.npz
+ ├── h36m_train.npz
+ ├── mpi_inf_3dhp_train.npz
+ ├── eft_mpii.npz
+ ├── eft_lspet.npz
+ ├── eft_coco_all.npz
+ └── pw3d_test.npz
+```
+
+## 文件夹结构
+
+### AGORA
+
+
+
+ `frame_list` > `origin_frames`。
+ 如果背景图片过大，应该指定`read_frames_batch` 为 `True`，以减轻输入输出的负担。如果视频的帧数大于等于500，上述设置会在代码中自动完成。
+
+- **smpl模型的pose和顶点:**
+ 可以采用以下两种方式传入smpl模型的mesh信息:
+ 1). 传入`poses`、 `betas`(可选)、 `transl`(可选) 和 `gender`(可选)。
+ 2). 也可以直接传入`verts`。如果采用传入`verts`的方式，由于需要获得`faces`，您需要指定`body_model` 或 `model_path`。
+ 优先级顺序为`verts` > (`poses` & `betas` & `transl` & `gender`)
+ 3). 对于多人的重建，您需要指定一个额外的维度`num_person`, 表示人的数量。例如, smpl模型的`verts` 的形状为 (num_frame, num_person, 6890, 3), smpl模型的`poses`参数的形状为 (num_frame, num_person, 72), smpl模型的`betas`参数的形状为 (num_frame, num_person, 10), vibe的`pred_cam` 的形状为 (num_frame, num_person, 3)。由于相机矩阵`K`, `R`和`T`是适用于每一帧的，上述操作并不会对它们造成影响。
+
+- **身体模型:**
+ 有两种传入人体模型的方式:
+ 1). 传入包含与`build_body_model`相同配置的字典`body_model_config`。
+ 2). 直接传入`body_model`。优先级顺序为`body_model` > (`model_path` & `model_type` & `gender`)。
+
+- **输出路径:**
+ 输出路径可以为视频文件(类型为`None` 或 `str`)或图像文件夹的路径(类型为`str`)。
+ 1). 如果输出路径指定为`None`, 不会写入输出文件。
+ 2). 如果输出路径指定为`xxx.mp4`, 将还会写入一个视频。请确保有足够的空间用于存放时序图像，这些图像会自动删除。
+ 3). 如果输出路径指定为图像文件夹`xxx/`, 将会创建一个文件夹，并将图像存放在文件夹里面。
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMHuman3D/vector_store/index.faiss
new file mode 100644
index 00000000..4f38cfcc
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMHuman3D/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/branches.md b/internlm_langchain/knowledge_base/MMOCR/content/branches.md
new file mode 100644
index 00000000..1d7f8d2f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/branches.md
@@ -0,0 +1,38 @@
+# 分支迁移
+
+在早期阶段，MMOCR 有三个分支：`main`、`1.x` 和 `dev-1.x`。随着 MMOCR 1.0.0 正式版的发布，我们也重命名了其中一些分支，下面提供了新旧分支的对照。
+
+- `main` 分支包括了 MMOCR 0.x（例如 v0.6.3）的代码。现在已经被重命名为 `0.x`。
+- `1.x` 包含了 MMOCR 1.x（例如 1.0.0rc6）的代码。现在它是 `main` 分支的别名，会在 2023 的年中删除。
+- `dev-1.x` 是 MMOCR 1.x 的开发分支。现在保持不变。
+
+有关分支的更多信息，请查看[分支](../notes/branches.md)。
+
+## 升级 `main` 分支时解决冲突
+
+对于希望从旧 `main` 分支（包含 MMOCR 0.x 代码）升级的用户，代码可能会导致冲突。要避免这些冲突，请按照以下步骤操作：
+
+1. 请 commit 在 `main` 上的所有更改（若有），并备份您当前的 `main` 分支。
+
+ ```bash
+ git checkout main
+ git add --all
+ git commit -m 'backup'
+ git checkout -b main_backup
+ ```
+
+2. 从远程存储库获取最新更改。
+
+ ```bash
+ git remote add openmmlab git@github.com:open-mmlab/mmocr.git
+ git fetch openmmlab
+ ```
+
+3. 通过运行 `git reset --hard openmmlab/main` 将 `main` 分支重置为远程存储库上的最新 `main` 分支。
+
+ ```bash
+ git checkout main
+ git reset --hard openmmlab/main
+ ```
+
+按照这些步骤，您可以成功升级您的 `main` 分支。
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/code.md b/internlm_langchain/knowledge_base/MMOCR/content/code.md
new file mode 100644
index 00000000..ee63dd95
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/code.md
@@ -0,0 +1,151 @@
+# 代码结构变动
+
+MMOCR 为了兼顾文本检测、识别和关键信息提取等任务，在初版设计时存在许多欠缺考虑的地方。在本次 1.0 版本的升级中，MMOCR 同步提出了新的模型架构，旨在尽量与 OpenMMLab 整体的设计对齐，且在算法库内部达成结构上的统一。虽然本次升级并非完全后向兼容，但所有的变动都是有迹可循的。因此，我们在本章节总结出了开发者可能会关心的改动，供有需要的用户参考。
+
+## 整体改动
+
+MMOCR 0.x 存在着对模块功能边界定义不清晰的问题。在 MMOCR 1.0 中，我们重构了模型模块的设计，并定义了它们的模块边界。
+
+- 考虑到方向差异过大，MMOCR 1.0 中取消了对命名实体识别的支持。
+
+- 模型中计算损失（loss）的部分模块被抽象化为 Module Loss，转换原始标注为损失目标（loss target）的功能也被包括在内。另一个模块抽象 Postprocessor 则负责在预测时解码模型原始输出为对应任务的 `DataSample`。
+
+- 所有模型的输入简化为包含图像原始特征的 `inputs` 和图片元信息的 `List[DataSample]`。输出格式也得到统一，训练时是包含 loss 的字典，测试时的输出为包含预测结果的对应任务的 [`DataSample`](<>)。
+
+- Module Loss 来源于 0.x 版本中实现与单个模型强相关的 `XXLoss` 类，它们在 1.0 中均被统一重命名为`XXModuleLoss`的形式（如`DBLoss` 被重命名为 `DBModuleLoss`）, `head` 传入的 loss 配置参数名也从 `loss` 改为 `module_loss`。
+
+- 与模型实现无关的通用损失类名称保持 `XXLoss` 的形式，并放置于 `mmocr/models/common/losses` 下，如 [`MaskedBCELoss`](mmocr.models.common.losses.MaskedBCELoss)。
+
+- `mmocr/models/common/losses` 下的改动：0.x 中 `DiceLoss` 被重名为 [`MaskedDiceLoss`](mmocr.models.common.losses.MaskedDiceLoss)。`FocalLoss` 被移除。
+
+- 增加了起源于 label converter 的 Dictionary 模块，它会在文本识别和关键信息提取任务中被用到。
+
+## 文本检测
+
+### 关键改动（太长不看版）
+
+- 旧版的模型权重仍然适用于新版，但需要将权重字典 `state_dict` 中以 `bbox_head` 开头的字段重命名为 `det_head`。
+
+- 计算 target 有关的变换 `XXTargets` 被转移到了 `XXModuleLoss` 中。
+
+### SingleStageTextDetector
+
+- 原本继承链为 `mmdet.BaseDetector->SingleStageDetector->SingleStageTextDetector`，现在改为直接继承自 `BaseDetector`, 中间的 `SingleStageDetector` 被删除。
+
+- `bbox_head` 改名为 `det_head`。
+
+- `train_cfg`、`test_cfg`和`pretrained`字段被移除。
+
+- `forward_train()` 与 `simple_test()` 分别被重构为 `loss()` 与 `predict()` 方法。其中 `simple_test()` 中负责将模型原始输出拆分并输入 `head.get_bounary()` 的部分被整合进了 `BaseTextDetPostProcessor` 中。
+
+- `TextDetectorMixin` 中只实现了 `show_result()`方法，实现与 `TextDetLocalVisualizer` 重合，因此已经被移除。
+
+### Head
+
+- `HeadMixin` 为`XXXHead` 在 0.x 版本中必须继承的基类，现在被 `BaseTextDetHead` 代替。里面的 `get_boundary()` 和 `resize_boundary()` 方法被重写为 `BaseTextDetPostProcessor` 的 `__call__()` 和 `rescale()` 方法。
+
+### ModuleLoss
+
+- 文本检测中特有的数据变换 `XXXTargets` 全部移动到 `XXXModuleLoss._get_target_single` 中，与生成 target 相关的配置不再在数据流水线（pipeline）中设置，转而在 `XXXLoss` 中被配置。例如，`DBNetTargets` 的实现被移动到 `DBModuleLoss._get_target_single()`中，而用户可以通过设置 `DBModuleLoss` 的初始化参数来控制损失目标的生成。
+
+### Postprocessor
+
+- 原本的 `XXXPostprocessor.__call__()` 中的逻辑转移到重构后的 `XXXPostprocessor.get_text_instances()` 。
+
+- `BasePostprocessor` 重构为 `BaseTextDetPostProcessor`，此基类会将模型输出的预测结果拆分并逐个进行处理，并支持根据 `scale_factor` 自动缩放输出的多边形（polygon）或界定框（bounding box）。
+
+## 文本识别
+
+### 关键改动（太长不看版）
+
+- 由于字典序发生了变化，且存在部分模型架构上的 bug 被修复，旧版的识别模型权重已经不再能直接应用于 1.0 中，我们将会在后续为有需要的用户推出迁移脚本教程。
+
+- 0.x 版本中的 SegOCR 支持暂时移除，TPS-CRNN 会在后续版本中被支持。
+
+- 测试时增强（test time augmentation）在此版本中暂未支持，但将会在后续版本中更新。
+
+- Label converter 模块被移除，里面的功能被拆分至 Dictionary, ModuleLoss 和 Postprocessor 模块中。
+
+- 统一模型中对 `max_seq_len` 的定义为模型的原始输出长度。
+
+### Label Converter
+
+- 原有的 label converter 存在拼写错误 (label convertor)，我们通过删除掉这个类规避了这个问题。
+
+- 负责对字符/字符串与数字索引互相转换的部分被提取至 [`Dictionary`](mmocr.models.common.Dictionary) 类中。
+
+- 在旧版本中，不同的 label converter 会有不一样的特殊字符集和字符序。在 0.x 版本中，字符序如下：
+
+ | Converter | 字符序 |
+ | ------------------------------- | ----------------------------------------- |
+ | `AttnConvertor`, `ABIConvertor` | ``, ``, ``, characters |
+ | `CTCConvertor` | ``, ``, characters |
+
+在 1.0 中，我们不再以任务为边界设计不同的字典和字符序，取而代之的是统一了字符序的 Dictionary，其字符序为 characters, \, \, \。`CTCConvertor` 中 \ 被等价替换为 \。
+
+- `label_convertor` 中原本支持三种方式初始化字典：`dict_type`、`dict_file` 和 `dict_list`，现在在 `Dictionary` 中被简化为 `dict_file` 一种。同时，我们也把原本在 `dict_type` 中支持的字典格式转化为现在 `dicts/` 目录下的预设字典文件。对应映射如下：
+
+ | MMOCR 0.x: `dict_type` | MMOCR 1.0: 字典路径 |
+ | ---------------------- | -------------------------------------- |
+ | DICT90 | dicts/english_digits_symbols.txt |
+ | DICT91 | dicts/english_digits_symbols_space.txt |
+ | DICT36 | dicts/lower_english_digits.txt |
+ | DICT37 | dicts/lower_english_digits_space.txt |
+
+- `label_converter` 中 `str2tensor()` 的实现被转移到 `ModuleLoss.get_targets()` 中。下面的表格列出了旧版与新版方法实现的对应关系。注意，新旧版的实现并非完全一致。
+
+ | MMOCR 0.x | MMOCR 1.0 | 备注 |
+ | --------------------------------------------------------- | --------------------------------------- | -------------------------------------------- |
+ | `ABIConvertor.str2tensor()`, `AttnConvertor.str2tensor()` | `BaseTextRecogModuleLoss.get_targets()` | 原本两个类中的实现存在的差异在新版本中被统一 |
+ | `CTCConvertor.str2tensor()` | `CTCModuleLoss.get_targets()` | |
+
+- `label_converter` 中 `tensor2idx()` 的实现被转移到 `Postprocessor.get_single_prediction()` 中。下面的表格列出了旧版与新版方法实现的对应关系。注意，新旧版的实现并非完全一致。
+
+ | MMOCR 0.x | MMOCR 1.0 |
+ | --------------------------------------------------------- | ------------------------------------------------ |
+ | `ABIConvertor.tensor2idx()`, `AttnConvertor.tensor2idx()` | `AttentionPostprocessor.get_single_prediction()` |
+ | `CTCConvertor.tensor2idx()` | `CTCPostProcessor.get_single_prediction()` |
+
+## 关键信息提取
+
+### 关键改动（太长不看版）
+
+- 由于模型的输入发生了变化，旧版模型的权重已经不再能直接应用于 1.0 中。
+
+### KIEDataset & OpensetKIEDataset
+
+- 读取数据的部分被简化到 `WildReceiptDataset` 中。
+
+- 对节点和边作额外处理的部分被转移到了 `LoadKIEAnnotation` 中。
+
+- 使用字典对文本进行转化的部分被转移到了 `SDMGRHead.convert_text()` 中，使用 `Dictionary` 实现。
+
+- 计算文本框之间关系的部分`compute_relation()` 被转移到 `SDMGRHead.compute_relations()` 中，在模型内进行。
+
+- 评估模型表现的部分被简化为 `F1Metric`。
+
+- `OpensetKIEDataset` 中处理模型边输出的部分被整理到 `SDMGRPostProcessor`中。
+
+### SDMGR
+
+- `show_result()` 被整合到 `KIEVisualizer` 中。
+
+- `forward_test()` 中对输出进行后处理的部分被整理到 `SDMGRPostProcessor`中。
+
+## Utils 变动
+
+原本散布在各处的功能函数现已被统一归类在 `mmocr/utils/` 下。以下为该目录下各文件的作用域：
+
+- bbox_utils.py：四边界定框（bounding box）有关的功能函数。
+- check_argument.py：检查参数类型的功能函数。
+- collect_env.py：收集运行环境的功能函数。
+- data_converter_utils.py：用于数据集转换的功能函数。
+- fileio.py：输入/输出有关的功能函数。
+- img_utils.py：处理图片的功能函数。
+- mask_utils.py：与掩码有关的功能函数。
+- ocr.py：用于 MMOCR 推理的功能函数。
+- parsers.py：解码文件的功能函数。
+- polygon_utils.py：多边形的功能函数。
+- setup_env.py：存放初始化 MMOCR 的功能函数。
+- string_utils.py：存放字符串的功能函数。
+- typing.py：存放 MMOCR 中常用数据类型的缩写。
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/config.md b/internlm_langchain/knowledge_base/MMOCR/content/config.md
new file mode 100644
index 00000000..fd16af58
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/config.md
@@ -0,0 +1,719 @@
+# 配置文件
+
+MMOCR 主要使用 Python 文件作为配置文件。其配置文件系统的设计整合了模块化与继承的思想，方便用户进行各种实验。
+
+## 常见用法
+
+```{note}
+本小节建议结合 {external+mmengine:doc}`MMEngine: 配置(Config) ` 中的初级用法共同阅读。
+```
+
+MMOCR 最常用的操作为三种：配置文件的继承，对 `_base_` 变量的引用以及对 `_base_` 变量的修改。对于 `_base_` 的继承与修改, MMEngine.Config 提供了两种语法，一种是针对 Python，Json， Yaml 均可使用的操作；另一种则仅适用于 Python 配置文件。在 MMOCR 中，我们**更推荐使用只针对Python的语法**，因此下文将以此为基础作进一步介绍。
+
+这里以 `configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py` 为例，说明常用的三种用法。
+
+```Python
+_base_ = [
+ '_base_dbnet_resnet18_fpnc.py',
+ '../_base_/datasets/icdar2015.py',
+ '../_base_/default_runtime.py',
+ '../_base_/schedules/schedule_sgd_1200e.py',
+]
+
+# dataset settings
+icdar2015_textdet_train = _base_.icdar2015_textdet_train
+icdar2015_textdet_train.pipeline = _base_.train_pipeline
+icdar2015_textdet_test = _base_.icdar2015_textdet_test
+icdar2015_textdet_test.pipeline = _base_.test_pipeline
+
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=icdar2015_textdet_train)
+
+val_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=icdar2015_textdet_test)
+```
+
+### 配置文件的继承
+
+配置文件存在继承的机制，即一个配置文件 A 可以将另一个配置文件 B 作为自己的基础并直接继承其中的所有字段，从而避免了大量的复制粘贴。
+
+在 dbnet_resnet18_fpnc_1200e_icdar2015.py 中可以看到：
+
+```Python
+_base_ = [
+ '_base_dbnet_resnet18_fpnc.py',
+ '../_base_/datasets/icdar2015.py',
+ '../_base_/default_runtime.py',
+ '../_base_/schedules/schedule_sgd_1200e.py',
+]
+```
+
+上述语句会读取列表中的所有基础配置文件，它们中的所有字段都会被载入到 dbnet_resnet18_fpnc_1200e_icdar2015.py 中。我们可以通过在 Python 解释中运行以下语句，了解配置文件被解析后的结构：
+
+```Python
+from mmengine import Config
+db_config = Config.fromfile('configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py')
+print(db_config)
+```
+
+可以发现，被解析的配置包含了所有base配置中的字段和信息。
+
+```{note}
+请注意：各 _base_ 配置文件中不能存在同名变量。
+```
+
+### `_base_` 变量的引用
+
+有时，我们可能需要直接引用 `_base_` 配置中的某些字段，以避免重复定义。假设我们想要获取 `_base_` 配置中的变量 `pseudo`，就可以直接通过 `_base_.pseudo` 获得 `_base_` 配置中的变量。
+
+该语法已广泛用于 MMOCR 的配置中。MMOCR 中各个模型的数据集和管道（pipeline）配置都引用于*基本*配置。如在
+
+```Python
+icdar2015_textdet_train = _base_.icdar2015_textdet_train
+# ...
+train_dataloader = dict(
+ # ...
+ dataset=icdar2015_textdet_train)
+```
+
+### `_base_` 变量的修改
+
+在 MMOCR 中不同算法在不同数据集通常有不同的数据流水线（pipeline)，因此经常会会存在修改数据集中 `pipeline` 的场景。同时还存在很多场景需要修改 `_base_` 配置中的变量，例如想修改某个算法的训练策略，某个模型的某些算法模块（更换 backbone 等）。用户可以直接利用 Python 的语法直接修改引用的 `_base_` 变量。针对 dict，我们也提供了与类属性修改类似的方法，可以直接修改类属性修改字典内的内容。
+
+1. 字典
+
+ 这里以修改数据集中的 `pipeline` 为例：
+
+ 可以利用 Python 语法修改字典：
+
+ ```python
+ # 获取 _base_ 中的数据集
+ icdar2015_textdet_train = _base_.icdar2015_textdet_train
+ # 可以直接利用 Python 的 update 修改变量
+ icdar2015_textdet_train.update(pipeline=_base_.train_pipeline)
+ ```
+
+ 也可以使用类属性的方法进行修改：
+
+ ```Python
+ # 获取 _base_ 中的数据集
+ icdar2015_textdet_train = _base_.icdar2015_textdet_train
+ # 类属性方法修改
+ icdar2015_textdet_train.pipeline = _base_.train_pipeline
+ ```
+
+2. 列表
+
+ 假设 `_base_` 配置中的变量 `pseudo = [1, 2, 3]`， 需要修改为 `[1, 2, 4]`:
+
+ ```Python
+ # pseudo.py
+ pseudo = [1, 2, 3]
+ ```
+
+ 可以直接重写：
+
+ ```Python
+ _base_ = ['pseudo.py']
+ pseudo = [1, 2, 4]
+ ```
+
+ 或者利用 Python 语法修改列表：
+
+ ```Python
+ _base_ = ['pseudo.py']
+ pseudo = _base_.pseudo
+ pseudo[2] = 4
+ ```
+
+### 命令行修改配置
+
+有时候我们只希望修部分配置，而不想修改配置文件本身。例如实验过程中想更换学习率，但是又不想重新写一个配置文件，可以通过命令行传入参数来覆盖相关配置。
+
+我们可以在命令行里传入 `--cfg-options`，并在其之后的参数直接修改对应字段，例如我们想在运行 train 的时候修改学习率，只需要在命令行执行：
+
+```Shell
+python tools/train.py example.py --cfg-options optim_wrapper.optimizer.lr=1
+```
+
+更多详细用法参考 {external+mmengine:ref}`MMEngine: 命令行修改配置 <命令行修改配置>`.
+
+## 配置内容
+
+通过配置文件与注册器的配合，MMOCR 可以在不侵入代码的前提下修改训练参数以及模型配置。具体而言，用户可以在配置文件中对如下模块进行自定义修改：环境配置、Hook 配置、日志配置、训练策略配置、数据相关配置、模型相关配置、评测配置、可视化配置。
+
+本文档将以文字检测算法 `DBNet` 和文字识别算法 `CRNN` 为例来详细介绍 Config 中的内容。
+
+
+
+### 环境配置
+
+```Python
+default_scope = 'mmocr'
+env_cfg = dict(
+ cudnn_benchmark=True,
+ mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+ dist_cfg=dict(backend='nccl'))
+randomness = dict(seed=None)
+```
+
+主要包含三个部分：
+
+- 设置所有注册器的默认 `scope` 为 `mmocr`， 保证所有的模块首先从 `MMOCR` 代码库中进行搜索。若果该模块不存在，则继续从上游算法库 `MMEngine` 和 `MMCV` 中进行搜索，详见 {external+mmengine:doc}`MMEngine: 注册器 `。
+
+- `env_cfg` 设置分布式环境配置， 更多配置可以详见 {external+mmengine:doc}`MMEngine: Runner `。
+
+- `randomness` 设置 numpy， torch，cudnn 等随机种子，更多配置详见 {external+mmengine:doc}`MMEngine: Runner `。
+
+
+
+### Hook 配置
+
+Hook 主要分为两个部分，默认 hook 以及自定义 hook。默认 hook 为所有任务想要运行所必须的配置，自定义 hook 一般服务于特定的算法或某些特定任务（目前为止 MMOCR 中没有自定义的 Hook）。
+
+```Python
+default_hooks = dict(
+ timer=dict(type='IterTimerHook'), # 时间记录，包括数据增强时间以及模型推理时间
+ logger=dict(type='LoggerHook', interval=1), # 日志打印间隔
+ param_scheduler=dict(type='ParamSchedulerHook'), # 更新学习率等超参
+ checkpoint=dict(type='CheckpointHook', interval=1),# 保存 checkpoint， interval控制保存间隔
+ sampler_seed=dict(type='DistSamplerSeedHook'), # 多机情况下设置种子
+ sync_buffer=dict(type='SyncBuffersHook'), # 多卡情况下，同步buffer
+ visualization=dict( # 可视化val 和 test 的结果
+ type='VisualizationHook',
+ interval=1,
+ enable=False,
+ show=False,
+ draw_gt=False,
+ draw_pred=False))
+ custom_hooks = []
+```
+
+这里简单介绍几个经常可能会变动的 hook，通用的修改方法参考[修改配置](#base-变量的修改)。
+
+- `LoggerHook`：用于配置日志记录器的行为。例如，通过修改 `interval` 可以控制日志打印的间隔，每 `interval` 次迭代 (iteration) 打印一次日志，更多设置可参考 [LoggerHook API](mmengine.hooks.LoggerHook)。
+
+- `CheckpointHook`：用于配置模型断点保存相关的行为，如保存最优权重，保存最新权重等。同样可以修改 `interval` 控制保存 checkpoint 的间隔。更多设置可参考 [CheckpointHook API](mmengine.hooks.CheckpointHook)
+
+- `VisualizationHook`：用于配置可视化相关行为，例如在验证或测试时可视化预测结果，**默认为关**。同时该 Hook 依赖[可视化配置](#可视化配置)。想要了解详细功能可以参考 [Visualizer](visualization.md)。更多配置可以参考 [VisualizationHook API](mmocr.engine.hooks.VisualizationHook)。
+
+如果想进一步了解默认 hook 的配置以及功能，可以参考 {external+mmengine:doc}`MMEngine: 钩子(Hook) `。
+
+
+
+### 日志配置
+
+此部分主要用来配置日志配置等级以及日志处理器。
+
+```Python
+log_level = 'INFO' # 日志记录等级
+log_processor = dict(type='LogProcessor',
+ window_size=10,
+ by_epoch=True)
+```
+
+- 日志配置等级与 {external+python:doc}`Python: logging ` 的配置一致，
+
+- 日志处理器主要用来控制输出的格式，详细功能可参考 {external+mmengine:doc}`MMEngine: 记录日志 `：
+
+ - `by_epoch=True` 表示按照epoch输出日志，日志格式需要和 `train_cfg` 中的 `type='EpochBasedTrainLoop'` 参数保持一致。例如想按迭代次数输出日志，就需要令 `log_processor` 中的 ` by_epoch=False` 的同时 `train_cfg` 中的 `type = 'IterBasedTrainLoop'`。
+
+ - `window_size` 表示损失的平滑窗口，即最近 `window_size` 次迭代的各种损失的均值。logger 中最终打印的 loss 值为各种损失的平均值。
+
+
+
+### 训练策略配置
+
+此部分主要包含优化器设置、学习率策略和 `Loop` 设置。
+
+对不同算法任务(文字检测，文字识别，关键信息提取)，通常有自己任务常用的调参策略。这里列出了文字识别中的 `CRNN` 所用涉及的相应配置。
+
+```Python
+# 优化器
+optim_wrapper = dict(
+ type='OptimWrapper', optimizer=dict(type='Adadelta', lr=1.0))
+param_scheduler = [dict(type='ConstantLR', factor=1.0)]
+train_cfg = dict(type='EpochBasedTrainLoop',
+ max_epochs=5, # 训练轮数
+ val_interval=1) # 评测间隔
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+```
+
+- `optim_wrapper` : 主要包含两个部分，优化器封装 (OptimWrapper) 以及优化器 (Optimizer)。详情使用信息可见 {external+mmengine:doc}`MMEngine: 优化器封装 `
+
+ - 优化器封装支持不同的训练策略，包括混合精度训练(AMP)、梯度累加和梯度截断。
+
+ - 优化器设置中支持了 PyTorch 所有的优化器，所有支持的优化器见 {external+torch:ref}`PyTorch 优化器列表 `。
+
+- `param_scheduler` : 学习率调整策略，支持大部分 PyTorch 中的学习率调度器，例如 `ExponentialLR`，`LinearLR`，`StepLR`，`MultiStepLR` 等，使用方式也基本一致，所有支持的调度器见[调度器接口文档](mmengine.optim.scheduler), 更多功能可以参考 {external+mmengine:doc}`MMEngine: 优化器参数调整策略 `。
+
+- `train/test/val_cfg` : 任务的执行流程，MMEngine 提供了四种流程：`EpochBasedTrainLoop`, `IterBasedTrainLoop`, `ValLoop`, `TestLoop` 更多可以参考 {external+mmengine:doc}`MMEngine: 循环控制器 `。
+
+### 数据相关配置
+
+
+ （为了对相同模型进行测试所做的具体修改 - 点击展开） +
+ + ```diff + diff --git a/eval.py b/eval.py + index c0b2886..04921e9 100644 + --- a/eval.py + +++ b/eval.py + @@ -10,6 +10,7 @@ import os + import sys + import numpy as np + from datetime import datetime + +import time + import argparse + import importlib + import torch + @@ -28,7 +29,7 @@ parser.add_argument('--checkpoint_path', default=None, help='Model checkpoint pa + parser.add_argument('--dump_dir', default=None, help='Dump dir to save sample outputs [default: None]') + parser.add_argument('--num_point', type=int, default=20000, help='Point Number [default: 20000]') + parser.add_argument('--num_target', type=int, default=256, help='Point Number [default: 256]') + -parser.add_argument('--batch_size', type=int, default=8, help='Batch Size during training [default: 8]') + +parser.add_argument('--batch_size', type=int, default=1, help='Batch Size during training [default: 8]') + parser.add_argument('--vote_factor', type=int, default=1, help='Number of votes generated from each seed [default: 1]') + parser.add_argument('--cluster_sampling', default='vote_fps', help='Sampling strategy for vote clusters: vote_fps, seed_fps, random [default: vote_fps]') + parser.add_argument('--ap_iou_thresholds', default='0.25,0.5', help='A list of AP IoU thresholds [default: 0.25,0.5]') + @@ -132,6 +133,7 @@ CONFIG_DICT = {'remove_empty_box': (not FLAGS.faster_eval), 'use_3d_nms': FLAGS. + # ------------------------------------------------------------------------- GLOBAL CONFIG END + + def evaluate_one_epoch(): + + time_list = list() + stat_dict = {} + ap_calculator_list = [APCalculator(iou_thresh, DATASET_CONFIG.class2type) \ + for iou_thresh in AP_IOU_THRESHOLDS] + @@ -144,6 +146,8 @@ def evaluate_one_epoch(): + + # Forward pass + inputs = {'point_clouds': batch_data_label['point_clouds']} + + torch.cuda.synchronize() + + start_time = time.perf_counter() + with torch.no_grad(): + end_points = net(inputs) + + @@ -161,6 +165,12 @@ def evaluate_one_epoch(): + + batch_pred_map_cls = parse_predictions(end_points, CONFIG_DICT) + batch_gt_map_cls = parse_groundtruths(end_points, CONFIG_DICT) + + torch.cuda.synchronize() + + elapsed = time.perf_counter() - start_time + + time_list.append(elapsed) + + + + if len(time_list==200): + + print("average inference time: %4f"%(sum(time_list[5:])/len(time_list[5:]))) + for ap_calculator in ap_calculator_list: + ap_calculator.step(batch_pred_map_cls, batch_gt_map_cls) + + ``` + +### PointPillars-car + +- __MMDetection3D__：在 v0.1.0 版本下, 执行如下命令： + + ```bash + ./tools/dist_train.sh configs/benchmark/hv_pointpillars_secfpn_3x8_100e_det3d_kitti-3d-car.py 8 --no-validate + ``` + +- __Det3D__：在 commit [519251e](https://github.com/poodarchu/Det3D/tree/519251e72a5c1fdd58972eabeac67808676b9bb7) 版本下，使用 `kitti_point_pillars_mghead_syncbn.py` 并执行如下命令： + + ```bash + ./tools/scripts/train.sh --launcher=slurm --gpus=8 + ``` + + 注意，为了训练 PointPillars，我们对 `train.sh` 进行了修改。 + +
+
+
+### PointPillars-3class
+
+- __MMDetection3D__：在 v0.1.0 版本下, 执行如下命令：
+
+ ```bash
+ ./tools/dist_train.sh configs/benchmark/hv_pointpillars_secfpn_4x8_80e_pcdet_kitti-3d-3class.py 8 --no-validate
+ ```
+
+- __OpenPCDet__：在 commit [b32fbddb](https://github.com/open-mmlab/OpenPCDet/tree/b32fbddbe06183507bad433ed99b407cbc2175c2) 版本下，执行如下命令：
+
+ ```bash
+ cd tools
+ sh scripts/slurm_train.sh ${PARTITION} ${JOB_NAME} 8 --cfg_file ./cfgs/kitti_models/pointpillar.yaml --batch_size 32 --workers 32 --epochs 80
+ ```
+
+### SECOND
+
+基准测试中的 SECOND 指在 [second.Pytorch](https://github.com/traveller59/second.pytorch) 首次被实现的 [SECONDv1.5](https://github.com/traveller59/second.pytorch/blob/master/second/configs/all.fhd.config)。Det3D 实现的 SECOND 中，使用了自己实现的 Multi-Group Head，因此无法将它的速度与其他代码库进行对比。
+
+- __MMDetection3D__：在 v0.1.0 版本下, 执行如下命令：
+
+ ```bash
+ ./tools/dist_train.sh configs/benchmark/hv_second_secfpn_4x8_80e_pcdet_kitti-3d-3class.py 8 --no-validate
+ ```
+
+- __OpenPCDet__：在 commit [b32fbddb](https://github.com/open-mmlab/OpenPCDet/tree/b32fbddbe06183507bad433ed99b407cbc2175c2) 版本下，执行如下命令：
+
+ ```bash
+ cd tools
+ sh ./scripts/slurm_train.sh ${PARTITION} ${JOB_NAME} 8 --cfg_file ./cfgs/kitti_models/second.yaml --batch_size 32 --workers 32 --epochs 80
+ ```
+
+### Part-A2
+
+- __MMDetection3D__：在 v0.1.0 版本下, 执行如下命令：
+
+ ```bash
+ ./tools/dist_train.sh configs/benchmark/hv_PartA2_secfpn_4x8_cyclic_80e_pcdet_kitti-3d-3class.py 8 --no-validate
+ ```
+
+- __OpenPCDet__：在 commit [b32fbddb](https://github.com/open-mmlab/OpenPCDet/tree/b32fbddbe06183507bad433ed99b407cbc2175c2) 版本下，执行如下命令以进行模型训练：
+
+ ```bash
+ cd tools
+ sh ./scripts/slurm_train.sh ${PARTITION} ${JOB_NAME} 8 --cfg_file ./cfgs/kitti_models/PartA2.yaml --batch_size 32 --workers 32 --epochs 80
+ ```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/changelog.md b/internlm_langchain/knowledge_base/MMDetection3D/content/changelog.md
new file mode 100644
index 00000000..258cba0c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/changelog.md
@@ -0,0 +1 @@
+# v1.1 变更日志
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/changelog_v1.0.x.md b/internlm_langchain/knowledge_base/MMDetection3D/content/changelog_v1.0.x.md
new file mode 100644
index 00000000..d7916ef6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/changelog_v1.0.x.md
@@ -0,0 +1 @@
+# v1.0.x 变更日志
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/compatibility.md b/internlm_langchain/knowledge_base/MMDetection3D/content/compatibility.md
new file mode 100644
index 00000000..97144d13
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/compatibility.md
@@ -0,0 +1 @@
+# 兼容性
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/config.md b/internlm_langchain/knowledge_base/MMDetection3D/content/config.md
new file mode 100644
index 00000000..f971a108
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/config.md
@@ -0,0 +1,558 @@
+# 学习配置文件
+
+MMDetection3D 和其他 OpenMMLab 仓库使用 [MMEngine 的配置文件系统](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html)。它具有模块化和继承性设计，以便于进行各种实验。
+
+## 配置文件的内容
+
+MMDetection3D 采用模块化设计，所有功能的模块可以通过配置文件进行配置。以 PointPillars 为例，我们将根据不同的功能模块介绍配置文件的各个字段。
+
+### 模型配置
+
+在 MMDetection3D 的配置中，我们使用 `model` 字段来配置检测算法的组件。除了 `voxel_encoder`，`backbone` 等神经网络组件外，还需要 `data_preprocessor`，`train_cfg` 和 `test_cfg`。`data_preprocessor` 负责对数据加载器（dataloader）输出的每一批数据进行预处理。模型配置中的 `train_cfg` 和 `test_cfg` 用于设置训练和测试组件的超参数。
+
+```python
+model = dict(
+ type='VoxelNet',
+ data_preprocessor=dict(
+ type='Det3DDataPreprocessor',
+ voxel=True,
+ voxel_layer=dict(
+ max_num_points=32,
+ point_cloud_range=[0, -39.68, -3, 69.12, 39.68, 1],
+ voxel_size=[0.16, 0.16, 4],
+ max_voxels=(16000, 40000))),
+ voxel_encoder=dict(
+ type='PillarFeatureNet',
+ in_channels=4,
+ feat_channels=[64],
+ with_distance=False,
+ voxel_size=[0.16, 0.16, 4],
+ point_cloud_range=[0, -39.68, -3, 69.12, 39.68, 1]),
+ middle_encoder=dict(
+ type='PointPillarsScatter', in_channels=64, output_shape=[496, 432]),
+ backbone=dict(
+ type='SECOND',
+ in_channels=64,
+ layer_nums=[3, 5, 5],
+ layer_strides=[2, 2, 2],
+ out_channels=[64, 128, 256]),
+ neck=dict(
+ type='SECONDFPN',
+ in_channels=[64, 128, 256],
+ upsample_strides=[1, 2, 4],
+ out_channels=[128, 128, 128]),
+ bbox_head=dict(
+ type='Anchor3DHead',
+ num_classes=3,
+ in_channels=384,
+ feat_channels=384,
+ use_direction_classifier=True,
+ assign_per_class=True,
+ anchor_generator=dict(
+ type='AlignedAnchor3DRangeGenerator',
+ ranges=[[0, -39.68, -0.6, 69.12, 39.68, -0.6],
+ [0, -39.68, -0.6, 69.12, 39.68, -0.6],
+ [0, -39.68, -1.78, 69.12, 39.68, -1.78]],
+ sizes=[[0.8, 0.6, 1.73], [1.76, 0.6, 1.73], [3.9, 1.6, 1.56]],
+ rotations=[0, 1.57],
+ reshape_out=False),
+ diff_rad_by_sin=True,
+ bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'),
+ loss_cls=dict(
+ type='mmdet.FocalLoss',
+ use_sigmoid=True,
+ gamma=2.0,
+ alpha=0.25,
+ loss_weight=1.0),
+ loss_bbox=dict(
+ type='mmdet.SmoothL1Loss',
+ beta=0.1111111111111111,
+ loss_weight=2.0),
+ loss_dir=dict(
+ type='mmdet.CrossEntropyLoss', use_sigmoid=False,
+ loss_weight=0.2)),
+ train_cfg=dict(
+ assigner=[
+ dict(
+ type='Max3DIoUAssigner',
+ iou_calculator=dict(type='BboxOverlapsNearest3D'),
+ pos_iou_thr=0.5,
+ neg_iou_thr=0.35,
+ min_pos_iou=0.35,
+ ignore_iof_thr=-1),
+ dict(
+ type='Max3DIoUAssigner',
+ iou_calculator=dict(type='BboxOverlapsNearest3D'),
+ pos_iou_thr=0.5,
+ neg_iou_thr=0.35,
+ min_pos_iou=0.35,
+ ignore_iof_thr=-1),
+ dict(
+ type='Max3DIoUAssigner',
+ iou_calculator=dict(type='BboxOverlapsNearest3D'),
+ pos_iou_thr=0.6,
+ neg_iou_thr=0.45,
+ min_pos_iou=0.45,
+ ignore_iof_thr=-1)
+ ],
+ allowed_border=0,
+ pos_weight=-1,
+ debug=False),
+ test_cfg=dict(
+ use_rotate_nms=True,
+ nms_across_levels=False,
+ nms_thr=0.01,
+ score_thr=0.1,
+ min_bbox_size=0,
+ nms_pre=100,
+ max_num=50))
+```
+
+### 数据集和评测器配置
+
+在使用[执行器（Runner）](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)进行训练、测试和验证时，我们需要配置[数据加载器](https://pytorch.org/docs/stable/data.html?highlight=data%20loader#torch.utils.data.DataLoader)。构建数据加载器需要设置数据集和数据处理流程。由于这部分的配置较为复杂，我们使用中间变量来简化数据加载器配置的编写。
+
+```python
+dataset_type = 'KittiDataset'
+data_root = 'data/kitti/'
+class_names = ['Pedestrian', 'Cyclist', 'Car']
+point_cloud_range = [0, -39.68, -3, 69.12, 39.68, 1]
+input_modality = dict(use_lidar=True, use_camera=False)
+metainfo = dict(classes=class_names)
+
+db_sampler = dict(
+ data_root=data_root,
+ info_path=data_root + 'kitti_dbinfos_train.pkl',
+ rate=1.0,
+ prepare=dict(
+ filter_by_difficulty=[-1],
+ filter_by_min_points=dict(Car=5, Pedestrian=5, Cyclist=5)),
+ classes=class_names,
+ sample_groups=dict(Car=15, Pedestrian=15, Cyclist=15),
+ points_loader=dict(
+ type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4))
+
+train_pipeline = [
+ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4),
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(type='ObjectSample', db_sampler=db_sampler, use_ground_plane=True),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.78539816, 0.78539816],
+ scale_ratio_range=[0.95, 1.05]),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='PointShuffle'),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_labels_3d', 'gt_bboxes_3d'])
+]
+test_pipeline = [
+ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4),
+ dict(
+ type='MultiScaleFlipAug3D',
+ img_scale=(1333, 800),
+ pts_scale_ratio=1,
+ flip=False,
+ transforms=[
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[0, 0],
+ scale_ratio_range=[1., 1.],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D'),
+ dict(
+ type='PointsRangeFilter', point_cloud_range=point_cloud_range)
+ ]),
+ dict(type='Pack3DDetInputs', keys=['points'])
+]
+eval_pipeline = [
+ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4),
+ dict(type='Pack3DDetInputs', keys=['points'])
+]
+train_dataloader = dict(
+ batch_size=6,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=dict(
+ type='RepeatDataset',
+ times=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_file='kitti_infos_train.pkl',
+ data_prefix=dict(pts='training/velodyne_reduced'),
+ pipeline=train_pipeline,
+ modality=input_modality,
+ test_mode=False,
+ metainfo=metainfo,
+ box_type_3d='LiDAR')))
+val_dataloader = dict(
+ batch_size=1,
+ num_workers=1,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(pts='training/velodyne_reduced'),
+ ann_file='kitti_infos_val.pkl',
+ pipeline=test_pipeline,
+ modality=input_modality,
+ test_mode=True,
+ metainfo=metainfo,
+ box_type_3d='LiDAR'))
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=1,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(pts='training/velodyne_reduced'),
+ ann_file='kitti_infos_val.pkl',
+ pipeline=test_pipeline,
+ modality=input_modality,
+ test_mode=True,
+ metainfo=metainfo,
+ box_type_3d='LiDAR'))
+```
+
+[评测器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html)用于计算训练模型在验证和测试数据集上的指标。评测器的配置由一个或一组评价指标配置组成：
+
+```python
+val_evaluator = dict(
+ type='KittiMetric',
+ ann_file=data_root + 'kitti_infos_val.pkl',
+ metric='bbox')
+test_evaluator = val_evaluator
+```
+
+由于测试数据集没有标注文件，因此 MMDetection3D 中的 test_dataloader 和 test_evaluator 配置通常等于 val。如果您想要保存在测试数据集上的检测结果，则可以像这样编写配置：
+
+```python
+# 在测试集上推理，
+# 并将检测结果转换格式以用于提交结果
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=1,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(pts='testing/velodyne_reduced'),
+ ann_file='kitti_infos_test.pkl',
+ load_eval_anns=False,
+ pipeline=test_pipeline,
+ modality=input_modality,
+ test_mode=True,
+ metainfo=metainfo,
+ box_type_3d='LiDAR'))
+test_evaluator = dict(
+ type='KittiMetric',
+ ann_file=data_root + 'kitti_infos_test.pkl',
+ metric='bbox',
+ format_only=True,
+ submission_prefix='results/kitti-3class/kitti_results')
+```
+
+### 训练和测试配置
+
+MMEngine 的执行器使用循环（Loop）来控制训练，验证和测试过程。用户可以使用这些字段设置最大训练轮次和验证间隔：
+
+```python
+train_cfg = dict(
+ type='EpochBasedTrainLoop',
+ max_epochs=80,
+ val_interval=2)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+```
+
+### 优化配置
+
+`optim_wrapper` 是配置优化相关设置的字段。优化器封装不仅提供了优化器的功能，还支持梯度裁剪、混合精度训练等功能。更多内容请看[优化器封装教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html)。
+
+```python
+optim_wrapper = dict( # 优化器封装配置
+ type='OptimWrapper', # 优化器封装类型，切换到 AmpOptimWrapper 启动混合精度训练
+ optimizer=dict( # 优化器配置。支持 PyTorch 的各种优化器，请参考 https://pytorch.org/docs/stable/optim.html#algorithms
+ type='AdamW', lr=0.001, betas=(0.95, 0.99), weight_decay=0.01),
+ clip_grad=dict(max_norm=35, norm_type=2)) # 梯度裁剪选项。设置为 None 禁用梯度裁剪。使用方法请见 https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html
+```
+
+`param_scheduler` 是配置调整优化器超参数（例如学习率和动量）的字段。用户可以组合多个调度器来创建所需要的参数调整策略。更多信息请参考[参数调度器教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/param_scheduler.html)和[参数调度器 API 文档](https://mmengine.readthedocs.io/zh_CN/latest/api/optim.html#scheduler)。
+
+```python
+param_scheduler = [
+ dict(
+ type='CosineAnnealingLR',
+ T_max=32,
+ eta_min=0.01,
+ begin=0,
+ end=32,
+ by_epoch=True,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingLR',
+ T_max=48,
+ eta_min=1.0000000000000001e-07,
+ begin=32,
+ end=80,
+ by_epoch=True,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingMomentum',
+ T_max=32,
+ eta_min=0.8947368421052632,
+ begin=0,
+ end=32,
+ by_epoch=True,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingMomentum',
+ T_max=48,
+ eta_min=1,
+ begin=32,
+ end=80,
+ by_epoch=True,
+ convert_to_iter_based=True),
+]
+```
+
+### 钩子配置
+
+用户可以在训练、验证和测试循环上添加钩子，从而在运行期间插入一些操作。有两种不同的钩子字段，一种是 `default_hooks`，另一种是 `custom_hooks`。
+
+`default_hooks` 是一个钩子配置字典，并且这些钩子是运行时所需要的。它们具有默认优先级，是不需要修改的。如果未设置，执行器将使用默认值。如果要禁用默认钩子，用户可以将其配置设置为 `None`。
+
+```python
+default_hooks = dict(
+ timer=dict(type='IterTimerHook'),
+ logger=dict(type='LoggerHook', interval=50),
+ param_scheduler=dict(type='ParamSchedulerHook'),
+ checkpoint=dict(type='CheckpointHook', interval=-1),
+ sampler_seed=dict(type='DistSamplerSeedHook'),
+ visualization=dict(type='Det3DVisualizationHook'))
+```
+
+`custom_hooks` 是一个由其他钩子配置组成的列表。用户可以开发自己的钩子并将其插入到该字段中。
+
+```python
+custom_hooks = []
+```
+
+### 运行配置
+
+```python
+default_scope = 'mmdet3d' # 寻找模块的默认注册器域。请参考 https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/registry.html
+
+env_cfg = dict(
+ cudnn_benchmark=False, # 是否启用 cudnn benchmark
+ mp_cfg=dict( # 多进程配置
+ mp_start_method='fork', # 使用 fork 来启动多进程。'fork' 通常比 'spawn' 更快，但可能不安全。请参考 https://github.com/pytorch/pytorch/issues/1355
+ opencv_num_threads=0), # 关闭 opencv 的多进程以避免系统超负荷
+ dist_cfg=dict(backend='nccl')) # 分布式配置
+
+vis_backends = [dict(type='LocalVisBackend')] # 可视化后端。请参考 https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html
+visualizer = dict(
+ type='Det3DLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+
+log_processor = dict(
+ type='LogProcessor', # 日志处理器用于处理运行时日志
+ window_size=50, # 日志数值的平滑窗口
+ by_epoch=True) # 是否使用 epoch 格式的日志。需要与训练循环的类型保持一致
+
+log_level = 'INFO' # 日志等级
+load_from = None # 从给定路径加载模型检查点作为预训练模型。这不会恢复训练。
+resume = False # 是否从 `load_from` 中定义的检查点恢复。如果 `load_from` 为 None，它将恢复 `work_dir` 中的最近检查点。
+```
+
+## 配置文件继承
+
+在 `configs/_base_` 文件夹下有 4 个基本组件类型，分别是：数据集（dataset），模型（model），训练策略（schedule）和运行时的默认设置（default runtime）。许多方法，如 SECOND、PointPillars、PartA2、VoteNet 都能够很容易地构建出来。由 `_base_` 下的组件组成的配置，被我们称为 _原始配置（primitive）_。
+
+对于同一个文件夹下的所有配置，推荐**只有一个**对应的 _原始配置_ 文件。所有其他的配置文件都应该继承自这个 _原始配置_ 文件。这样就能保证配置文件的最大继承深度为 3。
+
+为了便于理解，我们建议贡献者继承现有方法。例如，如果在 PointPillars 的基础上做了一些修改，用户可以首先通过指定 `_base_ = '../pointpillars/pointpillars_hv_fpn_sbn-all_8xb4-2x_nus-3d.py'` 来继承基础的 PointPillars 结构，然后修改配置文件中的必要参数以完成继承。
+
+如果您在构建一个与任何现有方法都不共享的全新方法，那么可以在 `configs` 文件夹下创建一个新的例如 `xxx_rcnn` 文件夹。
+
+更多细节请参考 [MMEngine 配置文件教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html)。
+
+通过设置 `_base_` 字段，我们可以设置当前配置文件继承自哪些文件。
+
+当 `_base_` 为文件路径字符串时，表示继承一个配置文件的内容。
+
+```python
+_base_ = './pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py'
+```
+
+当 `_base_` 是多个文件路径组成的列表式，表示继承多个文件。
+
+```python
+_base_ = [
+ '../_base_/models/pointpillars_hv_secfpn_kitti.py',
+ '../_base_/datasets/kitti-3d-3class.py',
+ '../_base_/schedules/cyclic-40e.py', '../_base_/default_runtime.py'
+]
+```
+
+如果需要检测配置文件，可以通过运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置。
+
+### 忽略基础配置文件里的部分字段
+
+有时，您也许会设置 `_delete_=True` 去忽略基础配置文件里的一些字段。您可以参考 [MMEngine 配置文件教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html) 来获得一些简单的指导。
+
+在 MMDetection3D 里，例如，修改以下 PointPillars 配置中的颈部网络：
+
+```python
+model = dict(
+ type='MVXFasterRCNN',
+ data_preprocessor=dict(voxel_layer=dict(...)),
+ pts_voxel_encoder=dict(...),
+ pts_middle_encoder=dict(...),
+ pts_backbone=dict(...),
+ pts_neck=dict(
+ type='FPN',
+ norm_cfg=dict(type='naiveSyncBN2d', eps=1e-3, momentum=0.01),
+ act_cfg=dict(type='ReLU'),
+ in_channels=[64, 128, 256],
+ out_channels=256,
+ start_level=0,
+ num_outs=3),
+ pts_bbox_head=dict(...))
+```
+
+`FPN` 和 `SECONDFPN` 使用不同的关键字来构建：
+
+```python
+_base_ = '../_base_/models/pointpillars_hv_fpn_nus.py'
+model = dict(
+ pts_neck=dict(
+ _delete_=True,
+ type='SECONDFPN',
+ norm_cfg=dict(type='naiveSyncBN2d', eps=1e-3, momentum=0.01),
+ in_channels=[64, 128, 256],
+ upsample_strides=[1, 2, 4],
+ out_channels=[128, 128, 128]),
+ pts_bbox_head=dict(...))
+```
+
+`_delete_=True` 将使用新的键去替换 `pts_neck` 字段内所有旧的键。
+
+### 在配置文件里使用中间变量
+
+配置文件里会使用一些中间变量，例如数据集里的 `train_pipeline`/`test_pipeline`。需要注意的是，当修改子配置文件中的中间变量时，用户需要再次将中间变量传递到对应的字段中。例如，我们想使用多尺度策略训练并测试 PointPillars，`train_pipeline`/`test_pipeline` 是我们想要修改的中间变量。
+
+```python
+_base_ = './nus-3d.py'
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ load_dim=5,
+ use_dim=5,
+ backend_args=backend_args),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10,
+ backend_args=backend_args),
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.3925, 0.3925],
+ scale_ratio_range=[0.95, 1.05],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectNameFilter', classes=class_names),
+ dict(type='PointShuffle'),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_labels_3d', 'gt_bboxes_3d'])
+]
+test_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ load_dim=5,
+ use_dim=5,
+ backend_args=backend_args),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10,
+ backend_args=backend_args),
+ dict(
+ type='MultiScaleFlipAug3D',
+ img_scale=(1333, 800),
+ pts_scale_ratio=[0.95, 1.0, 1.05],
+ flip=False,
+ transforms=[
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[0, 0],
+ scale_ratio_range=[1., 1.],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D'),
+ dict(
+ type='PointsRangeFilter', point_cloud_range=point_cloud_range)
+ ]),
+ dict(type='Pack3DDetInputs', keys=['points'])
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+```
+
+我们首先定义新的 `train_pipeline`/`test_pipeline`，然后传递到数据加载器字段中。
+
+### 复用 \_base\_ 文件中的变量
+
+如果用户希望复用 base 文件中的变量，则可以通过使用 `{{_base_.xxx}}` 获取对应变量的拷贝。例如：
+
+```python
+_base_ = './pointpillars_hv_secfpn_8xb6-160e_kitti-3d-3class.py'
+
+a = {{_base_.model}} # 变量 `a` 等于 `_base_` 中定义的 `model`
+```
+
+## 通过脚本参数修改配置
+
+当使用 `tools/train.py` 或者 `tools/test.py` 提交工作时，您可以通过指定 `--cfg-options` 来修改配置文件。
+
+- 更新配置字典的键值
+
+ 可以按照原始配置文件中字典的键值顺序指定配置选项。例如，使用 `--cfg-options model.backbone.norm_eval=False` 将模型主干网络中的所有 BN 模块都改为 `train` 模式。
+
+- 更新配置列表中的键值
+
+ 在配置文件里，一些配置字典被包含在列表中，例如，训练流程 `train_dataloader.dataset.pipeline` 通常是一个列表，例如 `[dict(type='LoadPointsFromFile'), ...]`。如果您想要将训练流程中的 `'LoadPointsFromFile'` 改成 `'LoadPointsFromDict'`，您需要指定 `--cfg-options data.train.pipeline.0.type=LoadPointsFromDict`。
+
+- 更新列表/元组的值
+
+ 如果要更新的值是列表或元组。例如，配置文件通常设置 `model.data_preprocessor.mean=[123.675, 116.28, 103.53]`。如果您想要改变这个均值，您需要指定 `--cfg-options model.data_preprocessor.mean="[127,127,127]"`。注意，引号 `"` 是支持列表/元组数据类型所必需的，并且在指定值的引号内**不允许**有空格。
+
+## 配置文件名称风格
+
+我们遵循以下样式来命名配置文件。建议贡献者遵循相同的风格。
+
+```
+{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}.py
+```
+
+文件名分为五个部分。所有部分和组件用 `_` 连接，每个部分或组件内的单词应该用 `-` 连接。
+
+- `{algorithm name}`：算法的名称。它可以是检测器的名称，例如 `pointpillars`、`fcos3d` 等。
+- `{model component names}`：算法中使用的组件名称，如 voxel_encoder、backbone、neck 等。例如 `second_secfpn_head-dcn-circlenms` 表示使用 SECOND 的 SparseEncoder，SECONDFPN，以及带有 DCN 和 circle NMS 的检测头。
+- `{training settings}`：训练设置的信息，例如批量大小，数据增强，损失函数策略，调度器以及训练轮次/迭代。例如 `8xb4-tta-cyclic-20e` 表示使用 8 个 gpu，每个 gpu 有 4 个数据样本，测试增强，余弦退火学习率，训练 20 个 epoch。缩写介绍：
+ - `{gpu x batch_per_gpu}`：GPU 数和每个 GPU 的样本数。`bN` 表示每个 GPU 上的批量大小为 N。例如 `4xb4` 是 4 个 GPU，每个 GPU 有 4 个样本数的缩写。
+ - `{schedule}`：训练方案，可选项为 `schedule-2x`、`schedule-3x`、`cyclic-20e` 等。`schedule-2x` 和 `schedule-3x` 分别代表 24 epoch 和 36 epoch。`cyclic-20e` 表示 20 epoch。
+- `{training dataset information}`：训练数据集名，例如 `kitti-3d-3class`，`nus-3d`，`s3dis-seg`，`scannet-seg`，`waymoD5-3d-car`。这里 `3d` 表示数据集用于 3D 目标检测，`seg` 表示数据集用于点云分割。
+- `{testing dataset information}`（可选）：当模型在一个数据集上训练，在另一个数据集上测试时的测试数据集名。如果没有注明，则表示训练和测试的数据集类型相同。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/coord_sys_tutorial.md b/internlm_langchain/knowledge_base/MMDetection3D/content/coord_sys_tutorial.md
new file mode 100644
index 00000000..d666ba75
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/coord_sys_tutorial.md
@@ -0,0 +1,245 @@
+# 坐标系
+
+## 概述
+
+MMDetection3D 使用 3 种不同的坐标系。3D 目标检测领域中不同坐标系的存在是非常有必要的，因为对于各种 3D 数据采集设备来说，如激光雷达、深度相机等，使用的坐标系是不一致的，不同的 3D 数据集也遵循不同的数据格式。早期的工作，比如 SECOND、VoteNet 将原始数据转换为另一种格式，形成了一些后续工作也遵循的约定，使得不同坐标系之间的转换变得更加复杂。
+
+尽管数据集和采集设备多种多样，但是通过总结 3D 目标检测的工作线，我们可以将坐标系大致分为三类：
+
+- 相机坐标系 -- 大多数相机的坐标系，在该坐标系中 y 轴正方向指向地面，x 轴正方向指向右侧，z 轴正方向指向前方。
+
+ ```
+ 上 z 前
+ | ^
+ | /
+ | /
+ | /
+ |/
+ 左 ------ 0 ------> x 右
+ |
+ |
+ |
+ |
+ v
+ y 下
+ ```
+
+- 激光雷达坐标系 -- 众多激光雷达的坐标系，在该坐标系中 z 轴负方向指向地面，x 轴正方向指向前方，y 轴正方向指向左侧。
+
+ ```
+ z 上 x 前
+ ^ ^
+ | /
+ | /
+ | /
+ |/
+ y 左 <------ 0 ------ 右
+ ```
+
+- 深度坐标系 -- VoteNet、H3DNet 等模型使用的坐标系，在该坐标系中 z 轴负方向指向地面，x 轴正方向指向右侧，y 轴正方向指向前方。
+
+ ```
+ z 上 y 前
+ ^ ^
+ | /
+ | /
+ | /
+ |/
+ 左 ------ 0 ------> x 右
+ ```
+
+该教程中的坐标系定义实际上**不仅仅是定义三个轴**。对于形如 $(x, y, z, dx, dy, dz, r)$ 的框来说，我们的坐标系也定义了如何解释框的尺寸 $(dx, dy, dz)$ 和转向角 (yaw) 角度 $r$。
+
+三个坐标系的图示如下：
+
+
+
+上面三张图是 3D 坐标系，下面三张图是鸟瞰图。
+
+以后我们将坚持使用本教程中定义的三个坐标系。
+
+## 转向角 (yaw) 的定义
+
+请参考[维基百科](https://en.wikipedia.org/wiki/Euler_angles#Tait%E2%80%93Bryan_angles)了解转向角的标准定义。在目标检测中，我们选择一个轴作为重力轴，并在垂直于重力轴的平面 $\\Pi$ 上选取一个参考方向，那么参考方向的转向角为 0，在 $\\Pi$ 上的其他方向有非零的转向角，其角度取决于其与参考方向的角度。
+
+目前，对于所有支持的数据集，标注不包括俯仰角 (pitch) 和滚动角 (roll)，这意味着我们在预测框和计算框之间的重叠时只需考虑转向角 (yaw)。
+
+在 MMDetection3D 中，所有坐标系都是右手坐标系，这意味着如果从重力轴的负方向（轴的正方向指向人眼）看，转向角 (yaw) 沿着逆时针方向增加。
+
+下图显示，在右手坐标系中，如果我们设定 x 轴正方向为参考方向，那么 y 轴正方向的转向角 (yaw) 为 $\\frac{\\pi}{2}$。
+
+```
+ z 上 y 前 (yaw=0.5*pi)
+ ^ ^
+ | /
+ | /
+ | /
+ |/
+左 (yaw=pi) ------ 0 ------> x 右 (yaw=0)
+```
+
+对于一个框来说，其转向角 (yaw) 的值等于其方向减去一个参考方向。在 MMDetection3D 的所有三个坐标系中，参考方向总是 x 轴的正方向，而如果一个框的转向角 (yaw) 为 0，则其方向被定义为与 x 轴平行。框的转向角 (yaw) 的定义如下图所示。
+
+```
+ y 前
+ ^ 框的方向 (yaw=0.5*pi)
+ /|\ ^
+ | /|\
+ | ____|____
+ | | | |
+ | | | |
+__|____|____|____|______\ x 右
+ | | | | /
+ | | | |
+ | |____|____|
+ |
+```
+
+## 框尺寸的定义
+
+框尺寸的定义与转向角 (yaw) 的定义是分不开的。在上一节中，我们提到如果一个框的转向角 (yaw) 为 0，它的方向就被定义为与 x 轴平行。那么自然地，一个框对应于 x 轴的尺寸应该是 $dx$。但是，这在某些数据集中并非总是如此（我们稍后会解决这个问题）。
+
+下图展示了 x 轴和 $dx$，y 轴和 $dy$ 对应的含义。
+
+```
+y 前
+ ^ 框的方向 (yaw=0.5*pi)
+ /|\ ^
+ | /|\
+ | ____|____
+ | | | |
+ | | | | dx
+__|____|____|____|______\ x 右
+ | | | | /
+ | | | |
+ | |____|____|
+ | dy
+```
+
+注意框的方向总是和 $dx$ 边平行。
+
+```
+y 前
+ ^ _________
+ /|\ | | |
+ | | | |
+ | | | | dy
+ | |____|____|____\ 框的方向 (yaw=0)
+ | | | | /
+__|____|____|____|_________\ x 右
+ | | | | /
+ | |____|____|
+ | dx
+ |
+```
+
+## 与支持的数据集的原始坐标系的关系
+
+### KITTI
+
+KITTI 数据集的原始标注是在相机坐标系下的，详见 [get_label_anno](https://github.com/open-mmlab/mmdetection3d/blob/master/tools/data_converter/kitti_data_utils.py)。在 MMDetection3D 中，为了在 KITTI 数据集上训练基于激光雷达的模型，首先将数据从相机坐标系转换到激光雷达坐标，详见 [get_ann_info](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/datasets/kitti_dataset.py)。对于训练基于视觉的模型，数据保持在相机坐标系不变。
+
+在 SECOND 中，框的激光雷达坐标系定义如下（鸟瞰图）：
+
+
+
+对于每个框来说，尺寸为 $(w, l, h)$，转向角 (yaw) 的参考方向为 y 轴正方向。更多细节请参考[代码库](https://github.com/traveller59/second.pytorch#concepts)。
+
+我们的激光雷达坐标系有两处改变：
+
+- 转向角 (yaw) 被定义为右手而非左手，从而保持一致性；
+- 框的尺寸为 $(l, w, h)$ 而非 $(w, l, h)$，由于在 KITTI 数据集中 $w$ 对应 $dy$，$l$ 对应 $dx$。
+
+### Waymo
+
+我们使用 Waymo 数据集的 KITTI 格式数据。因此，在我们的实现中 KITTI 和 Waymo 也共用相同的坐标系。
+
+### NuScenes
+
+NuScenes 提供了一个评估工具包，其中每个框都被包装成一个 `Box` 实例。`Box` 的坐标系不同于我们的激光雷达坐标系，在 `Box` 坐标系中，前两个表示框尺寸的元素分别对应 $(dy, dx)$ 或者 $(w, l)$，和我们的表示方法相反。更多细节请参考 NuScenes [教程](https://github.com/open-mmlab/mmdetection3d/blob/master/docs/zh_cn/datasets/nuscenes_det.md#notes)。
+
+读者可以参考 [NuScenes 开发工具](https://github.com/nutonomy/nuscenes-devkit/tree/master/python-sdk/nuscenes/eval/detection)，了解 [NuScenes 框](https://github.com/nutonomy/nuscenes-devkit/blob/2c6a752319f23910d5f55cc995abc547a9e54142/python-sdk/nuscenes/utils/data_classes.py#L457) 的定义和 [NuScenes 评估](https://github.com/nutonomy/nuscenes-devkit/blob/master/python-sdk/nuscenes/eval/detection/evaluate.py)的过程。
+
+### Lyft
+
+就涉及坐标系而言，Lyft 和 NuScenes 共用相同的数据格式。
+
+请参考[官方网站](https://www.kaggle.com/c/3d-object-detection-for-autonomous-vehicles/data)获取更多信息。
+
+### ScanNet
+
+ScanNet 的原始数据不是点云而是网格，需要在我们的深度坐标系下进行采样得到点云数据。对于 ScanNet 检测任务，框的标注是轴对齐的，并且转向角 (yaw) 始终是 0。因此，我们的深度坐标系中转向角 (yaw) 的方向对 ScanNet 没有影响。
+
+### SUN RGB-D
+
+SUN RGB-D 的原始数据不是点云而是 RGB-D 图像。我们通过反投影，可以得到每张图像对应的点云，其在我们的深度坐标系下。但是，数据集的标注并不在我们的系统中，所以需要进行转换。
+
+将原始标注转换为我们的深度坐标系下的标注的转换过程请参考 [sunrgbd_data_utils.py](https://github.com/open-mmlab/mmdetection3d/blob/master/tools/data_converter/sunrgbd_data_utils.py)。
+
+### S3DIS
+
+在我们的实现中，S3DIS 与 ScanNet 共用相同的坐标系。然而 S3DIS 是一个仅限于分割任务的数据集，因此没有标注是坐标系敏感的。
+
+## 例子
+
+### 框（在不同坐标系间）的转换
+
+以相机坐标系和激光雷达坐标系间的转换为例：
+
+首先，对于点和框的中心点，坐标转换前后满足下列关系：
+
+- $x\_{LiDAR}=z\_{camera}$
+- $y\_{LiDAR}=-x\_{camera}$
+- $z\_{LiDAR}=-y\_{camera}$
+
+然后，框的尺寸转换前后满足下列关系：
+
+- $dx\_{LiDAR}=dx\_{camera}$
+- $dy\_{LiDAR}=dz\_{camera}$
+- $dz\_{LiDAR}=dy\_{camera}$
+
+最后，转向角 (yaw) 也应该被转换：
+
+- $r\_{LiDAR}=-\\frac{\\pi}{2}-r\_{camera}$
+
+详见[此处](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/core/bbox/structures/box_3d_mode.py)代码了解更多细节。
+
+### 鸟瞰图
+
+如果 3D 框是 $(x, y, z, dx, dy, dz, r)$，相机坐标系下框的鸟瞰图是 $(x, z, dx, dz, -r)$。转向角 (yaw) 符号取反是因为相机坐标系重力轴的正方向指向地面。
+
+详见[此处](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/core/bbox/structures/cam_box3d.py)代码了解更多细节。
+
+### 框的旋转
+
+我们将各种框的旋转设定为绕着重力轴逆时针旋转。因此，为了旋转一个 3D 框，我们首先需要计算新的框的中心，然后将旋转角度添加到转向角 (yaw)。
+
+详见[此处](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/core/bbox/structures/cam_box3d.py)代码了解更多细节。
+
+## 常见问题
+
+#### Q1: 与框相关的算子是否适用于所有坐标系类型？
+
+否。例如，[用于 RoI-Aware Pooling 的算子](https://github.com/open-mmlab/mmcv/blob/master/mmcv/ops/roiaware_pool3d.py)只适用于深度坐标系和激光雷达坐标系下的框。由于如果从上方看，旋转是顺时针的，所以 KITTI 数据集[这里](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/core/evaluation/kitti_utils.py)的评估函数仅适用于相机坐标系下的框。
+
+对于每个和框相关的算子，我们注明了其所适用的框类型。
+
+#### Q2: 在每个坐标系中，三个轴是否分别准确地指向右侧、前方和地面？
+
+否。例如在 KITTI 中，从相机坐标系转换为激光雷达坐标系时，我们需要一个校准矩阵。
+
+#### Q3: 框中转向角 (yaw) $2\\pi$ 的相位差如何影响评估？
+
+对于交并比 (IoU) 计算，转向角 (yaw) 有 $2\\pi$ 的相位差的两个框是相同的，所以不会影响评估。
+
+对于角度预测评估，例如 NuScenes 中的 NDS 指标和 KITTI 中的 AOS 指标，会先对预测框的角度进行标准化，因此 $2\\pi$ 的相位差不会改变结果。
+
+#### Q4: 框中转向角 (yaw) $\\pi$ 的相位差如何影响评估？
+
+对于交并比 (IoU) 计算，转向角 (yaw) 有 $\\pi$ 的相位差的两个框是相同的，所以不会影响评估。
+
+然而，对于角度预测评估，这会导致完全相反的方向。
+
+考虑一辆汽车，转向角 (yaw) 是汽车前部方向与 x 轴正方向之间的夹角。如果我们将该角度增加 $\\pi$，车前部将变成车后部。
+
+对于某些类别，例如障碍物，前后没有区别，因此 $\\pi$ 的相位差不会对角度预测分数产生影响。
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/customize_dataset.md b/internlm_langchain/knowledge_base/MMDetection3D/content/customize_dataset.md
new file mode 100644
index 00000000..a481fa26
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/customize_dataset.md
@@ -0,0 +1,500 @@
+# 自定义数据集
+
+在本节中，您将了解如何使用自定义数据集训练和测试预定义模型。
+
+基本步骤如下：
+
+1. 准备数据
+2. 准备配置文件
+3. 在自定义数据集上训练，测试和推理模型
+
+## 数据准备
+
+理想情况下我们可以重新组织自定义的原始数据并将标注格式转换成 KITTI 风格。但是，考虑到对于自定义数据集而言，KITTI 格式的校准文件和 3D 标注难以获得，因此我们在文档中介绍基本的数据格式。
+
+### 基本数据格式
+
+#### 点云格式
+
+目前，我们只支持 `.bin` 格式的点云用于训练和推理。在训练自己的数据集之前，需要将其它格式的点云文件转换成 `.bin` 文件。常见的点云数据格式包括 `.pcd` 和 `.las`，我们列举了一些开源工具作为参考。
+
+1. `.pcd` 转换成 `.bin`：https://github.com/DanielPollithy/pypcd
+
+- 您可以通过以下指令安装 `pypcd`：
+
+ ```bash
+ pip install git+https://github.com/DanielPollithy/pypcd.git
+ ```
+
+- 您可以使用以下脚本读取 `.pcd` 文件，并将其转换成 `.bin` 格式来保存：
+
+ ```python
+ import numpy as np
+ from pypcd import pypcd
+
+ pcd_data = pypcd.PointCloud.from_path('point_cloud_data.pcd')
+ points = np.zeros([pcd_data.width, 4], dtype=np.float32)
+ points[:, 0] = pcd_data.pc_data['x'].copy()
+ points[:, 1] = pcd_data.pc_data['y'].copy()
+ points[:, 2] = pcd_data.pc_data['z'].copy()
+ points[:, 3] = pcd_data.pc_data['intensity'].copy().astype(np.float32)
+ with open('point_cloud_data.bin', 'wb') as f:
+ f.write(points.tobytes())
+ ```
+
+2. `.las` 转换成 `.bin`：常见的转换流程为 `.las -> .pcd -> .bin`，`.las -> .pcd` 的转换可以用该[工具](https://github.com/Hitachi-Automotive-And-Industry-Lab/semantic-segmentation-editor)实现。
+
+#### 标签格式
+
+最基本的信息：每个场景的 3D 边界框和类别标签应该包含在 `.txt` 标注文件中。每一行代表特定场景的一个 3D 框，如下所示：
+
+```
+# 格式：[x, y, z, dx, dy, dz, yaw, category_name]
+1.23 1.42 0.23 3.96 1.65 1.55 1.56 Car
+3.51 2.15 0.42 1.05 0.87 1.86 1.23 Pedestrian
+...
+```
+
+**注意**：对于自定义数据集的评估我们目前只支持 KITTI 评估方法。
+
+3D 框应存储在统一的 3D 坐标系中。
+
+#### 校准格式
+
+对于每个激光雷达收集的点云数据，通常会进行融合并转换到特定的激光雷达坐标系。因此，校准信息文件中通常应该包含每个相机的内参矩阵和激光雷达到每个相机的外参转换矩阵，并保存在 `.txt` 校准文件中，其中 `Px` 表示 `camera_x` 的内参矩阵，`lidar2camx` 表示 `lidar` 到 `camera_x` 的外参转换矩阵。
+
+```
+P0
+P1
+P2
+P3
+P4
+...
+lidar2cam0
+lidar2cam1
+lidar2cam2
+lidar2cam3
+lidar2cam4
+...
+```
+
+### 原始数据结构
+
+#### 基于激光雷达的 3D 检测
+
+基于激光雷达的 3D 目标检测原始数据通常组织成如下格式，其中 `ImageSets` 包含划分文件，指明哪些文件属于训练/验证集，`points` 包含存储成 `.bin` 格式的点云数据，`labels` 包含 3D 检测的标签文件。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── custom
+│ │ ├── ImageSets
+│ │ │ ├── train.txt
+│ │ │ ├── val.txt
+│ │ ├── points
+│ │ │ ├── 000000.bin
+│ │ │ ├── 000001.bin
+│ │ │ ├── ...
+│ │ ├── labels
+│ │ │ ├── 000000.txt
+│ │ │ ├── 000001.txt
+│ │ │ ├── ...
+```
+
+#### 基于视觉的 3D 检测
+
+基于视觉的 3D 目标检测原始数据通常组织成如下格式，其中 `ImageSets` 包含划分文件，指明哪些文件属于训练/验证集，`images` 包含来自不同相机的图像，例如 `camera_x` 获得的图像应放在 `images/images_x` 下，`calibs` 包含校准信息文件，其中存储了每个相机的内参矩阵，`labels` 包含 3D 检测的标签文件。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── custom
+│ │ ├── ImageSets
+│ │ │ ├── train.txt
+│ │ │ ├── val.txt
+│ │ ├── calibs
+│ │ │ ├── 000000.txt
+│ │ │ ├── 000001.txt
+│ │ │ ├── ...
+│ │ ├── images
+│ │ │ ├── images_0
+│ │ │ │ ├── 000000.png
+│ │ │ │ ├── 000001.png
+│ │ │ │ ├── ...
+│ │ │ ├── images_1
+│ │ │ ├── images_2
+│ │ │ ├── ...
+│ │ ├── labels
+│ │ │ ├── 000000.txt
+│ │ │ ├── 000001.txt
+│ │ │ ├── ...
+```
+
+#### 多模态 3D 检测
+
+多模态 3D 目标检测原始数据通常组织成如下格式。不同于基于视觉的 3D 目标检测，`calibs` 里的校准信息文件存储了每个相机的内参矩阵和外参矩阵。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── custom
+│ │ ├── ImageSets
+│ │ │ ├── train.txt
+│ │ │ ├── val.txt
+│ │ ├── calibs
+│ │ │ ├── 000000.txt
+│ │ │ ├── 000001.txt
+│ │ │ ├── ...
+│ │ ├── points
+│ │ │ ├── 000000.bin
+│ │ │ ├── 000001.bin
+│ │ │ ├── ...
+│ │ ├── images
+│ │ │ ├── images_0
+│ │ │ │ ├── 000000.png
+│ │ │ │ ├── 000001.png
+│ │ │ │ ├── ...
+│ │ │ ├── images_1
+│ │ │ ├── images_2
+│ │ │ ├── ...
+│ │ ├── labels
+│ │ │ ├── 000000.txt
+│ │ │ ├── 000001.txt
+│ │ │ ├── ...
+```
+
+#### 基于激光雷达的 3D 语义分割
+
+基于激光雷达的 3D 语义分割原始数据通常组织成如下格式，其中 `ImageSets` 包含划分文件，指明哪些文件属于训练/验证集，`points` 包含点云数据，`semantic_mask` 包含逐点级标签。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── custom
+│ │ ├── ImageSets
+│ │ │ ├── train.txt
+│ │ │ ├── val.txt
+│ │ ├── points
+│ │ │ ├── 000000.bin
+│ │ │ ├── 000001.bin
+│ │ │ ├── ...
+│ │ ├── semantic_mask
+│ │ │ ├── 000000.bin
+│ │ │ ├── 000001.bin
+│ │ │ ├── ...
+```
+
+### 数据转换
+
+按照我们的说明准备好原始数据后，您可以直接使用以下命令生成训练/验证信息文件。
+
+```bash
+python tools/create_data.py custom --root-path ./data/custom --out-dir ./data/custom --extra-tag custom
+```
+
+## 自定义数据集示例
+
+在完成数据准备后，我们可以在 `mmdet3d/datasets/my_dataset.py` 中创建一个新的数据集来加载数据。
+
+```python
+import mmengine
+
+from mmdet3d.registry import DATASETS
+from .det3d_dataset import Det3DDataset
+
+
+@DATASETS.register_module()
+class MyDataset(Det3DDataset):
+
+ # 替换成自定义 pkl 信息文件里的所有类别
+ METAINFO = {
+ 'classes': ('Pedestrian', 'Cyclist', 'Car')
+ }
+
+ def parse_ann_info(self, info):
+ """Process the `instances` in data info to `ann_info`.
+
+ Args:
+ info (dict): Data information of single data sample.
+
+ Returns:
+ dict: Annotation information consists of the following keys:
+
+ - gt_bboxes_3d (:obj:`LiDARInstance3DBoxes`):
+ 3D ground truth bboxes.
+ - gt_labels_3d (np.ndarray): Labels of ground truths.
+ """
+ ann_info = super().parse_ann_info(info)
+ if ann_info is None:
+ ann_info = dict()
+ # 空实例
+ ann_info['gt_bboxes_3d'] = np.zeros((0, 7), dtype=np.float32)
+ ann_info['gt_labels_3d'] = np.zeros(0, dtype=np.int64)
+
+ # 过滤掉没有在训练中使用的类别
+ ann_info = self._remove_dontcare(ann_info)
+ gt_bboxes_3d = LiDARInstance3DBoxes(ann_info['gt_bboxes_3d'])
+ ann_info['gt_bboxes_3d'] = gt_bboxes_3d
+ return ann_info
+```
+
+数据预处理后，用户可以通过以下两个步骤来训练自定义数据集：
+
+1. 修改配置文件来使用自定义数据集。
+2. 验证自定义数据集标注的正确性。
+
+这里我们以在自定义数据集上训练 PointPillars 为例：
+
+### 准备配置
+
+这里我们演示一个纯点云训练的配置示例：
+
+#### 准备数据集配置
+
+在 `configs/_base_/datasets/custom.py` 中：
+
+```python
+# 数据集设置
+dataset_type = 'MyDataset'
+data_root = 'data/custom/'
+class_names = ['Pedestrian', 'Cyclist', 'Car'] # 替换成您的数据集类别
+point_cloud_range = [0, -40, -3, 70.4, 40, 1] # 根据您的数据集进行调整
+input_modality = dict(use_lidar=True, use_camera=False)
+metainfo = dict(classes=class_names)
+
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=4, # 替换成您的点云数据维度
+ use_dim=4), # 替换成在训练和推理时实际使用的维度
+ dict(
+ type='LoadAnnotations3D',
+ with_bbox_3d=True,
+ with_label_3d=True),
+ dict(
+ type='ObjectNoise',
+ num_try=100,
+ translation_std=[1.0, 1.0, 0.5],
+ global_rot_range=[0.0, 0.0],
+ rot_range=[-0.78539816, 0.78539816]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.78539816, 0.78539816],
+ scale_ratio_range=[0.95, 1.05]),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='PointShuffle'),
+ dict(
+ type='Pack3DDetInputs',
+ keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+test_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ coord_type='LIDAR',
+ load_dim=4, # 替换成您的点云数据维度
+ use_dim=4),
+ dict(type='Pack3DDetInputs', keys=['points'])
+]
+# 为可视化阶段的数据和 GT 加载构造流水线
+eval_pipeline = [
+ dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4),
+ dict(type='Pack3DDetInputs', keys=['points']),
+]
+train_dataloader = dict(
+ batch_size=6,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=dict(
+ type='RepeatDataset',
+ times=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ ann_file='custom_infos_train.pkl', # 指定您的训练 pkl 信息
+ data_prefix=dict(pts='points'),
+ pipeline=train_pipeline,
+ modality=input_modality,
+ test_mode=False,
+ metainfo=metainfo,
+ box_type_3d='LiDAR')))
+val_dataloader = dict(
+ batch_size=1,
+ num_workers=1,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(pts='points'),
+ ann_file='custom_infos_val.pkl', # 指定您的验证 pkl 信息
+ pipeline=test_pipeline,
+ modality=input_modality,
+ test_mode=True,
+ metainfo=metainfo,
+ box_type_3d='LiDAR'))
+val_evaluator = dict(
+ type='KittiMetric',
+ ann_file=data_root + 'custom_infos_val.pkl', # 指定您的验证 pkl 信息
+ metric='bbox')
+```
+
+#### 准备模型配置
+
+对于基于体素化的检测器如 SECOND，PointPillars 及 CenterPoint，点云范围（point cloud range）和体素大小（voxel size）应该根据您的数据集做调整。理论上，`voxel_size` 和 `point_cloud_range` 的设置是相关联的。设置较小的 `voxel_size` 将增加体素数以及相应的内存消耗。此外，需要注意以下问题：
+
+如果将 `point_cloud_range` 和 `voxel_size` 分别设置成 `[0, -40, -3, 70.4, 40, 1]` 和 `[0.05, 0.05, 0.1]`，那么中间特征图的形状应该为 `[(1-(-3))/0.1+1, (40-(-40))/0.05, (70.4-0)/0.05]=[41, 1600, 1408]`。更改 `point_cloud_range` 时，请记得依据 `voxel_size` 更改 `middle_encoder` 里中间特征图的形状。
+
+关于 `anchor_range` 的设置，一般需要根据数据集做调整。需要注意的是，`z` 值需要根据点云的位置做相应调整，具体请参考此 [issue](https://github.com/open-mmlab/mmdetection3d/issues/986)。
+
+关于 `anchor_size` 的设置，通常需要计算整个训练集中目标的长、宽、高的平均值作为 `anchor_size`，以获得最好的结果。
+
+在 `configs/_base_/models/pointpillars_hv_secfpn_custom.py` 中：
+
+```python
+voxel_size = [0.16, 0.16, 4] # 根据您的数据集做调整
+point_cloud_range = [0, -39.68, -3, 69.12, 39.68, 1] # 根据您的数据集做调整
+model = dict(
+ type='VoxelNet',
+ data_preprocessor=dict(
+ type='Det3DDataPreprocessor',
+ voxel=True,
+ voxel_layer=dict(
+ max_num_points=32,
+ point_cloud_range=point_cloud_range,
+ voxel_size=voxel_size,
+ max_voxels=(16000, 40000))),
+ voxel_encoder=dict(
+ type='PillarFeatureNet',
+ in_channels=4,
+ feat_channels=[64],
+ with_distance=False,
+ voxel_size=voxel_size,
+ point_cloud_range=point_cloud_range),
+ # `output_shape` 需要根据 `point_cloud_range` 和 `voxel_size` 做相应调整
+ middle_encoder=dict(
+ type='PointPillarsScatter', in_channels=64, output_shape=[496, 432]),
+ backbone=dict(
+ type='SECOND',
+ in_channels=64,
+ layer_nums=[3, 5, 5],
+ layer_strides=[2, 2, 2],
+ out_channels=[64, 128, 256]),
+ neck=dict(
+ type='SECONDFPN',
+ in_channels=[64, 128, 256],
+ upsample_strides=[1, 2, 4],
+ out_channels=[128, 128, 128]),
+ bbox_head=dict(
+ type='Anchor3DHead',
+ num_classes=3,
+ in_channels=384,
+ feat_channels=384,
+ use_direction_classifier=True,
+ assign_per_class=True,
+ # 根据您的数据集调整 `ranges` 和 `sizes`
+ anchor_generator=dict(
+ type='AlignedAnchor3DRangeGenerator',
+ ranges=[
+ [0, -39.68, -0.6, 69.12, 39.68, -0.6],
+ [0, -39.68, -0.6, 69.12, 39.68, -0.6],
+ [0, -39.68, -1.78, 69.12, 39.68, -1.78],
+ ],
+ sizes=[[0.8, 0.6, 1.73], [1.76, 0.6, 1.73], [3.9, 1.6, 1.56]],
+ rotations=[0, 1.57],
+ reshape_out=False),
+ diff_rad_by_sin=True,
+ bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'),
+ loss_cls=dict(
+ type='mmdet.FocalLoss',
+ use_sigmoid=True,
+ gamma=2.0,
+ alpha=0.25,
+ loss_weight=1.0),
+ loss_bbox=dict(
+ type='mmdet.SmoothL1Loss', beta=1.0 / 9.0, loss_weight=2.0),
+ loss_dir=dict(
+ type='mmdet.CrossEntropyLoss', use_sigmoid=False,
+ loss_weight=0.2)),
+ # 模型训练和测试设置
+ train_cfg=dict(
+ assigner=[
+ dict( # for Pedestrian
+ type='Max3DIoUAssigner',
+ iou_calculator=dict(type='BboxOverlapsNearest3D'),
+ pos_iou_thr=0.5,
+ neg_iou_thr=0.35,
+ min_pos_iou=0.35,
+ ignore_iof_thr=-1),
+ dict( # for Cyclist
+ type='Max3DIoUAssigner',
+ iou_calculator=dict(type='BboxOverlapsNearest3D'),
+ pos_iou_thr=0.5,
+ neg_iou_thr=0.35,
+ min_pos_iou=0.35,
+ ignore_iof_thr=-1),
+ dict( # for Car
+ type='Max3DIoUAssigner',
+ iou_calculator=dict(type='BboxOverlapsNearest3D'),
+ pos_iou_thr=0.6,
+ neg_iou_thr=0.45,
+ min_pos_iou=0.45,
+ ignore_iof_thr=-1),
+ ],
+ allowed_border=0,
+ pos_weight=-1,
+ debug=False),
+ test_cfg=dict(
+ use_rotate_nms=True,
+ nms_across_levels=False,
+ nms_thr=0.01,
+ score_thr=0.1,
+ min_bbox_size=0,
+ nms_pre=100,
+ max_num=50))
+```
+
+#### 准备整体配置
+
+我们将上述的所有配置组合在 `configs/pointpillars/pointpillars_hv_secfpn_8xb6_custom.py` 文件中：
+
+```python
+_base_ = [
+ '../_base_/models/pointpillars_hv_secfpn_custom.py',
+ '../_base_/datasets/custom.py',
+ '../_base_/schedules/cyclic-40e.py', '../_base_/default_runtime.py'
+]
+```
+
+#### 可视化数据集（可选）
+
+为了验证准备的数据和配置是否正确，我们建议在训练和验证前使用 `tools/misc/browse_dataset.py` 脚本可视化数据集和标注。更多细节请参考[可视化文档](https://mmdetection3d.readthedocs.io/zh_CN/dev-1.x/user_guides/visualization.html)。
+
+## 评估
+
+准备好数据和配置之后，您可以遵循我们的文档直接运行训练/测试脚本。
+
+**注意**：我们为自定义数据集提供了 KITTI 风格的评估实现方法。在数据集配置中需要包含如下内容：
+
+```python
+val_evaluator = dict(
+ type='KittiMetric',
+ ann_file=data_root + 'custom_infos_val.pkl', # 指定您的验证 pkl 信息
+ metric='bbox')
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/customize_models.md b/internlm_langchain/knowledge_base/MMDetection3D/content/customize_models.md
new file mode 100644
index 00000000..677deca3
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/customize_models.md
@@ -0,0 +1,619 @@
+# 自定义模型
+
+我们通常把模型的各个组成成分分成 6 种类型：
+
+- 编码器（encoder）：包括 voxel encoder 和 middle encoder 等进入 backbone 前所使用的基于体素的方法，如 `HardVFE` 和 `PointPillarsScatter`。
+- 骨干网络（backbone）：通常采用 FCN 网络来提取特征图，如 `ResNet` 和 `SECOND`。
+- 颈部网络（neck）：位于 backbones 和 heads 之间的组成模块，如 `FPN` 和 `SECONDFPN`。
+- 检测头（head）：用于特定任务的组成模块，如`检测框的预测`和`掩码的预测`。
+- RoI 提取器（RoI extractor）：用于从特征图中提取 RoI 特征的组成模块，如 `H3DRoIHead` 和 `PartAggregationROIHead`。
+- 损失函数（loss）：heads 中用于计算损失函数的组成模块，如 `FocalLoss`、`L1Loss` 和 `GHMLoss`。
+
+## 开发新的组成模块
+
+### 添加新的编码器
+
+接下来我们以 HardVFE 为例展示如何开发新的组成模块。
+
+#### 1. 定义一个新的体素编码器（如 HardVFE：即 HV-SECOND 中使用的体素特征编码器）
+
+创建一个新文件 `mmdet3d/models/voxel_encoders/voxel_encoder.py`。
+
+```python
+import torch.nn as nn
+
+from mmdet3d.registry import MODELS
+
+
+@MODELS.register_module()
+class HardVFE(nn.Module):
+
+ def __init__(self, arg1, arg2):
+ pass
+
+ def forward(self, x): # 需要返回一个元组
+ pass
+```
+
+#### 2. 导入该模块
+
+您可以在 `mmdet3d/models/voxel_encoders/__init__.py` 中添加以下代码：
+
+```python
+from .voxel_encoder import HardVFE
+```
+
+或者在配置文件中添加以下代码，从而避免修改源码：
+
+```python
+custom_imports = dict(
+ imports=['mmdet3d.models.voxel_encoders.voxel_encoder'],
+ allow_failed_imports=False)
+```
+
+#### 3. 在配置文件中使用体素编码器
+
+```python
+model = dict(
+ ...
+ voxel_encoder=dict(
+ type='HardVFE',
+ arg1=xxx,
+ arg2=yyy),
+ ...
+)
+```
+
+### 添加新的骨干网络
+
+接下来我们以 [SECOND](https://www.mdpi.com/1424-8220/18/10/3337)（Sparsely Embedded Convolutional Detection）为例展示如何开发新的组成模块。
+
+#### 1. 定义一个新的骨干网络（如 SECOND）
+
+创建一个新文件 `mmdet3d/models/backbones/second.py`。
+
+```python
+from mmengine.model import BaseModule
+
+from mmdet3d.registry import MODELS
+
+
+@MODELS.register_module()
+class SECOND(BaseModule):
+
+ def __init__(self, arg1, arg2):
+ pass
+
+ def forward(self, x): # 需要返回一个元组
+ pass
+```
+
+#### 2. 导入该模块
+
+您可以在 `mmdet3d/models/backbones/__init__.py` 中添加以下代码：
+
+```python
+from .second import SECOND
+```
+
+或者在配置文件中添加以下代码，从而避免修改源码：
+
+```python
+custom_imports = dict(
+ imports=['mmdet3d.models.backbones.second'],
+ allow_failed_imports=False)
+```
+
+#### 3. 在配置文件中使用骨干网络
+
+```python
+model = dict(
+ ...
+ backbone=dict(
+ type='SECOND',
+ arg1=xxx,
+ arg2=yyy),
+ ...
+)
+```
+
+### 添加新的颈部网络
+
+#### 1. 定义一个新的颈部网络（如 SECONDFPN）
+
+创建一个新文件 `mmdet3d/models/necks/second_fpn.py`。
+
+```python
+from mmengine.model import BaseModule
+
+from mmdet3d.registry import MODELS
+
+
+@MODELS.register_module()
+class SECONDFPN(BaseModule):
+
+ def __init__(self,
+ in_channels=[128, 128, 256],
+ out_channels=[256, 256, 256],
+ upsample_strides=[1, 2, 4],
+ norm_cfg=dict(type='BN', eps=1e-3, momentum=0.01),
+ upsample_cfg=dict(type='deconv', bias=False),
+ conv_cfg=dict(type='Conv2d', bias=False),
+ use_conv_for_no_stride=False,
+ init_cfg=None):
+ pass
+
+ def forward(self, x):
+ # 具体实现忽略
+ pass
+```
+
+#### 2. 导入该模块
+
+您可以在 `mmdet3d/models/necks/__init__.py` 中添加以下代码：
+
+```python
+from .second_fpn import SECONDFPN
+```
+
+或者在配置文件中添加以下代码，从而避免修改源码：
+
+```python
+custom_imports = dict(
+ imports=['mmdet3d.models.necks.second_fpn'],
+ allow_failed_imports=False)
+```
+
+#### 3. 在配置文件中使用颈部网络
+
+```python
+model = dict(
+ ...
+ neck=dict(
+ type='SECONDFPN',
+ in_channels=[64, 128, 256],
+ upsample_strides=[1, 2, 4],
+ out_channels=[128, 128, 128]),
+ ...
+)
+```
+
+### 添加新的检测头
+
+接下来我们以 [PartA2 Head](https://arxiv.org/abs/1907.03670) 为例展示如何开发新的检测头。
+
+**注意**：此处展示的 `PartA2 RoI Head` 将用于检测器的第二阶段。对于单阶段的检测头，请参考 `mmdet3d/models/dense_heads/` 中的例子。由于其简单高效，它们更常用于自动驾驶场景下的 3D 检测中。
+
+首先，在 `mmdet3d/models/roi_heads/bbox_heads/parta2_bbox_head.py` 中添加新的 bbox head。`PartA2 RoI Head` 为目标检测实现了一个新的 bbox head。为了实现一个 bbox head，我们通常需要在新模块中实现如下两个函数。有时还需要实现其他相关函数，如 `loss` 和 `get_targets`。
+
+```python
+from mmengine.model import BaseModule
+
+from mmdet3d.registry import MODELS
+
+
+@MODELS.register_module()
+class PartA2BboxHead(BaseModule):
+ """PartA2 RoI head."""
+
+ def __init__(self,
+ num_classes,
+ seg_in_channels,
+ part_in_channels,
+ seg_conv_channels=None,
+ part_conv_channels=None,
+ merge_conv_channels=None,
+ down_conv_channels=None,
+ shared_fc_channels=None,
+ cls_channels=None,
+ reg_channels=None,
+ dropout_ratio=0.1,
+ roi_feat_size=14,
+ with_corner_loss=True,
+ bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'),
+ conv_cfg=dict(type='Conv1d'),
+ norm_cfg=dict(type='BN1d', eps=1e-3, momentum=0.01),
+ loss_bbox=dict(
+ type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=2.0),
+ loss_cls=dict(
+ type='CrossEntropyLoss',
+ use_sigmoid=True,
+ reduction='none',
+ loss_weight=1.0),
+ init_cfg=None):
+ super(PartA2BboxHead, self).__init__(init_cfg=init_cfg)
+
+ def forward(self, seg_feats, part_feats):
+ pass
+```
+
+其次，如果有必要的话需要实现一个新的 RoI Head。我们从 `Base3DRoIHead` 中继承得到新的 `PartAggregationROIHead`。我们可以发现 `Base3DRoIHead` 已经实现了如下函数。
+
+```python
+from mmdet.models.roi_heads import BaseRoIHead
+
+from mmdet3d.registry import MODELS, TASK_UTILS
+
+
+class Base3DRoIHead(BaseRoIHead):
+ """Base class for 3d RoIHeads."""
+
+ def __init__(self,
+ bbox_head=None,
+ bbox_roi_extractor=None,
+ mask_head=None,
+ mask_roi_extractor=None,
+ train_cfg=None,
+ test_cfg=None,
+ init_cfg=None):
+ super(Base3DRoIHead, self).__init__(
+ bbox_head=bbox_head,
+ bbox_roi_extractor=bbox_roi_extractor,
+ mask_head=mask_head,
+ mask_roi_extractor=mask_roi_extractor,
+ train_cfg=train_cfg,
+ test_cfg=test_cfg,
+ init_cfg=init_cfg)
+
+ def init_bbox_head(self, bbox_roi_extractor: dict,
+ bbox_head: dict) -> None:
+ """Initialize box head and box roi extractor.
+
+ Args:
+ bbox_roi_extractor (dict or ConfigDict): Config of box
+ roi extractor.
+ bbox_head (dict or ConfigDict): Config of box in box head.
+ """
+ self.bbox_roi_extractor = MODELS.build(bbox_roi_extractor)
+ self.bbox_head = MODELS.build(bbox_head)
+
+ def init_assigner_sampler(self):
+ """Initialize assigner and sampler."""
+ self.bbox_assigner = None
+ self.bbox_sampler = None
+ if self.train_cfg:
+ if isinstance(self.train_cfg.assigner, dict):
+ self.bbox_assigner = TASK_UTILS.build(self.train_cfg.assigner)
+ elif isinstance(self.train_cfg.assigner, list):
+ self.bbox_assigner = [
+ TASK_UTILS.build(res) for res in self.train_cfg.assigner
+ ]
+ self.bbox_sampler = TASK_UTILS.build(self.train_cfg.sampler)
+
+ def init_mask_head(self):
+ """Initialize mask head, skip since ``PartAggregationROIHead`` does not
+ have one."""
+ pass
+```
+
+接下来主要对 bbox_forward 的逻辑进行修改，同时其继承了来自 `Base3DRoIHead` 的其它逻辑。在 `mmdet3d/models/roi_heads/part_aggregation_roi_head.py` 中，我们实现了新的 RoI Head，如下所示：
+
+```python
+from typing import Dict, List, Tuple
+
+from mmdet.models.task_modules import AssignResult, SamplingResult
+from mmengine import ConfigDict
+from torch import Tensor
+from torch.nn import functional as F
+
+from mmdet3d.registry import MODELS
+from mmdet3d.structures import bbox3d2roi
+from mmdet3d.utils import InstanceList
+from ...structures.det3d_data_sample import SampleList
+from .base_3droi_head import Base3DRoIHead
+
+
+@MODELS.register_module()
+class PartAggregationROIHead(Base3DRoIHead):
+ """Part aggregation roi head for PartA2.
+
+ Args:
+ semantic_head (ConfigDict): Config of semantic head.
+ num_classes (int): The number of classes.
+ seg_roi_extractor (ConfigDict): Config of seg_roi_extractor.
+ bbox_roi_extractor (ConfigDict): Config of part_roi_extractor.
+ bbox_head (ConfigDict): Config of bbox_head.
+ train_cfg (ConfigDict): Training config.
+ test_cfg (ConfigDict): Testing config.
+ """
+
+ def __init__(self,
+ semantic_head: dict,
+ num_classes: int = 3,
+ seg_roi_extractor: dict = None,
+ bbox_head: dict = None,
+ bbox_roi_extractor: dict = None,
+ train_cfg: dict = None,
+ test_cfg: dict = None,
+ init_cfg: dict = None) -> None:
+ super(PartAggregationROIHead, self).__init__(
+ bbox_head=bbox_head,
+ bbox_roi_extractor=bbox_roi_extractor,
+ train_cfg=train_cfg,
+ test_cfg=test_cfg,
+ init_cfg=init_cfg)
+ self.num_classes = num_classes
+ assert semantic_head is not None
+ self.init_seg_head(seg_roi_extractor, semantic_head)
+
+ def init_seg_head(self, seg_roi_extractor: dict,
+ semantic_head: dict) -> None:
+ """Initialize semantic head and seg roi extractor.
+
+ Args:
+ seg_roi_extractor (dict): Config of seg
+ roi extractor.
+ semantic_head (dict): Config of semantic head.
+ """
+ self.semantic_head = MODELS.build(semantic_head)
+ self.seg_roi_extractor = MODELS.build(seg_roi_extractor)
+
+ @property
+ def with_semantic(self):
+ """bool: whether the head has semantic branch"""
+ return hasattr(self,
+ 'semantic_head') and self.semantic_head is not None
+
+ def predict(self,
+ feats_dict: Dict,
+ rpn_results_list: InstanceList,
+ batch_data_samples: SampleList,
+ rescale: bool = False,
+ **kwargs) -> InstanceList:
+ """Perform forward propagation of the roi head and predict detection
+ results on the features of the upstream network.
+
+ Args:
+ feats_dict (dict): Contains features from the first stage.
+ rpn_results_list (List[:obj:`InstanceData`]): Detection results
+ of rpn head.
+ batch_data_samples (List[:obj:`Det3DDataSample`]): The Data
+ samples. It usually includes information such as
+ `gt_instance_3d`, `gt_panoptic_seg_3d` and `gt_sem_seg_3d`.
+ rescale (bool): If True, return boxes in original image space.
+ Defaults to False.
+
+ Returns:
+ list[:obj:`InstanceData`]: Detection results of each sample
+ after the post process.
+ Each item usually contains following keys.
+
+ - scores_3d (Tensor): Classification scores, has a shape
+ (num_instances, )
+ - labels_3d (Tensor): Labels of bboxes, has a shape
+ (num_instances, ).
+ - bboxes_3d (BaseInstance3DBoxes): Prediction of bboxes,
+ contains a tensor with shape (num_instances, C), where
+ C >= 7.
+ """
+ assert self.with_bbox, 'Bbox head must be implemented in PartA2.'
+ assert self.with_semantic, 'Semantic head must be implemented' \
+ ' in PartA2.'
+
+ batch_input_metas = [
+ data_samples.metainfo for data_samples in batch_data_samples
+ ]
+ voxels_dict = feats_dict.pop('voxels_dict')
+ # TODO: Split predict semantic and bbox
+ results_list = self.predict_bbox(feats_dict, voxels_dict,
+ batch_input_metas, rpn_results_list,
+ self.test_cfg)
+ return results_list
+
+ def predict_bbox(self, feats_dict: Dict, voxel_dict: Dict,
+ batch_input_metas: List[dict],
+ rpn_results_list: InstanceList,
+ test_cfg: ConfigDict) -> InstanceList:
+ """Perform forward propagation of the bbox head and predict detection
+ results on the features of the upstream network.
+
+ Args:
+ feats_dict (dict): Contains features from the first stage.
+ voxel_dict (dict): Contains information of voxels.
+ batch_input_metas (list[dict], Optional): Batch image meta info.
+ Defaults to None.
+ rpn_results_list (List[:obj:`InstanceData`]): Detection results
+ of rpn head.
+ test_cfg (Config): Test config.
+
+ Returns:
+ list[:obj:`InstanceData`]: Detection results of each sample
+ after the post process.
+ Each item usually contains following keys.
+
+ - scores_3d (Tensor): Classification scores, has a shape
+ (num_instances, )
+ - labels_3d (Tensor): Labels of bboxes, has a shape
+ (num_instances, ).
+ - bboxes_3d (BaseInstance3DBoxes): Prediction of bboxes,
+ contains a tensor with shape (num_instances, C), where
+ C >= 7.
+ """
+ ...
+
+ def loss(self, feats_dict: Dict, rpn_results_list: InstanceList,
+ batch_data_samples: SampleList, **kwargs) -> dict:
+ """Perform forward propagation and loss calculation of the detection
+ roi on the features of the upstream network.
+
+ Args:
+ feats_dict (dict): Contains features from the first stage.
+ rpn_results_list (List[:obj:`InstanceData`]): Detection results
+ of rpn head.
+ batch_data_samples (List[:obj:`Det3DDataSample`]): The Data
+ samples. It usually includes information such as
+ `gt_instance_3d`, `gt_panoptic_seg_3d` and `gt_sem_seg_3d`.
+
+ Returns:
+ dict[str, Tensor]: A dictionary of loss components
+ """
+ assert len(rpn_results_list) == len(batch_data_samples)
+ losses = dict()
+ batch_gt_instances_3d = []
+ batch_gt_instances_ignore = []
+ voxels_dict = feats_dict.pop('voxels_dict')
+ for data_sample in batch_data_samples:
+ batch_gt_instances_3d.append(data_sample.gt_instances_3d)
+ if 'ignored_instances' in data_sample:
+ batch_gt_instances_ignore.append(data_sample.ignored_instances)
+ else:
+ batch_gt_instances_ignore.append(None)
+ if self.with_semantic:
+ semantic_results = self._semantic_forward_train(
+ feats_dict, voxels_dict, batch_gt_instances_3d)
+ losses.update(semantic_results.pop('loss_semantic'))
+
+ sample_results = self._assign_and_sample(rpn_results_list,
+ batch_gt_instances_3d)
+ if self.with_bbox:
+ feats_dict.update(semantic_results)
+ bbox_results = self._bbox_forward_train(feats_dict, voxels_dict,
+ sample_results)
+ losses.update(bbox_results['loss_bbox'])
+
+ return losses
+```
+
+此处我们省略了相关函数的更多细节。更多细节请参考[代码](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/models/roi_heads/part_aggregation_roi_head.py)。
+
+最后，用户需要在 `mmdet3d/models/roi_heads/bbox_heads/__init__.py` 和 `mmdet3d/models/roi_heads/__init__.py` 添加模块，从而能被相应的注册器找到并加载。
+
+此外，用户也可以在配置文件中添加以下代码以达到相同的目的。
+
+```python
+custom_imports=dict(
+ imports=['mmdet3d.models.roi_heads.part_aggregation_roi_head', 'mmdet3d.models.roi_heads.bbox_heads.parta2_bbox_head'],
+ allow_failed_imports=False)
+```
+
+`PartAggregationROIHead` 的配置文件如下所示：
+
+```python
+model = dict(
+ ...
+ roi_head=dict(
+ type='PartAggregationROIHead',
+ num_classes=3,
+ semantic_head=dict(
+ type='PointwiseSemanticHead',
+ in_channels=16,
+ extra_width=0.2,
+ seg_score_thr=0.3,
+ num_classes=3,
+ loss_seg=dict(
+ type='mmdet.FocalLoss',
+ use_sigmoid=True,
+ reduction='sum',
+ gamma=2.0,
+ alpha=0.25,
+ loss_weight=1.0),
+ loss_part=dict(
+ type='mmdet.CrossEntropyLoss',
+ use_sigmoid=True,
+ loss_weight=1.0)),
+ seg_roi_extractor=dict(
+ type='Single3DRoIAwareExtractor',
+ roi_layer=dict(
+ type='RoIAwarePool3d',
+ out_size=14,
+ max_pts_per_voxel=128,
+ mode='max')),
+ bbox_roi_extractor=dict(
+ type='Single3DRoIAwareExtractor',
+ roi_layer=dict(
+ type='RoIAwarePool3d',
+ out_size=14,
+ max_pts_per_voxel=128,
+ mode='avg')),
+ bbox_head=dict(
+ type='PartA2BboxHead',
+ num_classes=3,
+ seg_in_channels=16,
+ part_in_channels=4,
+ seg_conv_channels=[64, 64],
+ part_conv_channels=[64, 64],
+ merge_conv_channels=[128, 128],
+ down_conv_channels=[128, 256],
+ bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'),
+ shared_fc_channels=[256, 512, 512, 512],
+ cls_channels=[256, 256],
+ reg_channels=[256, 256],
+ dropout_ratio=0.1,
+ roi_feat_size=14,
+ with_corner_loss=True,
+ loss_bbox=dict(
+ type='mmdet.SmoothL1Loss',
+ beta=1.0 / 9.0,
+ reduction='sum',
+ loss_weight=1.0),
+ loss_cls=dict(
+ type='mmdet.CrossEntropyLoss',
+ use_sigmoid=True,
+ reduction='sum',
+ loss_weight=1.0))),
+ ...
+)
+```
+
+MMDetection 2.0 开始支持配置文件之间的继承，因此用户可以关注配置文件的修改。PartA2 Head 的第二阶段主要使用了新的 `PartAggregationROIHead` 和 `PartA2BboxHead`，需要根据对应模块的 `__init__` 函数来设置参数。
+
+### 添加新的损失函数
+
+假设您想要为检测框的回归添加一个新的损失函数 `MyLoss`。为了添加一个新的损失函数，用户需要在 `mmdet3d/models/losses/my_loss.py` 中实现该函数。装饰器 `weighted_loss` 能够保证对每个元素的损失进行加权平均。
+
+```python
+import torch
+import torch.nn as nn
+from mmdet.models.losses.utils import weighted_loss
+
+from mmdet3d.registry import MODELS
+
+
+@weighted_loss
+def my_loss(pred, target):
+ assert pred.size() == target.size() and target.numel() > 0
+ loss = torch.abs(pred - target)
+ return loss
+
+
+@MODELS.register_module()
+class MyLoss(nn.Module):
+
+ def __init__(self, reduction='mean', loss_weight=1.0):
+ super(MyLoss, self).__init__()
+ self.reduction = reduction
+ self.loss_weight = loss_weight
+
+ def forward(self,
+ pred,
+ target,
+ weight=None,
+ avg_factor=None,
+ reduction_override=None):
+ assert reduction_override in (None, 'none', 'mean', 'sum')
+ reduction = (
+ reduction_override if reduction_override else self.reduction)
+ loss_bbox = self.loss_weight * my_loss(
+ pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+ return loss_bbox
+```
+
+接下来，用户需要在 `mmdet3d/models/losses/__init__.py` 添加该函数。
+
+```python
+from .my_loss import MyLoss, my_loss
+```
+
+或者在配置文件中添加以下代码以达到相同的目的。
+
+```python
+custom_imports=dict(
+ imports=['mmdet3d.models.losses.my_loss'],
+ allow_failed_imports=False)
+```
+
+为了使用该函数，用户需要修改 `loss_xxx` 域。由于 `MyLoss` 是用于回归的，您需要修改 head 中的 `loss_bbox` 域。
+
+```python
+loss_bbox=dict(type='MyLoss', loss_weight=1.0)
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/customize_runtime.md b/internlm_langchain/knowledge_base/MMDetection3D/content/customize_runtime.md
new file mode 100644
index 00000000..9fea0d10
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/customize_runtime.md
@@ -0,0 +1,382 @@
+# 自定义运行时配置
+
+## 自定义优化器设置
+
+优化器相关的配置是由 `optim_wrapper` 管理的，其通常有三个字段：`optimizer`，`paramwise_cfg`，`clip_grad`。更多细节请参考 [OptimWrapper](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html)。如下所示，使用 `AdamW` 作为`优化器`，骨干网络的学习率降低 10 倍，并添加了梯度裁剪。
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ # 优化器
+ optimizer=dict(
+ type='AdamW',
+ lr=0.0001,
+ weight_decay=0.05,
+ eps=1e-8,
+ betas=(0.9, 0.999)),
+
+ # 参数级学习率及权重衰减系数设置
+ paramwise_cfg=dict(
+ custom_keys={
+ 'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+ },
+ norm_decay_mult=0.0),
+
+ # 梯度裁剪
+ clip_grad=dict(max_norm=0.01, norm_type=2))
+```
+
+### 自定义 PyTorch 支持的优化器
+
+我们已经支持使用所有 PyTorch 实现的优化器，且唯一需要修改的地方就是改变配置文件中的 `optim_wrapper` 字段中的 `optimizer` 字段。例如，如果您想使用 `Adam`（注意这样可能会使性能大幅下降），您可以这样修改：
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='Adam', lr=0.0003, weight_decay=0.0001))
+```
+
+为了修改模型的学习率，用户只需要修改 `optimizer` 中的 `lr` 字段。用户可以根据 PyTorch 的 [API 文档](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim)直接设置参数。
+
+### 自定义并实现优化器
+
+#### 1. 定义新的优化器
+
+一个自定义优化器可以按照如下过程定义：
+
+假设您想要添加一个叫 `MyOptimizer` 的，拥有参数 `a`，`b` 和 `c` 的优化器，您需要创建一个叫做 `mmdet3d/engine/optimizers` 的目录。接下来，应该在目录下某个文件中实现新的优化器，比如 `mmdet3d/engine/optimizers/my_optimizer.py`：
+
+```python
+from torch.optim import Optimizer
+
+from mmdet3d.registry import OPTIMIZERS
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+ def __init__(self, a, b, c):
+ pass
+```
+
+#### 2. 将优化器添加到注册器
+
+为了找到上述定义的优化器模块，该模块首先需要被引入主命名空间。有两种实现方法：
+
+- 修改 `mmdet3d/engine/optimizers/__init__.py` 导入该模块。
+
+ 新定义的模块应该在 `mmdet3d/engine/optimizers/__init__.py` 中被导入，从而被找到并且被添加到注册器中：
+
+ ```python
+ from .my_optimizer import MyOptimizer
+ ```
+
+- 在配置中使用 `custom_imports` 来人工导入新优化器。
+
+ ```python
+ custom_imports = dict(imports=['mmdet3d.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+ ```
+
+ 模块 `mmdet3d.engine.optimizers.my_optimizer` 会在程序开始被导入，且 `MyOptimizer` 类在那时会自动被注册。注意到应该只有包含 `MyOptimizer` 类的包被导入。`mmdet3d.engine.optimizers.my_optimizer.MyOptimizer`**不能**被直接导入。
+
+ 事实上，用户可以在这种导入的方法中使用完全不同的文件目录结构，只要保证根目录能在 `PYTHONPATH` 中被定位。
+
+#### 3. 在配置文件中指定优化器
+
+接下来您可以在配置文件的 `optimizer` 字段中使用 `MyOptimizer`。在配置文件中，优化器在 `optimizer` 字段中以如下方式定义：
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001))
+```
+
+为了使用您自己的优化器，该字段可以改为：
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value))
+```
+
+### 自定义优化器封装构造器
+
+部分模型可能会拥有一些参数专属的优化器设置，比如 BatchNorm 层的权重衰减 (weight decay)。用户可以通过自定义优化器封装构造器来对那些细粒度的参数进行调优。
+
+```python
+from mmengine.optim import DefaultOptimWrapperConstructor
+
+from mmdet3d.registry import OPTIM_WRAPPER_CONSTRUCTORS
+from .my_optimizer import MyOptimizer
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class MyOptimizerWrapperConstructor(DefaultOptimWrapperConstructor):
+
+ def __init__(self,
+ optim_wrapper_cfg: dict,
+ paramwise_cfg: Optional[dict] = None):
+ pass
+
+ def __call__(self, model: nn.Module) -> OptimWrapper:
+
+ return optim_wrapper
+```
+
+默认优化器封装构造器在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L18)实现。这部分代码也可以用作新优化器封装构造器的模板。
+
+### 额外的设置
+
+没有在优化器部分实现的技巧应该通过优化器封装构造器或者钩子来实现（比如逐参数的学习率设置）。我们列举了一些常用的可以稳定训练过程或者加速训练的设置。我们欢迎提供更多类似设置的 PR 和 issue。
+
+- __使用梯度裁剪 (gradient clip) 来稳定训练过程__：一些模型依赖梯度裁剪技术来裁剪训练中的梯度，以稳定训练过程。举例如下：
+
+ ```python
+ optim_wrapper = dict(
+ _delete_=True, clip_grad=dict(max_norm=35, norm_type=2))
+ ```
+
+ 如果您的配置继承了一个已经设置了 `optim_wrapper` 的基础配置，那么您可能需要 `_delete_=True` 字段来覆盖基础配置中无用的设置。更多细节请参考[配置文档](https://mmdetection3d.readthedocs.io/zh_CN/dev-1.x/user_guides/config.html)。
+
+- __使用动量调度器 (momentum scheduler) 来加速模型收敛__：我们支持用动量调度器来根据学习率更改模型的动量，这样可以使模型更快地收敛。动量调度器通常和学习率调度器一起使用，例如，如下配置文件在 [3D 检测](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/schedules/cyclic-20e.py)中被用于加速模型收敛。更多细节请参考 [CosineAnnealingLR](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py#L43) 和 [CosineAnnealingMomentum](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/momentum_scheduler.py#L71) 的实现方法。
+
+ ```python
+ param_scheduler = [
+ # 学习率调度器
+ # 在前 8 个 epoch，学习率从 0 升到 lr * 10
+ # 在接下来 12 个 epoch，学习率从 lr * 10 降到 lr * 1e-4
+ dict(
+ type='CosineAnnealingLR',
+ T_max=8,
+ eta_min=lr * 10,
+ begin=0,
+ end=8,
+ by_epoch=True,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingLR',
+ T_max=12,
+ eta_min=lr * 1e-4,
+ begin=8,
+ end=20,
+ by_epoch=True,
+ convert_to_iter_based=True),
+ # 动量调度器
+ # 在前 8 个 epoch，动量从 0 升到 0.85 / 0.95
+ # 在接下来 12 个 epoch，动量从 0.85 / 0.95 升到 1
+ dict(
+ type='CosineAnnealingMomentum',
+ T_max=8,
+ eta_min=0.85 / 0.95,
+ begin=0,
+ end=8,
+ by_epoch=True,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingMomentum',
+ T_max=12,
+ eta_min=1,
+ begin=8,
+ end=20,
+ by_epoch=True,
+ convert_to_iter_based=True)
+ ]
+ ```
+
+## 自定义训练调度
+
+默认情况下我们使用阶梯式学习率衰减的 1 倍训练调度，这会调用 MMEngine 中的 [`MultiStepLR`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py#L144)。我们在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py)支持了很多其他学习率调度，比如`余弦退火`和`多项式衰减`调度。下面是一些样例：
+
+- 多项式衰减调度：
+
+ ```python
+ param_scheduler = [
+ dict(
+ type='PolyLR',
+ power=0.9,
+ eta_min=1e-4,
+ begin=0,
+ end=8,
+ by_epoch=True)]
+ ```
+
+- 余弦退火调度：
+
+ ```python
+ param_scheduler = [
+ dict(
+ type='CosineAnnealingLR',
+ T_max=8,
+ eta_min=lr * 1e-5,
+ begin=0,
+ end=8,
+ by_epoch=True)]
+ ```
+
+## 自定义训练循环控制器
+
+默认情况下，我们在 `train_cfg` 中使用 `EpochBasedTrainLoop`，并在每一个训练 epoch 完成后进行一次验证，如下所示：
+
+```python
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_begin=1, val_interval=1)
+```
+
+事实上，[`IterBasedTrainLoop`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L185) 和 [`EpochBasedTrainLoop`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L18) 都支持动态间隔验证，如下所示：
+
+```python
+# 在第 365001 次迭代之前，我们每隔 5000 次迭代验证一次。
+# 在第 365000 次迭代之后，我们每隔 368750 次迭代验证一次，
+# 这意味着我们在训练结束后进行验证。
+
+interval = 5000
+max_iters = 368750
+dynamic_intervals = [(max_iters // interval * interval + 1, max_iters)]
+train_cfg = dict(
+ type='IterBasedTrainLoop',
+ max_iters=max_iters,
+ val_interval=interval,
+ dynamic_intervals=dynamic_intervals)
+```
+
+## 自定义钩子
+
+### 自定义并实现钩子
+
+#### 1. 实现一个新钩子
+
+MMEngine 提供了一些实用的[钩子](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html)，但有些场合用户可能需要实现一个新的钩子。在 v1.1.0rc0 之后，MMDetection3D 在训练时支持基于 MMEngine 自定义钩子。因此用户可以直接在 mmdet3d 或者基于 mmdet3d 的代码库中实现钩子并通过更改训练配置来使用钩子。这里我们给出一个在 mmdet3d 中创建并使用新钩子的例子。
+
+```python
+from mmengine.hooks import Hook
+
+from mmdet3d.registry import HOOKS
+
+
+@HOOKS.register_module()
+class MyHook(Hook):
+
+ def __init__(self, a, b):
+
+ def before_run(self, runner) -> None:
+
+ def after_run(self, runner) -> None:
+
+ def before_train(self, runner) -> None:
+
+ def after_train(self, runner) -> None:
+
+ def before_train_epoch(self, runner) -> None:
+
+ def after_train_epoch(self, runner) -> None:
+
+ def before_train_iter(self,
+ runner,
+ batch_idx: int,
+ data_batch: DATA_BATCH = None) -> None:
+
+ def after_train_iter(self,
+ runner,
+ batch_idx: int,
+ data_batch: DATA_BATCH = None,
+ outputs: Optional[dict] = None) -> None:
+```
+
+用户需要根据钩子的功能指定钩子在每个训练阶段时的行为，具体包括如下阶段：`before_run`，`after_run`，`before_train`，`after_train`，`before_train_epoch`，`after_train_epoch`，`before_train_iter`，和 `after_train_iter`。有更多的位点可以插入钩子，详情可参考 [base hook class](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/hook.py#L9)。
+
+#### 2. 注册新钩子
+
+接下来我们需要导入 `MyHook`。假设新钩子位于文件 `mmdet3d/engine/hooks/my_hook.py` 中，有两种实现方法：
+
+- 修改 `mmdet3d/engine/hooks/__init__.py` 导入该模块。
+
+ 新定义的模块应该在 `mmdet3d/engine/hooks/__init__.py` 中被导入，从而被找到并且被添加到注册器中：
+
+ ```python
+ from .my_hook import MyHook
+ ```
+
+- 在配置中使用 `custom_imports` 来人为地导入新钩子。
+
+ ```python
+ custom_imports = dict(imports=['mmdet3d.engine.hooks.my_hook'], allow_failed_imports=False)
+ ```
+
+#### 3. 更改配置文件
+
+```python
+custom_hooks = [
+ dict(type='MyHook', a=a_value, b=b_value)
+]
+```
+
+您可以将字段 `priority` 设置为 `'NORMAL'` 或者 `'HIGHEST'` 来设置钩子的优先级，如下所示：
+
+```python
+custom_hooks = [
+ dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+默认情况下，注册阶段钩子的优先级为 `'NORMAL'`。
+
+### 使用 MMDetection3D 中实现的钩子
+
+如果 MMDetection3D 中已经实现了该钩子，您可以直接通过更改配置文件来使用该钩子。
+
+#### 例子：`DisableObjectSampleHook`
+
+我们实现了一个名为 [DisableObjectSampleHook](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/mmdet3d/engine/hooks/disable_object_sample_hook.py) 的自定义钩子在训练阶段达到指定 epoch 后禁用 `ObjectSample` 增强策略。
+
+如果有需要的话我们可以在配置文件中设置它：
+
+```python
+custom_hooks = [dict(type='DisableObjectSampleHook', disable_after_epoch=15)]
+```
+
+### 更改默认的运行时钩子
+
+有一些常用的钩子通过 `default_hooks` 注册，它们是：
+
+- `IterTimerHook`：该钩子用来记录加载数据的时间 'data_time' 和模型训练一步的时间 'time'。
+- `LoggerHook`：该钩子用来从`执行器（Runner）`的不同组件收集日志并将其写入终端，json 文件，tensorboard 和 wandb 等。
+- `ParamSchedulerHook`：该钩子用来更新优化器中的一些超参数，例如学习率和动量。
+- `CheckpointHook`：该钩子用来定期地保存检查点。
+- `DistSamplerSeedHook`：该钩子用来设置采样和批采样的种子。
+- `Det3DVisualizationHook`：该钩子用来可视化验证和测试过程的预测结果。
+
+`IterTimerHook`，`ParamSchedulerHook` 和 `DistSamplerSeedHook` 都很简单，通常不需要修改，因此此处我们将介绍如何使用 `LoggerHook`，`CheckpointHook` 和 `Det3DVisualizationHook`。
+
+#### CheckpointHook
+
+除了定期地保存检查点，[`CheckpointHook`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L18) 提供了其它的可选项例如 `max_keep_ckpts`，`save_optimizer` 等。用户可以设置 `max_keep_ckpts` 只保存少量的检查点或者通过 `save_optimizer` 决定是否保存优化器的状态。参数的更多细节请参考[此处](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L18)。
+
+```python
+default_hooks = dict(
+ checkpoint=dict(
+ type='CheckpointHook',
+ interval=1,
+ max_keep_ckpts=3,
+ save_optimizer=True))
+```
+
+#### LoggerHook
+
+`LoggerHook` 允许设置日志记录间隔。详细介绍可参考[文档](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py#L19)。
+
+```python
+default_hooks = dict(logger=dict(type='LoggerHook', interval=50))
+```
+
+#### Det3DVisualizationHook
+
+`Det3DVisualizationHook` 使用 `DetLocalVisualizer` 来可视化预测结果，`Det3DLocalVisualizer` 支持不同的后端，例如 `TensorboardVisBackend` 和 `WandbVisBackend`（更多细节请参考[文档](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py)）。用户可以添加多个后端来进行可视化，如下所示。
+
+```python
+default_hooks = dict(
+ visualization=dict(type='Det3DVisualizationHook', draw=True))
+
+vis_backends = [dict(type='LocalVisBackend'),
+ dict(type='TensorboardVisBackend')]
+visualizer = dict(
+ type='Det3DLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/data_pipeline.md b/internlm_langchain/knowledge_base/MMDetection3D/content/data_pipeline.md
new file mode 100644
index 00000000..cf50d70f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/data_pipeline.md
@@ -0,0 +1,191 @@
+# 自定义数据预处理流程
+
+## 数据预处理流程的设计
+
+遵循一般惯例，我们使用 `Dataset` 和 `DataLoader` 来调用多个进程进行数据的加载。`Dataset` 将会返回与模型前向传播的参数所对应的数据项构成的字典。因为目标检测中的数据的尺寸可能无法保持一致（如点云中点的数量、真实标注框的尺寸等），我们在 MMCV 中引入一个 `DataContainer` 类型，来帮助收集和分发不同尺寸的数据。请参考[此处](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py)获取更多细节。
+
+数据预处理流程和数据集之间是互相分离的两个部分，通常数据集定义了如何处理标注信息，而数据预处理流程定义了准备数据项字典的所有步骤。数据集预处理流程包含一系列的操作，每个操作将一个字典作为输入，并输出应用于下一个转换的一个新的字典。
+
+我们将在下图中展示一个最经典的数据集预处理流程，其中蓝色框表示预处理流程中的各项操作。随着预处理的进行，每一个操作都会添加新的键值（图中标记为绿色）到输出字典中，或者更新当前存在的键值（图中标记为橙色）。
+
+
+
+预处理流程中的各项操作主要分为数据加载、预处理、格式化、测试时的数据增强。
+
+接下来将展示一个用于 PointPillars 模型的数据集预处理流程的例子。
+
+```python
+train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ load_dim=5,
+ use_dim=5,
+ backend_args=backend_args),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10,
+ backend_args=backend_args),
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.3925, 0.3925],
+ scale_ratio_range=[0.95, 1.05],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectNameFilter', classes=class_names),
+ dict(type='PointShuffle'),
+ dict(type='DefaultFormatBundle3D', class_names=class_names),
+ dict(type='Collect3D', keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+test_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ load_dim=5,
+ use_dim=5,
+ backend_args=backend_args),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10,
+ backend_args=backend_args),
+ dict(
+ type='MultiScaleFlipAug',
+ img_scale=(1333, 800),
+ pts_scale_ratio=1.0,
+ flip=False,
+ pcd_horizontal_flip=False,
+ pcd_vertical_flip=False,
+ transforms=[
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[0, 0],
+ scale_ratio_range=[1., 1.],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D'),
+ dict(
+ type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(
+ type='DefaultFormatBundle3D',
+ class_names=class_names,
+ with_label=False),
+ dict(type='Collect3D', keys=['points'])
+ ])
+]
+```
+
+对于每项操作，我们将列出相关的被添加/更新/移除的字典项。
+
+### 数据加载
+
+`LoadPointsFromFile`
+
+- 添加：points
+
+`LoadPointsFromMultiSweeps`
+
+- 更新：points
+
+`LoadAnnotations3D`
+
+- 添加：gt_bboxes_3d, gt_labels_3d, gt_bboxes, gt_labels, pts_instance_mask, pts_semantic_mask, bbox3d_fields, pts_mask_fields, pts_seg_fields
+
+### 预处理
+
+`GlobalRotScaleTrans`
+
+- 添加：pcd_trans, pcd_rotation, pcd_scale_factor
+- 更新：points, \*bbox3d_fields
+
+`RandomFlip3D`
+
+- 添加：flip, pcd_horizontal_flip, pcd_vertical_flip
+- 更新：points, \*bbox3d_fields
+
+`PointsRangeFilter`
+
+- 更新：points
+
+`ObjectRangeFilter`
+
+- 更新：gt_bboxes_3d, gt_labels_3d
+
+`ObjectNameFilter`
+
+- 更新：gt_bboxes_3d, gt_labels_3d
+
+`PointShuffle`
+
+- 更新：points
+
+`PointsRangeFilter`
+
+- 更新：points
+
+### 格式化
+
+`DefaultFormatBundle3D`
+
+- 更新：points, gt_bboxes_3d, gt_labels_3d, gt_bboxes, gt_labels
+
+`Collect3D`
+
+- 添加：img_meta （由 `meta_keys` 指定的键值构成的 img_meta）
+- 移除：所有除 `keys` 指定的键值以外的其他键值
+
+### 测试时的数据增强
+
+`MultiScaleFlipAug`
+
+- 更新: scale, pcd_scale_factor, flip, flip_direction, pcd_horizontal_flip, pcd_vertical_flip （与这些指定的参数对应的增强后的数据列表）
+
+## 扩展并使用自定义数据集预处理方法
+
+1. 在任意文件中写入新的数据集预处理方法，如 `my_pipeline.py`，该预处理方法的输入和输出均为字典
+
+ ```python
+ from mmdet.datasets import PIPELINES
+
+ @PIPELINES.register_module()
+ class MyTransform:
+
+ def __call__(self, results):
+ results['dummy'] = True
+ return results
+ ```
+
+2. 导入新的预处理方法类
+
+ ```python
+ from .my_pipeline import MyTransform
+ ```
+
+3. 在配置文件中使用该数据集预处理方法
+
+ ```python
+ train_pipeline = [
+ dict(
+ type='LoadPointsFromFile',
+ load_dim=5,
+ use_dim=5,
+ backend_args=backend_args),
+ dict(
+ type='LoadPointsFromMultiSweeps',
+ sweeps_num=10,
+ backend_args=backend_args),
+ dict(type='LoadAnnotations3D', with_bbox_3d=True, with_label_3d=True),
+ dict(
+ type='GlobalRotScaleTrans',
+ rot_range=[-0.3925, 0.3925],
+ scale_ratio_range=[0.95, 1.05],
+ translation_std=[0, 0, 0]),
+ dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+ dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+ dict(type='ObjectNameFilter', classes=class_names),
+ dict(type='MyTransform'),
+ dict(type='PointShuffle'),
+ dict(type='DefaultFormatBundle3D', class_names=class_names),
+ dict(type='Collect3D', keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+ ]
+ ```
diff --git a/internlm_langchain/knowledge_base/MMDetection3D/content/dataset_prepare.md b/internlm_langchain/knowledge_base/MMDetection3D/content/dataset_prepare.md
new file mode 100644
index 00000000..917015dc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMDetection3D/content/dataset_prepare.md
@@ -0,0 +1,233 @@
+# 数据预处理
+
+## 在数据预处理前
+
+我们推荐用户将数据集的路径软链接到 `$MMDETECTION3D/data`。如果你的文件夹结构和以下所展示的结构不一致，你可能需要改变配置文件中相应的数据路径。
+
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│ ├── nuscenes
+│ │ ├── maps
+│ │ ├── samples
+│ │ ├── sweeps
+│ │ ├── v1.0-test
+| | ├── v1.0-trainval
+│ ├── kitti
+│ │ ├── ImageSets
+│ │ ├── testing
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── velodyne
+│ │ ├── training
+│ │ │ ├── calib
+│ │ │ ├── image_2
+│ │ │ ├── label_2
+│ │ │ ├── velodyne
+│ ├── waymo
+│ │ ├── waymo_format
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── testing
+│ │ │ ├── gt.bin
+│ │ ├── kitti_format
+│ │ │ ├── ImageSets
+│ ├── lyft
+│ │ ├── v1.01-train
+│ │ │ ├── v1.01-train (训练数据)
+│ │ │ ├── lidar (训练激光雷达)
+│ │ │ ├── images (训练图片)
+│ │ │ ├── maps (训练地图)
+│ │ ├── v1.01-test
+│ │ │ ├── v1.01-test (测试数据)
+│ │ │ ├── lidar (测试激光雷达)
+│ │ │ ├── images (测试图片)
+│ │ │ ├── maps (测试地图)
+│ │ ├── train.txt
+│ │ ├── val.txt
+│ │ ├── test.txt
+│ │ ├── sample_submission.csv
+│ ├── s3dis
+│ │ ├── meta_data
+│ │ ├── Stanford3dDataset_v1.2_Aligned_Version
+│ │ ├── collect_indoor3d_data.py
+│ │ ├── indoor3d_util.py
+│ │ ├── README.md
+│ ├── scannet
+│ │ ├── meta_data
+│ │ ├── scans
+│ │ ├── scans_test
+│ │ ├── batch_load_scannet_data.py
+│ │ ├── load_scannet_data.py
+│ │ ├── scannet_utils.py
+│ │ ├── README.md
+│ ├── sunrgbd
+│ │ ├── OFFICIAL_SUNRGBD
+│ │ ├── matlab
+│ │ ├── sunrgbd_data.py
+│ │ ├── sunrgbd_utils.py
+│ │ ├── README.md
+
+```
+
+## 数据下载和预处理
+
+### KITTI
+
+在[这里](http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d)下载 KITTI 的 3D 检测数据。通过运行以下指令对 KITTI 数据进行预处理：
+
+```bash
+mkdir ./data/kitti/ && mkdir ./data/kitti/ImageSets
+
+# 下载数据划分文件
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/test.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/test.txt
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/train.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/train.txt
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/val.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/val.txt
+wget -c https://raw.githubusercontent.com/traveller59/second.pytorch/master/second/data/ImageSets/trainval.txt --no-check-certificate --content-disposition -O ./data/kitti/ImageSets/trainval.txt
+```
+
+然后通过运行以下指令生成信息文件：
+
+```bash
+python tools/create_data.py kitti --root-path ./data/kitti --out-dir ./data/kitti --extra-tag kitti
+```
+
+在使用 slurm 的环境下，用户需要使用下面的指令：
+
+```bash
+sh tools/create_data.sh + （为了对相同模型进行测试所做的具体修改 - 点击展开） +
+ + ```diff + diff --git a/tools/scripts/train.sh b/tools/scripts/train.sh + index 3a93f95..461e0ea 100755 + --- a/tools/scripts/train.sh + +++ b/tools/scripts/train.sh + @@ -16,9 +16,9 @@ then + fi + + # Voxelnet + -python -m torch.distributed.launch --nproc_per_node=8 ./tools/train.py examples/second/configs/ kitti_car_vfev3_spmiddlefhd_rpn1_mghead_syncbn.py --work_dir=$SECOND_WORK_DIR + +# python -m torch.distributed.launch --nproc_per_node=8 ./tools/train.py examples/second/configs/ kitti_car_vfev3_spmiddlefhd_rpn1_mghead_syncbn.py --work_dir=$SECOND_WORK_DIR + # python -m torch.distributed.launch --nproc_per_node=8 ./tools/train.py examples/cbgs/configs/ nusc_all_vfev3_spmiddleresnetfhd_rpn2_mghead_syncbn.py --work_dir=$NUSC_CBGS_WORK_DIR + # python -m torch.distributed.launch --nproc_per_node=8 ./tools/train.py examples/second/configs/ lyft_all_vfev3_spmiddleresnetfhd_rpn2_mghead_syncbn.py --work_dir=$LYFT_CBGS_WORK_DIR + + # PointPillars + -# python -m torch.distributed.launch --nproc_per_node=8 ./tools/train.py ./examples/point_pillars/configs/ original_pp_mghead_syncbn_kitti.py --work_dir=$PP_WORK_DIR + +python -m torch.distributed.launch --nproc_per_node=8 ./tools/train.py ./examples/point_pillars/configs/ kitti_point_pillars_mghead_syncbn.py + ``` + +
+
+```python
+import torch.nn.functional as F
+import torchvision
+import torchvision.transforms as transforms
+from torch.optim import SGD
+from torch.utils.data import DataLoader
+
+from mmengine.evaluator import BaseMetric
+from mmengine.model import BaseModel
+from mmengine.runner import Runner
+
+
+class MMResNet50(BaseModel):
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+
+ def forward(self, imgs, labels, mode):
+ x = self.resnet(imgs)
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+
+
+class Accuracy(BaseMetric):
+ def process(self, data_batch, data_samples):
+ score, gt = data_samples
+ self.results.append({
+ 'batch_size': len(gt),
+ 'correct': (score.argmax(dim=1) == gt).sum().cpu(),
+ })
+
+ def compute_metrics(self, results):
+ total_correct = sum(item['correct'] for item in results)
+ total_size = sum(item['batch_size'] for item in results)
+ return dict(accuracy=100 * total_correct / total_size)
+
+
+norm_cfg = dict(mean=[0.491, 0.482, 0.447], std=[0.202, 0.199, 0.201])
+train_dataloader = DataLoader(batch_size=32,
+ shuffle=True,
+ dataset=torchvision.datasets.CIFAR10(
+ 'data/cifar10',
+ train=True,
+ download=True,
+ transform=transforms.Compose([
+ transforms.RandomCrop(32, padding=4),
+ transforms.RandomHorizontalFlip(),
+ transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)
+ ])))
+
+val_dataloader = DataLoader(batch_size=32,
+ shuffle=False,
+ dataset=torchvision.datasets.CIFAR10(
+ 'data/cifar10',
+ train=False,
+ download=True,
+ transform=transforms.Compose([
+ transforms.ToTensor(),
+ transforms.Normalize(**norm_cfg)
+ ])))
+
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+)
+runner.train()
+```
+
+输出的训练日志如下：
+
+```
+2022/08/22 15:51:53 - mmengine - INFO -
+------------------------------------------------------------
+System environment:
+ sys.platform: linux
+ Python: 3.8.12 (default, Oct 12 2021, 13:49:34) [GCC 7.5.0]
+ CUDA available: True
+ numpy_random_seed: 1513128759
+ GPU 0: NVIDIA GeForce GTX 1660 SUPER
+ CUDA_HOME: /usr/local/cuda
+...
+
+2022/08/22 15:51:54 - mmengine - INFO - Checkpoints will be saved to /home/mazerun/work_dir by HardDiskBackend.
+2022/08/22 15:51:56 - mmengine - INFO - Epoch(train) [1][10/1563] lr: 1.0000e-03 eta: 0:18:23 time: 0.1414 data_time: 0.0077 memory: 392 loss: 5.3465
+2022/08/22 15:51:56 - mmengine - INFO - Epoch(train) [1][20/1563] lr: 1.0000e-03 eta: 0:11:29 time: 0.0354 data_time: 0.0077 memory: 392 loss: 2.7734
+2022/08/22 15:51:56 - mmengine - INFO - Epoch(train) [1][30/1563] lr: 1.0000e-03 eta: 0:09:10 time: 0.0352 data_time: 0.0076 memory: 392 loss: 2.7789
+2022/08/22 15:51:57 - mmengine - INFO - Epoch(train) [1][40/1563] lr: 1.0000e-03 eta: 0:08:00 time: 0.0353 data_time: 0.0073 memory: 392 loss: 2.5725
+2022/08/22 15:51:57 - mmengine - INFO - Epoch(train) [1][50/1563] lr: 1.0000e-03 eta: 0:07:17 time: 0.0347 data_time: 0.0073 memory: 392 loss: 2.7382
+2022/08/22 15:51:57 - mmengine - INFO - Epoch(train) [1][60/1563] lr: 1.0000e-03 eta: 0:06:49 time: 0.0347 data_time: 0.0072 memory: 392 loss: 2.5956
+2022/08/22 15:51:58 - mmengine - INFO - Epoch(train) [1][70/1563] lr: 1.0000e-03 eta: 0:06:28 time: 0.0348 data_time: 0.0072 memory: 392 loss: 2.7351
+...
+2022/08/22 15:52:50 - mmengine - INFO - Saving checkpoint at 1 epochs
+2022/08/22 15:52:51 - mmengine - INFO - Epoch(val) [1][10/313] eta: 0:00:03 time: 0.0122 data_time: 0.0047 memory: 392
+2022/08/22 15:52:51 - mmengine - INFO - Epoch(val) [1][20/313] eta: 0:00:03 time: 0.0122 data_time: 0.0047 memory: 308
+2022/08/22 15:52:51 - mmengine - INFO - Epoch(val) [1][30/313] eta: 0:00:03 time: 0.0123 data_time: 0.0047 memory: 308
+...
+2022/08/22 15:52:54 - mmengine - INFO - Epoch(val) [1][313/313] accuracy: 35.7000
+```
+
+基于 PyTorch 和基于 MMEngine 的训练流程对比如下：
+
+
+
+除了以上基础组件，你还可以利用**执行器**轻松地组合配置各种训练技巧，如开启混合精度训练和梯度累积（见 [优化器封装（OptimWrapper）](../tutorials/optim_wrapper.md)）、配置学习率衰减曲线（见 [评测指标与评测器（Metrics & Evaluator）](../tutorials/evaluation.md)）等。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/basedataset.md b/internlm_langchain/knowledge_base/MMEngine/content/basedataset.md
new file mode 100644
index 00000000..1e069826
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/basedataset.md
@@ -0,0 +1,501 @@
+# 数据集基类（BaseDataset）
+
+## 基本介绍
+
+算法库中的数据集类负责在训练/测试过程中为模型提供输入数据，OpenMMLab 下各个算法库中的数据集有一些共同的特点和需求，比如需要高效的内部数据存储格式，需要支持数据集拼接、数据集重复采样等功能。
+
+因此 **MMEngine** 实现了一个数据集基类（BaseDataset）并定义了一些基本接口，且基于这套接口实现了一些数据集包装（DatasetWrapper）。OpenMMLab 算法库中的大部分数据集都会满足这套数据集基类定义的接口，并使用统一的数据集包装。
+
+数据集基类的基本功能是加载数据集信息，这里我们将数据集信息分成两类，一种是元信息 (meta information)，代表数据集自身相关的信息，有时需要被模型或其他外部组件获取，比如在图像分类任务中，数据集的元信息一般包含类别信息 `classes`，因为分类模型 `model` 一般需要记录数据集的类别信息；另一种为数据信息 (data information)，在数据信息中，定义了具体样本的文件路径、对应标签等的信息。除此之外，数据集基类的另一个功能为不断地将数据送入数据流水线（data pipeline）中，进行数据预处理。
+
+### 数据标注文件规范
+
+为了统一不同任务的数据集接口，便于多任务的算法模型训练，OpenMMLab 制定了 **OpenMMLab 2.0 数据集格式规范**， 数据集标注文件需符合该规范，数据集基类基于该规范去读取与解析数据标注文件。如果用户提供的数据标注文件不符合规定格式，用户可以选择将其转化为规定格式，并使用 OpenMMLab 的算法库基于该数据标注文件进行算法训练和测试。
+
+OpenMMLab 2.0 数据集格式规范规定，标注文件必须为 `json` 或 `yaml`，`yml` 或 `pickle`，`pkl` 格式；标注文件中存储的字典必须包含 `metainfo` 和 `data_list` 两个字段。其中 `metainfo` 是一个字典，里面包含数据集的元信息；`data_list` 是一个列表，列表中每个元素是一个字典，该字典定义了一个原始数据（raw data），每个原始数据包含一个或若干个训练/测试样本。
+
+以下是一个 JSON 标注文件的例子（该例子中每个原始数据只包含一个训练/测试样本）:
+
+```json
+
+{
+ "metainfo":
+ {
+ "classes": ["cat", "dog"]
+ },
+ "data_list":
+ [
+ {
+ "img_path": "xxx/xxx_0.jpg",
+ "img_label": 0
+ },
+ {
+ "img_path": "xxx/xxx_1.jpg",
+ "img_label": 1
+ }
+ ]
+}
+```
+
+同时假设数据存放路径如下：
+
+```text
+data
+├── annotations
+│ ├── train.json
+├── train
+│ ├── xxx/xxx_0.jpg
+│ ├── xxx/xxx_1.jpg
+│ ├── ...
+```
+
+### 数据集基类的初始化流程
+
+数据集基类的初始化流程如下图所示：
+
+
+ 
+
+
+1. `load metainfo`：获取数据集的元信息，元信息有三种来源，优先级从高到低为：
+
+- `__init__()` 方法中用户传入的 `metainfo` 字典；改动频率最高，因为用户可以在实例化数据集时，传入该参数；
+
+- 类属性 `BaseDataset.METAINFO` 字典；改动频率中等，因为用户可以改动自定义数据集类中的类属性 `BaseDataset.METAINFO`；
+
+- 标注文件中包含的 `metainfo` 字典；改动频率最低，因为标注文件一般不做改动。
+
+ 如果三种来源中有相同的字段，优先级最高的来源决定该字段的值，这些字段的优先级比较是：用户传入的 `metainfo` 字典里的字段 > `BaseDataset.METAINFO` 字典里的字段 > 标注文件中 `metainfo` 字典里的字段。
+
+2. `join path`：处理数据与标注文件的路径；
+
+3. `build pipeline`：构建数据流水线（data pipeline），用于数据预处理与数据准备；
+
+4. `full init`：完全初始化数据集类，该步骤主要包含以下操作：
+
+- `load data list`：读取与解析满足 OpenMMLab 2.0 数据集格式规范的标注文件，该步骤中会调用 `parse_data_info()` 方法，该方法负责解析标注文件里的每个原始数据；
+
+- `filter data` (可选)：根据 `filter_cfg` 过滤无用数据，比如不包含标注的样本等；默认不做过滤操作，下游子类可以按自身所需对其进行重写；
+
+- `get subset` (可选)：根据给定的索引或整数值采样数据，比如只取前 10 个样本参与训练/测试；默认不采样数据，即使用全部数据样本；
+
+- `serialize data` (可选)：序列化全部样本，以达到节省内存的效果，详情请参考[节省内存](#节省内存)；默认操作为序列化全部样本。
+
+数据集基类中包含的 `parse_data_info()` 方法用于将标注文件里的一个原始数据处理成一个或若干个训练/测试样本的方法。因此对于自定义数据集类，用户需要实现 `parse_data_info()` 方法。
+
+### 数据集基类提供的接口
+
+与 `torch.utils.data.Dataset` 类似，数据集初始化后，支持 `__getitem__` 方法，用来索引数据，以及 `__len__` 操作获取数据集大小，除此之外，OpenMMLab 的数据集基类主要提供了以下接口来访问具体信息：
+
+- `metainfo`：返回元信息，返回值为字典
+
+- `get_data_info(idx)`：返回指定 `idx` 的样本全量信息，返回值为字典
+
+- `__getitem__(idx)`：返回指定 `idx` 的样本经过 pipeline 之后的结果（也就是送入模型的数据），返回值为字典
+
+- `__len__()`：返回数据集长度，返回值为整数型
+
+- `get_subset_(indices)`：根据 `indices` 以 inplace 的方式**修改原数据集类**。如果 `indices` 为 `int`，则原数据集类只包含前若干个数据样本；如果 `indices` 为 `Sequence[int]`，则原数据集类包含根据 `Sequence[int]` 指定的数据样本。
+
+- `get_subset(indices)`：根据 `indices` 以**非** inplace 的方式**返回子数据集类**，即重新复制一份子数据集。如果 `indices` 为 `int`，则返回的子数据集类只包含前若干个数据样本；如果 `indices` 为 `Sequence[int]`，则返回的子数据集类包含根据 `Sequence[int]` 指定的数据样本。
+
+## 使用数据集基类自定义数据集类
+
+在了解了数据集基类的初始化流程与提供的接口之后，就可以基于数据集基类自定义数据集类。
+
+### 对于满足 OpenMMLab 2.0 数据集格式规范的标注文件
+
+如上所述，对于满足 OpenMMLab 2.0 数据集格式规范的标注文件，用户可以重载 `parse_data_info()` 来加载标签。以下是一个使用数据集基类来实现某一具体数据集的例子。
+
+```python
+import os.path as osp
+
+from mmengine.dataset import BaseDataset
+
+
+class ToyDataset(BaseDataset):
+
+ # 以上面标注文件为例，在这里 raw_data_info 代表 `data_list` 对应列表里的某个字典：
+ # {
+ # 'img_path': "xxx/xxx_0.jpg",
+ # 'img_label': 0,
+ # ...
+ # }
+ def parse_data_info(self, raw_data_info):
+ data_info = raw_data_info
+ img_prefix = self.data_prefix.get('img_path', None)
+ if img_prefix is not None:
+ data_info['img_path'] = osp.join(
+ img_prefix, data_info['img_path'])
+ return data_info
+
+```
+
+#### 使用自定义数据集类
+
+在定义了数据集类后，就可以通过如下配置实例化 `ToyDataset`：
+
+```python
+
+class LoadImage:
+
+ def __call__(self, results):
+ results['img'] = cv2.imread(results['img_path'])
+ return results
+
+class ParseImage:
+
+ def __call__(self, results):
+ results['img_shape'] = results['img'].shape
+ return results
+
+pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='train/'),
+ ann_file='annotations/train.json',
+ pipeline=pipeline)
+```
+
+同时可以使用数据集类提供的对外接口访问具体的样本信息：
+
+```python
+toy_dataset.metainfo
+# dict(classes=('cat', 'dog'))
+
+toy_dataset.get_data_info(0)
+# {
+# 'img_path': "data/train/xxx/xxx_0.jpg",
+# 'img_label': 0,
+# ...
+# }
+
+len(toy_dataset)
+# 2
+
+toy_dataset[0]
+# {
+# 'img_path': "data/train/xxx/xxx_0.jpg",
+# 'img_label': 0,
+# 'img': a ndarray with shape (H, W, 3), which denotes the value of the image,
+# 'img_shape': (H, W, 3) ,
+# ...
+# }
+
+# `get_subset` 接口不对原数据集类做修改，即完全复制一份新的
+sub_toy_dataset = toy_dataset.get_subset(1)
+len(toy_dataset), len(sub_toy_dataset)
+# 2, 1
+
+# `get_subset_` 接口会对原数据集类做修改，即 inplace 的方式
+toy_dataset.get_subset_(1)
+len(toy_dataset)
+# 1
+```
+
+经过以上步骤，可以了解基于数据集基类如何自定义新的数据集类，以及如何使用自定义数据集类。
+
+#### 自定义视频的数据集类
+
+在上面的例子中，标注文件的每个原始数据只包含一个训练/测试样本（通常是图像领域）。如果每个原始数据包含若干个训练/测试样本（通常是视频领域），则只需保证 `parse_data_info()` 的返回值为 `list[dict]` 即可：
+
+```python
+from mmengine.dataset import BaseDataset
+
+
+class ToyVideoDataset(BaseDataset):
+
+ # raw_data_info 仍为一个字典，但它包含了多个样本
+ def parse_data_info(self, raw_data_info):
+ data_list = []
+
+ ...
+
+ for ... :
+
+ data_info = dict()
+
+ ...
+
+ data_list.append(data_info)
+
+ return data_list
+
+```
+
+`ToyVideoDataset` 使用方法与 `ToyDataset` 类似，在此不做赘述。
+
+### 对于不满足 OpenMMLab 2.0 数据集格式规范的标注文件
+
+对于不满足 OpenMMLab 2.0 数据集格式规范的标注文件，有两种方式来使用数据集基类：
+
+1. 将不满足规范的标注文件转换成满足规范的标注文件，再通过上述方式使用数据集基类。
+
+2. 实现一个新的数据集类，继承自数据集基类，并且重载数据集基类的 `load_data_list(self):` 函数，处理不满足规范的标注文件，并保证返回值为 `list[dict]`，其中每个 `dict` 代表一个数据样本。
+
+## 数据集基类的其它特性
+
+数据集基类还包含以下特性：
+
+### 懒加载（lazy init）
+
+在数据集类实例化时，需要读取并解析标注文件，因此会消耗一定时间。然而在某些情况比如预测可视化时，往往只需要数据集类的元信息，可能并不需要读取与解析标注文件。为了节省这种情况下数据集类实例化的时间，数据集基类支持懒加载：
+
+```python
+pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='train/'),
+ ann_file='annotations/train.json',
+ pipeline=pipeline,
+ # 在这里传入 lazy_init 变量
+ lazy_init=True)
+```
+
+当 `lazy_init=True` 时，`ToyDataset` 的初始化方法只执行了[数据集基类的初始化流程](#数据集基类的初始化流程)中的 1、2、3 步骤，此时 `toy_dataset` 并未被完全初始化，因为 `toy_dataset` 并不会读取与解析标注文件，只会设置数据集类的元信息（`metainfo`）。
+
+自然的，如果之后需要访问具体的数据信息，可以手动调用 `toy_dataset.full_init()` 接口来执行完整的初始化过程，在这个过程中数据标注文件将被读取与解析。调用 `get_data_info(idx)`, `__len__()`, `__getitem__(idx)`，`get_subset_(indices)`， `get_subset(indices)` 接口也会自动地调用 `full_init()` 接口来执行完整的初始化过程（仅在第一次调用时，之后调用不会重复地调用 `full_init()` 接口）：
+
+```python
+# 完整初始化
+toy_dataset.full_init()
+
+# 初始化完毕，现在可以访问具体数据
+len(toy_dataset)
+# 2
+toy_dataset[0]
+# {
+# 'img_path': "data/train/xxx/xxx_0.jpg",
+# 'img_label': 0,
+# 'img': a ndarray with shape (H, W, 3), which denotes the value the image,
+# 'img_shape': (H, W, 3) ,
+# ...
+# }
+```
+
+**注意：**
+
+通过直接调用 `__getitem__()` 接口来执行完整初始化会带来一定风险：如果一个数据集类首先通过设置 `lazy_init=True` 未进行完全初始化，然后直接送入数据加载器（dataloader）中，在后续读取数据的过程中，不同的 worker 会同时读取与解析标注文件，虽然这样可能可以正常运行，但是会消耗大量的时间与内存。**因此，建议在需要访问具体数据之前，提前手动调用 `full_init()` 接口来执行完整的初始化过程。**
+
+以上通过设置 `lazy_init=True` 未进行完全初始化，之后根据需求再进行完整初始化的方式，称为懒加载。
+
+### 节省内存
+
+在具体的读取数据过程中，数据加载器（dataloader）通常会起多个 worker 来预取数据，多个 worker 都拥有完整的数据集类备份，因此内存中会存在多份相同的 `data_list`，为了节省这部分内存消耗，数据集基类可以提前将 `data_list` 序列化存入内存中，使得多个 worker 可以共享同一份 `data_list`，以达到节省内存的目的。
+
+数据集基类默认是将 `data_list` 序列化存入内存，也可以通过 `serialize_data` 变量（默认为 `True`）来控制是否提前将 `data_list` 序列化存入内存中：
+
+```python
+pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='train/'),
+ ann_file='annotations/train.json',
+ pipeline=pipeline,
+ # 在这里传入 serialize_data 变量
+ serialize_data=False)
+```
+
+上面例子不会提前将 `data_list` 序列化存入内存中，因此不建议在使用数据加载器开多个 worker 加载数据的情况下，使用这种方式实例化数据集类。
+
+## 数据集基类包装
+
+除了数据集基类，MMEngine 也提供了若干个数据集基类包装：`ConcatDataset`, `RepeatDataset`, `ClassBalancedDataset`。这些数据集基类包装同样也支持懒加载与拥有节省内存的特性。
+
+### ConcatDataset
+
+MMEngine 提供了 `ConcatDataset` 包装来拼接多个数据集，使用方法如下：
+
+```python
+from mmengine.dataset import ConcatDataset
+
+pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+toy_dataset_1 = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='train/'),
+ ann_file='annotations/train.json',
+ pipeline=pipeline)
+
+toy_dataset_2 = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='val/'),
+ ann_file='annotations/val.json',
+ pipeline=pipeline)
+
+toy_dataset_12 = ConcatDataset(datasets=[toy_dataset_1, toy_dataset_2])
+
+```
+
+上述例子将数据集的 `train` 部分与 `val` 部分合成一个大的数据集。
+
+### RepeatDataset
+
+MMEngine 提供了 `RepeatDataset` 包装来重复采样某个数据集若干次，使用方法如下：
+
+```python
+from mmengine.dataset import RepeatDataset
+
+pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='train/'),
+ ann_file='annotations/train.json',
+ pipeline=pipeline)
+
+toy_dataset_repeat = RepeatDataset(dataset=toy_dataset, times=5)
+
+```
+
+上述例子将数据集的 `train` 部分重复采样了 5 次。
+
+### ClassBalancedDataset
+
+MMEngine 提供了 `ClassBalancedDataset` 包装，来基于数据集中类别出现频率，重复采样相应样本。
+
+**注意：**
+
+`ClassBalancedDataset` 包装假设了被包装的数据集类支持 `get_cat_ids(idx)` 方法，`get_cat_ids(idx)` 方法返回一个列表，该列表包含了 `idx` 指定的 `data_info` 包含的样本类别，使用方法如下：
+
+```python
+from mmengine.dataset import BaseDataset, ClassBalancedDataset
+
+class ToyDataset(BaseDataset):
+
+ def parse_data_info(self, raw_data_info):
+ data_info = raw_data_info
+ img_prefix = self.data_prefix.get('img_path', None)
+ if img_prefix is not None:
+ data_info['img_path'] = osp.join(
+ img_prefix, data_info['img_path'])
+ return data_info
+
+ # 必须支持的方法，需要返回样本的类别
+ def get_cat_ids(self, idx):
+ data_info = self.get_data_info(idx)
+ return [int(data_info['img_label'])]
+
+pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+ data_root='data/',
+ data_prefix=dict(img_path='train/'),
+ ann_file='annotations/train.json',
+ pipeline=pipeline)
+
+toy_dataset_repeat = ClassBalancedDataset(dataset=toy_dataset, oversample_thr=1e-3)
+
+```
+
+上述例子将数据集的 `train` 部分以 `oversample_thr=1e-3` 重新采样，具体地，对于数据集中出现频率低于 `1e-3` 的类别，会重复采样该类别对应的样本，否则不重复采样，具体采样策略请参考 `ClassBalancedDataset` API 文档。
+
+### 自定义数据集类包装
+
+由于数据集基类实现了懒加载的功能，因此在自定义数据集类包装时，需要遵循一些规则，下面以一个例子的方式来展示如何自定义数据集类包装：
+
+```python
+from mmengine.dataset import BaseDataset
+from mmengine.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ExampleDatasetWrapper:
+
+ def __init__(self, dataset, lazy_init=False, ...):
+ # 构建原数据集（self.dataset）
+ if isinstance(dataset, dict):
+ self.dataset = DATASETS.build(dataset)
+ elif isinstance(dataset, BaseDataset):
+ self.dataset = dataset
+ else:
+ raise TypeError(
+ 'elements in datasets sequence should be config or '
+ f'`BaseDataset` instance, but got {type(dataset)}')
+ # 记录原数据集的元信息
+ self._metainfo = self.dataset.metainfo
+
+ '''
+ 1. 在这里实现一些代码，来记录用于包装数据集的一些超参。
+ '''
+
+ self._fully_initialized = False
+ if not lazy_init:
+ self.full_init()
+
+ def full_init(self):
+ if self._fully_initialized:
+ return
+
+ # 将原数据集完全初始化
+ self.dataset.full_init()
+
+ '''
+ 2. 在这里实现一些代码，来包装原数据集。
+ '''
+
+ self._fully_initialized = True
+
+ @force_full_init
+ def _get_ori_dataset_idx(self, idx: int):
+
+ '''
+ 3. 在这里实现一些代码，来将包装的索引 `idx` 映射到原数据集的索引 `ori_idx`。
+ '''
+ ori_idx = ...
+
+ return ori_idx
+
+ # 提供与 `self.dataset` 一样的对外接口。
+ @force_full_init
+ def get_data_info(self, idx):
+ sample_idx = self._get_ori_dataset_idx(idx)
+ return self.dataset.get_data_info(sample_idx)
+
+ # 提供与 `self.dataset` 一样的对外接口。
+ def __getitem__(self, idx):
+ if not self._fully_initialized:
+ warnings.warn('Please call `full_init` method manually to '
+ 'accelerate the speed.')
+ self.full_init()
+
+ sample_idx = self._get_ori_dataset_idx(idx)
+ return self.dataset[sample_idx]
+
+ # 提供与 `self.dataset` 一样的对外接口。
+ @force_full_init
+ def __len__(self):
+
+ '''
+ 4. 在这里实现一些代码，来计算包装数据集之后的长度。
+ '''
+ len_wrapper = ...
+
+ return len_wrapper
+
+ # 提供与 `self.dataset` 一样的对外接口。
+ @property
+ def metainfo(self)
+ return copy.deepcopy(self._metainfo)
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/better_optimizers.md b/internlm_langchain/knowledge_base/MMEngine/content/better_optimizers.md
new file mode 100644
index 00000000..a70c84b7
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/better_optimizers.md
@@ -0,0 +1,92 @@
+# 性能更优的优化器
+
+本文档提供了一些 MMEngine 支持的第三方优化器，它们可能会带来更快的收敛速度或者更高的性能。
+
+## D-Adaptation
+
+[D-Adaptation](https://github.com/facebookresearch/dadaptation) 提供了 `DAdaptAdaGrad`、`DAdaptAdam` 和 `DAdaptSGD` 优化器。
+
+```{note}
+如使用 D-Adaptation 提供的优化器，需将 mmengine 升级至 `0.6.0`。
+```
+
+- 安装
+
+```bash
+pip install dadaptation
+```
+
+- 使用
+
+以使用 `DAdaptAdaGrad` 为例。
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ # 如需查看 DAdaptAdaGrad 的输入参数，可查看
+ # https://github.com/facebookresearch/dadaptation/blob/main/dadaptation/dadapt_adagrad.py
+ optim_wrapper=dict(optimizer=dict(type='DAdaptAdaGrad', lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+)
+runner.train()
+```
+
+## Lion
+
+[lion-pytorch](https://github.com/lucidrains/lion-pytorch) 提供了 `Lion` 优化器。
+
+```{note}
+如使用 Lion 提供的优化器，需将 mmengine 升级至 `0.6.0`。
+```
+
+- 安装
+
+```bash
+pip install lion-pytorch
+```
+
+- 使用
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ # 如需查看 Lion 的输入参数，可查看
+ # https://github.com/lucidrains/lion-pytorch/blob/main/lion_pytorch/lion_pytorch.py
+ optim_wrapper=dict(optimizer=dict(type='Lion', lr=1e-4, weight_decay=1e-2)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+)
+runner.train()
+```
+
+## Sophia
+
+[Sophia](https://github.com/kyegomez/Sophia) 提供了 `Sophia`、`SophiaG`、`DecoupledSophia` 和 `Sophia2` 优化器。
+
+```{note}
+如使用 Sophia 提供的优化器，需将 mmengine 升级至 `0.7.4`。
+```
+
+- 安装
+
+```bash
+pip install Sophia-Optimizer
+```
+
+- 使用
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ # 如需查看 SophiaG 的输入参数，可查看
+ # https://github.com/kyegomez/Sophia/blob/main/Sophia/Sophia.py
+ optim_wrapper=dict(optimizer=dict(type='SophiaG', lr=2e-4, betas=(0.965, 0.99), rho = 0.01, weight_decay=1e-1)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+)
+runner.train()
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/code_style.md b/internlm_langchain/knowledge_base/MMEngine/content/code_style.md
new file mode 100644
index 00000000..b294cde3
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/code_style.md
@@ -0,0 +1,609 @@
+# 代码规范
+
+## 代码规范标准
+
+### PEP 8 —— Python 官方代码规范
+
+[Python 官方的代码风格指南](https://www.python.org/dev/peps/pep-0008/)，包含了以下几个方面的内容：
+
+- 代码布局，介绍了 Python 中空行、断行以及导入相关的代码风格规范。比如一个常见的问题：当我的代码较长，无法在一行写下时，何处可以断行？
+
+- 表达式，介绍了 Python 中表达式空格相关的一些风格规范。
+
+- 尾随逗号相关的规范。当列表较长，无法一行写下而写成如下逐行列表时，推荐在末项后加逗号，从而便于追加选项、版本控制等。
+
+ ```python
+ # Correct:
+ FILES = ['setup.cfg', 'tox.ini']
+ # Correct:
+ FILES = [
+ 'setup.cfg',
+ 'tox.ini',
+ ]
+ # Wrong:
+ FILES = ['setup.cfg', 'tox.ini',]
+ # Wrong:
+ FILES = [
+ 'setup.cfg',
+ 'tox.ini'
+ ]
+ ```
+
+- 命名相关规范、注释相关规范、类型注解相关规范，我们将在后续章节中做详细介绍。
+
+ "A style guide is about consistency. Consistency with this style guide is important. Consistency within a project is more important. Consistency within one module or function is the most important." PEP 8 -- Style Guide for Python Code
+
+:::{note}
+PEP 8 的代码规范并不是绝对的，项目内的一致性要优先于 PEP 8 的规范。OpenMMLab 各个项目都在 setup.cfg 设定了一些代码规范的设置，请遵照这些设置。一个例子是在 PEP 8 中有如下一个例子：
+
+```python
+# Correct:
+hypot2 = x*x + y*y
+# Wrong:
+hypot2 = x * x + y * y
+```
+
+这一规范是为了指示不同优先级，但 OpenMMLab 的设置中通常没有启用 yapf 的 `ARITHMETIC_PRECEDENCE_INDICATION` 选项，因而格式规范工具不会按照推荐样式格式化，以设置为准。
+:::
+
+### Google 开源项目风格指南
+
+[Google 使用的编程风格指南](https://google.github.io/styleguide/pyguide.html)，包括了 Python 相关的章节。相较于 PEP 8，该指南提供了更为详尽的代码指南。该指南包括了语言规范和风格规范两个部分。
+
+其中，语言规范对 Python 中很多语言特性进行了优缺点的分析，并给出了使用指导意见，如异常、Lambda 表达式、列表推导式、metaclass 等。
+
+风格规范的内容与 PEP 8 较为接近，大部分约定建立在 PEP 8 的基础上，也有一些更为详细的约定，如函数长度、TODO 注释、文件与 socket 对象的访问等。
+
+推荐将该指南作为参考进行开发，但不必严格遵照，一来该指南存在一些 Python 2 兼容需求，例如指南中要求所有无基类的类应当显式地继承 Object, 而在仅使用 Python 3 的环境中，这一要求是不必要的，依本项目中的惯例即可。二来 OpenMMLab 的项目作为框架级的开源软件，不必对一些高级技巧过于避讳，尤其是 MMCV。但尝试使用这些技巧前应当认真考虑是否真的有必要，并寻求其他开发人员的广泛评估。
+
+另外需要注意的一处规范是关于包的导入，在该指南中，要求导入本地包时必须使用路径全称，且导入的每一个模块都应当单独成行，通常这是不必要的，而且也不符合目前项目的开发惯例，此处进行如下约定：
+
+```python
+# Correct
+from mmcv.cnn.bricks import (Conv2d, build_norm_layer, DropPath, MaxPool2d,
+ Linear)
+from ..utils import ext_loader
+
+# Wrong
+from mmcv.cnn.bricks import Conv2d, build_norm_layer, DropPath, MaxPool2d, \
+ Linear # 使用括号进行连接，而不是反斜杠
+from ...utils import is_str # 最多向上回溯一层，过多的回溯容易导致结构混乱
+```
+
+OpenMMLab 项目使用 pre-commit 工具自动格式化代码，详情见[贡献代码](./contributing.md#python-代码风格)。
+
+## 命名规范
+
+### 命名规范的重要性
+
+优秀的命名是良好代码可读的基础。基础的命名规范对各类变量的命名做了要求，使读者可以方便地根据代码名了解变量是一个类 / 局部变量 / 全局变量等。而优秀的命名则需要代码作者对于变量的功能有清晰的认识，以及良好的表达能力，从而使读者根据名称就能了解其含义，甚至帮助了解该段代码的功能。
+
+### 基础命名规范
+
+| 类型 | 公有 | 私有 |
+| --------------- | ---------------- | ------------------ |
+| 模块 | lower_with_under | \_lower_with_under |
+| 包 | lower_with_under | |
+| 类 | CapWords | \_CapWords |
+| 异常 | CapWordsError | |
+| 函数（方法） | lower_with_under | \_lower_with_under |
+| 函数 / 方法参数 | lower_with_under | |
+| 全局 / 类内常量 | CAPS_WITH_UNDER | \_CAPS_WITH_UNDER |
+| 全局 / 类内变量 | lower_with_under | \_lower_with_under |
+| 变量 | lower_with_under | \_lower_with_under |
+| 局部变量 | lower_with_under | |
+
+注意：
+
+- 尽量避免变量名与保留字冲突，特殊情况下如不可避免，可使用一个后置下划线，如 class\_
+- 尽量不要使用过于简单的命名，除了约定俗成的循环变量 i，文件变量 f，错误变量 e 等。
+- 不会被用到的变量可以命名为 \_，逻辑检查器会将其忽略。
+
+### 命名技巧
+
+良好的变量命名需要保证三点：
+
+1. 含义准确，没有歧义
+2. 长短适中
+3. 前后统一
+
+```python
+# Wrong
+class Masks(metaclass=ABCMeta): # 命名无法表现基类；Instance or Semantic？
+ pass
+
+# Correct
+class BaseInstanceMasks(metaclass=ABCMeta):
+ pass
+
+# Wrong，不同地方含义相同的变量尽量用统一的命名
+def __init__(self, inplanes, planes):
+ pass
+
+def __init__(self, in_channels, out_channels):
+ pass
+```
+
+常见的函数命名方法：
+
+- 动宾命名法：crop_img, init_weights
+- 动宾倒置命名法：imread, bbox_flip
+
+注意函数命名与参数的顺序，保证主语在前，符合语言习惯：
+
+- check_keys_exist(key, container)
+- check_keys_contain(container, key)
+
+注意避免非常规或统一约定的缩写，如 nb -> num_blocks，in_nc -> in_channels
+
+## docstring 规范
+
+### 为什么要写 docstring
+
+docstring 是对一个类、一个函数功能与 API 接口的详细描述，有两个功能，一是帮助其他开发者了解代码功能，方便 debug 和复用代码；二是在 Readthedocs 文档中自动生成相关的 API reference 文档，帮助不了解源代码的社区用户使用相关功能。
+
+### 如何写 docstring
+
+与注释不同，一份规范的 docstring 有着严格的格式要求，以便于 Python 解释器以及 sphinx 进行文档解析，详细的 docstring 约定参见 [PEP 257](https://www.python.org/dev/peps/pep-0257/)。此处以例子的形式介绍各种文档的标准格式，参考格式为 [Google 风格](https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/#comments)。
+
+1. 模块文档
+
+ 代码风格规范推荐为每一个模块（即 Python 文件）编写一个 docstring，但目前 OpenMMLab 项目大部分没有此类 docstring，因此不做硬性要求。
+
+ ```python
+ """A one line summary of the module or program, terminated by a period.
+
+ Leave one blank line. The rest of this docstring should contain an
+ overall description of the module or program. Optionally, it may also
+ contain a brief description of exported classes and functions and/or usage
+ examples.
+
+ Typical usage example:
+
+ foo = ClassFoo()
+ bar = foo.FunctionBar()
+ """
+ ```
+
+2. 类文档
+
+ 类文档是我们最常需要编写的，此处，按照 OpenMMLab 的惯例，我们使用了与 Google 风格不同的写法。如下例所示，文档中没有使用 Attributes 描述类属性，而是使用 Args 描述 __init__ 函数的参数。
+
+ 在 Args 中，遵照 `parameter (type): Description.` 的格式，描述每一个参数类型和功能。其中，多种类型可使用 `(float or str)` 的写法，可以为 None 的参数可以写为 `(int, optional)`。
+
+ ```python
+ class BaseRunner(metaclass=ABCMeta):
+ """The base class of Runner, a training helper for PyTorch.
+
+ All subclasses should implement the following APIs:
+
+ - ``run()``
+ - ``train()``
+ - ``val()``
+ - ``save_checkpoint()``
+
+ Args:
+ model (:obj:`torch.nn.Module`): The model to be run.
+ batch_processor (callable, optional): A callable method that process
+ a data batch. The interface of this method should be
+ ``batch_processor(model, data, train_mode) -> dict``.
+ Defaults to None.
+ optimizer (dict or :obj:`torch.optim.Optimizer`, optional): It can be
+ either an optimizer (in most cases) or a dict of optimizers
+ (in models that requires more than one optimizer, e.g., GAN).
+ Defaults to None.
+ work_dir (str, optional): The working directory to save checkpoints
+ and logs. Defaults to None.
+ logger (:obj:`logging.Logger`): Logger used during training.
+ Defaults to None. (The default value is just for backward
+ compatibility)
+ meta (dict, optional): A dict records some import information such as
+ environment info and seed, which will be logged in logger hook.
+ Defaults to None.
+ max_epochs (int, optional): Total training epochs. Defaults to None.
+ max_iters (int, optional): Total training iterations. Defaults to None.
+ """
+
+ def __init__(self,
+ model,
+ batch_processor=None,
+ optimizer=None,
+ work_dir=None,
+ logger=None,
+ meta=None,
+ max_iters=None,
+ max_epochs=None):
+ ...
+ ```
+
+ 另外，在一些算法实现的主体类中，建议加入原论文的链接；如果参考了其他开源代码的实现，则应加入 modified from，而如果是直接复制了其他代码库的实现，则应加入 copied from ，并注意源码的 License。如有必要，也可以通过 .. math:: 来加入数学公式
+
+ ```python
+ # 参考实现
+ # This func is modified from `detectron2
+ #
+| 模块 | +别名 | +注意事项 | + +
|---|---|---|
| nearest | +torch.nn.modules.upsampling.Upsample | +将 type 替换成 Upsample 后，需要额外将 mode 参数指定为 'nearest' | +
| bilinear | +torch.nn.modules.upsampling.Upsample | +将 type 替换成 Upsample 后，需要额外将 mode 参数指定为 'bilinear' | +
| Clip | +mmcv.cnn.bricks.activation.Clamp | +无 | +
| Conv | +mmcv.cnn.bricks.wrappers.Conv2d | +无 | +
| BN | +torch.nn.modules.batchnorm.BatchNorm2d | +无 | +
| BN1d | +torch.nn.modules.batchnorm.BatchNorm1d | +无 | +
| BN2d | +torch.nn.modules.batchnorm.BatchNorm2d | +无 | +
| BN3d | +torch.nn.modules.batchnorm.BatchNorm3d | +无 | +
| SyncBN | +torch.nn.SyncBatchNorm | +无 | +
| GN | +torch.nn.modules.normalization.GroupNorm | +无 | +
| LN | +torch.nn.modules.normalization.LayerNorm | +无 | +
| IN | +torch.nn.modules.instancenorm.InstanceNorm2d | +无 | +
| IN1d | +torch.nn.modules.instancenorm.InstanceNorm1d | +无 | +
| IN2d | +torch.nn.modules.instancenorm.InstanceNorm2d | +无 | +
| IN3d | +torch.nn.modules.instancenorm.InstanceNorm3d | +无 | +
| zero | +torch.nn.modules.padding.ZeroPad2d | +无 | +
| reflect | +torch.nn.modules.padding.ReflectionPad2d | +无 | +
| replicate | +torch.nn.modules.padding.ReplicationPad2d | +无 | +
| ConvWS | +mmcv.cnn.bricks.conv_ws.ConvWS2d | +无 | +
| ConvAWS | +mmcv.cnn.bricks.conv_ws.ConvAWS2d | +无 | +
| HSwish | +torch.nn.modules.activation.Hardswish | +无 | +
| pixel_shuffle | +mmcv.cnn.bricks.upsample.PixelShufflePack | +无 | +
| deconv | +mmcv.cnn.bricks.wrappers.ConvTranspose2d | +无 | +
| deconv3d | +mmcv.cnn.bricks.wrappers.ConvTranspose3d | +无 | +
| Constant | +mmengine.model.weight_init.ConstantInit | +无 | +
| Xavier | +mmengine.model.weight_init.XavierInit | +无 | +
| Normal | +mmengine.model.weight_init.NormalInit | +无 | +
| TruncNormal | +mmengine.model.weight_init.TruncNormalInit | +无 | +
| Uniform | +mmengine.model.weight_init.UniformInit | +无 | +
| Kaiming | +mmengine.model.weight_init.KaimingInit | +无 | +
| Caffe2Xavier | +mmengine.model.weight_init.Caffe2XavierInit | +无 | +
| Pretrained | +mmengine.model.weight_init.PretrainedInit | +无 | +
+
+将代码克隆到本地
+
+```shell
+git clone git@github.com:{username}/mmengine.git
+```
+
+添加原代码库为上游代码库
+
+```bash
+git remote add upstream git@github.com:open-mmlab/mmengine
+```
+
+检查 remote 是否添加成功，在终端输入 `git remote -v`
+
+```bash
+origin git@github.com:{username}/mmengine.git (fetch)
+origin git@github.com:{username}/mmengine.git (push)
+upstream git@github.com:open-mmlab/mmengine (fetch)
+upstream git@github.com:open-mmlab/mmengine (push)
+```
+
+```{note}
+这里对 origin 和 upstream 进行一个简单的介绍，当我们使用 git clone 来克隆代码时，会默认创建一个 origin 的 remote，它指向我们克隆的代码库地址，而 upstream 则是我们自己添加的，用来指向原始代码库地址。当然如果你不喜欢他叫 upstream，也可以自己修改，比如叫 open-mmlab。我们通常向 origin 提交代码（即 fork 下来的远程仓库），然后向 upstream 提交一个 pull request。如果提交的代码和最新的代码发生冲突，再从 upstream 拉取最新的代码，和本地分支解决冲突，再提交到 origin。
+```
+
+### 2. 配置 pre-commit
+
+在本地开发环境中，我们使用 [pre-commit](https://pre-commit.com/#intro) 来检查代码风格，以确保代码风格的统一。在提交代码，需要先安装 pre-commit（需要在 mmengine 目录下执行）:
+
+```shell
+pip install -U pre-commit
+pre-commit install
+```
+
+检查 pre-commit 是否配置成功，并安装 `.pre-commit-config.yaml` 中的钩子：
+
+```shell
+pre-commit run --all-files
+```
+
+
+
+
+
+```{note}
+如果你是中国用户，由于网络原因，可能会出现安装失败的情况，这时可以使用国内源
+pre-commit install -c .pre-commit-config-zh-cn.yaml
+pre-commit run --all-files -c .pre-commit-config-zh-cn.yaml
+```
+
+如果安装过程被中断，可以重复执行 `pre-commit run ...` 继续安装。
+
+如果提交的代码不符合代码风格规范，pre-commit 会发出警告，并自动修复部分错误。
+
+
+
+如果我们想临时绕开 pre-commit 的检查提交一次代码，可以在 `git commit` 时加上 `--no-verify`（需要保证最后推送至远程仓库的代码能够通过 pre-commit 检查）。
+
+```shell
+git commit -m "xxx" --no-verify
+```
+
+### 3. 创建开发分支
+
+安装完 pre-commit 之后，我们需要基于 master 创建开发分支，建议的分支命名规则为 `username/pr_name`。
+
+```shell
+git checkout -b yhc/refactor_contributing_doc
+```
+
+在后续的开发中，如果本地仓库的 master 分支落后于 upstream 的 master 分支，我们需要先拉取 upstream 的代码进行同步，再执行上面的命令
+
+```shell
+git pull upstream master
+```
+
+### 4. 提交代码并在本地通过单元测试
+
+- MMEngine 引入了 mypy 来做静态类型检查，以增加代码的鲁棒性。因此我们在提交代码时，需要补充 Type Hints。具体规则可以参考[教程](https://zhuanlan.zhihu.com/p/519335398)。
+
+- 提交的代码同样需要通过单元测试
+
+ ```shell
+ # 通过全量单元测试
+ pytest tests
+
+ # 我们需要保证提交的代码能够通过修改模块的单元测试，以 runner 为例
+ pytest tests/test_runner/test_runner.py
+ ```
+
+ 如果你由于缺少依赖无法运行修改模块的单元测试，可以参考[指引-单元测试](#单元测试)
+
+- 如果修改/添加了文档，参考[指引](#文档渲染)确认文档渲染正常。
+
+### 5. 推送代码到远程
+
+代码通过单元测试和 pre-commit 检查后，将代码推送到远程仓库，如果是第一次推送，可以在 `git push` 后加上 `-u` 参数以关联远程分支
+
+```shell
+git push -u origin {branch_name}
+```
+
+这样下次就可以直接使用 `git push` 命令推送代码了，而无需指定分支和远程仓库。
+
+### 6. 提交拉取请求（PR）
+
+(1) 在 GitHub 的 Pull request 界面创建拉取请求
+
+
+(2) 根据指引修改 PR 描述，以便于其他开发者更好地理解你的修改
+
+
+
+描述规范详见[拉取请求规范](#拉取请求规范)
+
+
+
+**注意事项**
+
+(a) PR 描述应该包含修改理由、修改内容以及修改后带来的影响，并关联相关 Issue（具体方式见[文档](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)）
+
+(b) 如果是第一次为 OpenMMLab 做贡献，需要签署 CLA
+
+
+
+(c) 检查提交的 PR 是否通过 CI（集成测试）
+
+
+
+MMEngine 会在不同的平台（Linux、Window、Mac），基于不同版本的 Python、PyTorch、CUDA 对提交的代码进行单元测试，以保证代码的正确性，如果有任何一个没有通过，我们可点击上图中的 `Details` 来查看具体的测试信息，以便于我们修改代码。
+
+(3) 如果 PR 通过了 CI，那么就可以等待其他开发者的 review，并根据 reviewer 的意见，修改代码，并重复 [4](#4-提交代码并在本地通过单元测试)-[5](#5-推送代码到远程) 步骤，直到 reviewer 同意合入 PR。
+
+
+
+所有 reviewer 同意合入 PR 后，我们会尽快将 PR 合并到主分支。
+
+### 7. 解决冲突
+
+随着时间的推移，我们的代码库会不断更新，这时候，如果你的 PR 与主分支存在冲突，你需要解决冲突，解决冲突的方式有两种：
+
+```shell
+git fetch --all --prune
+git rebase upstream/master
+```
+
+或者
+
+```shell
+git fetch --all --prune
+git merge upstream/master
+```
+
+如果你非常善于处理冲突，那么可以使用 rebase 的方式来解决冲突，因为这能够保证你的 commit log 的整洁。如果你不太熟悉 `rebase` 的使用，那么可以使用 `merge` 的方式来解决冲突。
+
+## 指引
+
+### 单元测试
+
+在提交修复代码错误或新增特性的拉取请求时，我们应该尽可能的让单元测试覆盖所有提交的代码，计算单元测试覆盖率的方法如下
+
+```shell
+python -m coverage run -m pytest /path/to/test_file
+python -m coverage html
+# check file in htmlcov/index.html
+```
+
+### 文档渲染
+
+在提交修复代码错误或新增特性的拉取请求时，可能会需要修改/新增模块的 docstring。我们需要确认渲染后的文档样式是正确的。
+本地生成渲染后的文档的方法如下
+
+```shell
+pip install -r requirements/docs.txt
+cd docs/zh_cn/
+# or docs/en
+make html
+# check file in ./docs/zh_cn/_build/html/index.html
+```
+
+## Python 代码风格
+
+[PEP8](https://www.python.org/dev/peps/pep-0008/) 作为 OpenMMLab 算法库首选的代码规范，我们使用以下工具检查和格式化代码
+
+- [flake8](https://github.com/PyCQA/flake8): Python 官方发布的代码规范检查工具，是多个检查工具的封装
+- [isort](https://github.com/timothycrosley/isort): 自动调整模块导入顺序的工具
+- [yapf](https://github.com/google/yapf): Google 发布的代码规范检查工具
+- [codespell](https://github.com/codespell-project/codespell): 检查单词拼写是否有误
+- [mdformat](https://github.com/executablebooks/mdformat): 检查 markdown 文件的工具
+- [docformatter](https://github.com/myint/docformatter): 格式化 docstring 的工具
+
+yapf 和 isort 的配置可以在 [setup.cfg](https://github.com/open-mmlab/mmengine/blob/main/setup.cfg) 找到
+
+通过配置 [pre-commit hook](https://pre-commit.com/) ，我们可以在提交代码时自动检查和格式化 `flake8`、`yapf`、`isort`、`trailing whitespaces`、`markdown files`，修复 `end-of-files`、`double-quoted-strings`、`python-encoding-pragma`、`mixed-line-ending`，调整 `requirments.txt` 的包顺序。
+pre-commit 钩子的配置可以在 [.pre-commit-config](https://github.com/open-mmlab/mmengine/blob/main/.pre-commit-config-zh-cn.yaml) 找到。
+
+pre-commit 具体的安装使用方式见[拉取请求](#2-配置-pre-commit)。
+
+更具体的规范请参考 [OpenMMLab 代码规范](code_style.md)。
+
+## 拉取请求规范
+
+1. 使用 [pre-commit hook](https://pre-commit.com)，尽量减少代码风格相关问题
+
+2. 一个`拉取请求`对应一个短期分支
+
+3. 粒度要细，一个`拉取请求`只做一件事情，避免超大的`拉取请求`
+
+ - Bad：实现 Faster R-CNN
+ - Acceptable：给 Faster R-CNN 添加一个 box head
+ - Good：给 box head 增加一个参数来支持自定义的 conv 层数
+
+4. 每次 Commit 时需要提供清晰且有意义 commit 信息
+
+5. 提供清晰且有意义的`拉取请求`描述
+
+ - 标题写明白任务名称，一般格式:\[Prefix\] Short description of the pull request (Suffix)
+ - prefix: 新增功能 \[Feature\], 修 bug \[Fix\], 文档相关 \[Docs\], 开发中 \[WIP\] (暂时不会被review)
+ - 描述里介绍`拉取请求`的主要修改内容，结果，以及对其他部分的影响, 参考`拉取请求`模板
+ - 关联相关的`议题` (issue) 和其他`拉取请求`
+
+6. 如果引入了其他三方库，或借鉴了三方库的代码，请确认他们的许可证和 MMEngine 兼容，并在借鉴的代码上补充 `This code is inspired from http://`
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/cross_library.md b/internlm_langchain/knowledge_base/MMEngine/content/cross_library.md
new file mode 100644
index 00000000..a70dc728
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/cross_library.md
@@ -0,0 +1,94 @@
+# 跨库调用模块
+
+通过使用 MMEngine 的[注册器（Registry）](registry.md)和[配置文件（Config）](config.md)，用户可以实现跨软件包的模块构建。
+例如，在 [MMDetection](https://github.com/open-mmlab/mmdetection) 中使用 [MMPretrain](https://github.com/open-mmlab/mmpretrain) 的 Backbone，或者在 [MMRotate](https://github.com/open-mmlab/mmrotate) 中使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 的 Transform，或者在 [MMTracking](https://github.com/open-mmlab/mmtracking) 中使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 的 Detector。
+一般来说，同类模块都可以进行跨库调用，只需要在配置文件的模块类型前加上软件包名的前缀即可。下面举几个常见的例子：
+
+## 跨库调用 Backbone:
+
+以在 MMDetection 中调用 MMPretrain 的 ConvNeXt 为例，首先需要在配置中加入 `custom_imports` 字段将 MMPretrain 的 Backbone 添加进注册器，然后只需要在 Backbone 的配置中的 `type` 加上 MMPretrain 的软件包名 `mmpretrain` 作为前缀，即 `mmpretrain.ConvNeXt` 即可：
+
+```python
+# 使用 custom_imports 将 mmpretrain 的 models 添加进注册器
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+
+model = dict(
+ type='MaskRCNN',
+ data_preprocessor=dict(...),
+ backbone=dict(
+ type='mmpretrain.ConvNeXt', # 添加 mmpretrain 前缀完成跨库调用
+ arch='tiny',
+ out_indices=[0, 1, 2, 3],
+ drop_path_rate=0.4,
+ layer_scale_init_value=1.0,
+ gap_before_final_norm=False,
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint=
+ 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth',
+ prefix='backbone.')),
+ neck=dict(...),
+ rpn_head=dict(...))
+```
+
+## 跨库调用 Transform:
+
+与上文的跨库调用 Backbone 一样，使用 custom_imports 和添加前缀即可实现跨库调用：
+
+```python
+# 使用 custom_imports 将 mmdet 的 transforms 添加进注册器
+custom_imports = dict(imports=['mmdet.datasets.transforms'], allow_failed_imports=False)
+
+# 添加 mmdet 前缀完成跨库调用
+train_pipeline=[
+ dict(type='mmdet.LoadImageFromFile'),
+ dict(type='mmdet.LoadAnnotations', with_bbox=True, box_type='qbox'),
+ dict(type='ConvertBoxType', box_type_mapping=dict(gt_bboxes='rbox')),
+ dict(type='mmdet.Resize', scale=(1024, 2014), keep_ratio=True),
+ dict(type='mmdet.RandomFlip', prob=0.5),
+ dict(type='mmdet.PackDetInputs')
+]
+```
+
+## 跨库调用 Detector:
+
+跨库调用算法是一个比较复杂的例子，一个算法会包含多个子模块，因此每个子模块也需要在`type`中增加前缀，以在 MMTracking 中调用 MMDetection 的 YOLOX 为例：
+
+```python
+# 使用 custom_imports 将 mmdet 的 models 添加进注册器
+custom_imports = dict(imports=['mmdet.models'], allow_failed_imports=False)
+model = dict(
+ type='mmdet.YOLOX',
+ backbone=dict(type='mmdet.CSPDarknet', deepen_factor=1.33, widen_factor=1.25),
+ neck=dict(
+ type='mmdet.YOLOXPAFPN',
+ in_channels=[320, 640, 1280],
+ out_channels=320,
+ num_csp_blocks=4),
+ bbox_head=dict(
+ type='mmdet.YOLOXHead', num_classes=1, in_channels=320, feat_channels=320),
+ train_cfg=dict(assigner=dict(type='mmdet.SimOTAAssigner', center_radius=2.5)))
+```
+
+为了避免给每个子模块手动增加前缀，配置文件中引入了 `_scope_` 关键字，当某一模块的配置中添加了 `_scope_` 关键字后，该模块配置文件下面的所有子模块配置都会从该关键字所对应的软件包内去构建：
+
+```python
+# 使用 custom_imports 将 mmdet 的 models 添加进注册器
+custom_imports = dict(imports=['mmdet.models'], allow_failed_imports=False)
+model = dict(
+ _scope_='mmdet', # 使用 _scope_ 关键字，避免给所有子模块添加前缀
+ type='YOLOX',
+ backbone=dict(type='CSPDarknet', deepen_factor=1.33, widen_factor=1.25),
+ neck=dict(
+ type='YOLOXPAFPN',
+ in_channels=[320, 640, 1280],
+ out_channels=320,
+ num_csp_blocks=4),
+ bbox_head=dict(
+ type='YOLOXHead', num_classes=1, in_channels=320, feat_channels=320),
+ train_cfg=dict(assigner=dict(type='SimOTAAssigner', center_radius=2.5)))
+```
+
+以上这两种写法互相等价。
+
+若希望了解更多关于注册器和配置文件的内容，请参考[配置文件教程](config.md)和[注册器教程](registry.md)
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/data_element.md b/internlm_langchain/knowledge_base/MMEngine/content/data_element.md
new file mode 100644
index 00000000..7574a925
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/data_element.md
@@ -0,0 +1,1098 @@
+# 抽象数据接口
+
+在模型的训练/测试过程中，组件之间往往有大量的数据需要传递，不同的算法需要传递的数据经常是不一样的，例如，训练单阶段检测器需要获得数据集的标注框（ground truth bounding boxes）和标签（ground truth box labels），训练 Mask R-CNN 时还需要实例掩码（instance masks）。
+训练这些模型时的代码如下所示
+
+```python
+for img, img_metas, gt_bboxes, gt_labels in data_loader:
+ loss = retinanet(img, img_metas, gt_bboxes, gt_labels)
+```
+
+```python
+for img, img_metas, gt_bboxes, gt_masks, gt_labels in data_loader:
+ loss = mask_rcnn(img, img_metas, gt_bboxes, gt_masks, gt_labels)
+```
+
+可以发现，在不加封装的情况下，不同算法所需数据的不一致导致了不同算法模块之间接口的不一致，影响了算法库的拓展性，同时一个算法库内的模块为了保持兼容性往往在接口上存在冗余。
+上述弊端在算法库之间会体现地更加明显，导致在实现多任务（同时进行如语义分割、检测、关键点检测等多个任务）感知模型时模块难以复用，接口难以拓展。
+
+为了解决上述问题，MMEngine 定义了一套抽象的数据接口来封装模型运行过程中的各种数据。假设将上述不同的数据封装进 `data_sample` ，不同算法的训练都可以被抽象和统一成如下代码
+
+```python
+for img, data_sample in dataloader:
+ loss = model(img, data_sample)
+```
+
+通过对各种数据提供统一的封装，抽象数据接口统一并简化了算法库中各个模块的接口，可以被用于算法库中 dataset，model，visualizer，和 evaluator 组件之间，或者 model 内各个模块之间的数据传递。
+抽象数据接口实现了基本的增/删/改/查功能，同时支持不同设备之间的迁移，支持类字典和张量的操作，可以充分满足算法库对于这些数据的使用要求。
+基于 MMEngine 的算法库可以继承这套抽象数据接口并实现自己的抽象数据接口来适应不同算法中数据的特点与实际需要，在保持统一接口的同时提高了算法模块的拓展性。
+
+在实际实现过程中，算法库中的各个组件所具备的数据接口，一般为以下两种：
+
+- 一个训练或测试样本（例如一张图像）的所有的标注信息和预测信息的集合，例如数据集的输出、模型以及可视化器的输入一般为单个训练或测试样本的所有信息。MMEngine 将其定义为数据样本（DataSample）
+- 单一类型的预测或标注，一般是算法模型中某个子模块的输出, 例如二阶段检测中RPN的输出、语义分割模型的输出、关键点分支的输出，GAN中生成器的输出等。MMEngine 将其定义为数据元素（XXXData）
+
+下边首先介绍一下数据样本与数据元素的基类 [BaseDataElement](mmengine.structures.BaseDataElement)。
+
+## 数据基类(BaseDataElement)
+
+`BaseDataElement` 中存在两种类型的数据，一种是 `data` 类型，如标注框、框的标签、和实例掩码等；另一种是 `metainfo` 类型，包含数据的元信息以确保数据的完整性，如 `img_shape`, `img_id` 等数据所在图片的一些基本信息，方便可视化等情况下对数据进行恢复和使用。用户在创建 `BaseDataElement` 的过程中需要对这两类属性的数据进行显式地区分和声明。
+
+为了能够更加方便地使用 `BaseDataElement`，`data` 和 `metainfo` 中的数据均为 `BaseDataElement` 的属性。我们可以通过访问类属性的方式直接访问 `data` 和 `metainfo` 中的数据。此外，`BaseDataElement` 还提供了很多方法，方便我们操作 `data` 内的数据：
+
+- 增/删/改/查 `data` 中不同字段的数据
+- 将 `data` 迁移至目标设备
+- 支持像访问字典/张量一样访问 data 内的数据以充分满足算法库对于这些数据的使用要求。
+
+### 1. 数据元素的创建
+
+`BaseDataElement` 的 data 参数可以直接通过 `key=value` 的方式自由添加，metainfo 的字段需要显式通过关键字 `metainfo` 指定。
+
+```python
+import torch
+from mmengine.structures import BaseDataElement
+# 可以声明一个空的 object
+data_element = BaseDataElement()
+
+bboxes = torch.rand((5, 4)) # 假定 bboxes 是一个 Nx4 维的 tensor，N 代表框的个数
+scores = torch.rand((5,)) # 假定框的分数是一个 N 维的 tensor，N 代表框的个数
+img_id = 0 # 图像的 ID
+H = 800 # 图像的高度
+W = 1333 # 图像的宽度
+
+# 直接设置 BaseDataElement 的 data 参数
+data_element = BaseDataElement(bboxes=bboxes, scores=scores)
+
+# 显式声明来设置 BaseDataElement 的参数 metainfo
+data_element = BaseDataElement(
+ bboxes=bboxes,
+ scores=scores,
+ metainfo=dict(img_id=img_id, img_shape=(H, W)))
+```
+
+### 2. `new` 与 `clone` 函数
+
+用户可以使用 `new()` 方法基于已有的 `BaseDataElement` 创建一个具有相同 `data` 和 `metainfo` 的 `BaseDataElement`。用户也可以在调用 `new` 方法时传入新的 `data` 和 `metainfo`，例如 `new(metainfo=xx)` ，此时创建的 `BaseDataElement` 相较于已有的 `BaseDataElement`，`data` 完全一致 ，而 `metainfo` 则为新设置的内容。
+也可以直接使用 `clone()` 来获得一份深拷贝，`clone()` 函数的行为与 PyTorch 中 Tensor 的 `clone()` 参数保持一致。
+
+```python
+data_element = BaseDataElement(
+ bboxes=torch.rand((5, 4)),
+ scores=torch.rand((5,)),
+ metainfo=dict(img_id=1, img_shape=(640, 640)))
+
+# 可以在创建新 `BaseDataElement` 时设置 metainfo 和 data，使得新的 BaseDataElement 有相同未被设置的数据
+data_element1 = data_element.new(metainfo=dict(img_id=2, img_shape=(320, 320)))
+print('bboxes is in data_element1:', 'bboxes' in data_element1) # True
+print('bboxes in data_element1 is same as bbox in data_element', (data_element1.bboxes == data_element.bboxes).all())
+print('img_id in data_element1 is', data_element1.img_id == 2) # True
+
+data_element2 = data_element.new(label=torch.rand(5,))
+print('bboxes is not in data_element2', 'bboxes' not in data_element2) # True
+print('img_id in data_element2 is same as img_id in data_element', data_element2.img_id == data_element.img_id)
+print('label in data_element2 is', 'label' in data_element2)
+
+# 也可以通过 `clone` 构建一个新的 object，新的 object 会拥有和 data_element 相同的 data 和 metainfo 内容以及状态。
+data_element2 = data_element1.clone()
+```
+
+```
+bboxes is in data_element1: True
+bboxes in data_element1 is same as bbox in data_element tensor(True)
+img_id in data_element1 is True
+bboxes is not in data_element2 True
+img_id in data_element2 is same as img_id in data_element True
+label in data_element2 is True
+```
+
+### 3. 属性的增加与查询
+
+对增加属性而言，用户可以像增加类属性那样增加 `data` 内的属性；对 `metainfo` 而言，一般储存的为一些图像的元信息，一般情况下不会修改，如果需要增加，用户应当使用 `set_metainfo` 接口显示地修改。
+
+对查询而言，用户可以可以通过 `keys`，`values`，和 `items` 来访问只存在于 data 中的键值，也可以通过 `metainfo_keys`，`metainfo_values`，和`metainfo_items` 来访问只存在于 metainfo 中的键值。
+用户还能通过 `all_keys`，`all_values`， `all_items` 来访问 `BaseDataElement` 的所有的属性并且不区分他们的类型。
+
+同时为了方便使用，用户可以像访问类属性一样访问 data 与 metainfo 内的数据，或着类字典方式通过 `get()` 接口访问数据。
+
+**注意：**
+
+1. `BaseDataElement` 不支持 metainfo 和 data 属性中有同名的字段，所以用户应当避免 metainfo 和 data 属性中设置相同的字段，否则 `BaseDataElement` 会报错。
+2. 考虑到 `InstanceData` 和 `PixelData` 支持对数据进行切片操作，为了避免 `[]` 用法的不一致，同时减少同种需求的不同方法，`BaseDataElement` 不支持像字典那样访问和设置它的属性，所以类似 `BaseDataElement[name]` 的取值赋值操作是不被支持的。
+
+```python
+data_element = BaseDataElement()
+# 通过 `set_metainfo`设置 data_element 的 metainfo 字段，
+# 同时 img_id 和 img_shape 成为 data_element 的属性
+data_element.set_metainfo(dict(img_id=9, img_shape=(100, 100)))
+# 查看 metainfo 的 key, value 和 item
+print("metainfo'keys are", data_element.metainfo_keys())
+print("metainfo'values are", data_element.metainfo_values())
+for k, v in data_element.metainfo_items():
+ print(f'{k}: {v}')
+
+print("通过类属性查看 img_id 和 img_shape")
+print('img_id:', data_element.img_id)
+print('img_shape:', data_element.img_shape)
+```
+
+```
+metainfo'keys are ['img_id', 'img_shape']
+metainfo'values are [9, (100, 100)]
+img_id: 9
+img_shape: (100, 100)
+通过类属性查看 img_id 和 img_shape
+img_id: 9
+img_shape: (100, 100)
+```
+
+```python
+
+# 通过类属性直接设置 BaseDataElement 中的 data 字段
+data_element.scores = torch.rand((5,))
+data_element.bboxes = torch.rand((5, 4))
+
+print("data's key is:", data_element.keys())
+print("data's value is:", data_element.values())
+for k, v in data_element.items():
+ print(f'{k}: {v}')
+
+print("通过类属性查看 scores 和 bboxes")
+print('scores:', data_element.scores)
+print('bboxes:', data_element.bboxes)
+
+print("通过 get() 查看 scores 和 bboxes")
+print('scores:', data_element.get('scores', None))
+print('bboxes:', data_element.get('bboxes', None))
+print('fake:', data_element.get('fake', 'not exist'))
+```
+
+```
+data's key is: ['scores', 'bboxes']
+data's value is: [tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515]), tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])]
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+通过类属性查看 scores 和 bboxes
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+通过 get() 查看 scores 和 bboxes
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+fake: not exist
+```
+
+```python
+
+print("All key in data_element is:", data_element.all_keys())
+print("The length of values in data_element is", len(data_element.all_values()))
+for k, v in data_element.all_items():
+ print(f'{k}: {v}')
+```
+
+```
+All key in data_element is: ['img_id', 'img_shape', 'scores', 'bboxes']
+The length of values in data_element is 4
+img_id: 9
+img_shape: (100, 100)
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+ [0.7993, 0.8982, 0.5698, 0.4120],
+ [0.7085, 0.7016, 0.3069, 0.3216],
+ [0.0206, 0.5253, 0.1376, 0.9322],
+ [0.2512, 0.7683, 0.3010, 0.2672]])
+```
+
+### 4. 属性的删改
+
+用户可以像修改实例属性一样修改 `BaseDataElement` 的 `data`, 对`metainfo` 而言，一般储存的为一些图像的元信息，一般情况下不会修改，如果需要修改，用户应当使用 `set_metainfo` 接口显示的修改。
+
+同时为了操作的便捷性，对 `data` 和 `metainfo` 中的数据可以通过 `del` 直接删除，也支持 `pop` 在访问属性后删除属性。
+
+```python
+data_element = BaseDataElement(
+ bboxes=torch.rand((6, 4)), scores=torch.rand((6,)),
+ metainfo=dict(img_id=0, img_shape=(640, 640))
+)
+for k, v in data_element.all_items():
+ print(f'{k}: {v}')
+```
+
+```
+img_id: 0
+img_shape: (640, 640)
+scores: tensor([0.8445, 0.6678, 0.8172, 0.9125, 0.7186, 0.5462])
+bboxes: tensor([[0.5773, 0.0289, 0.4793, 0.7573],
+ [0.8187, 0.8176, 0.3455, 0.3368],
+ [0.6947, 0.5592, 0.7285, 0.0281],
+ [0.7710, 0.9867, 0.7172, 0.5815],
+ [0.3999, 0.9192, 0.7817, 0.2535],
+ [0.2433, 0.0132, 0.1757, 0.6196]])
+```
+
+```python
+# 对 data 进行修改
+data_element.bboxes = data_element.bboxes * 2
+data_element.scores = data_element.scores * -1
+for k, v in data_element.items():
+ print(f'{k}: {v}')
+
+# 删除 data 中的属性
+del data_element.bboxes
+for k, v in data_element.items():
+ print(f'{k}: {v}')
+
+data_element.pop('scores', None)
+print('The keys in data is', data_element.keys())
+```
+
+```
+scores: tensor([-0.8445, -0.6678, -0.8172, -0.9125, -0.7186, -0.5462])
+bboxes: tensor([[1.1546, 0.0578, 0.9586, 1.5146],
+ [1.6374, 1.6352, 0.6911, 0.6735],
+ [1.3893, 1.1185, 1.4569, 0.0562],
+ [1.5420, 1.9734, 1.4344, 1.1630],
+ [0.7999, 1.8384, 1.5635, 0.5070],
+ [0.4867, 0.0264, 0.3514, 1.2392]])
+scores: tensor([-0.8445, -0.6678, -0.8172, -0.9125, -0.7186, -0.5462])
+The keys in data is []
+```
+
+```python
+# 对 metainfo 进行修改
+data_element.set_metainfo(dict(img_shape = (1280, 1280), img_id=10))
+print(data_element.img_shape) # (1280, 1280)
+for k, v in data_element.metainfo_items():
+ print(f'{k}: {v}')
+
+# 提供了便捷的属性删除和访问操作 pop
+del data_element.img_shape
+for k, v in data_element.metainfo_items():
+ print(f'{k}: {v}')
+
+data_element.pop('img_id')
+print('The keys in metainfo is', data_element.metainfo_keys())
+```
+
+```
+(1280, 1280)
+img_id: 10
+img_shape: (1280, 1280)
+img_id: 10
+The keys in metainfo is []
+```
+
+### 5. 类张量操作
+
+用户可以像 torch.Tensor 那样对 `BaseDataElement` 的 data 进行状态转换，目前支持 `cuda`， `cpu`， `to`， `numpy` 等操作。
+其中，`to` 函数拥有和 `torch.Tensor.to()` 相同的接口，使得用户可以灵活地将被封装的 tensor 进行状态转换。
+**注意：** 这些接口只会处理类型为 np.array，torch.Tensor，或者数字的序列，其他属性的数据（如字符串）会被跳过处理。
+
+```python
+data_element = BaseDataElement(
+ bboxes=torch.rand((6, 4)), scores=torch.rand((6,)),
+ metainfo=dict(img_id=0, img_shape=(640, 640))
+)
+# 将所有 data 转移到 GPU 上
+cuda_element_1 = data_element.cuda()
+print('cuda_element_1 is on the device of', cuda_element_1.bboxes.device) # cuda:0
+cuda_element_2 = data_element.to('cuda:0')
+print('cuda_element_1 is on the device of', cuda_element_2.bboxes.device) # cuda:0
+
+# 将所有 data 转移到 cpu 上
+cpu_element_1 = cuda_element_1.cpu()
+print('cpu_element_1 is on the device of', cpu_element_1.bboxes.device) # cpu
+cpu_element_2 = cuda_element_2.to('cpu')
+print('cpu_element_2 is on the device of', cpu_element_2.bboxes.device) # cpu
+
+# 将所有 data 变成 FP16
+fp16_instances = cuda_element_1.to(
+ device=None, dtype=torch.float16, non_blocking=False, copy=False,
+ memory_format=torch.preserve_format)
+print('The type of bboxes in fp16_instances is', fp16_instances.bboxes.dtype) # torch.float16
+
+# 阻断所有 data 的梯度
+cuda_element_3 = cuda_element_2.detach()
+print('The data in cuda_element_3 requires grad: ', cuda_element_3.bboxes.requires_grad)
+# 转移 data 到 numpy array
+np_instances = cpu_element_1.numpy()
+print('The type of cpu_element_1 is convert to', type(np_instances.bboxes))
+```
+
+```
+cuda_element_1 is on the device of cuda:0
+cuda_element_1 is on the device of cuda:0
+cpu_element_1 is on the device of cpu
+cpu_element_2 is on the device of cpu
+The type of bboxes in fp16_instances is torch.float16
+The data in cuda_element_3 requires grad: False
+The type of cpu_element_1 is convert to
+
+
+
+如果我们希望在测试中使用上述数据流水线，则配置文件如下所示：
+
+```python
+test_dataloader = dict(
+ batch_size=32,
+ dataset=dict(
+ type='ImageNet',
+ data_root='data/imagenet',
+ pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize', size=256, keep_ratio=True),
+ dict(type='CenterCrop', crop_size=224),
+ dict(type='PackClsInputs'),
+ ]
+ )
+)
+```
+
+## 常用的数据变换类
+
+按照功能，常用的数据变换类可以大致分为数据加载、数据预处理与增强、数据格式化。我们在 MMCV 中提供了一系列常用的数据变换类：
+
+### 数据加载
+
+为了支持大规模数据集的加载，通常在数据集初始化时不加载数据，只加载相应的路径。因此需要在数据流水线中进行具体数据的加载。
+
+| 数据变换类 | 功能 |
+| :------------------------------------------------------: | :---------------------------------------: |
+| [`LoadImageFromFile`](mmcv.transforms.LoadImageFromFile) | 根据路径加载图像 |
+| [`LoadAnnotations`](mmcv.transforms.LoadAnnotations) | 加载和组织标注信息，如 bbox、语义分割图等 |
+
+### 数据预处理及增强
+
+数据预处理和增强通常是对图像本身进行变换，如裁剪、填充、缩放等。
+
+| 数据变换类 | 功能 |
+| :--------------------------------------------------------: | :--------------------------------: |
+| [`Pad`](mmcv.transforms.Pad) | 填充图像边缘 |
+| [`CenterCrop`](mmcv.transforms.CenterCrop) | 居中裁剪 |
+| [`Normalize`](mmcv.transforms.Normalize) | 对图像进行归一化 |
+| [`Resize`](mmcv.transforms.Resize) | 按照指定尺寸或比例缩放图像 |
+| [`RandomResize`](mmcv.transforms.RandomResize) | 缩放图像至指定范围的随机尺寸 |
+| [`RandomChoiceResize`](mmcv.transforms.RandomChoiceResize) | 缩放图像至多个尺寸中的随机一个尺寸 |
+| [`RandomGrayscale`](mmcv.transforms.RandomGrayscale) | 随机灰度化 |
+| [`RandomFlip`](mmcv.transforms.RandomFlip) | 图像随机翻转 |
+
+### 数据格式化
+
+数据格式化操作通常是对数据进行的类型转换。
+
+| 数据变换类 | 功能 |
+| :----------------------------------------------: | :-------------------------------: |
+| [`ToTensor`](mmcv.transforms.ToTensor) | 将指定的数据转换为 `torch.Tensor` |
+| [`ImageToTensor`](mmcv.transforms.ImageToTensor) | 将图像转换为 `torch.Tensor` |
+
+## 自定义数据变换类
+
+要实现一个新的数据变换类，需要继承 `BaseTransform`，并实现 `transform` 方法。这里，我们使用一个简单的翻转变换（`MyFlip`）作为示例：
+
+```python
+import random
+import mmcv
+from mmcv.transforms import BaseTransform, TRANSFORMS
+
+@TRANSFORMS.register_module()
+class MyFlip(BaseTransform):
+ def __init__(self, direction: str):
+ super().__init__()
+ self.direction = direction
+
+ def transform(self, results: dict) -> dict:
+ img = results['img']
+ results['img'] = mmcv.imflip(img, direction=self.direction)
+ return results
+```
+
+从而，我们可以实例化一个 `MyFlip` 对象，并将之作为一个可调用对象，来处理我们的数据字典。
+
+```python
+import numpy as np
+
+transform = MyFlip(direction='horizontal')
+data_dict = {'img': np.random.rand(224, 224, 3)}
+data_dict = transform(data_dict)
+processed_img = data_dict['img']
+```
+
+又或者，在配置文件的 pipeline 中使用 `MyFlip` 变换
+
+```python
+pipeline = [
+ ...
+ dict(type='MyFlip', direction='horizontal'),
+ ...
+]
+```
+
+需要注意的是，如需在配置文件中使用，需要保证 `MyFlip` 类所在的文件在运行时能够被导入。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/dataset.md b/internlm_langchain/knowledge_base/MMEngine/content/dataset.md
new file mode 100644
index 00000000..a7fd09a1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/dataset.md
@@ -0,0 +1,198 @@
+# 数据集（Dataset）与数据加载器（DataLoader）
+
+```{hint}
+如果你没有接触过 PyTorch 的数据集与数据加载器，我们推荐先浏览 [PyTorch 官方教程](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html)以了解一些基本概念
+```
+
+数据集与数据加载器是 MMEngine 中训练流程的必要组件，它们的概念来源于 PyTorch，并且在含义上与 PyTorch 保持一致。通常来说，数据集定义了数据的总体数量、读取方式以及预处理，而数据加载器则在不同的设置下迭代地加载数据，如批次大小（`batch_size`）、随机乱序（`shuffle`）、并行（`num_workers`）等。数据集经过数据加载器封装后构成了数据源。在本篇教程中，我们将按照从外（数据加载器）到内（数据集）的顺序，逐步介绍它们在 MMEngine 执行器中的用法，并给出一些常用示例。读完本篇教程，你将会：
+
+- 掌握如何在 MMEngine 的执行器中配置数据加载器
+- 学会在配置文件中使用已有（如 `torchvision`）数据集
+- 了解如何使用自己的数据集
+
+## 数据加载器详解
+
+在执行器（`Runner`）中，你可以分别配置以下 3 个参数来指定对应的数据加载器
+
+- `train_dataloader`：在 `Runner.train()` 中被使用，为模型提供训练数据
+- `val_dataloader`：在 `Runner.val()` 中被使用，也会在 `Runner.train()` 中每间隔一段时间被使用，用于模型的验证评测
+- `test_dataloader`：在 `Runner.test()` 中被使用，用于模型的测试
+
+MMEngine 完全支持 PyTorch 的原生 `DataLoader`，因此上述 3 个参数均可以直接传入构建好的 `DataLoader`，如[15分钟上手](../get_started/15_minutes.md)中的例子所示。同时，借助 MMEngine 的[注册机制](../advanced_tutorials/registry.md)，以上参数也可以传入 `dict`，如下面代码（以下简称例 1）所示。字典中的键值与 `DataLoader` 的构造参数一一对应。
+
+```python
+runner = Runner(
+ train_dataloader=dict(
+ batch_size=32,
+ sampler=dict(
+ type='DefaultSampler',
+ shuffle=True),
+ dataset=torchvision.datasets.CIFAR10(...),
+ collate_fn=dict(type='default_collate')
+ )
+)
+```
+
+在这种情况下，数据加载器会在实际被用到时，在执行器内部被构建。
+
+```{note}
+关于 `DataLoader` 的更多可配置参数，你可以参考 [PyTorch API 文档](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)
+```
+
+```{note}
+如果你对于构建的具体细节感兴趣，你可以参考 [build_dataloader](mmengine.runner.Runner.build_dataloader)
+```
+
+细心的你可能会发现，例 1 **并非**直接由[15分钟上手](../get_started/15_minutes.md)中的示例代码简单修改而来。你可能本以为将 `DataLoader` 简单替换为 `dict` 就可以无缝切换，但遗憾的是，基于注册机制构建时 MMEngine 会有一些隐式的转换和约定。我们将介绍其中的不同点，以避免你使用配置文件时产生不必要的疑惑。
+
+### sampler 与 shuffle
+
+与 15 分钟上手明显不同，例 1 中我们添加了 `sampler` 参数，这是由于在 MMEngine 中我们要求通过 `dict` 传入的数据加载器的配置**必须包含 `sampler` 参数**。同时，`shuffle` 参数也从 `DataLoader` 中移除，这是由于在 PyTorch 中 **`sampler` 与 `shuffle` 参数是互斥的**，见 [PyTorch API 文档](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)。
+
+```{note}
+事实上，在 PyTorch 的实现中，`shuffle` 只是一个便利记号。当设置为 `True` 时 `DataLoader` 会自动在内部使用 `RandomSampler`
+```
+
+当考虑 `sampler` 时，例 1 代码**基本**可以认为等价于下面的代码块
+
+```python
+from mmengine.dataset import DefaultSampler
+
+dataset = torchvision.datasets.CIFAR10(...)
+sampler = DefaultSampler(dataset, shuffle=True)
+
+runner = Runner(
+ train_dataloader=DataLoader(
+ batch_size=32,
+ sampler=sampler,
+ dataset=dataset,
+ collate_fn=default_collate
+ )
+)
+```
+
+```{warning}
+上述代码的等价性只有在：1）使用单进程训练，以及 2）没有配置执行器的 `randomness` 参数时成立。这是由于使用 `dict` 传入 `sampler` 时，执行器会保证它在分布式训练环境设置完成后才被惰性构造，并接收到正确的随机种子。这两点在手动构造时需要额外工作且极易出错。因此，上述的写法只是一个示意而非推荐写法。我们**强烈建议 `sampler` 以 `dict` 的形式传入**，让执行器处理构造顺序，以避免出现问题。
+```
+
+### DefaultSampler
+
+上面例子可能会让你好奇：`DefaultSampler` 是什么，为什么要使用它，是否有其他选项？事实上，`DefaultSampler` 是 MMEngine 内置的一种采样器，它屏蔽了单进程训练与多进程训练的细节差异，使得单卡与多卡训练可以无缝切换。如果你有过使用 PyTorch `DistributedDataParallel` 的经验，你一定会对其中更换数据加载器的 `sampler` 参数有所印象。但在 MMEngine 中，这一细节通过 `DefaultSampler` 而被屏蔽。
+
+除了 `Dataset` 本身之外，`DefaultSampler` 还支持以下参数配置：
+
+- `shuffle` 设置为 `True` 时会打乱数据集的读取顺序
+- `seed` 打乱数据集所用的随机种子，通常不需要在此手动设置，会从 `Runner` 的 `randomness` 入参中读取
+- `round_up` 设置为 `True` 时，与 PyTorch `DataLoader` 中设置 `drop_last=False` 行为一致。如果你在迁移 PyTorch 的项目，你可能需要注意这一点。
+
+```{note}
+更多关于 `DefaultSampler` 的内容可以参考 [API 文档](mmengine.dataset.DefaultSampler)
+```
+
+`DefaultSampler` 适用于绝大部分情况，并且我们保证在执行器中使用它时，随机数等容易出错的细节都被正确地处理，防止你陷入多进程训练的常见陷阱。如果你想要使用基于迭代次数 (iteration-based) 的训练流程，你也许会对 [InfiniteSampler](mmengine.dataset.InfiniteSampler) 感兴趣。如果你有更多的进阶需求，你可能会想要参考上述两个内置 `sampler` 的代码，实现一个自定义的 `sampler` 并注册到 `DATA_SAMPLERS` 根注册器中。
+
+```python
+@DATA_SAMPLERS.register_module()
+class MySampler(Sampler):
+ pass
+
+runner = Runner(
+ train_dataloader=dict(
+ sampler=dict(type='MySampler'),
+ ...
+ )
+)
+```
+
+### 不起眼的 collate_fn
+
+PyTorch 的 `DataLoader` 中，`collate_fn` 这一参数常常被使用者忽略，但在 MMEngine 中你需要额外注意：当你传入 `dict` 来构造数据加载器时，MMEngine 会默认使用内置的 [pseudo_collate](mmengine.dataset.pseudo_collate)，这一点明显区别于 PyTorch 默认的 [default_collate](https://pytorch.org/docs/stable/data.html#torch.utils.data.default_collate)。因此，当你迁移 PyTorch 项目时，需要在配置文件中手动指明 `collate_fn` 以保持行为一致。
+
+```{note}
+MMEngine 中使用 `pseudo_collate` 作为默认值，主要是由于历史兼容性原因，你可以不必过于深究，只需了解并避免错误使用即可。
+```
+
+MMengine 中提供了 2 种内置的 `collate_fn`：
+
+- `pseudo_collate`，缺省时的默认参数。它不会将数据沿着 `batch` 的维度合并。详细说明可以参考 [pseudo_collate](mmengine.dataset.pseudo_collate)
+- `default_collate`，与 PyTorch 中的 `default_collate` 行为几乎完全一致，会将数据转化为 `Tensor` 并沿着 `batch` 维度合并。一些细微不同和详细说明可以参考 [default_collate](mmengine.dataset.default_collate)
+
+如果你想要使用自定义的 `collate_fn`，你也可以将它注册到 `FUNCTIONS` 根注册器中来使用
+
+```python
+@FUNCTIONS.register_module()
+def my_collate_func(data_batch: Sequence) -> Any:
+ pass
+
+runner = Runner(
+ train_dataloader=dict(
+ ...
+ collate_fn=dict(type='my_collate_func')
+ )
+)
+```
+
+## 数据集详解
+
+数据集通常定义了数据的数量、读取方式与预处理，并作为参数传递给数据加载器供后者分批次加载。由于我们使用了 PyTorch 的 `DataLoader`，因此数据集也自然与 PyTorch `Dataset` 完全兼容。同时得益于注册机制，当数据加载器使用 `dict` 在执行器内部构建时，`dataset` 参数也可以使用 `dict` 传入并在内部被构建。这一点使得编写配置文件成为可能。
+
+### 使用 torchvision 数据集
+
+`torchvision` 中提供了丰富的公开数据集，它们都可以在 MMEngine 中直接使用，例如 [15 分钟上手](../get_started/15_minutes.md)中的示例代码就使用了其中的 `Cifar10` 数据集，并且使用了 `torchvision` 中内置的数据预处理模块。
+
+但是，当需要将上述示例转换为配置文件时，你需要对 `torchvision` 中的数据集进行额外的注册。如果你同时用到了 `torchvision` 中的数据预处理模块，那么你也需要编写额外代码来对它们进行注册和构建。下面我们将给出一个等效的例子来展示如何做到这一点。
+
+```python
+import torchvision.transforms as tvt
+from mmengine.registry import DATASETS, TRANSFORMS
+from mmengine.dataset.base_dataset import Compose
+
+# 注册 torchvision 的 CIFAR10 数据集
+# 数据预处理也需要在此一起构建
+@DATASETS.register_module(name='Cifar10', force=False)
+def build_torchvision_cifar10(transform=None, **kwargs):
+ if isinstance(transform, dict):
+ transform = [transform]
+ if isinstance(transform, (list, tuple)):
+ transform = Compose(transform)
+ return torchvision.datasets.CIFAR10(**kwargs, transform=transform)
+
+# 注册 torchvision 中用到的数据预处理模块
+DATA_TRANSFORMS.register_module('RandomCrop', module=tvt.RandomCrop)
+DATA_TRANSFORMS.register_module('RandomHorizontalFlip', module=tvt.RandomHorizontalFlip)
+DATA_TRANSFORMS.register_module('ToTensor', module=tvt.ToTensor)
+DATA_TRANSFORMS.register_module('Normalize', module=tvt.Normalize)
+
+# 在 Runner 中使用
+runner = Runner(
+ train_dataloader=dict(
+ batch_size=32,
+ sampler=dict(
+ type='DefaultSampler',
+ shuffle=True),
+ dataset=dict(type='Cifar10',
+ root='data/cifar10',
+ train=True,
+ download=True,
+ transform=[
+ dict(type='RandomCrop', size=32, padding=4),
+ dict(type='RandomHorizontalFlip'),
+ dict(type='ToTensor'),
+ dict(type='Normalize', **norm_cfg)])
+ )
+)
+```
+
+```{note}
+上述例子中大量使用了[注册机制](../advanced_tutorials/registry.md)，并且用到了 MMEngine 中的 [Compose](mmengine.dataset.Compose)。如果你急需在配置文件中使用 `torchvision` 数据集，你可以参考上述代码并略作修改。但我们更加推荐你有需要时在下游库（如 [MMDet](https://github.com/open-mmlab/mmdetection) 和 [MMPretrain](https://github.com/open-mmlab/mmpretrain) 等）中寻找对应的数据集实现，从而获得更好的使用体验。
+```
+
+### 自定义数据集
+
+你可以像使用 PyTorch 一样，自由地定义自己的数据集，或将之前 PyTorch 项目中的数据集拷贝过来。如果你想要了解如何自定义数据集，可以参考 [PyTorch 官方教程](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html#creating-a-custom-dataset-for-your-files)
+
+### 使用 MMEngine 的数据集基类
+
+除了直接使用 PyTorch 的 `Dataset` 来自定义数据集之外，你也可以使用 MMEngine 内置的 `BaseDataset`，参考[数据集基类](../advanced_tutorials/basedataset.md)文档。它对标注文件的格式做了一些约定，使得数据接口更加统一、多任务训练更加便捷。同时，数据集基类也可以轻松地搭配内置的[数据变换](../advanced_tutorials/data_transform.md)使用，减轻你从头搭建训练流程的工作量。
+
+目前，`BaseDataset` 已经在 OpenMMLab 2.0 系列的下游仓库中被广泛使用。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/debug_tricks.md b/internlm_langchain/knowledge_base/MMEngine/content/debug_tricks.md
new file mode 100644
index 00000000..734e967c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/debug_tricks.md
@@ -0,0 +1,153 @@
+# 调试技巧
+
+## 设置数据集的长度
+
+在调试代码的过程中，有时需要训练几个 epoch，例如调试验证过程或者权重的保存是否符合期望。然而如果数据集太大，需要花费较长时间才能训完一个 epoch，这种情况下可以设置数据集的长度。注意，只有继承自 [BaseDataset](mmengine.dataset.BaseDataset) 的 Dataset 才支持这个功能，`BaseDataset` 的用法可阅读 [数据集基类（BASEDATASET）](../advanced_tutorials/basedataset.md)。
+
+以 `MMPretrain` 为例（参考[文档](https://mmpretrain.readthedocs.io/zh_CN/latest/get_started.html)安装 MMPretrain）。
+
+启动训练命令
+
+```bash
+python tools/train.py configs/resnet/resnet18_8xb16_cifar10.py
+```
+
+下面是训练的部分日志，其中 `3125` 表示需要迭代的次数。
+
+```
+02/20 14:43:11 - mmengine - INFO - Epoch(train) [1][ 100/3125] lr: 1.0000e-01 eta: 6:12:01 time: 0.0149 data_time: 0.0003 memory: 214 loss: 2.0611
+02/20 14:43:13 - mmengine - INFO - Epoch(train) [1][ 200/3125] lr: 1.0000e-01 eta: 4:23:08 time: 0.0154 data_time: 0.0003 memory: 214 loss: 2.0963
+02/20 14:43:14 - mmengine - INFO - Epoch(train) [1][ 300/3125] lr: 1.0000e-01 eta: 3:46:27 time: 0.0146 data_time: 0.0003 memory: 214 loss: 1.9858
+```
+
+关掉训练，然后修改 [configs/_base_/datasets/cifar10_bs16.py](https://github.com/open-mmlab/mmpretrain/blob/main/configs/_base_/datasets/cifar100_bs16.py) 中的 `dataset` 字段，设置 `indices=5000`。
+
+```python
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=2,
+ dataset=dict(
+ type=dataset_type,
+ data_prefix='data/cifar10',
+ test_mode=False,
+ indices=5000, # 设置 indices=5000，表示每个 epoch 只迭代 5000 个样本
+ pipeline=train_pipeline),
+ sampler=dict(type='DefaultSampler', shuffle=True),
+)
+```
+
+重新启动训练
+
+```bash
+python tools/train.py configs/resnet/resnet18_8xb16_cifar10.py
+```
+
+可以看到，迭代次数变成了 `313`，相比原先，这样能够更快跑完一个 epoch。
+
+```
+02/20 14:44:58 - mmengine - INFO - Epoch(train) [1][100/313] lr: 1.0000e-01 eta: 0:31:09 time: 0.0154 data_time: 0.0004 memory: 214 loss: 2.1852
+02/20 14:44:59 - mmengine - INFO - Epoch(train) [1][200/313] lr: 1.0000e-01 eta: 0:23:18 time: 0.0143 data_time: 0.0002 memory: 214 loss: 2.0424
+02/20 14:45:01 - mmengine - INFO - Epoch(train) [1][300/313] lr: 1.0000e-01 eta: 0:20:39 time: 0.0143 data_time: 0.0003 memory: 214 loss: 1.814
+```
+
+## 检查不参与 loss 计算的参数
+
+使用多卡训练时，当模型的参数参与了前向计算，但没有参与 loss 的计算，程序会抛出下面的错误：
+
+```
+RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one. This error indicates that your module has parameters that were not used in producing loss. You can enable unused parameter detection by passing the keyword argument `find_unused_parameters=True` to `torch.nn.parallel.DistributedDataParallel`, and by
+making sure all `forward` function outputs participate in calculating loss.
+```
+
+我们以[15 分钟上手 MMEngine](../get_started/15_minutes.md) 中定义的模型为例：
+
+```python
+class MMResNet50(BaseModel):
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+
+ def forward(self, imgs, labels, mode):
+ x = self.resnet(imgs)
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+```
+
+将其修改为下面的代码：
+
+```python
+class MMResNet50(BaseModel):
+
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+ self.param = nn.Parameter(torch.ones(1))
+
+ def forward(self, imgs, labels, mode):
+ x = self.resnet(imgs)
+ # self.param 参与了前向计算，但 y 没有参与 loss 的计算
+ y = self.param + x
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+```
+
+使用两张卡启动训练
+
+```bash
+torchrun --nproc-per-node 2 examples/distributed_training.py --launcher pytorch
+```
+
+程序会抛出上面提到的错误。
+
+我们可以通过设置 `find_unused_parameters=True` 来解决这个问题，
+
+```python
+cfg = dict(
+ model_wrapper_cfg=dict(
+ type='MMDistributedDataParallel', find_unused_parameters=True)
+)
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=2, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ launcher=args.launcher,
+ cfg=cfg,
+)
+runner.train()
+```
+
+重新启动训练，可以看到程序可以正常训练并打印日志。
+
+但是，设置 `find_unused_parameters=True` 会让程序变慢，因此，我们希望找出这些参数并分析它们没有参与 loss 计算的原因。
+
+可以通过设置 `detect_anomalous_params=True` 来打印未被使用的参数。
+
+```python
+cfg = dict(
+ model_wrapper_cfg=dict(
+ type='MMDistributedDataParallel',
+ find_unused_parameters=True,
+ detect_anomalous_params=True),
+)
+```
+
+重新启动训练，可以看到日志中打印了未参与 loss 计算的参数。
+
+```
+08/03 15:04:42 - mmengine - ERROR - mmengine/logging/logger.py - print_log - 323 - module.param with shape torch.Size([1]) is not in the computational graph
+```
+
+在找到这些参数后，我们可以分析为什么这些参数没有参与 loss 的计算。
+
+```{important}
+只应在调试时设置 `find_unused_parameters=True` 和 `detect_anomalous_params=True`。
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/debug_with_vscode.md b/internlm_langchain/knowledge_base/MMEngine/content/debug_with_vscode.md
new file mode 100644
index 00000000..121d8e4e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/debug_with_vscode.md
@@ -0,0 +1,75 @@
+# VS Code 调试程序
+
+## 调试多卡程序
+
+多进程（多卡）程序出现错误时，先判断是否和多进程相关，如不相关，建议使用单卡调试。
+
+本文将基于 MMEngine 中的 [example](https://github.com/open-mmlab/mmengine/blob/main/examples/distributed_training.py) 脚本来介绍如何使用 VS Code 调试多卡程序。
+
+### 安装 MMEngine
+
+因为需要使用 MMEngine 中的 example 脚本，为了方便，可以源码安装 MMEngine。
+
+```bash
+# 如果克隆代码仓库的速度过慢，可以从 https://gitee.com/open-mmlab/mmengine.git 克隆
+git clone https://github.com/open-mmlab/mmengine.git
+cd mmengine
+pip install -e . -v
+```
+
+### 运行多卡程序
+
+```bash
+torchrun --nproc_per_node=2 examples/distributed_training.py --launcher pytorch
+```
+
+运行上面的命令，可以看到脚本正常运行并打印训练日志。
+
+
+
+脚本正常运行后，可以停掉程序。
+
+### 调试多卡程序
+
+使用 VS Code 调试需先配置 `~/.vscode/launch.json`。
+
+```json
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "Python: torchrun",
+ "type": "python",
+ "request": "launch",
+ // 设置 program 的路径为 torchrun 脚本对应的绝对路径
+ // 可使用 pip show torch 查看 torch 的安装路径
+ "program": "/home/username/miniconda3/envs/py39pt20cu117/lib/python3.9/site-packages/torch/distributed/run.py",
+ // 设置 torchrun 命令的参数
+ "args":[
+ "--nproc_per_node=2",
+ // examples/distributed_training.py 的绝对路径
+ "/home/username/codebases/mmengine/examples/distributed_training.py",
+ "--launcher=pytorch"
+ ],
+ "console": "integratedTerminal",
+ "justMyCode": true
+ }
+ ]
+}
+```
+
+```{note}
+如果你使用的启动命令是 `python -m torch.distributed.launch --nproc_per_node=2 examples/distributed_training.py --launcher pytorch`，则只需将上面配置的 program 的 `run.py` 替换为 `launcher.py` 即可。
+```
+
+接下来在 VS Code 中设置断点，例如我们希望看一下 MMEngine Runner 的 train 过程，我们可以在 `runner.train()` 处设置断点。
+
+
+
+最后点击 `Python: Current File` 按钮即可开始调试。
+
+
+
+点击 F11 可跳入 `runner.train()` 查看它的实现。
+
+
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/distributed.md b/internlm_langchain/knowledge_base/MMEngine/content/distributed.md
new file mode 100644
index 00000000..ffa2e5ee
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/distributed.md
@@ -0,0 +1,47 @@
+# 分布式通信原语
+
+在分布式训练或测试的过程中，不同进程有时需要根据分布式的环境信息执行不同的代码逻辑，同时不同进程之间也经常会有相互通信的需求，对一些数据进行同步等操作。
+PyTorch 提供了一套基础的通信原语用于多进程之间张量的通信，基于这套原语，MMEngine 实现了更高层次的通信原语封装以满足更加丰富的需求。基于 MMEngine 的通信原语，算法库中的模块可以
+
+1. 在使用通信原语封装时不显式区分分布式/非分布式环境
+2. 进行除 Tensor 以外类型数据的多进程通信
+3. 无需了解底层通信后端或框架
+
+这些通信原语封装的接口和功能可以大致归类为如下三种，我们在后续章节中逐个介绍
+
+1. 分布式初始化：`init_dist` 负责初始化执行器的分布式环境
+2. 分布式信息获取与控制：包括 `get_world_size` 等函数获取当前的 `rank` 和 `world_size` 等信息
+3. 分布式通信接口：包括如 `all_reduce` 等通信函数（collective functions）
+
+## 分布式初始化
+
+- [init_dist](mmengine.dist.init_dist)： 是分布式训练的启动函数，目前支持 pytorch，slurm，MPI 3 种分布式启动方式，同时允许设置通信的后端，默认使用 NCCL。
+
+## 分布式信息获取与控制
+
+分布式信息的获取与控制函数没有参数，这些函数兼容非分布式训练的情况，功能如下
+
+- [get_world_size](mmengine.dist.get_world_size)：获取当前进程组的进程总数，非分布式情况下返回 1
+- [get_rank](mmengine.dist.get_rank)：获取当前进程对应的全局 rank 数，非分布式情况下返回 0
+- [get_backend](mmengine.dist.get_backend)：获取当前通信使用的后端，非分布式情况下返回 None
+- [get_local_rank](mmengine.dist.get_local_rank)：获取当前进程对应到当前机器的 rank 数，非分布式情况下返回 0
+- [get_local_size](mmengine.dist.get_local_size)：获取当前进程所在机器的总进程数，非分布式情况下返回 0
+- [get_dist_info](mmengine.dist.get_dist_info)：获取当前任务的进程总数和当前进程对应到全局的 rank 数，非分布式情况下 word_size = 1，rank = 0
+- [is_main_process](mmengine.dist.is_main_process)：判断是否为 0 号主进程，非分布式情况下返回 True
+- [master_only](mmengine.dist.master_only)：函数装饰器，用于修饰只需要全局 0 号进程（rank 0 而不是 local rank 0）执行的函数
+- [barrier](mmengine.dist.barrier)：同步所有进程到达相同位置
+
+## 分布式通信函数
+
+通信函数 （Collective functions），主要用于进程间数据的通信，基于 PyTorch 原生的 all_reduce，all_gather，gather，broadcast 接口，MMEngine 提供了如下接口，兼容非分布式训练的情况，并支持更丰富数据类型的通信。
+
+- [all_reduce](mmengine.dist.all_reduce): 对进程间 tensor 进行 AllReduce 操作
+- [all_gather](mmengine.dist.all_gather)：对进程间 tensor 进行 AllGather 操作
+- [gather](mmengine.dist.gather)：将进程的 tensor 收集到一个目标 rank
+- [broadcast](mmengine.dist.broadcast)：对某个进程的 tensor 进行广播
+- [sync_random_seed](mmengine.dist.sync_random_seed)：同步进程之间的随机种子
+- [broadcast_object_list](mmengine.dist.broadcast_object_list)：支持对任意可被 Pickle 序列化的 Python 对象列表进行广播，基于 broadcast 接口实现
+- [all_reduce_dict](mmengine.dist.all_reduce_dict)：对 dict 中的内容进行 all_reduce 操作，基于 broadcast 和 all_reduce 接口实现
+- [all_gather_object](mmengine.dist.all_gather_object)：基于 all_gather 实现对任意可以被 Pickle 序列化的 Python 对象进行 all_gather 操作
+- [gather_object](mmengine.dist.gather_object)：将 group 里每个 rank 中任意可被 Pickle 序列化的 Python 对象 gather 到指定的目标 rank
+- [collect_results](mmengine.dist.collect_results)：支持基于 CPU 通信或者 GPU 通信对不同进程间的列表数据进行收集
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/distributed_training.md b/internlm_langchain/knowledge_base/MMEngine/content/distributed_training.md
new file mode 100644
index 00000000..8afedc96
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/distributed_training.md
@@ -0,0 +1,107 @@
+# 分布式训练
+
+MMEngine 支持 CPU、单卡、单机多卡以及多机多卡的训练。当环境中有多张显卡时，我们可以使用以下命令开启单机多卡或者多机多卡的方式从而缩短模型的训练时间。
+
+## 启动训练
+
+### 单机多卡
+
+假设当前机器有 8 张显卡，可以使用以下命令开启多卡训练
+
+```bash
+python -m torch.distributed.launch --nproc_per_node=8 examples/distributed_training.py --launcher pytorch
+```
+
+如果需要指定显卡的编号，可以设置 `CUDA_VISIBLE_DEVICES` 环境变量，例如使用第 0 和第 3 张卡
+
+```bash
+CUDA_VISIBLE_DEVICES=0,3 python -m torch.distributed.launch --nproc_per_node=2 examples/distributed_training.py --launcher pytorch
+```
+
+### 多机多卡
+
+假设有 2 台机器，每台机器有 8 张卡。
+
+第一台机器运行以下命令
+
+```bash
+python -m torch.distributed.launch \
+ --nnodes 8 \
+ --node_rank 0 \
+ --master_addr 127.0.0.1 \
+ --master_port 29500 \
+ --nproc_per_node=8 \
+ examples/distributed_training.py --launcher pytorch
+```
+
+第 2 台机器运行以下命令
+
+```bash
+python -m torch.distributed.launch \
+ --nnodes 8 \
+ --node_rank 1 \
+ --master_addr 127.0.0.1 \
+ --master_port 29500 \
+ --nproc_per_node=8 \
+ examples/distributed_training.py --launcher pytorch
+```
+
+如果在 slurm 集群运行 MMEngine，只需运行以下命令即可开启 2 机 16 卡的训练
+
+```bash
+srun -p mm_dev \
+ --job-name=test \
+ --gres=gpu:8 \
+ --ntasks=16 \
+ --ntasks-per-node=8 \
+ --cpus-per-task=5 \
+ --kill-on-bad-exit=1 \
+ python examples/distributed_training.py --launcher="slurm"
+```
+
+## 定制化分布式训练
+
+当用户从单卡训练切换到多卡训练时，无需做任何改动，[Runner](mmengine.runner.Runner.wrap_model) 会默认使用 [MMDistributedDataParallel](mmengine.model.MMDistributedDataParallel) 封装 model，从而支持多卡训练。
+如果你希望给 `MMDistributedDataParallel` 传入更多的参数或者使用自定义的 `CustomDistributedDataParallel`，你可以设置 `model_wrapper_cfg`。
+
+### 往 MMDistributedDataParallel 传入更多的参数
+
+例如设置 `find_unused_parameters` 为 `True`：
+
+```python
+cfg = dict(
+ model_wrapper_cfg=dict(
+ type='MMDistributedDataParallel', find_unused_parameters=True)
+)
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+ cfg=cfg,
+)
+runner.train()
+```
+
+### 使用自定义的 CustomDistributedDataParallel
+
+```python
+from mmengine.registry import MODEL_WRAPPERS
+
+@MODEL_WRAPPERS.register_module()
+class CustomDistributedDataParallel(DistributedDataParallel):
+ pass
+
+
+cfg = dict(model_wrapper_cfg=dict(type='CustomDistributedDataParallel'))
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+ cfg=cfg,
+)
+runner.train()
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/epoch_to_iter.md b/internlm_langchain/knowledge_base/MMEngine/content/epoch_to_iter.md
new file mode 100644
index 00000000..5f844b3f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/epoch_to_iter.md
@@ -0,0 +1,342 @@
+# 从 EpochBased 切换至 IterBased
+
+MMEngine 支持两种训练模式，基于轮次的 EpochBased 方式和基于迭代次数的 IterBased 方式，这两种方式在下游算法库均有使用，例如 [MMDetection](https://github.com/open-mmlab/mmdetection) 默认使用 EpochBased 方式，[MMSegmentation](https://github.com/open-mmlab/mmsegmentation) 默认使用 IterBased 方式。
+
+MMEngine 很多模块默认以 EpochBased 的模式执行，例如 `ParamScheduler`, `LoggerHook`, `CheckpointHook` 等，常见的 EpochBased 配置写法如下：
+
+```python
+param_scheduler = dict(
+ type='MultiStepLR',
+ milestones=[6, 8]
+ by_epoch=True # by_epoch 默认为 True，这边显式的写出来只是为了方便对比
+)
+
+default_hooks = dict(
+ logger=dict(type='LoggerHook'),
+ checkpoint=dict(type='CheckpointHook', interval=2),
+)
+
+train_cfg = dict(
+ by_epoch=True, # by_epoch 默认为 True，这边显式的写出来只是为了方便对比
+ max_epochs=10,
+ val_interval=2
+)
+
+log_processor = dict(
+ by_epoch=True
+) # log_processor 的 by_epoch 默认为 True，这边显式的写出来只是为了方便对比， 实际上不需要设置
+
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.001, momentum=0.9)),
+ param_scheduler=param_scheduler
+ default_hooks=default_hooks,
+ log_processor=log_processor,
+ train_cfg=train_cfg,
+ resume=True,
+)
+```
+
+如果想按照 iter 训练模型，需要做以下改动：
+
+1. 将 `train_cfg` 中的 `by_epoch` 设置为 `False`，同时将 `max_iters` 设置为训练的总 iter 数，`val_iterval` 设置为验证间隔的 iter 数。
+
+ ```python
+ train_cfg = dict(
+ by_epoch=False,
+ max_iters=10000,
+ val_interval=2000
+ )
+ ```
+
+2. 将 `default_hooks` 中的 `logger` 的 `log_metric_by_epoch` 设置为 False， `checkpoint` 的 `by_epoch` 设置为 `False`。
+
+ ```python
+ default_hooks = dict(
+ logger=dict(type='LoggerHook', log_metric_by_epoch=False),
+ checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+ )
+ ```
+
+3. 将 `param_scheduler` 中的 `by_epoch` 设置为 `False`，并將 `epoch` 相关的参数换算成 `iter`
+
+ ```python
+ param_scheduler = dict(
+ type='MultiStepLR',
+ milestones=[6000, 8000],
+ by_epoch=False,
+ )
+ ```
+
+ 除了这种方式，如果你能保证 IterBasedTraining 和 EpochBasedTraining 总 iter 数一致，直接设置 `convert_to_iter_based` 为 `True` 即可。
+
+ ```python
+ param_scheduler = dict(
+ type='MultiStepLR',
+ milestones=[6, 8]
+ convert_to_iter_based=True
+ )
+ ```
+
+4. 将 `log_processor` 的 `by_epoch` 设置为 `False`。
+
+ ```python
+ log_processor = dict(
+ by_epoch=False
+ )
+ ```
+
+以 [15 分钟教程训练 CIFAR10 数据集](../get_started/15_minutes.md)为例：
+
+
+| Step | +Training by epoch | +Training by iteration | +
|---|---|---|
| Build model | +
+
+```python
+import torch.nn.functional as F
+import torchvision
+from mmengine.model import BaseModel
+
+
+class MMResNet50(BaseModel):
+ def __init__(self):
+ super().__init__()
+ self.resnet = torchvision.models.resnet50()
+
+ def forward(self, imgs, labels, mode):
+ x = self.resnet(imgs)
+ if mode == 'loss':
+ return {'loss': F.cross_entropy(x, labels)}
+ elif mode == 'predict':
+ return x, labels
+```
+
+ |
+
+|
| Build dataloader | + ++ +```python +import torchvision.transforms as transforms +from torch.utils.data import DataLoader + +norm_cfg = dict(mean=[0.491, 0.482, 0.447], std=[0.202, 0.199, 0.201]) +train_dataloader = DataLoader( + batch_size=32, + shuffle=True, + dataset=torchvision.datasets.CIFAR10( + 'data/cifar10', + train=True, + download=True, + transform=transforms.Compose([ + transforms.RandomCrop(32, padding=4), + transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + transforms.Normalize(**norm_cfg)]))) + +val_dataloader = DataLoader( + batch_size=32, + shuffle=False, + dataset=torchvision.datasets.CIFAR10( + 'data/cifar10', + train=False, + download=True, + transform=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(**norm_cfg)]))) +``` + + | +|
| Prepare metric | ++ +```python +from mmengine.evaluator import BaseMetric + +class Accuracy(BaseMetric): + def process(self, data_batch, data_samples): + score, gt = data_samples + # save the middle result of a batch to `self.results` + self.results.append({ + 'batch_size': len(gt), + 'correct': (score.argmax(dim=1) == gt).sum().cpu(), + }) + + def compute_metrics(self, results): + total_correct = sum(item['correct'] for item in results) + total_size = sum(item['batch_size'] for item in results) + # return the dict containing the eval results + # the key is the name of the metric name + return dict(accuracy=100 * total_correct / total_size) +``` + + | +|
| Configure default hooks | +
+
+
+```python
+default_hooks = dict(
+ logger=dict(type='LoggerHook', log_metric_by_epoch=True),
+ checkpoint=dict(type='CheckpointHook', interval=2, by_epoch=True),
+)
+```
+
+
+ |
+
+
+
+
+```python
+default_hooks = dict(
+ logger=dict(type='LoggerHook', log_metric_by_epoch=False),
+ checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+)
+```
+
+
+ |
+
| Configure parameter scheduler | +
+
+
+```python
+param_scheduler = dict(
+ type='MultiStepLR',
+ milestones=[6, 8],
+ by_epoch=True,
+)
+```
+
+
+ |
+
+
+
+
+```python
+param_scheduler = dict(
+ type='MultiStepLR',
+ milestones=[6000, 8000],
+ by_epoch=False,
+)
+```
+
+
+ |
+
| Configure log_processor | +
+
+
+```python
+# The default configuration of log_processor is used for epoch based training.
+# Defining it here additionally is for building runner with the same way.
+log_processor = dict(by_epoch=True)
+```
+
+
+ |
+
+
+
+
+```python
+log_processor = dict(by_epoch=False)
+```
+
+
+ |
+
| Configure train_cfg | +
+
+
+```python
+train_cfg = dict(
+ by_epoch=True,
+ max_epochs=10,
+ val_interval=2
+)
+```
+
+
+ |
+
+
+
+
+```python
+train_cfg = dict(
+ by_epoch=False,
+ max_iters=10000,
+ val_interval=2000
+)
+```
+
+
+ |
+
| Build Runner | ++ +```python +from torch.optim import SGD +from mmengine.runner import Runner +runner = Runner( + model=MMResNet50(), + work_dir='./work_dir', + train_dataloader=train_dataloader, + optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)), + train_cfg=train_cfg, + log_processor=log_processor, + default_hooks=default_hooks, + val_dataloader=val_dataloader, + val_cfg=dict(), + val_evaluator=dict(type=Accuracy), +) +runner.train() +``` + + | +|
+ 
+
+
+## 增加自定义评测指标
+
+在 OpenMMLab 的各个算法库中，已经实现了对应方向的常用评测指标。如 MMDetection 中提供了 COCO 评测指标，MMPretrain 中提供了 Accuracy、F1Score 等评测指标等。
+
+用户也可以增加自定义的评测指标。具体方法可以参考[教程文档](../tutorials/evaluation.md#自定义评测指标)中给出的示例。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/fileio.md b/internlm_langchain/knowledge_base/MMEngine/content/fileio.md
new file mode 100644
index 00000000..10a58734
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/fileio.md
@@ -0,0 +1,213 @@
+# 文件读写
+
+`MMEngine` 在 `fileio` 模块中实现了一套统一的文件读写接口。通过 `fileio` 模块，我们可以用同一个函数来处理不同的文件格式，如 `json`、`yaml` 和 `pickle`，并且可以方便地拓展其它的文件格式。
+
+`fileio` 模块也支持从多种文件存储后端读写文件，包括本地磁盘、Petrel（内部使用）、Memcached、LMDB 和 HTTP。
+
+## 读取和保存数据
+
+`MMEngine` 为读取和保存数据提供了统一的 API 接口，目前支持的格式有 `json`、`yaml` 和 `pickle`。
+
+### 从硬盘中读写文件
+
+```python
+from mmengine import load, dump
+
+# 从文件中读取数据
+data = load('test.json')
+data = load('test.yaml')
+data = load('test.pkl')
+# 从文件对象中读取数据
+with open('test.json', 'r') as f:
+ data = load(f, file_format='json')
+
+# 将数据序列化为字符串
+json_str = dump(data, file_format='json')
+
+# 将数据保存至文件 (根据文件名后缀反推文件类型)
+dump(data, 'out.pkl')
+
+# 将数据保存至文件对象
+with open('test.yaml', 'w') as f:
+ data = dump(data, f, file_format='yaml')
+```
+
+### 从其它文件存储后端读写文件
+
+```python
+from mmengine import load, dump
+
+# 从 s3 文件中读取数据
+data = load('s3://bucket-name/test.json')
+data = load('s3://bucket-name/test.yaml')
+data = load('s3://bucket-name/test.pkl')
+
+# 将数据保存至 s3 文件（根据文件名后缀反推文件类型）
+dump(data, 's3://bucket-name/out.pkl')
+```
+
+拓展 API 以支持更多的文件格式是很方便的。你所需要做的是写一个继承自 `BaseFileHandler` 的文件句柄，并使用一个或者多个文件格式来注册它。
+
+```python
+from mmengine import register_handler, BaseFileHandler
+
+# 为了注册多个文件格式，可以使用列表作为参数。
+# @register_handler(['txt', 'log'])
+@register_handler('txt')
+class TxtHandler1(BaseFileHandler):
+
+ def load_from_fileobj(self, file):
+ return file.read()
+
+ def dump_to_fileobj(self, obj, file):
+ file.write(str(obj))
+
+ def dump_to_str(self, obj, **kwargs):
+ return str(obj)
+```
+
+以 `PickleHandler` 为例：
+
+```python
+from mmengine import BaseFileHandler
+import pickle
+
+class PickleHandler(BaseFileHandler):
+
+ def load_from_fileobj(self, file, **kwargs):
+ return pickle.load(file, **kwargs)
+
+ def load_from_path(self, filepath, **kwargs):
+ return super(PickleHandler, self).load_from_path(
+ filepath, mode='rb', **kwargs)
+
+ def dump_to_str(self, obj, **kwargs):
+ kwargs.setdefault('protocol', 2)
+ return pickle.dumps(obj, **kwargs)
+
+ def dump_to_fileobj(self, obj, file, **kwargs):
+ kwargs.setdefault('protocol', 2)
+ pickle.dump(obj, file, **kwargs)
+
+ def dump_to_path(self, obj, filepath, **kwargs):
+ super(PickleHandler, self).dump_to_path(
+ obj, filepath, mode='wb', **kwargs)
+```
+
+## 读取文件并返回列表或字典
+
+例如，`a.txt` 是文本文件，一共有 5 行内容。
+
+```
+a
+b
+c
+d
+e
+```
+
+### 从硬盘读取
+
+使用 `list_from_file` 从 `a.txt` 中读取列表：
+
+```python
+from mmengine import list_from_file
+
+print(list_from_file('a.txt'))
+# ['a', 'b', 'c', 'd', 'e']
+print(list_from_file('a.txt', offset=2))
+# ['c', 'd', 'e']
+print(list_from_file('a.txt', max_num=2))
+# ['a', 'b']
+print(list_from_file('a.txt', prefix='/mnt/'))
+# ['/mnt/a', '/mnt/b', '/mnt/c', '/mnt/d', '/mnt/e']
+```
+
+例如，`b.txt` 是文本文件，一共有 3 行内容。
+
+```
+1 cat
+2 dog cow
+3 panda
+```
+
+使用 `dict_from_file` 从 `b.txt` 中读取字典：
+
+```python
+from mmengine import dict_from_file
+
+print(dict_from_file('b.txt'))
+# {'1': 'cat', '2': ['dog', 'cow'], '3': 'panda'}
+print(dict_from_file('b.txt', key_type=int))
+# {1: 'cat', 2: ['dog', 'cow'], 3: 'panda'}
+```
+
+### 从其他存储后端读取
+
+使用 `list_from_file` 从 `s3://bucket-name/a.txt` 中读取列表：
+
+```python
+from mmengine import list_from_file
+
+print(list_from_file('s3://bucket-name/a.txt'))
+# ['a', 'b', 'c', 'd', 'e']
+print(list_from_file('s3://bucket-name/a.txt', offset=2))
+# ['c', 'd', 'e']
+print(list_from_file('s3://bucket-name/a.txt', max_num=2))
+# ['a', 'b']
+print(list_from_file('s3://bucket-name/a.txt', prefix='/mnt/'))
+# ['/mnt/a', '/mnt/b', '/mnt/c', '/mnt/d', '/mnt/e']
+```
+
+使用 `dict_from_file` 从 `s3://bucket-name/b.txt` 中读取字典：
+
+```python
+from mmengine import dict_from_file
+
+print(dict_from_file('s3://bucket-name/b.txt'))
+# {'1': 'cat', '2': ['dog', 'cow'], '3': 'panda'}
+print(dict_from_file('s3://bucket-name/b.txt', key_type=int))
+# {1: 'cat', 2: ['dog', 'cow'], 3: 'panda'}
+```
+
+## 读取和保存权重文件
+
+通常情况下，我们可以通过下面的方式从磁盘或网络远端读取权重文件：
+
+```python
+import torch
+
+filepath1 = '/path/of/your/checkpoint1.pth'
+filepath2 = 'http://path/of/your/checkpoint3.pth'
+
+# 从本地磁盘读取权重文件
+checkpoint = torch.load(filepath1)
+# 保存权重文件到本地磁盘
+torch.save(checkpoint, filepath1)
+
+# 从网络远端读取权重文件
+checkpoint = torch.utils.model_zoo.load_url(filepath2)
+```
+
+在 `MMEngine` 中，在不同存储格式中读取权重文件可以通过 `load_checkpoint` 和 `save_checkpoint` 来统一实现：
+
+```python
+from mmengine import load_checkpoint, save_checkpoint
+
+filepath1 = '/path/of/your/checkpoint1.pth'
+filepath2 = 's3://bucket-name/path/of/your/checkpoint1.pth'
+filepath3 = 'http://path/of/your/checkpoint3.pth'
+
+# 从本地磁盘读取权重文件
+checkpoint = load_checkpoint(filepath1)
+# 保存权重文件到本地磁盘
+save_checkpoint(checkpoint, filepath1)
+
+# 从 s3 读取权重文件
+checkpoint = load_checkpoint(filepath2)
+# 保存权重文件到 s3
+save_checkpoint(checkpoint, filepath2)
+
+# 从网络远端读取权重文件
+checkpoint = load_checkpoint(filepath3)
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/hook.md b/internlm_langchain/knowledge_base/MMEngine/content/hook.md
new file mode 100644
index 00000000..98756b37
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/hook.md
@@ -0,0 +1,204 @@
+# 钩子
+
+钩子编程是一种编程模式，是指在程序的一个或者多个位置设置位点（挂载点），当程序运行至某个位点时，会自动调用运行时注册到位点的所有方法。钩子编程可以提高程序的灵活性和拓展性，用户将自定义的方法注册到位点便可被调用而无需修改程序中的代码。
+
+## 钩子示例
+
+下面是钩子的简单示例。
+
+```python
+pre_hooks = [(print, 'hello')]
+post_hooks = [(print, 'goodbye')]
+
+def main():
+ for func, arg in pre_hooks:
+ func(arg)
+ print('do something here')
+ for func, arg in post_hooks:
+ func(arg)
+
+main()
+```
+
+下面是程序的输出：
+
+```
+hello
+do something here
+goodbye
+```
+
+可以看到，`main` 函数在两个位置调用钩子中的函数而无需做任何改动。
+
+在 PyTorch 中，钩子的应用也随处可见，例如神经网络模块（nn.Module）中的钩子可以获得模块的前向输入输出以及反向的输入输出。以 [`register_forward_hook`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.register_forward_hook) 方法为例，该方法往模块注册一个前向钩子，钩子可以获得模块的前向输入和输出。
+
+下面是 `register_forward_hook` 用法的简单示例：
+
+```python
+import torch
+import torch.nn as nn
+
+def forward_hook_fn(
+ module, # 被注册钩子的对象
+ input, # module 前向计算的输入
+ output, # module 前向计算的输出
+):
+ print(f'"forward_hook_fn" is invoked by {module.name}')
+ print('weight:', module.weight.data)
+ print('bias:', module.bias.data)
+ print('input:', input)
+ print('output:', output)
+
+class Model(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc = nn.Linear(3, 1)
+
+ def forward(self, x):
+ y = self.fc(x)
+ return y
+
+model = Model()
+# 将 forward_hook_fn 注册到 model 每个子模块
+for module in model.children():
+ module.register_forward_hook(forward_hook_fn)
+
+x = torch.Tensor([[0.0, 1.0, 2.0]])
+y = model(x)
+```
+
+下面是程序的输出：
+
+```python
+"forward_hook_fn" is invoked by Linear(in_features=3, out_features=1, bias=True)
+weight: tensor([[-0.4077, 0.0119, -0.3606]])
+bias: tensor([-0.2943])
+input: (tensor([[0., 1., 2.]]),)
+output: tensor([[-1.0036]], grad_fn=
+| Initializer | +Registered name | +Function | +
|---|---|---|
| ConstantInit | +Constant | +将 weight 和 bias 初始化为指定常量，通常用于初始化卷积 | +
| XavierInit | +Xavier | +将 weight Xavier 方式初始化，将 bias 初始化成指定常量，通常用于初始化卷积 | +
| NormalInit | +Normal | +将 weight 以正态分布的方式初始化，将 bias 初始化成指定常量，通常用于初始化卷积 | +
| TruncNormalInit | +TruncNormal | +将 weight 以被截断的正态分布的方式初始化，参数 a 和 b 为正态分布的有效区域；将 bias 初始化成指定常量，通常用于初始化 Transformer | +
| UniformInit | +Uniform | +将 weight 以均匀分布的方式初始化，参数 a 和 b 为均匀分布的范围；将 bias 初始化为指定常量，通常用于初始化卷积 | +
| KaimingInit | +Kaiming | +将 weight 以 Kaiming 的方式初始化，将 bias 初始化成指定常量，通常用于初始化卷积 | +
| Caffe2XavierInit | +Caffe2Xavier | +Caffe2 中 Xavier 初始化方式，在 Pytorch 中对应 "fan_in", "normal" 模式的 Kaiming 初始化，，通常用于初始化卷 | +
| Pretrained | +PretrainedInit | +加载预训练权重 | +
| 初始化函数 | +功能 | +
|---|---|
| constant_init | +将 weight 和 bias 初始化为指定常量，通常用于初始化卷积 | +
| xavier_init | +将 weight 以 Xavier 方式初始化，将 bias 初始化成指定常量，通常用于初始化卷积 | +
| normal_init | +将 weight 以正态分布的方式初始化，将 bias 初始化成指定常量，通常用于初始化卷积 | +
| trunc_normal_init | +将 weight 以被截断的正态分布的方式初始化，参数 a 和 b 为正态分布的有效区域；将 bias 初始化成指定常量，通常用于初始化 Transformer | +
| uniform_init | +将 weight 以均匀分布的方式初始化，参数 a 和 b 为均匀分布的范围；将 bias 初始化为指定常量，通常用于初始化卷积 | +
| kaiming_init | +将 weight 以 Kaiming 方式初始化，将 bias 初始化成指定常量，通常用于初始化卷积 | +
| caffe2_xavier_init | +Caffe2 中 Xavier 初始化方式，在 Pytorch 中对应 "fan_in", "normal" 模式的 Kaiming 初始化，通常用于初始化卷积 | +
| bias_init_with_prob | +以概率值的形式初始化 bias | +
+
+MMEngine 将训练过程中涉及的组件和它们的关系进行了抽象，如上图所示。不同算法库中的同类型组件具有相同的接口定义。
+
+### 核心模块与相关组件
+
+训练引擎的核心模块是[执行器（Runner）](../tutorials/runner.md)。执行器负责执行训练、测试和推理任务并管理这些过程中所需要的各个组件。在训练、测试、推理任务执行过程中的特定位置，执行器设置了[钩子（Hook）](../tutorials/hook.md)来允许用户拓展、插入和执行自定义逻辑。执行器主要调用如下组件来完成训练和推理过程中的循环：
+
+- [数据集（Dataset）](../tutorials/dataset.md)：负责在训练、测试、推理任务中构建数据集，并将数据送给模型。实际使用过程中会被数据加载器（DataLoader）封装一层，数据加载器会启动多个子进程来加载数据。
+- [模型（Model）](../tutorials/model.md)：在训练过程中接受数据并输出 loss；在测试、推理任务中接受数据，并进行预测。分布式训练等情况下会被模型的封装器（Model Wrapper，如 `MMDistributedDataParallel`）封装一层。
+- [优化器封装（Optimizer）](../tutorials/optim_wrapper.md)：优化器封装负责在训练过程中执行反向传播优化模型，并且以统一的接口支持了混合精度训练和梯度累加。
+- [参数调度器（Parameter Scheduler）](../tutorials/param_scheduler.md)：训练过程中，对学习率、动量等优化器超参数进行动态调整。
+
+在训练间隙或者测试阶段，[评测指标与评测器（Metrics & Evaluator）](../tutorials/evaluation.md)会负责对模型性能进行评测。其中评测器负责基于数据集对模型的预测进行评估。评测器内还有一层抽象是评测指标，负责计算具体的一个或多个评测指标（如召回率、正确率等）。
+
+为了统一接口，OpenMMLab 2.0 中各个算法库的评测器，模型和数据之间交流的接口都使用了[数据元素（Data Element）](../advanced_tutorials/data_element.md)来进行封装。
+
+在训练、推理执行过程中，上述各个组件都可以调用日志管理模块和可视化器进行结构化和非结构化日志的存储与展示。[日志管理（Logging Modules）](../advanced_tutorials/logging.md)：负责管理执行器运行过程中产生的各种日志信息。其中消息枢纽（MessageHub）负责实现组件与组件、执行器与执行器之间的数据共享，日志处理器（Log Processor）负责对日志信息进行处理，处理后的日志会分别发送给执行器的日志器（Logger）和可视化器（Visualizer）进行日志的管理与展示。[可视化器（Visualizer）](../advanced_tutorials/visualization.md)：可视化器负责对模型的特征图、预测结果和训练过程中产生的结构化日志进行可视化，支持 Tensorboard 和 WanDB 等多种可视化后端。
+
+### 公共基础模块
+
+MMEngine 中还实现了各种算法模型执行过程中需要用到的公共基础模块，包括
+
+- [配置类（Config）](../advanced_tutorials/config.md)：在 OpenMMLab 算法库中，用户可以通过编写 config 来配置训练、测试过程以及相关的组件。
+- [注册器（Registry）](../advanced_tutorials/registry.md)：负责管理算法库中具有相同功能的模块。MMEngine 根据对算法库模块的抽象，定义了一套根注册器，算法库中的注册器可以继承自这套根注册器，实现模块的跨算法库调用。
+- [文件读写（File I/O）](../advanced_tutorials/fileio.md)：为各个模块的文件读写提供了统一的接口，以统一的形式支持了多种文件读写后端和多种文件格式，并具备扩展性。
+- [分布式通信原语（Distributed Communication Primitives）](../advanced_tutorials/distributed.md)：负责在程序分布式运行过程中不同进程间的通信。这套接口屏蔽了分布式和非分布式环境的区别，同时也自动处理了数据的设备和通信后端。
+- [其他工具（Utils）](../advanced_tutorials/manager_mixin.md)：还有一些工具性的模块，如 ManagerMixin，它实现了一种全局变量的创建和获取方式，执行器内很多全局可见对象的基类就是 ManagerMixin。
+
+用户可以进一步阅读[教程](../tutorials/runner.md)来了解这些模块的高级用法，也可以参考[设计文档](../design/hook.md) 了解它们的设计思路与细节。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/large_model_training.md b/internlm_langchain/knowledge_base/MMEngine/content/large_model_training.md
new file mode 100644
index 00000000..6539d1a2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/large_model_training.md
@@ -0,0 +1,265 @@
+# 大模型训练
+
+在训练大模型时，需要庞大的资源。单卡显存通常不能满足训练的需要，因此出现了大模型训练技术，其中典型的一种是 [DeepSpeed ZeRO](https://www.deepspeed.ai/tutorials/zero/#zero-overview)。DeepSpedd ZeRO 支持切分优化器、梯度以及参数。
+
+为了更加灵活地支持大模型训练技术，从 MMEngine v0.8.0 开始，我们提供了新的执行器 [FlexibleRunner](mmengine.runner.FlexibleRunner) 和多个抽象策略 [Strategy](../api/strategy)。
+
+```{warning}
+新的执行器 FlexibleRunner 和 Strategy 还处于实验性阶段，在将来的版本中，它们的接口有可能会发生变化。
+```
+
+下面的示例代码摘自 [examples/distributed_training_with_flexible_runner.py](https://github.com/open-mmlab/mmengine/blob/main/examples/distributed_training_with_flexible_runner.py)。
+
+## DeepSpeed
+
+[DeepSpeed](https://github.com/microsoft/DeepSpeed/tree/master) 是微软开源的基于 PyTorch 的分布式框架，其支持了 `ZeRO`, `3D-Parallelism`, `DeepSpeed-MoE`, `ZeRO-Infinity` 等训练策略。
+MMEngine 自 v0.8.0 开始支持使用 DeepSpeed 进行模型的训练。
+
+使用 DeepSpeed 前需安装 deepspeed：
+
+```bash
+pip install deepspeed
+```
+
+安装好 deepspeed 后，需配置 FlexibleRunner 的 strategy 和 optim_wrapper 参数：
+
+- strategy：指定 `type='DeepSpeedStrategy'` 并配置参数。参数的详细介绍可阅读 [DeepSpeedStrategy](mmengine._strategy.DeepSpeedStrategy)。
+- optim_wrapper：指定 `type='DeepSpeedOptimWrapper'` 并配置参数。参数的详细介绍可阅读 [DeepSpeedOptimWrapper](mmengine._strategy.deepspeed.DeepSpeedOptimWrapper)。
+
+下面是 DeepSpeed 相关的配置：
+
+```python
+from mmengine.runner._flexible_runner import FlexibleRunner
+
+# 指定 DeepSpeedStrategy 并配置参数
+strategy = dict(
+ type='DeepSpeedStrategy',
+ fp16=dict(
+ enabled=True,
+ fp16_master_weights_and_grads=False,
+ loss_scale=0,
+ loss_scale_window=500,
+ hysteresis=2,
+ min_loss_scale=1,
+ initial_scale_power=15,
+ ),
+ inputs_to_half=[0],
+ zero_optimization=dict(
+ stage=3,
+ allgather_partitions=True,
+ reduce_scatter=True,
+ allgather_bucket_size=50000000,
+ reduce_bucket_size=50000000,
+ overlap_comm=True,
+ contiguous_gradients=True,
+ cpu_offload=False),
+)
+
+# 指定 DeepSpeedOptimWrapper 并配置参数
+optim_wrapper = dict(
+ type='DeepSpeedOptimWrapper',
+ optimizer=dict(type='AdamW', lr=1e-3))
+
+# 初始化 FlexibleRunner
+runner = FlexibleRunner(
+ model=MMResNet50(),
+ work_dir='./work_dirs',
+ strategy=strategy,
+ train_dataloader=train_dataloader,
+ optim_wrapper=optim_wrapper,
+ param_scheduler=dict(type='LinearLR'),
+ train_cfg=dict(by_epoch=True, max_epochs=10, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy))
+
+# 开始训练
+runner.train()
+```
+
+使用两张卡启动分布式训练：
+
+```bash
+torchrun --nproc-per-node 2 examples/distributed_training_with_flexible_runner.py --use-deepspeed
+```
+
+
+
+
+## FullyShardedDataParallel (FSDP)
+
+PyTorch 从 v1.11 版本开始支持 [FullyShardedDataParallel](https://pytorch.org/docs/stable/fsdp.html) 训练，但由于其接口一直处于变动中，我们只支持 PyTorch v2.0.0 及以上的版本。
+
+使用 FSDP 需配置 FlexibleRunner 的 strategy 参数：指定 `type='FSDPStrategy'` 并配置参数。参数的详细介绍可阅读 [FSDPStrategy](mmengine._strategy.FSDPStrategy)。
+
+下面是 FSDP 相关的配置：
+
+```python
+from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy
+size_based_auto_wrap_policy = partial(
+ size_based_auto_wrap_policy, min_num_params=1e7)
+
+# 指定 FSDPStrategy 并配置参数
+strategy = dict(
+ type='FSDPStrategy',
+ model_wrapper=dict(auto_wrap_policy=size_based_auto_wrap_policy))
+
+# 指定 AmpOptimWrapper 并配置参数
+optim_wrapper = dict(
+ type='AmpOptimWrapper', optimizer=dict(type='AdamW', lr=1e-3))
+
+# 初始化 FlexibleRunner
+runner = FlexibleRunner(
+ model=MMResNet50(),
+ work_dir='./work_dirs',
+ strategy=strategy,
+ train_dataloader=train_dataloader,
+ optim_wrapper=optim_wrapper,
+ param_scheduler=dict(type='LinearLR'),
+ train_cfg=dict(by_epoch=True, max_epochs=10, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy))
+
+# 开始训练
+runner.train()
+```
+
+使用两张卡启动分布式训练：
+
+```bash
+torchrun --nproc-per-node 2 examples/distributed_training_with_flexible_runner.py --use-fsdp
+```
+
+训练日志
+ +``` +07/03 13:04:17 - mmengine - INFO - Epoch(train) [1][ 10/196] lr: 3.3333e-04 eta: 0:13:14 time: 0.4073 data_time: 0.0335 memory: 970 loss: 6.1887 +07/03 13:04:19 - mmengine - INFO - Epoch(train) [1][ 20/196] lr: 3.3333e-04 eta: 0:09:39 time: 0.1904 data_time: 0.0327 memory: 970 loss: 2.5746 +07/03 13:04:21 - mmengine - INFO - Epoch(train) [1][ 30/196] lr: 3.3333e-04 eta: 0:08:32 time: 0.1993 data_time: 0.0342 memory: 970 loss: 2.4180 +07/03 13:04:23 - mmengine - INFO - Epoch(train) [1][ 40/196] lr: 3.3333e-04 eta: 0:08:01 time: 0.2052 data_time: 0.0368 memory: 970 loss: 2.3682 +07/03 13:04:25 - mmengine - INFO - Epoch(train) [1][ 50/196] lr: 3.3333e-04 eta: 0:07:39 time: 0.2013 data_time: 0.0356 memory: 970 loss: 2.3025 +07/03 13:04:27 - mmengine - INFO - Epoch(train) [1][ 60/196] lr: 3.3333e-04 eta: 0:07:25 time: 0.2025 data_time: 0.0353 memory: 970 loss: 2.2078 +07/03 13:04:29 - mmengine - INFO - Epoch(train) [1][ 70/196] lr: 3.3333e-04 eta: 0:07:13 time: 0.1999 data_time: 0.0352 memory: 970 loss: 2.2045 +07/03 13:04:31 - mmengine - INFO - Epoch(train) [1][ 80/196] lr: 3.3333e-04 eta: 0:07:04 time: 0.2013 data_time: 0.0350 memory: 970 loss: 2.1709 +07/03 13:04:33 - mmengine - INFO - Epoch(train) [1][ 90/196] lr: 3.3333e-04 eta: 0:06:56 time: 0.1975 data_time: 0.0341 memory: 970 loss: 2.2070 +07/03 13:04:35 - mmengine - INFO - Epoch(train) [1][100/196] lr: 3.3333e-04 eta: 0:06:49 time: 0.1993 data_time: 0.0347 memory: 970 loss: 2.0891 +07/03 13:04:37 - mmengine - INFO - Epoch(train) [1][110/196] lr: 3.3333e-04 eta: 0:06:44 time: 0.1995 data_time: 0.0357 memory: 970 loss: 2.0700 +07/03 13:04:39 - mmengine - INFO - Epoch(train) [1][120/196] lr: 3.3333e-04 eta: 0:06:38 time: 0.1966 data_time: 0.0342 memory: 970 loss: 1.9983 +07/03 13:04:41 - mmengine - INFO - Epoch(train) [1][130/196] lr: 3.3333e-04 eta: 0:06:37 time: 0.2216 data_time: 0.0341 memory: 970 loss: 1.9409 +07/03 13:04:43 - mmengine - INFO - Epoch(train) [1][140/196] lr: 3.3333e-04 eta: 0:06:32 time: 0.1944 data_time: 0.0336 memory: 970 loss: 1.9800 +07/03 13:04:45 - mmengine - INFO - Epoch(train) [1][150/196] lr: 3.3333e-04 eta: 0:06:27 time: 0.1946 data_time: 0.0338 memory: 970 loss: 1.9356 +07/03 13:04:47 - mmengine - INFO - Epoch(train) [1][160/196] lr: 3.3333e-04 eta: 0:06:22 time: 0.1937 data_time: 0.0333 memory: 970 loss: 1.8145 +07/03 13:04:49 - mmengine - INFO - Epoch(train) [1][170/196] lr: 3.3333e-04 eta: 0:06:18 time: 0.1941 data_time: 0.0335 memory: 970 loss: 1.8525 +07/03 13:04:51 - mmengine - INFO - Epoch(train) [1][180/196] lr: 3.3333e-04 eta: 0:06:17 time: 0.2204 data_time: 0.0341 memory: 970 loss: 1.7637 +07/03 13:04:53 - mmengine - INFO - Epoch(train) [1][190/196] lr: 3.3333e-04 eta: 0:06:14 time: 0.1998 data_time: 0.0345 memory: 970 loss: 1.7523 +``` + +
+
+
+## ColossalAI
+
+[ColossalAI](https://colossalai.org/) 是一个具有高效并行化技术的综合大规模模型训练系统。MMEngine 自 v0.8.5 开始，支持使用 ColossalAI 中的 ZeRO 系列优化策略训练模型。
+
+安装版本大于 v0.3.1 的 ColossalAI。这个版本限制是由于 v0.3.1 存在一些程序阻塞的 [Bug](https://github.com/hpcaitech/ColossalAI/issues/4393)，而该 Bug 在之后的版本中已经修复。如果目前 ColossalAI 的最高版本仍为 v0.3.1，建议从源码安装主分支的 ColossalAI。
+
+```{note}
+需要注意的是，如果你的 PyTorch 版本高于 2.0，并遇到了 `nvcc fatal : Unsupported gpu architecture 'compute_90'` 类似的编译错误，则需要 git clone 源码，参考该 [PR](https://github.com/hpcaitech/ColossalAI/pull/4357) 进行修改源码，再进行安装
+```
+
+```bash
+pip install git+https://github.com/hpcaitech/ColossalAI
+```
+
+如果 ColossalAI 的最新版本大于 v0.3.1，可以直接使用 pip 安装：
+
+```bash
+pip install colossalai
+```
+
+安装好 ColossalAI 后，需配置 FlexibleRunner 的 strategy 和 optim_wrapper 参数：
+
+- strategy：指定 `type='ColossalAIStrategy'` 并配置参数。参数的详细介绍可阅读 [ColossalAIStrategy](mmengine._strategy.ColossalAIStrategy)。
+- optim_wrapper：缺省 `type` 参数，或指定 `type=ColossalAIOptimWrapper`，优化器类型建议选择 `HybridAdam`。其他可配置类型可阅读 [ColossalAIOptimWrapper](mmengine._strategy.ColossalAIOptimWrapper)。
+
+下面是 ColossalAI 相关的配置：
+
+```python
+from mmengine.runner._flexible_runner import FlexibleRunner
+
+strategy = dict(type='ColossalAIStrategy')
+optim_wrapper = dict(optimizer=dict(type='HybridAdam', lr=1e-3))
+
+# 初始化 FlexibleRunner
+runner = FlexibleRunner(
+ model=MMResNet50(),
+ work_dir='./work_dirs',
+ strategy=strategy,
+ train_dataloader=train_dataloader,
+ optim_wrapper=optim_wrapper,
+ param_scheduler=dict(type='LinearLR'),
+ train_cfg=dict(by_epoch=True, max_epochs=10, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy))
+
+# 开始训练
+runner.train()
+```
+
+使用两张卡启动分布式训练：
+
+```bash
+torchrun --nproc-per-node 2 examples/distributed_training_with_flexible_runner.py --use-colossalai
+```
+
+训练日志
+ +``` +07/03 13:05:37 - mmengine - INFO - Epoch(train) [1][ 10/196] lr: 3.3333e-04 eta: 0:08:28 time: 0.2606 data_time: 0.0330 memory: 954 loss: 6.1265 +07/03 13:05:38 - mmengine - INFO - Epoch(train) [1][ 20/196] lr: 3.3333e-04 eta: 0:05:18 time: 0.0673 data_time: 0.0325 memory: 954 loss: 2.5584 +07/03 13:05:39 - mmengine - INFO - Epoch(train) [1][ 30/196] lr: 3.3333e-04 eta: 0:04:13 time: 0.0666 data_time: 0.0320 memory: 954 loss: 2.4816 +07/03 13:05:39 - mmengine - INFO - Epoch(train) [1][ 40/196] lr: 3.3333e-04 eta: 0:03:41 time: 0.0666 data_time: 0.0321 memory: 954 loss: 2.3695 +07/03 13:05:40 - mmengine - INFO - Epoch(train) [1][ 50/196] lr: 3.3333e-04 eta: 0:03:21 time: 0.0671 data_time: 0.0324 memory: 954 loss: 2.3208 +07/03 13:05:41 - mmengine - INFO - Epoch(train) [1][ 60/196] lr: 3.3333e-04 eta: 0:03:08 time: 0.0667 data_time: 0.0320 memory: 954 loss: 2.2431 +07/03 13:05:41 - mmengine - INFO - Epoch(train) [1][ 70/196] lr: 3.3333e-04 eta: 0:02:58 time: 0.0667 data_time: 0.0320 memory: 954 loss: 2.1873 +07/03 13:05:42 - mmengine - INFO - Epoch(train) [1][ 80/196] lr: 3.3333e-04 eta: 0:02:51 time: 0.0669 data_time: 0.0320 memory: 954 loss: 2.2006 +07/03 13:05:43 - mmengine - INFO - Epoch(train) [1][ 90/196] lr: 3.3333e-04 eta: 0:02:45 time: 0.0671 data_time: 0.0324 memory: 954 loss: 2.1547 +07/03 13:05:43 - mmengine - INFO - Epoch(train) [1][100/196] lr: 3.3333e-04 eta: 0:02:40 time: 0.0667 data_time: 0.0321 memory: 954 loss: 2.1361 +07/03 13:05:44 - mmengine - INFO - Epoch(train) [1][110/196] lr: 3.3333e-04 eta: 0:02:36 time: 0.0668 data_time: 0.0320 memory: 954 loss: 2.0405 +07/03 13:05:45 - mmengine - INFO - Epoch(train) [1][120/196] lr: 3.3333e-04 eta: 0:02:32 time: 0.0669 data_time: 0.0320 memory: 954 loss: 2.0228 +07/03 13:05:45 - mmengine - INFO - Epoch(train) [1][130/196] lr: 3.3333e-04 eta: 0:02:29 time: 0.0670 data_time: 0.0324 memory: 954 loss: 2.0375 +07/03 13:05:46 - mmengine - INFO - Epoch(train) [1][140/196] lr: 3.3333e-04 eta: 0:02:26 time: 0.0664 data_time: 0.0320 memory: 954 loss: 1.9926 +07/03 13:05:47 - mmengine - INFO - Epoch(train) [1][150/196] lr: 3.3333e-04 eta: 0:02:24 time: 0.0668 data_time: 0.0320 memory: 954 loss: 1.9820 +07/03 13:05:47 - mmengine - INFO - Epoch(train) [1][160/196] lr: 3.3333e-04 eta: 0:02:22 time: 0.0674 data_time: 0.0325 memory: 954 loss: 1.9728 +07/03 13:05:48 - mmengine - INFO - Epoch(train) [1][170/196] lr: 3.3333e-04 eta: 0:02:20 time: 0.0666 data_time: 0.0320 memory: 954 loss: 1.9359 +07/03 13:05:49 - mmengine - INFO - Epoch(train) [1][180/196] lr: 3.3333e-04 eta: 0:02:18 time: 0.0667 data_time: 0.0321 memory: 954 loss: 1.9488 +07/03 13:05:49 - mmengine - INFO - Epoch(train) [1][190/196] lr: 3.3333e-04 eta: 0:02:16 time: 0.0671 data_time: 0.0323 memory: 954 loss: 1.9023\ +``` + +
+
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/logging.md b/internlm_langchain/knowledge_base/MMEngine/content/logging.md
new file mode 100644
index 00000000..451ba04e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/logging.md
@@ -0,0 +1,312 @@
+# 记录日志
+
+[执行器（Runner）](../tutorials/runner.md)在运行过程中会产生很多日志，例如损失、迭代时间、学习率等。MMEngine 实现了一套灵活的日志系统让我们能够在配置执行器时，选择不同类型日志的统计方式；在代码的任意位置，新增需要被统计的日志。
+
+## 灵活的日志统计方式
+
+我们可以通过在构建执行器时候配置[日志处理器](mmengine.runner.LogProcessor)，来灵活地选择日志统计方式。如果不为执行器配置日志处理器，则会按照日志处理器的默认参数构建实例，效果等价于：
+
+```python
+log_processor = dict(window_size=10, by_epoch=True, custom_cfg=None, num_digits=4)
+```
+
+其输出的日志格式如下：
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+from mmengine.runner import Runner
+from mmengine.model import BaseModel
+
+train_dataset = [(torch.ones(1, 1), torch.ones(1, 1))] * 50
+train_dataloader = DataLoader(train_dataset, batch_size=2)
+
+
+class ToyModel(BaseModel):
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, mode):
+ feat = self.linear(img)
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ return dict(loss1=loss1, loss2=loss2)
+
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01))
+)
+runner.train()
+```
+
+```
+08/21 02:58:41 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0019 data_time: 0.0004 loss1: 0.8381 loss2: 0.9007 loss: 1.7388
+08/21 02:58:41 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0029 data_time: 0.0010 loss1: 0.1978 loss2: 0.4312 loss: 0.6290
+```
+
+以训练阶段为例，日志处理器默认会按照以下方式统计执行器输出的日志：
+
+- 日志前缀：
+ - Epoch 模式（`by_epoch=True`）：`Epoch(train) [{当前epoch次数}][{当前迭代次数}/{Dataloader 总长度}]`
+ - Iter 模式（`by_epoch=False`）： `Iter(train) [{当前迭代次数}/{总迭代次数}]`
+- 学习率（`lr`）：统计最近一次迭代，参数更新的学习率
+- 时间
+ - 迭代时间（`time`）：最近 `window_size`（日志处理器参数） 次迭代，处理一个 batch 数据（包括数据加载和模型前向推理）的平均时间
+ - 数据时间（`data_time`）：最近 `window_size` 次迭代，加载一个 batch 数据的平均时间
+ - 剩余时间（`eta`）：根据总迭代次数和历次迭代时间计算出来的总剩余时间，剩余时间随着迭代次数增加逐渐趋于稳定
+- 损失：模型前向推理得到的各种字段的损失，默认统计最近 `window_size` 次迭代的平均损失。
+
+默认情况下，`window_size=10`，日志处理器会统计最近 10 次迭代，损失、迭代时间、数据时间的均值。
+
+默认情况下，所有日志的有效位数（`num_digits` 参数）为 4。
+
+默认情况下，输出所有自定义日志最近一次迭代的值。
+
+基于上述规则，代码示例中的日志处理器会输出 `loss1` 和 `loss2` 每 10 次迭代的均值。如果我们想统计 `loss1` 从第一次迭代开始至今的全局均值，可以这样配置：
+
+```python
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)),
+ log_processor=dict( # 配置日志处理器
+ custom_cfg=[
+ dict(data_src='loss1', # 原日志名：loss1
+ method_name='mean', # 统计方法：均值统计
+ window_size='global')]) # 统计窗口：全局
+)
+runner.train()
+```
+
+```
+08/21 02:58:49 - mmengine - INFO - Epoch(train) [1][10/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0026 data_time: 0.0007 loss1: 0.7381 loss2: 0.8446 loss: 1.5827
+08/21 02:58:49 - mmengine - INFO - Epoch(train) [1][20/25] lr: 1.0000e-02 eta: 0:00:00 time: 0.0030 data_time: 0.0012 loss1: 0.4521 loss2: 0.3939 loss: 0.5600
+```
+
+```{note}
+log_processor 默认输出 `by_epoch=True` 格式的日志。日志格式需要和 `train_cfg` 中的 `by_epoch` 参数保持一致，例如我们想按迭代次数输出日志，就需要另 `log_processor` 和 `train_cfg` 的 `by_epoch=False`。
+```
+
+其中 `data_src` 为原日志名，`mean` 为统计方法，`global` 为统计方法的参数。这样的话，日志中统计的 `loss1` 就是全局均值。我们可以在日志处理器中配置以下统计方法：
+
+训练日志
+ +``` +08/18 11:56:34 - mmengine - INFO - Epoch(train) [1][ 10/196] lr: 3.3333e-04 eta: 0:10:31 time: 0.3238 data_time: 0.0344 memory: 597 loss: 3.8766 +08/18 11:56:35 - mmengine - INFO - Epoch(train) [1][ 20/196] lr: 3.3333e-04 eta: 0:06:56 time: 0.1057 data_time: 0.0338 memory: 597 loss: 2.3797 +08/18 11:56:36 - mmengine - INFO - Epoch(train) [1][ 30/196] lr: 3.3333e-04 eta: 0:05:45 time: 0.1068 data_time: 0.0342 memory: 597 loss: 2.3219 +08/18 11:56:37 - mmengine - INFO - Epoch(train) [1][ 40/196] lr: 3.3333e-04 eta: 0:05:08 time: 0.1059 data_time: 0.0337 memory: 597 loss: 2.2641 +08/18 11:56:38 - mmengine - INFO - Epoch(train) [1][ 50/196] lr: 3.3333e-04 eta: 0:04:45 time: 0.1062 data_time: 0.0338 memory: 597 loss: 2.2250 +08/18 11:56:40 - mmengine - INFO - Epoch(train) [1][ 60/196] lr: 3.3333e-04 eta: 0:04:31 time: 0.1097 data_time: 0.0339 memory: 597 loss: 2.1672 +08/18 11:56:41 - mmengine - INFO - Epoch(train) [1][ 70/196] lr: 3.3333e-04 eta: 0:04:21 time: 0.1096 data_time: 0.0340 memory: 597 loss: 2.1688 +08/18 11:56:42 - mmengine - INFO - Epoch(train) [1][ 80/196] lr: 3.3333e-04 eta: 0:04:13 time: 0.1098 data_time: 0.0338 memory: 597 loss: 2.1781 +08/18 11:56:43 - mmengine - INFO - Epoch(train) [1][ 90/196] lr: 3.3333e-04 eta: 0:04:06 time: 0.1097 data_time: 0.0338 memory: 597 loss: 2.0938 +08/18 11:56:44 - mmengine - INFO - Epoch(train) [1][100/196] lr: 3.3333e-04 eta: 0:04:01 time: 0.1097 data_time: 0.0339 memory: 597 loss: 2.1078 +08/18 11:56:45 - mmengine - INFO - Epoch(train) [1][110/196] lr: 3.3333e-04 eta: 0:04:01 time: 0.1395 data_time: 0.0340 memory: 597 loss: 2.0141 +08/18 11:56:46 - mmengine - INFO - Epoch(train) [1][120/196] lr: 3.3333e-04 eta: 0:03:56 time: 0.1090 data_time: 0.0338 memory: 597 loss: 2.0273 +08/18 11:56:48 - mmengine - INFO - Epoch(train) [1][130/196] lr: 3.3333e-04 eta: 0:03:52 time: 0.1096 data_time: 0.0339 memory: 597 loss: 2.0086 +08/18 11:56:49 - mmengine - INFO - Epoch(train) [1][140/196] lr: 3.3333e-04 eta: 0:03:49 time: 0.1096 data_time: 0.0339 memory: 597 loss: 1.9180 +08/18 11:56:50 - mmengine - INFO - Epoch(train) [1][150/196] lr: 3.3333e-04 eta: 0:03:46 time: 0.1092 data_time: 0.0339 memory: 597 loss: 1.9578 +08/18 11:56:51 - mmengine - INFO - Epoch(train) [1][160/196] lr: 3.3333e-04 eta: 0:03:43 time: 0.1097 data_time: 0.0339 memory: 597 loss: 1.9375 +08/18 11:56:52 - mmengine - INFO - Epoch(train) [1][170/196] lr: 3.3333e-04 eta: 0:03:40 time: 0.1092 data_time: 0.0339 memory: 597 loss: 1.9312 +08/18 11:56:53 - mmengine - INFO - Epoch(train) [1][180/196] lr: 3.3333e-04 eta: 0:03:37 time: 0.1070 data_time: 0.0339 memory: 597 loss: 1.9078 +``` + +| 统计方法 | +参数 | +功能 | +
|---|---|---|
| mean | +window_size | +统计窗口内日志的均值 | +
| min | +window_size | +统计窗口内日志的最小值 | +
| max | +window_size | +统计窗口内日志的最大值 | +
| current | +/ | +返回最近一次更新的日志 | +
| MMCV 模型 | +MMEngine 模型 | +
|---|---|
+
+```python
+class MMCVToyModel(nn.Module):
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, return_loss=False):
+ feat = self.linear(img)
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ loss = (loss1 + loss2).sum()
+ return dict(loss=loss,
+ num_samples=len(img),
+ log_vars=dict(
+ loss1=loss1.sum().item(),
+ loss2=loss2.sum().item()))
+
+ def train_step(self, data, optimizer=None):
+ return self(*data, return_loss=True)
+
+ def val_step(self, data, optimizer=None):
+ return self(*data, return_loss=False)
+```
+
+
+ |
+
+
+```python
+class MMEngineToyModel(BaseModel):
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, mode):
+ if mode == 'loss':
+ feat = self.linear(img)
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ return dict(loss1=loss1, loss2=loss2)
+ elif mode == 'predict':
+ return [_feat for _feat in feat]
+ else:
+ pass
+
+ # 模型基类 `train_step` 等效代码
+ # def train_step(self, data, optim_wrapper):
+ # data = self.data_preprocessor(data)
+ # loss_dict = self(*data, mode='loss')
+ # loss_dict['loss1'] = loss_dict['loss1'].sum()
+ # loss_dict['loss2'] = loss_dict['loss2'].sum()
+ # loss = (loss_dict['loss1'] + loss_dict['loss2']).sum()
+ # 调用优化器封装更新模型参数
+ # optim_wrapper.update_params(loss)
+ # return loss_dict
+```
+
+
+ |
+
| Training gan in MMCV | +Training gan in MMEngine | +
|---|---|
+
+```python
+ def train_discriminator(self, inputs, optimizer):
+ real_imgs = inputs['inputs']
+ z = torch.randn(
+ (real_imgs.shape[0], self.noise_size)).type_as(real_imgs)
+ with torch.no_grad():
+ fake_imgs = self.generator(z)
+
+ disc_pred_fake = self.discriminator(fake_imgs)
+ disc_pred_real = self.discriminator(real_imgs)
+
+ parsed_losses, log_vars = self.disc_loss(disc_pred_fake,
+ disc_pred_real)
+ parsed_losses.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ return log_vars
+
+ def train_generator(self, inputs, optimizer_wrapper):
+ real_imgs = inputs['inputs']
+ z = torch.randn(inputs['inputs'].shape[0], self.noise_size).type_as(
+ real_imgs)
+
+ fake_imgs = self.generator(z)
+
+ disc_pred_fake = self.discriminator(fake_imgs)
+ parsed_loss, log_vars = self.gen_loss(disc_pred_fake)
+
+ parsed_losses.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ return log_vars
+```
+
+ |
+
+
+
+```python
+ def train_discriminator(self, inputs, optimizer_wrapper):
+ real_imgs = inputs['inputs']
+ z = torch.randn(
+ (real_imgs.shape[0], self.noise_size)).type_as(real_imgs)
+ with torch.no_grad():
+ fake_imgs = self.generator(z)
+
+ disc_pred_fake = self.discriminator(fake_imgs)
+ disc_pred_real = self.discriminator(real_imgs)
+
+ parsed_losses, log_vars = self.disc_loss(disc_pred_fake,
+ disc_pred_real)
+ optimizer_wrapper.update_params(parsed_losses)
+ return log_vars
+
+
+
+ def train_generator(self, inputs, optimizer_wrapper):
+ real_imgs = inputs['inputs']
+ z = torch.randn(real_imgs.shape[0], self.noise_size).type_as(real_imgs)
+
+ fake_imgs = self.generator(z)
+
+ disc_pred_fake = self.discriminator(fake_imgs)
+ parsed_loss, log_vars = self.gen_loss(disc_pred_fake)
+
+ optimizer_wrapper.update_params(parsed_loss)
+ return log_vars
+```
+
+ |
+
+
| MMCV 分布式训练构建模型 | +MMEngine 分布式训练 | +
|---|---|
+
+```python
+model = MMDistributedDataParallel(
+ model,
+ device_ids=[int(os.environ['LOCAL_RANK'])],
+ broadcast_buffers=False,
+ find_unused_parameters=find_unused_parameters)
+...
+runner = Runner(model=model, ...)
+```
+
+
+ |
+
+
+```python
+runner = Runner(
+ model=model,
+ launcher='pytorch', #开启分布式训练
+ ..., # 其他参数
+)
+```
+
+
+ |
+
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + warmup='constant', + warmup_ratio=0.1, + warmup_iters=500, + warmup_by_epoch=False +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='ConstantLR', + factor=0.1, + begin=0, + end=500, + by_epoch=False), + dict(...) # 主学习率调度器配置 +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + warmup='linear', + warmup_ratio=0.1, + warmup_iters=500, + warmup_by_epoch=False +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='LinearLR', + start_factor=0.1, + begin=0, + end=500, + by_epoch=False), + dict(...) # 主学习率调度器配置 +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + warmup='exp', + warmup_ratio=0.1, + warmup_iters=500, + warmup_by_epoch=False +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='ExponentialLR', + gamma=0.1, + begin=0, + end=500, + by_epoch=False), + dict(...) # 主学习率调度器配置 +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict(policy='fixed') +``` + + | ++ +```python +param_scheduler = [ + dict(type='ConstantLR', factor=1) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='step', + step=[8, 11], + gamma=0.1, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='MultiStepLR', + milestones=[8, 11], + gamma=0.1, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='poly', + power=0.7, + min_lr=0.001, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='PolyLR', + power=0.7, + eta_min=0.001, + begin=0, + end=num_epochs, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='exp', + power=0.5, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='ExponentialLR', + gamma=0.5, + begin=0, + end=num_epochs, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='CosineAnnealing', + min_lr=0.5, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='CosineAnnealingLR', + eta_min=0.5, + T_max=num_epochs, + begin=0, + end=num_epochs, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='FlatCosineAnnealing', + start_percent=0.5, + min_lr=0.005, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='ConstantLR', factor=1, begin=0, end=num_epochs * 0.75) + dict(type='CosineAnnealingLR', + eta_min=0.005, + begin=num_epochs * 0.75, + end=num_epochs, + T_max=num_epochs * 0.25, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict(policy='CosineRestart', + periods=[5, 10, 15], + restart_weights=[1, 0.7, 0.3], + min_lr=0.001, + by_epoch=True) +``` + + | ++ +```python +param_scheduler = [ + dict(type='CosineRestartLR', + periods=[5, 10, 15], + restart_weights=[1, 0.7, 0.3], + eta_min=0.001, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict(policy='OneCycle', + max_lr=0.02, + total_steps=90000, + pct_start=0.3, + anneal_strategy='cos', + div_factor=25, + final_div_factor=1e4, + three_phase=True, + by_epoch=False) +``` + + | ++ +```python +param_scheduler = [ + dict(type='OneCycleLR', + eta_max=0.02, + total_steps=90000, + pct_start=0.3, + anneal_strategy='cos', + div_factor=25, + final_div_factor=1e4, + three_phase=True, + by_epoch=False) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='LinearAnnealing', + min_lr_ratio=0.01, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + dict(type='LinearLR', + start_factor=1, + end_factor=0.01, + begin=0, + end=num_epochs, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict(...) +momentum_config = dict( + policy='CosineAnnealing', + min_momentum=0.1, + by_epoch=True +) +``` + + | ++ +```python +param_scheduler = [ + # 学习率调度器配置 + dict(...), + # 动量调度器配置 + dict(type='CosineAnnealingMomentum', + eta_min=0.1, + T_max=num_epochs, + begin=0, + end=num_epochs, + by_epoch=True) +] +``` + + | +
| MMCV-1.x | +MMEngine | +
|---|---|
| + +```python +lr_config = dict( + policy='CosineAnnealing', + min_lr=0.5, + by_epoch=False +) +``` + + | ++ +```python +param_scheduler = [ + dict( + type='CosineAnnealingLR', + eta_min=0.5, + T_max=num_epochs, + by_epoch=True, # 注意，by_epoch 需要设置为 True + convert_to_iter_based=True # 转换为按 iter 更新参数 + ) +] +``` + + | +
+ 
+
+
+可以调用 [count_registered_modules](mmengine.registry.count_registered_modules) 函数打印已注册到 MMEngine 的模块以及层级结构。
+
+```python
+from mmengine.registry import count_registered_modules
+
+count_registered_modules()
+```
+
+在 `MMAlpha` 中定义模块 `LogSoftmax`，并往 `MMAlpha` 的 `MODELS` 注册。
+
+```python
+@MODELS.register_module()
+class LogSoftmax(nn.Module):
+ def __init__(self, dim=None):
+ super().__init__()
+
+ def forward(self, x):
+ print('call LogSoftmax.forward')
+ return x
+```
+
+在 `MMAlpha` 中使用配置调用 `LogSoftmax`
+
+```python
+model = MODELS.build(cfg=dict(type='LogSoftmax'))
+```
+
+也可以在 `MMAlpha` 中调用父节点 `MMEngine` 的模块。
+
+```python
+model = MODELS.build(cfg=dict(type='RReLU', lower=0.2))
+# 也可以加 scope
+model = MODELS.build(cfg=dict(type='mmengine.RReLU'))
+```
+
+如果不加前缀，`build` 方法首先查找当前节点是否存在该模块，如果存在则返回该模块，否则会继续向上查找父节点甚至祖先节点直到找到该模块，因此，如果当前节点和父节点存在同一模块并且希望调用父节点的模块，我们需要指定 `scope` 前缀。
+
+```python
+import torch
+
+input = torch.randn(2)
+output = model(input)
+# call RReLU.forward
+print(output)
+```
+
+### 调用兄弟节点的模块
+
+除了可以调用父节点的模块，也可以调用兄弟节点的模块。
+
+假设有另一个项目叫 `MMBeta`，它和 `MMAlpha` 一样，定义了 `MODELS` 以及设置其父节点为 `MMEngine` 的 `MODELS`。
+
+```python
+from mmengine import Registry, MODELS as MMENGINE_MODELS
+
+MODELS = Registry('model', parent=MMENGINE_MODELS, scope='mmbeta')
+```
+
+下图是 MMEngine，MMAlpha 和 MMBeta 的注册器层级结构。
+
+
+
+ 
+
+
+在 `MMBeta` 中调用兄弟节点 `MMAlpha` 的模块，
+
+```python
+model = MODELS.build(cfg=dict(type='mmalpha.LogSoftmax'))
+output = model(input)
+# call LogSoftmax.forward
+print(output)
+```
+
+调用兄弟节点的模块需要在 `type` 中指定 `scope` 前缀，所以上面的配置需要加前缀 `mmalpha`。
+
+如果需要调用兄弟节点的数个模块，每个模块都加前缀，这需要做大量的修改。于是 `MMEngine` 引入了 [DefaultScope](mmengine.registry.DefaultScope)，`Registry` 借助它可以很方便地支持临时切换当前节点为指定的节点。
+
+如果需要临时切换当前节点为指定的节点，只需在 `cfg` 设置 `_scope_` 为指定节点的作用域。
+
+```python
+model = MODELS.build(cfg=dict(type='LogSoftmax', _scope_='mmalpha'))
+output = model(input)
+# call LogSoftmax.forward
+print(output)
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/resume_training.md b/internlm_langchain/knowledge_base/MMEngine/content/resume_training.md
new file mode 100644
index 00000000..a7382597
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/resume_training.md
@@ -0,0 +1,36 @@
+# 恢复训练
+
+恢复训练是指从之前某次训练保存下来的状态开始继续训练，这里的状态包括模型的权重、优化器和优化器参数调整策略的状态。
+
+## 自动恢复训练
+
+用户可以设置 `Runner` 的 `resume` 参数开启自动恢复训练的功能。在启动训练时，设置 `Runner` 的 `resume` 等于 `True`，`Runner` 会从 `work_dir` 中加载最新的 checkpoint。如果 `work_dir` 中有最新的 checkpoint（例如该训练在上一次训练时被中断），则会从该 checkpoint 恢复训练，否则（例如上一次训练还没来得及保存 checkpoint 或者启动了新的训练任务）会重新开始训练。下面是一个开启自动恢复训练的示例
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+ resume=True,
+)
+runner.train()
+```
+
+## 指定 checkpoint 路径
+
+如果希望指定恢复训练的路径，除了设置 `resume=True`，还需要设置 `load_from` 参数。需要注意的是，如果只设置了 `load_from` 而没有设置 `resume=True`，则只会加载 checkpoint 中的权重并重新开始训练，而不是接着之前的状态继续训练。
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+ load_from='./work_dir/epoch_2.pth',
+ resume=True,
+)
+runner.train()
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/runner.md b/internlm_langchain/knowledge_base/MMEngine/content/runner.md
new file mode 100644
index 00000000..474d7bdc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/runner.md
@@ -0,0 +1,157 @@
+# 执行器
+
+深度学习算法的训练、验证和测试通常都拥有相似的流程，因此， MMEngine 抽象出了执行器来负责通用的算法模型的训练、测试、推理任务。用户一般可以直接使用 MMEngine 中的默认执行器，也可以对执行器进行修改以满足定制化需求。
+
+在介绍执行器的设计之前，我们先举几个例子来帮助用户理解为什么需要执行器。下面是一段使用 PyTorch 进行模型训练的伪代码：
+
+```python
+model = ResNet()
+optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
+train_dataset = ImageNetDataset(...)
+train_dataloader = DataLoader(train_dataset, ...)
+
+for i in range(max_epochs):
+ for data_batch in train_dataloader:
+ optimizer.zero_grad()
+ outputs = model(data_batch)
+ loss = loss_func(outputs, data_batch)
+ loss.backward()
+ optimizer.step()
+```
+
+下面是一段使用 PyTorch 进行模型测试的伪代码：
+
+```python
+model = ResNet()
+model.load_state_dict(torch.load(CKPT_PATH))
+model.eval()
+
+test_dataset = ImageNetDataset(...)
+test_dataloader = DataLoader(test_dataset, ...)
+
+for data_batch in test_dataloader:
+ outputs = model(data_batch)
+ acc = calculate_acc(outputs, data_batch)
+```
+
+下面是一段使用 PyTorch 进行模型推理的伪代码：
+
+```python
+model = ResNet()
+model.load_state_dict(torch.load(CKPT_PATH))
+model.eval()
+
+for img in imgs:
+ prediction = model(img)
+```
+
+可以从上面的三段代码看出，这三个任务的执行流程都可以归纳为构建模型、读取数据、循环迭代等步骤。上述代码都是以图像分类为例，但不论是图像分类还是目标检测或是图像分割，都脱离不了这套范式。
+因此，我们将模型的训练、验证、测试的流程整合起来，形成了执行器。在执行器中，我们只需要准备好模型、数据等任务必须的模块或是这些模块的配置文件，执行器会自动完成任务流程的准备和执行。
+通过使用执行器以及 MMEngine 中丰富的功能模块，用户不再需要手动搭建训练测试的流程，也不再需要去处理分布式与非分布式训练的区别，可以专注于算法和模型本身。
+
+
+
+MMEngine 的执行器内包含训练、测试、验证所需的各个模块，以及循环控制器（Loop）和[钩子（Hook）](../tutorials/hook.md)。用户通过提供配置文件或已构建完成的模块，执行器将自动完成运行环境的配置，模块的构建和组合，最终通过循环控制器执行任务循环。执行器对外提供三个接口：`train`， `val`， `test`，当调用这三个接口时，便会运行对应的循环控制器，并在循环的运行过程中调用钩子模块各个位点的钩子函数。
+
+当用户构建一个执行器并调用训练、验证、测试的接口时，执行器的执行流程如下：创建工作目录 -> 配置运行环境 -> 准备任务所需模块 -> 注册钩子 -> 运行循环
+
+
+
+执行器具有延迟初始化（Lazy Initialization）的特性，在初始化执行器时，并不需要依赖训练、验证和测试的全量模块，只有当运行某个循环控制器时，才会检查所需模块是否构建。因此，若用户只需要执行训练、验证或测试中的某一项功能，只需提供对应的模块或模块的配置即可。
+
+## 循环控制器
+
+在 MMEngine 中，我们将任务的执行流程抽象成循环控制器（Loop），因为大部分的深度学习任务执行流程都可以归纳为模型在一组或多组数据上进行循环迭代。
+MMEngine 内提供了四种默认的循环控制器：
+
+- EpochBasedTrainLoop 基于轮次的训练循环
+- IterBasedTrainLoop 基于迭代次数的训练循环
+- ValLoop 标准的验证循环
+- TestLoop 标准的测试循环
+
+
+
+MMEngine 中的默认执行器和循环控制器能够完成大部分的深度学习任务，但不可避免会存在无法满足的情况。有的用户希望能够对执行器进行更多自定义修改，因此，MMEngine 支持自定义模型的训练、验证以及测试的流程。
+
+用户可以通过继承循环基类来实现自己的训练流程。循环基类需要提供两个输入：`runner` 执行器的实例和 `dataloader` 循环所需要迭代的迭代器。
+用户如果有自定义的需求，也可以增加更多的输入参数。MMEngine 中同样提供了 LOOPS 注册器对循环类进行管理，用户可以向注册器内注册自定义的循环模块，然后在配置文件的 `train_cfg`、`val_cfg`、`test_cfg` 中增加 `type` 字段来指定使用何种循环。
+用户可以在自定义的循环中实现任意的执行逻辑，也可以增加或删减钩子（hook）点位，但需要注意的是一旦钩子点位被修改，默认的钩子函数可能不会被执行，导致一些训练过程中默认发生的行为发生变化。
+因此，我们强烈建议用户按照本文档中定义的循环执行流程图以及[钩子设计](../tutorials/hook.md) 去重载循环基类。
+
+```python
+from mmengine.registry import LOOPS, HOOKS
+from mmengine.runner import BaseLoop
+from mmengine.hooks import Hook
+
+
+# 自定义验证循环
+@LOOPS.register_module()
+class CustomValLoop(BaseLoop):
+ def __init__(self, runner, dataloader, evaluator, dataloader2):
+ super().__init__(runner, dataloader, evaluator)
+ self.dataloader2 = runner.build_dataloader(dataloader2)
+
+ def run(self):
+ self.runner.call_hooks('before_val_epoch')
+ for idx, data_batch in enumerate(self.dataloader):
+ self.runner.call_hooks(
+ 'before_val_iter', batch_idx=idx, data_batch=data_batch)
+ outputs = self.run_iter(idx, data_batch)
+ self.runner.call_hooks(
+ 'after_val_iter', batch_idx=idx, data_batch=data_batch, outputs=outputs)
+ metric = self.evaluator.evaluate()
+
+ # 增加额外的验证循环
+ for idx, data_batch in enumerate(self.dataloader2):
+ # 增加额外的钩子点位
+ self.runner.call_hooks(
+ 'before_valloader2_iter', batch_idx=idx, data_batch=data_batch)
+ self.run_iter(idx, data_batch)
+ # 增加额外的钩子点位
+ self.runner.call_hooks(
+ 'after_valloader2_iter', batch_idx=idx, data_batch=data_batch, outputs=outputs)
+ metric2 = self.evaluator.evaluate()
+
+ ...
+
+ self.runner.call_hooks('after_val_epoch')
+
+
+# 定义额外点位的钩子类
+@HOOKS.register_module()
+class CustomValHook(Hook):
+ def before_valloader2_iter(self, batch_idx, data_batch):
+ ...
+
+ def after_valloader2_iter(self, batch_idx, data_batch, outputs):
+ ...
+
+```
+
+上面的例子中实现了一个与默认验证循环不一样的自定义验证循环，它在两个不同的验证集上进行验证，同时对第二次验证增加了额外的钩子点位，并在最后对两个验证结果进行进一步的处理。在实现了自定义的循环类之后，只需要在配置文件的 `val_cfg` 内设置 `type='CustomValLoop'`，并添加额外的配置即可。
+
+```python
+# 自定义验证循环
+val_cfg = dict(type='CustomValLoop', dataloader2=dict(dataset=dict(type='ValDataset2'), ...))
+# 额外点位的钩子
+custom_hooks = [dict(type='CustomValHook')]
+```
+
+## 自定义执行器
+
+更进一步，如果默认执行器中依然有其他无法满足需求的部分，用户可以像自定义其他模块一样，通过继承重写的方式，实现自定义的执行器。执行器同样也可以通过注册器进行管理。具体实现流程与其他模块无异：继承 MMEngine 中的 Runner，重写需要修改的函数，添加进 RUNNERS 注册器中，最后在配置文件中指定 `runner_type` 即可。
+
+```python
+from mmengine.registry import RUNNERS
+from mmengine.runner import Runner
+
+@RUNNERS.register_module()
+class CustomRunner(Runner):
+
+ def setup_env(self):
+ ...
+```
+
+上述例子实现了一个自定义的执行器，并重写了 `setup_env` 函数，然后添加进了 RUNNERS 注册器中，完成了这些步骤之后，便可以在配置文件中设置 `runner_type='CustomRunner'` 来构建自定义的执行器。
+
+你可能还想阅读[执行器的教程](../tutorials/runner.md)或者[执行器的 API 文档](mmengine.runner.Runner)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/save_gpu_memory.md b/internlm_langchain/knowledge_base/MMEngine/content/save_gpu_memory.md
new file mode 100644
index 00000000..efa95264
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/save_gpu_memory.md
@@ -0,0 +1,120 @@
+# 节省显存
+
+在深度学习训练推理过程中显存容量至关重要，其决定了模型是否能成功运行。常见的节省显存办法包括：
+
+- 启用高效卷积BN评估功能（实验性）
+
+ 基于在[这篇论文](https://arxiv.org/abs/2305.11624)中讨论的概念，我们最近在MMCV中[引入](https://github.com/open-mmlab/mmcv/pull/2807)了一个实验性功能：高效卷积BN评估。这个功能的设计目标是在不损害性能的情况下减少网络训练过程中的显存占用。如果你的网络架构包含了一系列连续的Conv+BN模块，而且这些BN层在训练过程中保持在 `eval` 模式（在使用 [MMDetection](https://github.com/open-mmlab/mmdetection)训练对象检测器时很常见），这个功能可以将显存消耗减少超过 $20%$。要启用高效卷积BN评估功能，只需添加以下命令行参数：`--cfg-options efficient_conv_bn_eval="[backbone]"`。当你在输出日志中看到 `Enabling the "efficient_conv_bn_eval" feature for these modules ...`时，意味着功能已成功启用。由于这仍处于实验阶段，我们非常期待听到你对它的使用体验。请在[这个讨论线程](https://github.com/open-mmlab/mmengine/discussions/1252)分享你的使用报告、观察和建议。你的反馈对于进一步的开发和确定是否应将此功能集成到稳定版中至关重要。
+
+- 梯度累加
+
+ 梯度累加是指在每计算一个批次的梯度后，不进行清零而是进行梯度累加，当累加到一定的次数之后，再更新网络参数和梯度清零。 通过这种参数延迟更新的手段，实现与采用大 batch 尺寸相近的效果，达到节省显存的目的。但是需要注意如果模型中包含 batch normalization 层，使用梯度累加会对性能有一定影响。
+
+- 梯度检查点
+
+ 梯度检查点是一种以时间换空间的方法，通过减少保存的激活值来压缩模型占用空间，但是在计算梯度时必须重新计算没有存储的激活值。在 torch.utils.checkpoint 包中已经实现了对应功能。简要实现过程是：在前向阶段传递到 checkpoint 中的 forward 函数会以 `torch.no_grad` 模式运行，并且仅仅保存 forward 函数的输入和输出，然后在反向阶段重新计算中间层的激活值 （intermediate activations）。
+
+- 大模型训练技术
+
+ 最近的研究表明大型模型训练将有利于提高模型质量，但是训练如此大的模型需要巨大的资源，单卡显存已经越来越难以满足存放整个模型，因此诞生了大模型训练技术，典型的如 [DeepSpeed ZeRO](https://www.deepspeed.ai/tutorials/zero/#zero-overview) 和 FairScale 的[完全分片数据并行](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/)（Fully Sharded Data Parallel, FSDP）技术，其允许在数据并行进程之间分片模型的参数、梯度和优化器状态，并同时仍然保持数据并行的简单性。
+
+MMEngine 目前支持`梯度累加`和`大模型训练 FSDP 技术 `。下面说明其用法。
+
+## 梯度累加
+
+配置写法如下所示：
+
+```python
+optim_wrapper_cfg = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='SGD', lr=0.001, momentum=0.9),
+ # 累加 4 次参数更新一次
+ accumulative_counts=4)
+```
+
+配合 Runner 使用的完整例子如下：
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from mmengine.runner import Runner
+from mmengine.model import BaseModel
+
+train_dataset = [(torch.ones(1, 1), torch.ones(1, 1))] * 50
+train_dataloader = DataLoader(train_dataset, batch_size=2)
+
+
+class ToyModel(BaseModel):
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, mode):
+ feat = self.linear(img)
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ return dict(loss1=loss1, loss2=loss2)
+
+
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01),
+ accumulative_counts=4)
+)
+runner.train()
+```
+
+## 大模型训练
+
+```{warning}
+如果你有训练大模型的需求，推荐阅读[大模型训练](./large_model_training.md)。
+```
+
+PyTorch 1.11 中已经原生支持了 FSDP 技术。配置写法如下所示：
+
+```python
+# 位于 cfg 配置文件中
+model_wrapper_cfg=dict(type='MMFullyShardedDataParallel', cpu_offload=True)
+```
+
+配合 Runner 使用的完整例子如下：
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from mmengine.runner import Runner
+from mmengine.model import BaseModel
+
+train_dataset = [(torch.ones(1, 1), torch.ones(1, 1))] * 50
+train_dataloader = DataLoader(train_dataset, batch_size=2)
+
+
+class ToyModel(BaseModel):
+ def __init__(self) -> None:
+ super().__init__()
+ self.linear = nn.Linear(1, 1)
+
+ def forward(self, img, label, mode):
+ feat = self.linear(img)
+ loss1 = (feat - label).pow(2)
+ loss2 = (feat - label).abs()
+ return dict(loss1=loss1, loss2=loss2)
+
+
+runner = Runner(
+ model=ToyModel(),
+ work_dir='tmp_dir',
+ train_dataloader=train_dataloader,
+ train_cfg=dict(by_epoch=True, max_epochs=1),
+ optim_wrapper=dict(optimizer=dict(type='SGD', lr=0.01)),
+ cfg=dict(model_wrapper_cfg=dict(type='MMFullyShardedDataParallel', cpu_offload=True))
+)
+runner.train()
+```
+
+注意必须在分布式训练环境中 FSDP 才能生效。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/set_interval.md b/internlm_langchain/knowledge_base/MMEngine/content/set_interval.md
new file mode 100644
index 00000000..38073760
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/set_interval.md
@@ -0,0 +1,116 @@
+# 设置日志、权重保存、验证的频率
+
+MMEngine 支持两种训练模式，基于轮次的 `EpochBased` 方式和基于迭代次数的 `IterBased` 方式，这两种方式在下游算法库均有使用，例如 [MMDetection](https://github.com/open-mmlab/mmdetection) 默认使用 EpochBased 方式，[MMSegmentation](https://github.com/open-mmlab/mmsegmentation) 默认使用 IterBased 方式。
+
+在不同的训练模式下，MMEngine 间隔（interval）的语义会有区别，`EpochBased` 的间隔以 `Epoch` 为单位，`IterBased` 以 `Iteration` 为单位。
+
+## 设置训练和验证的间隔
+
+设置 [Runner](mmengine.runner.Runner) 初始化参数 `train_cfg` 中的 `val_interval` 值即可定制训练和验证的间隔。
+
+- EpochBased
+
+在 `EpochBased` 模式下，`val_interval` 的默认值为 1，表示训练一个 Epoch，验证一次。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+)
+runner.train()
+```
+
+- IterBased
+
+在 `IterBased` 模式下，`val_interval` 的默认值为 1000，表示训练迭代 1000 次，验证一次。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=False, max_iters=10000, val_interval=2000),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+)
+runner.train()
+```
+
+## 设置保存权重的间隔
+
+设置 [CheckpointHook](mmengine.hooks.CheckpointHook) 的 `interval` 值即可定制保存权重的间隔。
+
+- EpochBased
+
+在 `EpochBased` 模式下，`interval` 的默认值为 1，表示训练一个 Epoch，保存一次权重。
+
+```python
+# 将 interval 设置为 2，表示每 2 个 epoch 保存一次权重
+default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=2))
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ default_hooks=default_hooks,
+)
+runner.train()
+```
+
+- IterBased
+
+默认以 Epoch 为单位保存权重，如果希望以 Iteration 为单位，需设置 `by_epoch=False`。
+
+```python
+# 设置 by_epoch=False 以及 interval = 500，表示每 500 个 iteration 保存一次权重
+default_hooks = dict(checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=500))
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=False, max_iters=10000, val_interval=1000),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ default_hooks=default_hooks,
+)
+runner.train()
+```
+
+`CheckpointHook` 的更多用法可查看 [CheckpointHook 教程](../tutorials/hook.md#checkpointhook)。
+
+## 设置打印日志的间隔
+
+默认情况下，每迭代 10 次往终端打印 1 次日志，可以通过设置 [LoggerHook](mmengine.hooks.LoggerHook) 的 `interval` 参数进行设置。
+
+```python
+# 设置每 20 次打印一次
+default_hooks = dict(logger=dict(type='LoggerHook', interval=20))
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ default_hooks=default_hooks,
+)
+runner.train()
+```
+
+`LoggerHook` 的更多用法可查看 [LoggerHook 教程](../tutorials/hook.md#loggerhook)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/set_random_seed.md b/internlm_langchain/knowledge_base/MMEngine/content/set_random_seed.md
new file mode 100644
index 00000000..7b0ce555
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/set_random_seed.md
@@ -0,0 +1,29 @@
+# 设置随机种子
+
+在 [PyTorch REPRODUCIBILITY](https://pytorch.org/docs/stable/notes/randomness.html) 中介绍了影响实验是否可复现的两个因素，一个是随机数，另一个是某些算子的实现算法具有不确定性。
+
+MMEngine 提供了设置随机数以及是否选择确定性算法的功能，用户只需设置 `Runner` 的 `randomness` 参数（最终调用 [set_random_seed](mmengine.runner.set_random_seed)）即可，它有以下三个可设置的字段：
+
+- seed: 随机种子，如果不设置 seed，则会使用随机数作为种子
+- diff_rank_seed: 是否为不同的进程设置不同的种子，在 seed 的基础上加上进程索引数
+- deterministic: 是否为 CUDNN 后端设置确定性选项
+
+以[15 分钟上手 MMEngine](../get_started/15_minutes.md) 的 Runner 初始化参数中添加 `randomness` 为例。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ # 新增 randomness 设置
+ randomness=dict(seed=0),
+)
+runner.train()
+```
+
+需要注意的是，即使设置了随机数以及选择了确定性算法，依然可能出现两次实验有波动，具体分析见[基于PyTorch的MMDetection中训练的随机性来自何处？](https://www.zhihu.com/question/453511684/answer/1839683634)
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/speed_up_training.md b/internlm_langchain/knowledge_base/MMEngine/content/speed_up_training.md
new file mode 100644
index 00000000..2c5d0919
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/speed_up_training.md
@@ -0,0 +1,79 @@
+# 加速训练
+
+## 分布式训练
+
+```{warning}
+内容已被迁移至 [分布式训练](./distributed_training.md)。
+```
+
+## 混合精度训练
+
+Nvidia 在 Volta 和 Turing 架构中引入 Tensor Core 单元，来支持 FP32 和 FP16 混合精度计算。在 Ampere 架构中，他们进一步支持了 BF16 计算。开启自动混合精度训练后，部分算子的操作精度是 FP16/BF16，其余算子的操作精度是 FP32。这样在不改变模型、不降低模型训练精度的前提下，可以缩短训练时间，降低存储需求，因而能支持更大的 batch size、更大模型和尺寸更大的输入的训练。
+
+[PyTorch 从 1.6 开始官方支持 amp](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/)。如果你对自动混合精度的实现感兴趣，可以阅读 [torch.cuda.amp: 自动混合精度详解](https://zhuanlan.zhihu.com/p/348554267)。
+
+MMEngine 提供自动混合精度的封装 [AmpOptimWrapper](mmengine.optim.AmpOptimWrapper) ，只需在 `optim_wrapper` 设置 `type='AmpOptimWrapper'` 即可开启自动混合精度训练，无需对代码做其他修改。
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader_cfg,
+ optim_wrapper=dict(
+ type='AmpOptimWrapper',
+ # 如果你想要使用 BF16，请取消下面一行的代码注释
+ # dtype='bfloat16', # 可用值： ('float16', 'bfloat16', None)
+ optimizer=dict(type='SGD', lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=3),
+)
+runner.train()
+```
+
+```{warning}
+截止到 PyTorch 1.13 版本，在 `Convolution` 中直接使用 `torch.bfloat16` 性能低下，必须手动设置环境变量 `TORCH_CUDNN_V8_API_ENABLED=1` 以启用 CuDNN 版本的 BF16 Convolution。相关讨论见 [PyTorch Issue](https://github.com/pytorch/pytorch/issues/57707#issuecomment-1166656767)
+```
+
+## 模型编译
+
+PyTorch 2.0 版本引入了 [torch.compile](https://pytorch.org/docs/2.0/dynamo/get-started.html) 新特性，通过对模型进行编译来加速训练、验证。MMEngine 从 v0.7.0 版本开始支持这一特性，你可以通过向 `Runner` 的 `cfg` 参数传入一个带有 `compile` 关键词的字典来开启模型编译：
+
+```python
+runner = Runner(
+ model=ResNet18(),
+ ... # 你的其他 Runner 配置参数
+ cfg=dict(compile=True)
+)
+```
+
+此外，你也可以传入更多的编译配置选项，所有编译配置选项可以参考 [torch.compile API 文档](https://pytorch.org/docs/2.0/generated/torch.compile.html#torch-compile)
+
+```python
+compile_options = dict(backend='inductor', mode='max-autotune')
+runner = Runner(
+ model=ResNet18(),
+ ... # 你的其他 Runner 配置参数
+ cfg=dict(compile=compile_options)
+)
+```
+
+这一特性只有在你安装 PyTorch >= 2.0.0 版本时才可用。
+
+```{warning}
+`torch.compile` 目前仍然由 PyTorch 团队持续开发中，一些模型可能会编译失败。如果遇到了类似问题，你可以查阅 [PyTorch Dynamo FAQ](https://pytorch.org/docs/2.0/dynamo/faq.html) 解决常见问题，或参考 [TorchDynamo Troubleshooting](https://pytorch.org/docs/2.0/dynamo/troubleshooting.html) 向 PyTorch 提 issue.
+```
+
+## 使用更快的优化器
+
+如果使用了昇腾的设备，可以使用昇腾的优化器从而缩短模型的训练时间。昇腾设备支持的优化器如下
+
+- NpuFusedAdadelta
+- NpuFusedAdam
+- NpuFusedAdamP
+- NpuFusedAdamW
+- NpuFusedBertAdam
+- NpuFusedLamb
+- NpuFusedRMSprop
+- NpuFusedRMSpropTF
+- NpuFusedSGD
+
+使用方式同原生优化器一样，可参考[优化器的使用](../tutorials/optim_wrapper.md#在执行器中配置优化器封装)。
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/test_time_augmentation.md b/internlm_langchain/knowledge_base/MMEngine/content/test_time_augmentation.md
new file mode 100644
index 00000000..77b85b51
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/test_time_augmentation.md
@@ -0,0 +1,159 @@
+# 测试时增强（Test time augmentation）
+
+测试时增强（Test time augmentation，后文简称 TTA）是一种测试阶段的数据增强策略，旨在测试过程中，对同一张图片做翻转、缩放等各种数据增强，将增强后每张图片预测的结果还原到原始尺寸并做融合，以获得更加准确的预测结果。为了让用户更加方便地使用 TTA，MMEngine 提供了 [BaseTTAModel](mmengine.model.BaseTTAModel) 类，用户只需按照任务需求，继承 BaseTTAModel 类，实现不同的 TTA 策略即可。
+
+TTA 的核心实现通常分为两个部分：
+
+1. 测试时的数据增强：测试时数据增强主要在 MMCV 中实现，可以参考 [TestTimeAug 的 API 文档](mmcv.transforms.TestTimeAug)，本文档不再赘述。
+2. 模型推理以及结果融合：`BaseTTAModel` 的主要功能就是实现这一部分，`BaseTTAModel.test_step` 会解析测试时增强后的数据并进行推理。用户继承 `BaseTTAModel` 后只需实现相应的融合策略即可。
+
+## 快速上手
+
+一个简单的支持 TTA 的示例可以参考 [examples/test_time_augmentation.py](https://github.com/open-mmlab/mmengine/blob/main/examples/test_time_augmentation.py)
+
+### 准备 TTA 数据增强
+
+`BaseTTAModel` 需要配合 MMCV 中实现的 `TestTimeAug` 使用，这边简单给出一个样例配置：
+
+```python
+tta_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(
+ type='TestTimeAug',
+ transforms=[
+ [dict(type='Resize', img_scale=(1333, 800), keep_ratio=True)],
+ [dict(type='RandomFlip', flip_ratio=0.),
+ dict(type='RandomFlip', flip_ratio=1.)],
+ [dict(type='PackXXXInputs', keys=['img'])],
+ ])
+]
+```
+
+该配置表示在测试时，每张图片缩放（Resize）后都会进行翻转增强，变成两张图片。
+
+### 定义 TTA 模型融合策略
+
+`BaseTTAModel` 需要对翻转前后的图片进行推理，并将结果融合。`merge_preds` 方法接受一列表，列表中每一个元素表示 batch 中的某个数据反复增强后的结果。例如 batch_size=3，我们对 batch 中的每张图片做翻转增强，`merge_preds` 接受的参数为：
+
+```python
+# data_{i}_{j} 表示对第 i 张图片做第 j 种增强后的结果，
+# 例如 batch_size=3，那么 i 的 取值范围为 0，1，2，
+# 增强方式有 2 种（翻转），那么 j 的取值范围为 0，1
+
+demo_results = [
+ [data_0_0, data_0_1],
+ [data_1_0, data_1_1],
+ [data_2_0, data_2_1],
+]
+```
+
+merge_preds 需要将 demo_results 融合成整个 batch 的推理结果。以融合分类结果为例：
+
+```python
+class AverageClsScoreTTA(BaseTTAModel):
+ def merge_preds(
+ self,
+ data_samples_list: List[List[ClsDataSample]],
+ ) -> List[ClsDataSample]:
+
+ merged_data_samples = []
+ for data_samples in data_samples_list:
+ merged_data_sample: ClsDataSample = data_samples[0].new()
+ merged_score = sum(data_sample.pred_label.score
+ for data_sample in data_samples) / len(data_samples)
+ merged_data_sample.set_pred_score(merged_score)
+ merged_data_samples.append(merged_data_sample)
+ return merged_data_samples
+```
+
+相应的配置文件为：
+
+```python
+tta_model = dict(type='AverageClsScoreTTA')
+```
+
+### 改写测试脚本
+
+```python
+cfg.model = ConfigDict(**cfg.tta_model, module=cfg.model)
+cfg.test_dataloader.dataset.pipeline = cfg.tta_pipeline
+```
+
+## 进阶使用
+
+一般情况下，用户继承 `BaseTTAModel` 后，只需要实现 `merge_preds` 方法，即可完成结果融合。但是对于复杂情况，例如融合多阶段检测器的推理结果，则可能会需要重写 `test_step` 方法。这就要求我们去进一步了解 `BaseTTAModel` 的数据流以及它和各组件之间的关系。
+
+### BaseTTAModel 和各组件的关系
+
+`BaseTTAModel` 是 `DDPWrapper` 和 `Model` 的中间层。在执行 `Runner.test()` 的过程中，会先执行 `DDPWrapper.test_step()`，然后执行 `TTAModel.test_step()`，最后再执行 `model.test_step()`：
+
+
+| 原图 | +预测结果 | +标签 | +
|---|---|---|
| + | MMClassification (旧) | +MMDetection (旧) | +MMCV (新) | +
|---|---|---|---|
LoadImageFromFile |
+ 从 'img_prefix' 和 'img_info.filename' 字段组合获得文件路径并读取 | +从 'img_prefix' 和 'img_info.filename' 字段组合获得文件路径并读取，支持指定通道顺序 | +从 'img_path' 获得文件路径并读取，支持指定加载失败不报错，支持指定解码后端 | +
LoadAnnotations |
+ 无 | +支持读取 bbox，label，mask（包括多边形样式），seg map，转换 bbox 坐标系 | +支持读取 bbox，label，mask（不包括多边形样式），seg map | +
Pad |
+ 填充 "img_fields" 中所有字段，不支持指定填充至整数倍 | +填充 "img_fields" 中所有字段，支持指定填充至整数倍 | +填充 "img" 字段，支持指定填充至整数倍 | +
CenterCrop |
+ 裁切 "img_fields" 中所有字段，支持以 EfficientNet 方式进行裁切 | +无 | +裁切 "img" 字段的图像，"gt_bboxes" 字段的 bbox，"gt_seg_map" 字段的分割图，"gt_keypoints" 字段的关键点，支持自动填充裁切边缘 | +
Normalize |
+ 图像归一化 | +无差异 | +无差异，但 MMEngine 推荐在数据预处理器中进行归一化 | +
Resize |
+ 缩放 "img_fields" 中所有字段，允许指定根据某边长等比例缩放 | +功能由 Resize 实现。需要 ratio_range 为 None，img_scale 仅指定一个尺寸，且 multiscale_mode 为 "value" 。 |
+ 缩放 "img" 字段的图像，"gt_bboxes" 字段的 bbox，"gt_seg_map" 字段的分割图，"gt_keypoints" 字段的关键点，支持指定缩放比例，支持等比例缩放图像至指定尺寸内 | +
RandomResize |
+ 无 | +功能由 Resize 实现。需要 ratio_range 为 None，img_scale指定两个尺寸，且 multiscale_mode 为 "range"，或 ratio_range 不为 None。
+ Resize( + img_sacle=[(640, 480), (960, 720)], + mode="range", +)+ |
+ 缩放功能同 Resize，支持从指定尺寸范围或指定比例范围随机采样缩放尺寸。
+ RandomResize(scale=[(640, 480), (960, 720)])+ |
+
RandomChoiceResize |
+ 无 | +功能由 Resize 实现。需要 ratio_range 为 None，img_scale 指定多个尺寸，且 multiscale_mode 为 "value"。
+ Resize( + img_sacle=[(640, 480), (960, 720)], + mode="value", +)+ |
+ 缩放功能同 Resize，支持从若干指定尺寸中随机选择缩放尺寸。
+ RandomChoiceResize(scales=[(640, 480), (960, 720)])+ |
+
RandomGrayscale |
+ 灰度化 "img_fields" 中所有字段，灰度化后保持通道数。 | +无 | +灰度化 "img" 字段，支持指定灰度化权重，支持指定是否在灰度化后保持通道数（默认不保持）。 | +
RandomFlip |
+ 翻转 "img_fields" 中所有字段，支持指定水平或垂直翻转。 | +翻转 "img_fields", "bbox_fields", "mask_fields", "seg_fields" 中所有字段，支持指定水平、垂直或对角翻转，支持指定各类翻转概率。 | +翻转 "img", "gt_bboxes", "gt_seg_map", "gt_keypoints" 字段，支持指定水平、垂直或对角翻转，支持指定各类翻转概率。 | +
MultiScaleFlipAug |
+ 无 | +用于测试时增强 | +使用 TestTimeAug |
+
ToTensor |
+ 将指定字段转换为 torch.Tensor |
+ 无差异 | +无差异 | +
ImageToTensor |
+ 将指定字段转换为 torch.Tensor，并调整通道顺序至 CHW。 |
+ 无差异 | +无差异 | +
+
+
+
+```python
+visualizer.set_image(image=image)
+visualizer.draw_texts("cat and dog", torch.tensor([10, 20]))
+visualizer.show()
+```
+
+
+
+
+
+
+你也可以通过各个绘制接口中提供的参数来定制绘制对象的颜色和宽度等等
+
+```python
+visualizer.set_image(image=image)
+visualizer.draw_bboxes(torch.tensor([72, 13, 179, 147]),
+ edge_colors='r',
+ line_widths=3)
+visualizer.draw_bboxes(torch.tensor([[33, 120, 209, 220]]),line_styles='--')
+visualizer.show()
+```
+
+
+
+
+
+
+(2) 叠加显示
+
+上述绘制接口可以多次调用，从而实现叠加显示需求
+
+```python
+visualizer.set_image(image=image)
+visualizer.draw_bboxes(torch.tensor([[33, 120, 209, 220], [72, 13, 179, 147]]))
+visualizer.draw_texts("cat and dog",
+ torch.tensor([10, 20])).draw_circles(torch.tensor([40, 50]),
+ torch.tensor([20]))
+visualizer.show()
+```
+
+
+
+
+
+
+## 特征图绘制
+
+特征图可视化功能较多，目前只支持单张特征图的可视化，为了方便理解，将其对外接口梳理如下：
+
+```python
+@staticmethod
+def draw_featmap(
+ # 输入格式要求为 CHW
+ featmap: torch.Tensor,
+ # 如果同时输入了 image 数据，则特征图会叠加到 image 上绘制
+ overlaid_image: Optional[np.ndarray] = None,
+ # 多个通道压缩为单通道的策略
+ channel_reduction: Optional[str] = 'squeeze_mean',
+ # 可选择激活度最高的 topk 个特征图显示
+ topk: int = 10,
+ # 多通道展开为多张图时候布局
+ arrangement: Tuple[int, int] = (5, 2),
+ # 可以指定 resize_shape 参数来缩放特征图
+ resize_shape: Optional[tuple] = None,
+ # 图片和特征图绘制的叠加比例
+ alpha: float = 0.5,
+) -> np.ndarray:
+```
+
+其功能可以归纳如下
+
+- 输入的 Tensor 一般是包括多个通道的，channel_reduction 参数可以将多个通道压缩为单通道，然后和图片进行叠加显示
+
+ - `squeeze_mean` 将输入的 C 维度采用 mean 函数压缩为一个通道，输出维度变成 (1, H, W)
+ - `select_max` 从输入的 C 维度中先在空间维度 sum，维度变成 (C, )，然后选择值最大的通道
+ - `None` 表示不需要压缩，此时可以通过 topk 参数可选择激活度最高的 topk 个特征图显示
+
+- 在 channel_reduction 参数为 None 的情况下，topk 参数生效，其会按照激活度排序选择 topk 个通道，然后和图片进行叠加显示，并且此时会通过 arrangement 参数指定显示的布局
+
+ - 如果 topk 不是 -1，则会按照激活度排序选择 topk 个通道显示
+ - 如果 topk = -1，此时通道 C 必须是 1 或者 3 表示输入数据是图片，否则报错提示用户应该设置 `channel_reduction`来压缩通道。
+
+- 考虑到输入的特征图通常非常小，函数支持输入 `resize_shape` 参数，方便将特征图进行上采样后进行可视化。
+
+常见用法如下：以预训练好的 ResNet18 模型为例，通过提取 layer4 层输出进行特征图可视化
+
+(1) 将多通道特征图采用 `select_max` 参数压缩为单通道并显示
+
+```python
+import numpy as np
+from torchvision.models import resnet18
+from torchvision.transforms import Compose, Normalize, ToTensor
+
+def preprocess_image(img, mean, std):
+ preprocessing = Compose([
+ ToTensor(),
+ Normalize(mean=mean, std=std)
+ ])
+ return preprocessing(img.copy()).unsqueeze(0)
+
+model = resnet18(pretrained=True)
+
+def _forward(x):
+ x = model.conv1(x)
+ x = model.bn1(x)
+ x = model.relu(x)
+ x = model.maxpool(x)
+
+ x1 = model.layer1(x)
+ x2 = model.layer2(x1)
+ x3 = model.layer3(x2)
+ x4 = model.layer4(x3)
+ return x4
+
+model.forward = _forward
+
+image_norm = np.float32(image) / 255
+input_tensor = preprocess_image(image_norm,
+ mean=[0.485, 0.456, 0.406],
+ std=[0.229, 0.224, 0.225])
+feat = model(input_tensor)[0]
+
+visualizer = Visualizer()
+drawn_img = visualizer.draw_featmap(feat, channel_reduction='select_max')
+visualizer.show(drawn_img)
+```
+
+
+
+
+
+
+由于输出的 feat 特征图尺寸为 7x7，直接可视化效果不佳，用户可以通过叠加输入图片或者 `resize_shape` 参数来缩放特征图。如果传入图片尺寸和特征图大小不一致，会强制将特征图采样到和输入图片相同空间尺寸
+
+```python
+drawn_img = visualizer.draw_featmap(feat, image, channel_reduction='select_max')
+visualizer.show(drawn_img)
+```
+
+
+
+
+
+
+(2) 利用 `topk=5` 参数选择多通道特征图中激活度最高的 5 个通道并采用 2x3 布局显示
+
+```python
+drawn_img = visualizer.draw_featmap(feat, image, channel_reduction=None,
+ topk=5, arrangement=(2, 3))
+visualizer.show(drawn_img)
+```
+
+
+
+
+
+
+用户可以通过 `arrangement` 参数选择自己想要的布局
+
+```python
+drawn_img = visualizer.draw_featmap(feat, image, channel_reduction=None,
+ topk=5, arrangement=(4, 2))
+visualizer.show(drawn_img)
+```
+
+
+
+
+
+
+## 基础存储接口
+
+在绘制完成后，可以选择本地窗口显示，也可以存储到不同后端中，目前 MMEngine 内置了本地存储、Tensorboard 存储和 WandB 存储 3 个后端，且支持存储绘制后的图片、loss 等标量数据和配置文件。
+
+**(1) 存储绘制后的图片**
+
+假设存储后端为本地存储
+
+```python
+visualizer = Visualizer(image=image,
+ vis_backends=[dict(type='LocalVisBackend')],
+ save_dir='temp_dir')
+visualizer.draw_bboxes(torch.tensor([[33, 120, 209, 220], [72, 13, 179, 147]]))
+visualizer.draw_texts("cat and dog", torch.tensor([10, 20]))
+visualizer.draw_circles(torch.tensor([40, 50]), torch.tensor([20]))
+
+# 会生成 temp_dir/vis_data/vis_image/demo_0.png
+visualizer.add_image('demo', visualizer.get_image())
+```
+
+其中生成的后缀 0 是用来区分不同 step 场景
+
+```python
+# 会生成 temp_dir/vis_data/vis_image/demo_1.png
+visualizer.add_image('demo', visualizer.get_image(), step=1)
+# 会生成 temp_dir/vis_data/vis_image/demo_3.png
+visualizer.add_image('demo', visualizer.get_image(), step=3)
+```
+
+如果想使用其他后端，则只需要修改配置文件即可
+
+```python
+# TensorboardVisBackend
+visualizer = Visualizer(image=image,
+ vis_backends=[dict(type='TensorboardVisBackend')],
+ save_dir='temp_dir')
+# 或者 WandbVisBackend
+visualizer = Visualizer(image=image,
+ vis_backends=[dict(type='WandbVisBackend')],
+ save_dir='temp_dir')
+```
+
+**(2) 存储特征图**
+
+```python
+visualizer = Visualizer(vis_backends=[dict(type='LocalVisBackend')],
+ save_dir='temp_dir')
+drawn_img = visualizer.draw_featmap(feat, image, channel_reduction=None,
+ topk=5, arrangement=(2, 3))
+# 会生成 temp_dir/vis_data/vis_image/feat_0.png
+visualizer.add_image('feat', drawn_img)
+```
+
+**(3) 存储 loss 等标量数据**
+
+```python
+# 会生成 temp_dir/vis_data/scalars.json
+# 保存 loss
+visualizer.add_scalar('loss', 0.2, step=0)
+visualizer.add_scalar('loss', 0.1, step=1)
+# 保存 acc
+visualizer.add_scalar('acc', 0.7, step=0)
+visualizer.add_scalar('acc', 0.8, step=1)
+```
+
+也可以一次性保存多个标量数据
+
+```python
+# 会将内容追加到 temp_dir/vis_data/scalars.json
+visualizer.add_scalars({'loss': 0.3, 'acc': 0.8}, step=3)
+```
+
+**(4) 保存配置文件**
+
+```python
+from mmengine import Config
+cfg=Config.fromfile('tests/data/config/py_config/config.py')
+# 会生成 temp_dir/vis_data/config.py
+visualizer.add_config(cfg)
+```
+
+## 多后端存储
+
+实际上，任何一个可视化器都可以配置任意多个存储后端，可视化器会循环调用配置好的多个存储后端，从而将结果保存到多后端中。
+
+```python
+visualizer = Visualizer(image=image,
+ vis_backends=[dict(type='TensorboardVisBackend'),
+ dict(type='LocalVisBackend')],
+ save_dir='temp_dir')
+# 会生成 temp_dir/vis_data/events.out.tfevents.xxx 文件
+visualizer.draw_bboxes(torch.tensor([[33, 120, 209, 220], [72, 13, 179, 147]]))
+visualizer.draw_texts("cat and dog", torch.tensor([10, 20]))
+visualizer.draw_circles(torch.tensor([40, 50]), torch.tensor([20]))
+
+visualizer.add_image('demo', visualizer.get_image())
+```
+
+注意：如果多个存储后端中存在同一个类的多个后端，那么必须指定 name 字段，否则无法区分是哪个存储后端
+
+```python
+visualizer = Visualizer(
+ image=image,
+ vis_backends=[
+ dict(type='TensorboardVisBackend', name='tb_1', save_dir='temp_dir_1'),
+ dict(type='TensorboardVisBackend', name='tb_2', save_dir='temp_dir_2'),
+ dict(type='LocalVisBackend', name='local')
+ ],
+ save_dir='temp_dir')
+```
+
+## 任意点位进行可视化
+
+在深度学习过程中，会存在在某些代码位置插入可视化函数，并将其保存到不同后端的需求，这类需求主要用于可视化分析和调试阶段。MMEngine 设计的可视化器支持在任意点位获取同一个可视化器然后进行可视化的功能。
+用户只需要在初始化时候通过 `get_instance` 接口实例化可视化对象，此时该可视化对象即为全局可获取唯一对象，后续通过 `Visualizer.get_current_instance()` 即可在代码任意位置获取。
+
+```python
+# 在程序初始化时候调用
+visualizer1 = Visualizer.get_instance(
+ name='vis',
+ vis_backends=[dict(type='LocalVisBackend')]
+)
+
+# 在任何代码位置都可调用
+visualizer2 = Visualizer.get_current_instance()
+visualizer2.add_scalar('map', 0.7, step=0)
+
+assert id(visualizer1) == id(visualizer2)
+```
+
+也可以通过字段配置方式全局初始化
+
+```python
+from mmengine.registry import VISUALIZERS
+
+visualizer_cfg = dict(type='Visualizer',
+ name='vis_new',
+ vis_backends=[dict(type='LocalVisBackend')])
+VISUALIZERS.build(visualizer_cfg)
+```
+
+## 扩展存储后端和可视化器
+
+**(1) 调用特定存储后端**
+
+目前存储后端仅仅提供了保存配置、保存标量等基本功能，但是由于 WandB 和 Tensorboard 这类存储后端功能非常强大， 用户可能会希望利用到这类存储后端的其他功能。因此，存储后端提供了 `experiment` 属性来方便用户获取后端对象，满足各类定制化功能。
+例如 WandB 提供了表格显示的 API 接口，用户可以通过 `experiment`属性获取 WandB 对象，然后调用特定的 API 来将自定义数据保存为表格显示
+
+```python
+visualizer = Visualizer(image=image,
+ vis_backends=[dict(type='WandbVisBackend')],
+ save_dir='temp_dir')
+
+# 获取 WandB 对象
+wandb = visualizer.get_backend('WandbVisBackend').experiment
+# 追加表格数据
+table = wandb.Table(columns=["step", "mAP"])
+table.add_data(1, 0.2)
+table.add_data(2, 0.5)
+table.add_data(3, 0.9)
+# 保存
+wandb.log({"table": table})
+```
+
+**(2) 扩展存储后端**
+
+用户可以方便快捷的扩展存储后端。只需要继承自 `BaseVisBackend` 并实现各类 `add_xx` 方法即可
+
+```python
+from mmengine.registry import VISBACKENDS
+from mmengine.visualization import BaseVisBackend
+
+@VISBACKENDS.register_module()
+class DemoVisBackend(BaseVisBackend):
+ def add_image(self, **kwargs):
+ pass
+
+visualizer = Visualizer(vis_backends=[dict(type='DemoVisBackend')],
+ save_dir='temp_dir')
+visualizer.add_image('demo',image)
+```
+
+**(3) 扩展可视化器**
+
+同样的，用户可以通过继承 Visualizer 并实现想覆写的函数来方便快捷的扩展可视化器。大部分情况下，用户需要覆写 `add_datasample`来进行拓展。数据中通常包括标注或模型预测的检测框和实例掩码，该接口为各个下游库绘制 datasample 数据的抽象接口。以 MMDetection 为例，datasample 数据中通常包括标注 bbox、标注 mask 、预测 bbox 或者预测 mask 等数据，MMDetection 会继承 Visualizer 并实现 `add_datasample` 接口，在该接口内部会针对检测任务相关数据进行可视化绘制，从而简化检测任务可视化需求。
+
+```python
+from mmengine.registry import VISUALIZERS
+
+@VISUALIZERS.register_module()
+class DetLocalVisualizer(Visualizer):
+ def add_datasample(self,
+ name,
+ image: np.ndarray,
+ data_sample: Optional['BaseDataElement'] = None,
+ draw_gt: bool = True,
+ draw_pred: bool = True,
+ show: bool = False,
+ wait_time: int = 0,
+ step: int = 0) -> None:
+ pass
+
+visualizer_cfg = dict(type='DetLocalVisualizer',
+ vis_backends=[dict(type='WandbVisBackend')],
+ name='visualizer')
+
+# 全局初始化
+VISUALIZERS.build(visualizer_cfg)
+
+# 任意代码位置
+det_local_visualizer = Visualizer.get_current_instance()
+det_local_visualizer.add_datasample('det', image, data_sample)
+```
diff --git a/internlm_langchain/knowledge_base/MMEngine/content/visualize_training_log.md b/internlm_langchain/knowledge_base/MMEngine/content/visualize_training_log.md
new file mode 100644
index 00000000..36830df9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMEngine/content/visualize_training_log.md
@@ -0,0 +1,151 @@
+# 可视化训练日志
+
+MMEngine 集成了 [TensorBoard](https://www.tensorflow.org/tensorboard?hl=zh-cn)、[Weights & Biases (WandB)](https://docs.wandb.ai/)、[MLflow](https://mlflow.org/docs/latest/index.html) 、[ClearML](https://clear.ml/docs/latest/docs) 和 [Neptune](https://docs.neptune.ai/) 实验管理工具，你可以很方便地跟踪和可视化损失及准确率等指标。
+
+下面基于[15 分钟上手 MMENGINE](../get_started/15_minutes.md)中的例子介绍如何一行配置实验管理工具。
+
+## TensorBoard
+
+设置 `Runner` 初始化参数中的 `visualizer`，并将 `vis_backends` 设置为 [TensorboardVisBackend](mmengine.visualization.TensorboardVisBackend)。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ visualizer=dict(type='Visualizer', vis_backends=[dict(type='TensorboardVisBackend')]),
+)
+runner.train()
+```
+
+## WandB
+
+使用 WandB 前需安装依赖库 `wandb` 并登录至 wandb。
+
+```bash
+pip install wandb
+wandb login
+```
+
+设置 `Runner` 初始化参数中的 `visualizer`，并将 `vis_backends` 设置为 [WandbVisBackend](mmengine.visualization.WandbVisBackend)。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ visualizer=dict(type='Visualizer', vis_backends=[dict(type='WandbVisBackend')]),
+)
+runner.train()
+```
+
+
+
+可以点击 [WandbVisBackend API](mmengine.visualization.WandbVisBackend) 查看 `WandbVisBackend` 可配置的参数。例如 `init_kwargs`，该参数会传给 [wandb.init](https://docs.wandb.ai/ref/python/init) 方法。
+
+```python
+runner = Runner(
+ ...
+ visualizer=dict(
+ type='Visualizer',
+ vis_backends=[
+ dict(
+ type='WandbVisBackend',
+ init_kwargs=dict(project='toy-example')
+ ),
+ ],
+ ),
+ ...
+)
+runner.train()
+```
+
+## MLflow (WIP)
+
+## ClearML
+
+使用 ClearML 前需安装依赖库 `clearml` 并参考 [Connect ClearML SDK to the Server](https://clear.ml/docs/latest/docs/getting_started/ds/ds_first_steps#connect-clearml-sdk-to-the-server) 进行配置。
+
+```bash
+pip install clearml
+clearml-init
+```
+
+设置 `Runner` 初始化参数中的 `visualizer`，并将 `vis_backends` 设置为 [ClearMLVisBackend](mmengine.visualization.ClearMLVisBackend)。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ visualizer=dict(type='Visualizer', vis_backends=[dict(type='ClearMLVisBackend')]),
+)
+runner.train()
+```
+
+
+
+## Neptune
+
+使用 Neptune 前需先安装依赖库 `neptune` 并登录 [Neptune.AI](https://docs.neptune.ai/) 进行配置。
+
+```bash
+pip install neptune
+```
+
+设置 `Runner` 初始化参数中的 `visualizer`，并将 `vis_backends` 设置为 [NeptuneVisBackend](mmengine.visualization.NeptuneVisBackend)。
+
+```python
+runner = Runner(
+ model=MMResNet50(),
+ work_dir='./work_dir',
+ train_dataloader=train_dataloader,
+ optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+ train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+ val_dataloader=val_dataloader,
+ val_cfg=dict(),
+ val_evaluator=dict(type=Accuracy),
+ visualizer=dict(type='Visualizer', vis_backends=[dict(type='NeptuneVisBackend')]),
+)
+runner.train()
+```
+
+
+
+请注意：若未提供 `project` 和 `api_token` ，neptune 将被设置成离线模式，产生的文件将保存到本地 `.neptune` 文件下。
+推荐在初始化时提供 `project` 和 `api_token` ，具体方法如下所示：
+
+```python
+runner = Runner(
+ ...
+ visualizer=dict(
+ type='Visualizer',
+ vis_backends=[
+ dict(
+ type='NeptuneVisBackend',
+ init_kwargs=dict(project='workspace-name/project-name',
+ api_token='your api token')
+ ),
+ ],
+ ),
+ ...
+)
+runner.train()
+```
+
+更多初始化配置参数可点击 [neptune.init_run API](https://docs.neptune.ai/api/neptune/#init_run) 查询。
diff --git a/internlm_langchain/knowledge_base/MMEngine/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMEngine/vector_store/index.faiss
new file mode 100644
index 00000000..cedca32f
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMEngine/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMFashion/content/ATTR_DATASET.md b/internlm_langchain/knowledge_base/MMFashion/content/ATTR_DATASET.md
new file mode 100644
index 00000000..cc46d1ff
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMFashion/content/ATTR_DATASET.md
@@ -0,0 +1,137 @@
+# AttrDataset
+
+- Annotations (Anno_fine/ Anno_coarse/)
+
+ - Attribute Annotations (list_attr_cloth.txt & list_attr_img.txt)
+
+ clothing attribute labels. See ATTRIBUTE LABELS section below for more info.
+
+ - Bounding Box Annotations (list_bbox.txt)
+
+ bounding box labels. See BBOX LABELS section below for more info.
+
+ - Category Annotations (list_category_cloth.txt & list_category_img.txt)
+
+ clothing category labels. See CATEGORY LABELS section below for more info.
+
+ - Fashion Landmark Annotations (list_landmarks.txt)
+
+ fashion landmark labels. See LANDMARK LABELS section below for more info.
+
+- Images (Img/)
+
+ clothes images. See IMAGE section below for more info.
+
+- Evaluation Partitions (Eval/list_eval_partition.txt)
+
+ image names for training, validation and testing set respectively. See EVALUATION PARTITIONS section below for more info.
+
+
+## IMAGE
+
+*.jpg
+
+format: JPG
+
+Notes:
+1. The long side of images are resized to 300;
+2. The aspect ratios of original images are kept unchanged.
+
+
+## BBOX LABELS
+
+list_bbox.txt
+
+```sh
+First Row: number of images
+Second Row: entry names
+Rest of the Rows:
++ 例如, `SMPL_NEUTRAL.pkl` `SMPL_MALE.pkl` `SMPL_FEMALE.pkl` +- [J_regressor_extra.npy](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/J_regressor_extra.npy?versionId=CAEQHhiBgIDD6c3V6xciIGIwZDEzYWI5NTBlOTRkODU4OTE1M2Y4YTI0NTVlZGM1) +- [J_regressor_h36m.npy](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/J_regressor_h36m.npy?versionId=CAEQHhiBgIDE6c3V6xciIDdjYzE3MzQ4MmU4MzQyNmRiZDA5YTg2YTI5YWFkNjRi) +- [smpl_mean_params.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/smpl_mean_params.npz?versionId=CAEQHhiBgICN6M3V6xciIDU1MzUzNjZjZGNiOTQ3OWJiZTJmNThiZmY4NmMxMTM4) + +下载上述所有文件，并按如下结构安排文件夹: + +```text +mmhuman3d +├── mmhuman3d +├── docs +├── tests +├── tools +├── configs +└── data + └── body_models + ├── J_regressor_extra.npy + ├── J_regressor_h36m.npy + ├── smpl_mean_params.npz + └── smpl + ├── SMPL_FEMALE.pkl + ├── SMPL_MALE.pkl + └── SMPL_NEUTRAL.pkl +``` + +## 推理 / 演示 +### 离线Demo +我们提供了用于从图像或视频中估计单人或多人`SMPL`模型参数的演示脚本，运行该脚本可能会用到`MMDetection`和`MMTracking`。通过该脚本进行演示，您只需要从模型库中选择用到的预训练模型(我们目前只支持[HMR](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/hmr/)、 [SPIN](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/spin/)、[VIBE](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/vibe/) 和[PARE](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/pare/), 未来会加入更多的SOTA方法)，并指定少量的参数。 + +以下是一些参数的释义: + +- 如果指定`--output` 和 `--show_path`, 演示脚本会将结果储存在`human_data`中，并且渲染得到的人体mesh。 +- 如果指定`--smooth_type`, 演示脚本会使用特定的方法进行平滑。目前可以选择的平滑方法包括`gaus1d`、`oneeuro`和 `savgol`。 +- 如果指定`--speed_up_type`, 演示脚本会使用特定的方法进行加速处理。目前支持基于学习的方法`deciwatch`, 更多的信息请参考[DeciWatch](../configs/_base_/post_processing/README.md)。 + +对于单人 + +```shell +python demo/estimate_smpl.py \ + ${MMHUMAN3D_CONFIG_FILE} \ + ${MMHUMAN3D_CHECKPOINT_FILE} \ + --single_person_demo \ + --det_config ${MMDET_CONFIG_FILE} \ + --det_checkpoint ${MMDET_CHECKPOINT_FILE} \ + --input_path ${VIDEO_PATH_OR_IMG_PATH} \ + [--show_path ${VIS_OUT_PATH}] \ + [--output ${RESULT_OUT_PATH}] \ + [--smooth_type ${SMOOTH_TYPE}] \ + [--speed_up_type ${SPEED_UP_TYPE}] \ + [--draw_bbox] \ +``` + +例如: +```shell +python demo/estimate_smpl.py \ + configs/hmr/resnet50_hmr_pw3d.py \ + data/checkpoints/resnet50_hmr_pw3d.pth \ + --single_person_demo \ + --det_config demo/mmdetection_cfg/faster_rcnn_r50_fpn_coco.py \ + --det_checkpoint https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \ + --input_path demo/resources/single_person_demo.mp4 \ + --show_path vis_results/single_person_demo.mp4 \ + --output demo_result \ + --smooth_type savgol \ + --speed_up_type deciwatch \ + --draw_bbox +``` + +对于多人 + + +```shell +python demo/estimate_smpl.py \ + ${MMHUMAN3D_CONFIG_FILE} \ + ${MMHUMAN3D_CHECKPOINT_FILE} \ + --multi_person_demo \ + --tracking_config ${MMTRACKING_CONFIG_FILE} \ + --input_path ${VIDEO_PATH_OR_IMG_PATH} \ + [--show_path ${VIS_OUT_PATH}] \ + [--output ${RESULT_OUT_PATH}] \ + [--smooth_type ${SMOOTH_TYPE}] \ + [--speed_up_type ${SPEED_UP_TYPE}] \ + [--draw_bbox] +``` + +例如: +```shell +python demo/estimate_smpl_image.py \ + configs/hmr/resnet50_hmr_pw3d.py \ + data/checkpoints/resnet50_hmr_pw3d.pth \ + --multi_person_demo \ + --tracking_config demo/mmtracking_cfg/deepsort_faster-rcnn_fpn_4e_mot17-private-half.py \ + --input_path demo/resources/multi_person_demo.mp4 \ + --show_path vis_results/multi_person_demo.mp4 \ + --smooth_type savgol \ + --speed_up_type deciwatch \ + [--draw_bbox] + +``` +MMHuman3D的checkpoints文件可以从[model zoo](../docs_zh-CN/model_zoo.md)下载。 +这里我们使用HMR (resnet50_hmr_pw3d.pth)作为示例。 + +### 在线Demo +我们提供一个从相机或者一个指定的视频文件估计SMPL参数的webcam演示脚本。你可以简单的运行下面的命令： +```shell +python demo/webcam_demo.py +``` +以下是一些参数的释义: +- 如果指定`--output`, 演示脚本会将可视化结果储存到对应的文件中。这可能会降低帧率。 +- 如果指定`--synchronous`, 视频的 I/O 和模型的推理在时序上将会对齐. 注意这会降低帧率. +- 如果你想以离线的方式在视频文件上运行webcam演示, 你应该指定`--cam-id=VIDEO_FILE_PATH`. 注意`--synchronous` 在这种情形下应该被设置为 `True`. +- 视频的I/O和模型的推理是异步的运行，而且后者往往需要更多的时间. 为了缓解延时，你可以: + + - 根据显示在左上角的推理延时设置`--display-delay=MILLISECONDS` 来延时视频流. 或者, + + - 设置 `--synchronous=True` 强制视频流和推理结果对齐. 这可能降低视频的帧率。 + + +## 测试 + +我们提供的预训练模型可以参见 [config](https://github.com/open-mmlab/mmhuman3d/tree/main/configs). + +### 使用单（多）个GPU进行测试 + +```shell +python tools/test.py ${CONFIG} --work-dir=${WORK_DIR} ${CHECKPOINT} --metrics=${METRICS} +``` +例如: +```shell +python tools/test.py configs/hmr/resnet50_hmr_pw3d.py --work-dir=work_dirs/hmr work_dirs/hmr/latest.pth --metrics pa-mpjpe mpjpe +``` + +### 使用slurm进行测试 + +如果通过[slurm](https://slurm.schedmd.com/)在集群上使用MMHuman3D, 您可以使用脚本 `slurm_test.sh`进行测试。 + +```shell +./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} ${CONFIG} ${WORK_DIR} ${CHECKPOINT} --metrics ${METRICS} +``` +例如: +```shell +./tools/slurm_test.sh my_partition test_hmr configs/hmr/resnet50_hmr_pw3d.py work_dirs/hmr work_dirs/hmr/latest.pth 8 --metrics pa-mpjpe mpjpe +``` + + +## 训练 + +### 使用单（多）个GPU进行训练 + +```shell +python tools/train.py ${CONFIG_FILE} ${WORK_DIR} --no-validate +``` +例如: 使用单个GPU训练HMR. +```shell +python tools/train.py ${CONFIG_FILE} ${WORK_DIR} --gpus 1 --no-validate +``` + +### 使用slurm进行训练 + +如果通过[slurm](https://slurm.schedmd.com/)在集群上使用MMHuman3D, 您可以使用脚本 `slurm_train.sh`进行训练。 + +```shell +./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR} ${GPU_NUM} --no-validate +``` + +可选参数包括: +- `--resume-from ${CHECKPOINT_FILE}`: 继承之前的权重继续训练。 +- `--no-validate`: 在训练时是否进行测试。 + +例如: 在集群上使用8卡训练HMR。 +```shell +./tools/slurm_train.sh my_partition my_job configs/hmr/resnet50_hmr_pw3d.py work_dirs/hmr 8 --no-validate +``` + +详情请见[slurm_train.sh](https://github.com/open-mmlab/mmhuman3d/tree/main/tools/slurm_train.sh)。 + +## 更多教程 + +- [Camera conventions](../docs_zh-CN/cameras.md) +- [Keypoint conventions](../docs_zh-CN/keypoints_convention.md) +- [Custom keypoint conventions](../docs_zh-CN/customize_keypoints_convention.md) +- [HumanData](../docs_zh-CN/human_data.md) +- [Keypoint visualization](../docs_zh-CN/visualize_keypoints.md) +- [Mesh visualization](../docs_zh-CN/visualize_smpl.md) diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/human_data.md b/internlm_langchain/knowledge_base/MMHuman3D/content/human_data.md new file mode 100644 index 00000000..a866f453 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMHuman3D/content/human_data.md @@ -0,0 +1,287 @@ +## HumanData数据格式 + +### 总览 + +`HumanData`是Python内置字典的子类，主要用于存放包含人体的单视角图像的信息。它具有通用的基础结构，也兼容具有新特性的客制化数据。 +原生的`HumanData`包含`numpy.ndarray`或其他的Python内置的数据结构，但不包含`torch.Tensor`的数据。可以使用`human_data.to()`将其转换为`torch.Tensor`(支持CPU和GPU)。 + +### `Key/Value`的定义：如下是对`HumanData`支持的`Key`和`Value`的描述. + +#### 路径: + +通常包含图片路径，如果数据集有提供额外的深度或者分割图，也可以记录下来。 +- image_path: (N, ), 字符串组成的列表, 每一个元素是图像相对于根目录的路径。 +- segmantation_path (可选): (N, ), 字符串组成的列表, 每一个元素是图像分割图相对于根目录的路径。 +- depth_path (可选): (N, ), 字符串组成的列表, 每一个元素是图像深度图相对于根目录的路径。 + +#### 关键点： + +以下关键点keys如果适用，则应包含在HumanData中。任何一个关键点的key，应存在一个mask，表示其中哪些关键点有效。如`keypoints3d_original`应对应`keypoints3d_original_mask`。 +`HumanData` 中的关键点存储格式为`HUMAN_DATA`, 包含190个关键点。MMHuman3d中提供了很多常用关键点格式的转换（2d及3d均支持）, 详见 [keypoints_convention](../docs_zh-CN/keypoints_convention.md). +- keypoints3d_smpl / keypoints3d_smplx: (N, 190, 4), numpy array, `smplx / smplx`模型的3d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- keypoints3d_original: (N, 190, 4), numpy array, 由数据集本身提供的3d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- keypoints2d_smpl / keypoints2d_smplx: (N, 190, 3), numpy array, `smpl / smplx`模型的2d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- keypoints2d_original: (N, 190, 3), numpy array, 由数据集本身提供的2d关节点与置信度, 每一个数据集的关节点映射到了`HUMAN_DATA`的关节点。 +- （mask示例） keypoints2d_smpl_mask: (190, ), numpy array, 表示`keypoints2d_smpl`中关键点是否有效的掩膜。 0表示该位置的关键点在原始数据集中无法找到。 + +#### 检测框： + +身体（smpl），手脸（smplx）的检测框，标注为`[x_min, y_min, width, height, confidence]`，且不应超出图片。 +- bbox_xywh: (N, 5), numpy array, 边界框的置信度, 边界框左下角点的坐标x和y, 边界框的宽w和高h, 置信度得分放置在最后。 +- face_bbox_xywh, lhand_bbox_xywh, rhand_bbox_xywh（可选）： (N, 5), numpy array, 如果数据标注中含有`smplx`, 则应包括这三个key，由smplx2d关键点得出，格式同上。 + +#### 人体模型参数： + +通常以smpl/smplx格式存储。 +- smpl: (1, ), 字典, `keys` 分别为 ['body_pose': numpy array, (N, 23, 3), 'global_orient': numpy array, (N, 3), 'betas': numpy array, (N, 10), 'transl': numpy array, (N, 3)]. +- smplx: (1, ), 字典, `keys` 分别为 ['body_pose': numpy array, (N, 21, 3),'global_orient': numpy array, (N, 3), 'betas': numpy array, (N, 10), 'transl': numpy array, (N, 3), 'left_hand_pose': numpy array, (N, 15, 3), 'right_hand_pose': numpy array, (N, 15, 3), 'expression': numpy array (N, 10), 'leye_pose': numpy array (N, 3), 'reye_pose': (N, 3), 'jaw_pose': numpy array (N, 3)]. + +#### 其它keys + +- config: (), 字符串, 单个数据集的配置的标志。 +- meta: (1, ), 字典, `keys`为数据集中的各种元数据。 +- misc: (1, ), 字典, `keys`为数据集中各种独特设定，也可以由用户自定义。`misc`占用的空间（可以通过`sys.getsizeof(misc)`获取）不能超过6MB。 + +#### `HumanData['misc']`中建议（可能）包含的内容: +Miscellaneous部分中包含了每个数据集的独特设定，包括相机种类，关键点标注来源，检测框来源，是否包含smpl/smplx标注等等，用于便利数据读取。 +`HumanData['misc']`中包含一个dictionary，建议包含的key如下所示： +- kps3d_root_aligned： Bool 描述keypoints3d是否经过root align，建议不进行root_alignment，如果不包含这个key，则默认没有进行过root_aligenment +- flat_hand_mean：Bool 对于smplx标注的数据，应该存在此项，大多数数据集中`flat_hand_mean=False` +- bbox_source：描述检测框的来源，`bbox_soruce='keypoints2d_smpl' or 'keypoints2d_smplx' or 'keypoints2d_original'`，描述检测框是由哪种关键点得出的，或者`bbox_source='provide_by_dataset'`表示检测框由数据集直接给出（比如用其自带检测器生成而不是由关键点推导得出） +- bbox_body_scale: 如果检测框由关键点推导得出，则应包含此项，描述由smpl/smplx/2d_gt关键点推导出的身体检测框的放大比例，建议`bbox_body_scale=1.2` +- bbox_hand_scale, bbox_face_scale: 如果检测框由关键点推导得出，则应包含这两项，描述由smpl/smplx/2d_gt关键点推导出的身体检测框的放大比例，建议`bbox_hand_scale=1.0, bbox_face_scale=1.0` +- smpl_source / smplx_source: 描述smpl/smplx的来源，`'original', 'nerual_annot', 'eft', 'osx_annot', 'cliff_annot'`, 来描述smpl/smnplx是来源于数据集提供，或者其它标注来源 +- cam_param_type: 描述相机参数的种类，`cam_param_type='prespective' or 'predicted_camera' or 'eft_camera'` +- principal_point, focal_length: (1, 2), numpy array，如果数据集中相机参数恒定，则应包含这两项，通常适用于生成数据集。 +- image_shape: (1, 2), numpy array，如果数据集中图片大小恒定，则应包含此项。 + +#### `HumanData['meta']`中建议（可能）包含的内容: +- gender: (N, )， 字符串组成的列表, 每一个元素是smplx模型的性别（中性则不必标注） +- height（width）：(N, )， 字符串组成的列表, 每一个元素是图片的高（或宽），这里不推荐使用`image_shape=(width, height): (N, 2)`，因为有时需要按反顺序读取图片格式。（数据集图片分辨率一致则应标注在`HumanData['misc']`中） +- 其它有标识性的key，若数据集中该key不一致，且会影响keypoints or smpl/smplx，则建议标注，如focal_length与principal_point, focal_length = (N, 2), principal_point = (N, 2) + +#### 关于HumanData的一些说明 + +- 所有数据标注均已从世界坐标转移到opencv相机空间，进行smpl/smplx的相机空间转换可以用 + +```from mmhuman3d.models.body_models.utils import transform_to_camera_frame, batch_transform_to_camera_frame``` + +#### 检查`HumanData`中的`key`. + +在默认的`HumanData`中，只能包含之前描述过`key`。如果无法避免这个问题，还有一个方法。 通过指定`__key_strict__ == False`构建一个`HumanData`实例。 + +```python +human_data = HumanData.new(key_strict=False) +human_data['video_path'] = 'test.mp4' +``` +返回的`HumanData`允许任何客制化的`key`，并在第一次接受新`key`时log一个警告。如果正在使用客制化的`key`，请忽略该警告，在程序结束前它不会再出现。 + +如果您已经构建了一个`HumanData`, 并且想改变`strict`模式, 可以使用`set_key_strict`: + +```python +human_data = HumanData.fromfile('human_data.npz') +key_strict = human_data.get_key_strict() +human_data.set_key_strict(not key_strict) +``` + + + +#### 检查`HumanData`中的`value`. + +只有指定`human_data[key] == value`时，才会检查之前提到过的`value`，相关规范在`HumanData.SUPPORTED_KEYS`中定义。 + +对于每个`value`, 必须在其`key`下指定数据类型: + +```python +'smpl': { + 'type': dict, +}, +``` + +对于类型为`numpy.ndarray`的`value`, 需要指定`shape`和`dim`参数: + +```python +'keypoints3d': { + 'type': np.ndarray, + 'shape': (-1, -1, 4), + # value.ndim==3 value.shape[2]==4 + # value.shape[0:2] is arbitrary. + 'dim': 0 + # dimension 0 marks time(frame index, or second) +}, +``` + +对于不随帧变化的`value`，指定其`dim=-1`以跳过帧检查: + +```python +'keypoints3d_mask': { + 'type': np.ndarray, + 'shape': (-1, ), + 'dim': -1 +}, +``` + +### 数据压缩 + +#### 压缩`mask` + +由于`HUMAN_DATA`的关键点定义整合自不同的数据集，部分关键点缺失是很常见的。使用如下的方式，可以通过`mask`滤除缺失的关键点: + +```python +# keypoints2d_agora 是一个形状为[frame_num, 127, 3]的numpy数组. +# Agora中定义了127个关键点. +keypoints2d_human_data, mask = convert_kps(keypoints2d_agora, 'agora', 'human_data') +# keypoints2d_human_data 是一个形状为[frame_num, 190, 3]的numpy数组. +# mask 是一个形状为[190, ]的numpy数组, 内含了127个1和63个0. +``` + +指定`keypoints2d_mask` 和 `keypoints2d`, 很明显`keypoints2d`中有很多冗余的0: + +```python +human_data = HumanData() +human_data['keypoints2d_mask'] = mask +human_data['keypoints2d'] = keypoints2d_human_data +``` + +调用`compress_keypoints_by_mask()`去掉冗余的0。 该方法会检查所有包含`keypoints`的`key`是否具有相应的`mask`，如果同时存在，就进行压缩: + +```python +human_data.compress_keypoints_by_mask() +``` + +调用`get_raw_value()`获得储存在`HumanData`实例中压缩过的`value`. 当通过`[]`获得`item`时, 将返回用0填充后的关键点: + +```python +keypoints2d_human_data = human_data.get_raw_value('keypoints2d') +print(keypoints2d_human_data.shape) # [frame_num, 127, 3] +keypoints2d_human_data = human_data['keypoints2d'] +print(keypoints2d_human_data.shape) # [frame_num, 190, 3] +``` + +在`keypoints_compressed`模式中, 可以对关键点进行编辑。有两种不同的方式，设置填充数据或直接指定压缩数据: + +```python +padded_keypoints2d = np.zeros(shape=[100, 190, 3]) +human_data['keypoints2d'] = padded_keypoints2d # [frame_num, 190, 3] +compressed_keypoints2d = np.zeros(shape=[100, 127, 3]) +human_data.set_raw_value('keypoints2d', compressed_keypoints2d) # [frame_num, 127, 3] +``` + +当`HumanData`实例处于`keypoints_compressed`模式, 所有关键点的`masks`会被锁定。当您尝试进行修改时, 会log一个警告并且`value`不会被修改。如果需要修改`mask`，使用`decompress_keypoints()`进行解压缩: + +```python +human_data.decompress_keypoints() +``` + +上述特性也适用于其他类似于`keypoints*`和`keypoints*_mask`的`key-value`对。 + +#### 压缩文件 + +调用`dump()` 将`HumanData`压缩成`.npz`文件。 + +`dump`后的`.npz`文件可以使用`load()`进行加载: + +```python +# 保存 +human_data.dump('./dumped_human_data.npz') +# 加载 +another_human_data = HumanData() +another_human_data.load('./dumped_human_data.npz') +``` + +有时`HumanData`太长了，直接进行`dump`会报错。这种情况下，可以调用`dump_by_pickle`和`load_by_pickle`将`HumanData`压缩成`.pkl`文件。 + +#### 压缩`key` + +如果`HumanData`实例不处于`key_strict`模式, 其可能会包含不受支持的项目。调用`pop_unsupported_items()`清除这些项目，以节省空间: + +```python +human_data = HumanData.fromfile('human_data_not_strict.npz') +human_data.pop_unsupported_items() +human_data.set_key_strict(True) +``` + +### 数据选择 + +#### 通过形状进行选择 + +假定`keypoints2d` 是一个`array`，其形状为[200, 190, 3], 只需要最开始的10帧: + +```python +first_ten_frames = human_data.get_value_in_shape('keypoints2d', shape=[10, -1, -1]) +``` + +在一些情况下, 我们需要将`array`扩充成特定的形状: + +```python +# 通过填0将其形状从[200, 190, 3]扩充成[200, 300, 3] +padded_keypoints2d = human_data.get_value_in_shape('keypoints2d', shape=[200, 300, -1]) +# 填充的数值可以被修改 +padded_keypoints2d = human_data.get_value_in_shape('keypoints2d', shape=[200, 300, -1], padding_constant=1) +``` + +#### 通过时间切片进行选择 + +假设在一个`HumanData`实例中有200帧, 只需要中间10至20帧: + +```python +# 所有支持的`value`都会被切片 +sub_human_data = human_data.get_slice(10, 21) +``` + +也可以进行下采样,下面的例子描述了一种选择其33%数据的方法: + +```python +# 选择 [0, 3, 6, 9,..., 198] +sub_human_data = human_data.get_slice(0, 200, 3) +``` + +### 转换为`torch.Tensor` + +之前提到，原生的`HumanData`中包含`numpy.ndarray`或python内置类型的`value`，但`numpy.ndarray`可以轻松转换为`torch.Tensor`: + +```python +# ndarray会被转换成cpu上的Tensor. +# 其他类型的value不会发生变化. +# 返回一个形如HumanData的字典. +dict_of_tensor = human_data.to() +# 也可以转换为GPU上的Tensor +gpu0_device = torch.device('cuda:0') +dict_of_gpu_tensor = human_data.to(gpu0_device) +``` +## MultiHumanData + +MulitHumanData 被设计来支持多人重建。它继承于HumanData。在HumanData中，因为图片和数据是一一对应的，所以我们可以直接索引数据。然而，在MultiHumanData中数据和图像是多对一的关系。 + +MultiHumanData在HumanData的基础上添加一个新的key叫做`frame_range`,它定义如下： + +```python +'frame_range': { + 'type': np.ndarray, + 'shape': (-1, 2), + 'dim': 0 + } +``` + +`frame_range`是和图像一一对应的。 `frame_range`中的每个元素是两个指针，它们指向一个数据区域。 + +假设我们有一个MultiHumanData的实例，我们想索引第i张图像对应的数据。 首先我们用主索引索引`frame_range`，它会返回两个指针，用这两个指针我们就可以索引第i张图像对应的所有数据。 + +``` +image_0 ----> human_0 <--- frame_range[0][0] + - . + - . + --> human_(n-1) <--- frame_range[0][0] + (n-1) + -> human_n <--- frame_range[0][1] + . + . + . + + +image_n ----> human_0 <--- frame_range[n][0] + - . + - . + --> human_(n-1) <--- frame_range[n][0] + (n-1) + -> human_n <--- frame_range[n][1] + +``` diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/install.md b/internlm_langchain/knowledge_base/MMHuman3D/content/install.md new file mode 100644 index 00000000..4464b640 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMHuman3D/content/install.md @@ -0,0 +1,227 @@ +# 安装 + +- [安装](#安装) +- [依赖](#依赖) +- [准备环境](#准备环境) +- [安装 MMHuman3D](#安装-mmhuman3d) +- [从头开始安装的脚本](#从头开始安装的脚本) + +## 依赖 + +- Linux +- ffmpeg +- Python 3.7+ +- PyTorch 1.6.0, 1.7.0, 1.7.1, 1.8.0, 1.8.1, 1.9.0 或 1.9.1. +- CUDA 9.2+ +- GCC 5+ +- PyTorch3D 0.4+ +- [MMCV](https://github.com/open-mmlab/mmcv) (请安装用于GPU的mmcv-full, 要求版本>=1.3.17,<1.6.0) + +Optional: +- [MMPose](https://github.com/open-mmlab/mmpose) (只用于演示) +- [MMDetection](https://github.com/open-mmlab/mmdetection) (只用于演示) +- [MMTracking](https://github.com/open-mmlab/mmtracking) (只用于多人的演示。请安装 mmcls<0.23.1, mmcv-full>=1.3.17,<1.6.0) + +## 准备环境 + +a. 创建conda虚拟环境并激活. + +```shell +conda create -n open-mmlab python=3.8 -y +conda activate open-mmlab +``` + +b. 安装 ffmpeg + +直接使用conda安装ffmpeg + +```shell +conda install ffmpeg +``` + +c. 根据 [官方指导](https://pytorch.org/) ，安装PyTorch和torchvision . +```shell +conda install pytorch={torch_version} torchvision cudatoolkit={cu_version} -c pytorch +``` + +以安装 PyTorch 1.8.0 和 CUDA 10.2为例. +```shell +conda install pytorch=1.8.0 torchvision cudatoolkit=10.2 -c pytorch +``` + +**注意:** 请确保compilation CUDA version和runtime CUDA version相匹配。 +另外， 对于RTX 30系列的显卡， 需要cudatoolkit>=11.0. + +d. 在Linux或者Windows上安装PyTorch3D. + +对于Linux： + +```shell +conda install -c fvcore -c iopath -c conda-forge fvcore iopath -y +conda install -c bottler nvidiacub -y + +conda install pytorch3d -c pytorch3d +``` + +用户也可以参考 [PyTorch3D-install](https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md) 的更多细节。 +然而我们近期的测试显示使用 conda 安装会遇到依赖冲突的问题。 +因此，用户也可选择按照下列步骤从源码安装Pytorch3D。 + +```shell +git clone https://github.com/facebookresearch/pytorch3d.git +cd pytorch3d +pip install . +cd .. +``` + +对于Windows： + +请参考 [官方安装文档](https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md) 。 这里我们提供一个 [例子](https://github.com/open-mmlab/mmhuman3d/pull/199#issue-1274739041) 供用户参考。 +**注意:** 这部分是针对想在Windows平台安装MMHuman3D的用户。 + +运行如下命令测试PyTorch3D是否安装成功: + +```shell +echo "import pytorch3d;print(pytorch3d.__version__); \ + from pytorch3d.renderer import MeshRenderer;print(MeshRenderer);\ + from pytorch3d.structures import Meshes;print(Meshes);\ + from pytorch3d.renderer import cameras;print(cameras);\ + from pytorch3d.transforms import Transform3d;print(Transform3d);"|python + +echo "import torch;device=torch.device('cuda');\ + from pytorch3d.utils import torus;\ + Torus = torus(r=10, R=20, sides=100, rings=100, device=device);\ + print(Torus.verts_padded());"|python +``` + +## 安装 MMHuman3D + +a. 安装 mmcv-full 、 mmpose 、 mmdet 和 mmtrack + +- mmcv-full + +推荐使用如下命令安装mmcv-full. + +对于 CPU: +```shell +pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cpu/{torch_version}/index.html +``` +使用您的pytorch版本号替换`{torch_version}` + +对于 GPU: + ```shell + pip install "mmcv-full>=1.3.17,<=1.5.3" -f https://download.openmmlab.com/mmcv/dist/{cu_version}/{torch_version}/index.html + ``` +使用您的cuda版本号和pytorch版本号替换`{cu_version}`和`{torch_version}` + +以在CUDA 10.2和PyTorch 1.8.0的环境下, 安装mmcv-full为例: +```shell +pip install "mmcv-full>=1.3.17,<=1.5.3" -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html +``` +您可以从 [这里](https://mmcv.readthedocs.io/en/latest/get_started/installation.html) 查看适配于不同CUDA版本和PyTorch版本的MMCV. +更多版本的下载信息，请参考 [openmmlab-download](https://download.openmmlab.com/mmcv/dist/index.html) 。 + +您也可以使用如下命令，从源码编译mmcv + +```shell +git clone https://github.com/open-mmlab/mmcv.git -b v1.5.3 +cd mmcv +MMCV_WITH_OPS=1 pip install -e . # 执行此步骤会安装包含cuda算子的mmcv-full +# 或者运行 pip install -e . # 执行此步骤会安装不包含cuda算子的mmcv +cd .. +``` + +**注意** 如果已经安装了mmcv，您需要先运行`pip uninstall mmcv`。 同时安装了mmcv和mmcv-full，可能会出现`ModuleNotFoundError`。 + +- mmdetection (可选) + +```shell +pip install "mmdet<=2.25.1" +``` + +如果想要修改mmdet的代码，您也可以使用如下命令，从源码构建mmdet： +```shell +git clone https://github.com/open-mmlab/mmdetection.git -b v2.25.1 +cd mmdetection +pip install -r requirements/build.txt +pip install -v -e . +``` + +- mmpose (可选) +```shell +pip install "mmpose<=0.28.1" +``` + +如果您想要修改mmdet的代码，您也可以使用如下命令，从源码构建mmpose： + +```shell +git clone https://github.com/open-mmlab/mmpose.git -b v0.28.1 +cd mmpose +pip install -r requirements.txt +pip install -v -e . +``` + +- mmtracking (可选) + +```shell +pip install "mmcls<=0.23.2" "mmtrack<=0.13.0" +``` + +如果您想要修改mmdet的代码，您也可以使用如下命令，从源码构建mmtracking： + +```shell +git clone https://github.com/open-mmlab/mmtracking.git -b v0.13.0 +cd mmtracking +pip install -r requirements/build.txt +pip install -v -e . # 或者 "python setup.py develop" +``` +b. 克隆mmhuman3d仓库. + +```shell +git clone https://github.com/open-mmlab/mmhuman3d.git +cd mmhuman3d +``` + + +c. 安装依赖项并安装mmhuman3d. + +```shell +pip install -v -e . # 或者 "python setup.py develop" +``` + +## 从头开始安装的脚本 + +```shell +# 安装 conda 环境 +conda create -n open-mmlab python=3.8 -y +conda activate open-mmlab + +# 安装 ffmpeg +conda install ffmpeg + +# 安装 PyTorch +conda install pytorch==1.8.0 torchvision cudatoolkit=10.2 -c pytorch -y + +# 安装 PyTorch3D +conda install -c fvcore -c iopath -c conda-forge fvcore iopath -y +conda install -c bottler nvidiacub -y +conda install pytorch3d -c pytorch3d -y +# 在遇到依赖冲突的情况下也可使用从源码中安装 +# git clone https://github.com/facebookresearch/pytorch3d.git +# cd pytorch3d +# pip install . +# cd .. + +# 安装 mmcv-full +pip install "mmcv-full>=1.3.17,<1.6.0" -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html + +# 可选: 安装 mmdetection，mmpose 及 mmtracking +pip install "mmdet<=2.25.1" +pip install "mmpose<=0.28.1" +pip install "mmcls<=0.23.2" "mmtrack<=0.13.0" + +# 安装 mmhuman3d +git clone https://github.com/open-mmlab/mmhuman3d.git +cd mmhuman3d +pip install -v -e . +``` diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/keypoints_convention.md b/internlm_langchain/knowledge_base/MMHuman3D/content/keypoints_convention.md new file mode 100644 index 00000000..141f0fee --- /dev/null +++ b/internlm_langchain/knowledge_base/MMHuman3D/content/keypoints_convention.md @@ -0,0 +1,377 @@ +# 关键点类型 + +## 总览 + +MMHuamn3D中的关键点类型整合了各种常用数据集中不同关键点的定义。由于标注数据的过程不尽相同，不同数据集中具有相同名字的关键点可能会对应不同的身体部位。相对的，拥有不同名字的关键点可能对应相同的身体部位。 +为了统一不同数据集中不同关键点的对应关系，我们采用`human_data`结构作为转换和存储关键点的基本类型。 + +## 使用方法 + +### 不同类型之间的转换 + +使用 `convert_kps` 函数可以转换不同数据集中的关键点。 + +为了将`human_data`转换为`coco`的格式，需要指定源类型和目标类型。 + + +```python +from mmhuman3d.core.conventions.keypoints_mapping import convert_kps + +keypoints_human_data = np.zeros((100, 190, 3)) +keypoints_coco, mask = convert_kps(keypoints_human_data, src='human_data', dst='coco') +assert mask.all()==1 +``` + +如果目标类型是源类型的子集合，输出的`mask`应该全为1。没有对应关系的关键点的置信度会被设置为0, 可以使用`mask`作为关键点的置信度。 + +### 通过置信度进行转换 + +如果获得了关键点的置信度，可以使用原始`mask`对其进行标记，然后将信息更新为返回的`mask`。例如，想要将`smpl`的关键点转换为`coco`的关键点，并且已知`left_shoulder`被遮挡。想要在转换过程中继承该信息，可以像如下这样设置原始`mask`并且转换为`coco`类型: + +```python +import numpy as np +from mmhuman3d.core.conventions.keypoints_mapping import KEYPOINTS_FACTORY, convert_kps + +keypoints = np.zeros((1, len(KEYPOINTS_FACTORY['smpl']), 3)) +confidence = np.ones((len(KEYPOINTS_FACTORY['smpl']))) + +# 假设 'left_shoulder' 是无效的. +confidence[KEYPOINTS_FACTORY['smpl'].index('left_shoulder')] = 0 + +_, conf_coco = convert_kps( + keypoints=keypoints, confidence=confidence, src='smpl', dst='coco') +_, conf_coco_full = convert_kps( + keypoints=keypoints, src='smpl', dst='coco') + +assert conf_coco[KEYPOINTS_FACTORY['coco'].index('left_shoulder')] == 0 +conf_coco[KEYPOINTS_FACTORY['coco'].index('left_shoulder')] = 1 +assert (conf_coco == conf_coco_full).all() +``` + +`mask`表示有效信息，其`dtype`为`uint8`，同时关键点的置信度范围为0到1。 +例如，想要将`smpl`的关键点转换为`coco`的关键点, 并且已知`left_shoulder`被遮挡。 + +```python +confidence = np.ones((len(KEYPOINTS_FACTORY['smpl']))) +confidence[KEYPOINTS_FACTORY['smpl'].index('left_shoulder')] = 0.5 +kp_smpl = np.concatenate([kp_smpl, confidence], -1) +kp_smpl_converted, mask = convert_kps(kp_smpl, src='smpl', dst='coco') +new_confidence = kp_smpl_converted[..., 2:] +assert new_confidence[KEYPOINTS_FACTORY['smpl'].index('left_shoulder')] == 0.5 +``` + +## 支持的种类 + + +以下是支持的关键点种类: + - [AGORA](#agora) + - [COCO](#coco) + - [COCO-WHOLEBODY](#coco-wholebody) + - [CrowdPose](#crowdpose) + - [GTA-Human](#gta-human) + - [Human3.6M](#human36m) + - human_data + - [HybrIK](#hybrik) + - [LSP](#lsp) + - [MPI-INF-3DHP](#mpi-inf-3dhp) + - [MPII](#mpii) + - openpose + - [PennAction](#pennaction) + - [PoseTrack18](#posetrack18) + - [PW3D](#pw3d) + - [SMPL](#smpl) + - [SMPL-X](#smplx) + + +### HUMANDATA + +`HumanData` 中的前 144 个关键点对应于 `SMPL-X` 中的关键点。后缀为`_extra`的关键点是指从`Jregressor_extra`获得的关键点。 后缀为`_openpose`的关键点是指从`OpenPose`预测中获得的关键点。 + +`MPI-INF-3DHP`、`Human3.6M` 和 `Posetrack` 中有几个关键点具有相同的名称，但在含义上与 `SMPL-X` 中的关键点不同。 因此，我们添加了一个额外的后缀`head_h36m`来区分这些关键点。 + +### AGORA + +
+
+
+### COCO
+
+AGORA (CVPR'2021)
+ +```bibtex +@inproceedings{Patel:CVPR:2021, + title = {{AGORA}: Avatars in Geography Optimized for Regression Analysis}, + author = {Patel, Priyanka and Huang, Chun-Hao P. and Tesch, Joachim and Hoffmann, David T. and Tripathi, Shashank and Black, Michael J.}, + booktitle = {Proceedings IEEE/CVF Conf.~on Computer Vision and Pattern Recognition ({CVPR})}, + month = jun, + year = {2021}, + month_numeric = {6} +} +``` + +
+
+
+
+### COCO-WHOLEBODY
+
+COCO (ECCV'2014)
+ +```bibtex +@inproceedings{lin2014microsoft, + title={Microsoft coco: Common objects in context}, + author={Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C Lawrence}, + booktitle={European conference on computer vision}, + pages={740--755}, + year={2014}, + organization={Springer} +} +``` + +
+
+
+
+### CrowdPose
+
+COCO-Wholebody (ECCV'2020)
+ +```bibtex +@inproceedings{jin2020whole, + title={Whole-Body Human Pose Estimation in the Wild}, + author={Jin, Sheng and Xu, Lumin and Xu, Jin and Wang, Can and Liu, Wentao and Qian, Chen and Ouyang, Wanli and Luo, Ping}, + booktitle={Proceedings of the European Conference on Computer Vision (ECCV)}, + year={2020} +} +``` + +
+
+
+### Human3.6M
+
+
+CrowdPose (CVPR'2019)
+ +```bibtex +@article{li2018crowdpose, + title={CrowdPose: Efficient Crowded Scenes Pose Estimation and A New Benchmark}, + author={Li, Jiefeng and Wang, Can and Zhu, Hao and Mao, Yihuan and Fang, Hao-Shu and Lu, Cewu}, + journal={Proceedings IEEE/CVF Conf.~on Computer Vision and Pattern Recognition ({CVPR})}, + year={2019} +} +``` + +
+
+
+
+### GTA-Human
+
+Human3.6M (TPAMI'2014)
+ +```bibtex +@article{h36m_pami, + author = {Ionescu, Catalin and Papava, Dragos and Olaru, Vlad and Sminchisescu, Cristian}, + title = {Human3.6M: Large Scale Datasets and Predictive Methods for 3D Human Sensing in Natural Environments}, + journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher = {IEEE Computer Society}, + volume = {36}, + number = {7}, + pages = {1325-1339}, + month = {jul}, + year = {2014} +} +``` + +
+
+
+
+### HybrIK
+
+GTA-Human (arXiv'2021)
+ +```bibtex +@article{cai2021playing, + title={Playing for 3D Human Recovery}, + author={Cai, Zhongang and Zhang, Mingyuan and Ren, Jiawei and Wei, Chen and Ren, Daxuan and Li, Jiatong and Lin, Zhengyu and Zhao, Haiyu and Yi, Shuai and Yang, Lei and others}, + journal={arXiv preprint arXiv:2110.07588}, + year={2021} +} +``` + +
+
+
+### LSP
+
+
+HybrIK (CVPR'2021)
+ +```bibtex +@inproceedings{li2020hybrikg, + author = {Li, Jiefeng and Xu, Chao and Chen, Zhicun and Bian, Siyuan and Yang, Lixin and Lu, Cewu}, + title = {HybrIK: A Hybrid Analytical-Neural Inverse Kinematics Solution for 3D Human Pose and Shape Estimation}, + booktitle={CVPR 2021}, + pages={3383--3393}, + year={2021}, + organization={IEEE} +} +``` + +
+
+
+### MPI-INF-3DHP
+
+LSP (BMVC'2010)
+ +```bibtex +@inproceedings{johnson2010clustered, + title={Clustered Pose and Nonlinear Appearance Models for Human Pose Estimation.}, + author={Johnson, Sam and Everingham, Mark}, + booktitle={bmvc}, + volume={2}, + number={4}, + pages={5}, + year={2010}, + organization={Citeseer} +} +``` +
+
+
+
+### MPII
+
+
+MPI_INF_3DHP (3DV'2017)
+ +```bibtex +@inproceedings{mono-3dhp2017, + author = {Mehta, Dushyant and Rhodin, Helge and Casas, Dan and Fua, Pascal and Sotnychenko, Oleksandr and Xu, Weipeng and Theobalt, Christian}, + title = {Monocular 3D Human Pose Estimation In The Wild Using Improved CNN Supervision}, + booktitle = {3D Vision (3DV), 2017 Fifth International Conference on}, + url = {http://gvv.mpi-inf.mpg.de/3dhp_dataset}, + year = {2017}, + organization={IEEE}, + doi={10.1109/3dv.2017.00064}, +} +``` + +
+
+
+### PoseTrack18
+
+
+MPII (CVPR'2014)
+ +```bibtex +@inproceedings{andriluka14cvpr, + author = {Mykhaylo Andriluka and Leonid Pishchulin and Peter Gehler and Schiele, Bernt}, + title = {2D Human Pose Estimation: New Benchmark and State of the Art Analysis}, + booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2014}, + month = {June} +} +``` + +
+
+
+### OpenPose
+
+
+PoseTrack18 (CVPR'2018)
+ +```bibtex +@inproceedings{andriluka2018posetrack, + title={Posetrack: A benchmark for human pose estimation and tracking}, + author={Andriluka, Mykhaylo and Iqbal, Umar and Insafutdinov, Eldar and Pishchulin, Leonid and Milan, Anton and Gall, Juergen and Schiele, Bernt}, + booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, + pages={5167--5176}, + year={2018} +} +``` + +
+
+
+### PennAction
+
+
+OpenPose(TPMAI'2019)
+ +```bibtex +@article{8765346, + author = {Z. {Cao} and G. {Hidalgo Martinez} and T. {Simon} and S. {Wei} and Y. A. {Sheikh}}, + journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence}, + title = {OpenPose: Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields}, + year = {2019} +} +``` + +
+
+
+
+### SMPL
+
+
+PennAction(ICCV'2013)
+ +```bibtex +@inproceedings{zhang2013, + title={From Actemes to Action: A Strongly-supervised Representation for Detailed Action Understanding}, + author={Zhang, Weiyu and Zhu, Menglong and Derpanis, Konstantinos}, + booktitle={Proceedings of the International Conference on Computer Vision}, + year={2013} +} +``` + +
+
+
+
+### SMPL-X
+
+
+SMPL(ACM'2015)
+ +```bibtex +@article{SMPL:2015, + author = {Loper, Matthew and Mahmood, Naureen and Romero, Javier and Pons-Moll, Gerard and Black, Michael J.}, + title = {{SMPL}: A Skinned Multi-Person Linear Model}, + journal = {ACM Trans. Graphics (Proc. SIGGRAPH Asia)}, + month = oct, + number = {6}, + pages = {248:1--248:16}, + publisher = {ACM}, + volume = {34}, + year = {2015} + } +``` + +
+
+
+
+### 客制化关键点种类
+
+请参考[customize_keypoints_convention](../docs_zh-CN/customize_keypoints_convention.md).
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/model_zoo.md b/internlm_langchain/knowledge_base/MMHuman3D/content/model_zoo.md
new file mode 100644
index 00000000..0c093834
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/model_zoo.md
@@ -0,0 +1,34 @@
+# 模型库
+
+我们为所有支持的算法提供配置文件，log文件和预训练模型。
+所有的预训练模型在三个benchmark上进行评估：`3DPW`, `Human3.6M`, 和 `MPI-INF-3DHP`。
+
+## 基准算法
+
+### HMR
+
+详情请参考[HMR](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/hmr/)。
+
+### SPIN
+
+详情请参考[SPIN](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/spin/)。
+
+### VIBE
+
+详情请参考[VIBE](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/vibe/)。
+
+### HybrIK
+
+详情请参考[HybrIK](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/hybrik/)。
+
+### PARE
+
+详情请参考[PARE](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/pare/)。
+
+### ExPose
+
+详情请参考[ExPose](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/expose/)。
+
+### PyMAF-X
+
+详情请参考[PyMAF-X](https://github.com/open-mmlab/mmhuman3d/tree/main/configs/pymafx/)。
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/preprocess_dataset.md b/internlm_langchain/knowledge_base/MMHuman3D/content/preprocess_dataset.md
new file mode 100644
index 00000000..3ec7ff87
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/preprocess_dataset.md
@@ -0,0 +1,1306 @@
+# 数据预处理
+
+
+
+- [不同算法使用的数据集](#datasets-for-supported-algorithms)
+- [文件夹结构](#folder-structure)
+ * [AGORA](#agora)
+ * [COCO](#coco)
+ * [COCO-WholeBody](#coco-wholebody)
+ * [CrowdPose](#crowdpose)
+ * [EFT](#eft)
+ * [GTA-Human](#gta-human)
+ * [Human3.6M](#human36m)
+ * [Human3.6M Mosh](#human36m-mosh)
+ * [HybrIK](#hybrik)
+ * [LSP](#lsp)
+ * [LSPET](#lspet)
+ * [MPI-INF-3DHP](#mpi-inf-3dhp)
+ * [MPII](#mpii)
+ * [PoseTrack18](#posetrack18)
+ * [Penn Action](#penn-action)
+ * [PW3D](#pw3d)
+ * [SPIN](#spin)
+ * [SURREAL](#surreal)
+
+
+## 总览
+
+我们使用 [HumanData](./human_data.md) 结构用于存储和加载数据。经过处理的.npz可以使用我们提供的数据转换脚本从原始数据格式获取，详情请参考[convert_datasets.py](https://github.com/open-mmlab/mmhuman3d/tree/main/tools/convert_datasets.py).
+
+如下是我们支持的格式转换方式和具体的 `数据集名称`:
+- AgoraConverter (`agora`)
+- AmassConverter (`amass`)
+- CocoConverter (`coco`)
+- CocoHybrIKConverter (`coco_hybrik`)
+- CocoWholebodyConverter (`coco_wholebody`)
+- CrowdposeConverter (`crowdpose`)
+- EftConverter (`eft`)
+- GTAHumanConverter (`gta_human`)
+- H36mConverter (`h36m_p1`, `h36m_p2`)
+- H36mHybrIKConverter (`h36m_hybrik`)
+- H36mSpinConverter (`h36m_spin`)
+- InstaVibeConverter (`instavariety_vibe`)
+- LspExtendedConverter (`lsp_extended`)
+- LspConverter (`lsp_original`, `lsp_dataset`)
+- MpiiConverter (`mpii`)
+- MpiInf3dhpConverter (`mpi_inf_3dhp`)
+- MpiInf3dhpHybrIKConverter (`mpi_inf_3dhp_hybrik`)
+- PennActionConverter (`penn_action`)
+- PosetrackConverter (`posetrack`)
+- Pw3dConverter (`pw3d`)
+- Pw3dHybrIKConverter (`pw3d_hybrik`)
+- SurrealConverter (`surreal`)
+- SpinConverter (`spin`)
+- Up3dConverter (`up3d`)
+
+
+
+## 不同算法使用的数据集
+
+所有算法使用的数据集路径和经过处理的.npz文件路径为`data/datasets` 和 `data/preprocessed_datasets`。使用如下命令进行数据格式转换：
+
+```bash
+python tools/convert_datasets.py \
+ --datasets SMPL-X(CVPR'2019)
+ +```bibtex +@inproceedings{SMPL-X:2019, + title = {Expressive Body Capture: {3D} Hands, Face, and Body from a Single Image}, + author = {Pavlakos, Georgios and Choutas, Vasileios and Ghorbani, Nima and Bolkart, Timo and Osman, Ahmed A. A. and Tzionas, Dimitrios and Black, Michael J.}, + booktitle = {Proceedings IEEE Conf. on Computer Vision and Pattern Recognition (CVPR)}, + pages = {10975--10985}, + year = {2019} +} +``` + +
+
+
+请从[这里](https://agora.is.tue.mpg.de/index.html)下载AGORA数据集，并按照如下结构放置文件夹:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── agora
+ ├── camera_dataframe # smplx annotations
+ │ ├── train_0_withjv.pkl
+ │ ├── validation_0_withjv.pkl
+ │ └── ...
+ ├── camera_dataframe_smpl # smpl annotations
+ │ ├── train_0_withjv.pkl
+ │ ├── validation_0_withjv.pkl
+ │ └── ...
+ ├── images
+ │ ├── train
+ │ │ ├── ag_trainset_3dpeople_bfh_archviz_5_10_cam00_00000_1280x720.png
+ │ │ ├── ag_trainset_3dpeople_bfh_archviz_5_10_cam00_00001_1280x720.png
+ │ │ └── ...
+ │ ├── validation
+ │ └── test
+ ├── smpl_gt
+ │ ├── trainset_3dpeople_adults_bfh
+ │ │ ├── 10004_w_Amaya_0_0.mtl
+ │ │ ├── 10004_w_Amaya_0_0.obj
+ │ │ ├── 10004_w_Amaya_0_0.pkl
+ │ │ └── ...
+ │ └── ...
+ └── smplx_gt
+ ├── 10004_w_Amaya_0_0.obj
+ ├── 10004_w_Amaya_0_0.pkl
+ └── ...
+```
+
+### AMASS
+
+
+
+AGORA (CVPR'2021)
+ +```bibtex +@inproceedings{Patel:CVPR:2021, + title = {{AGORA}: Avatars in Geography Optimized for Regression Analysis}, + author = {Patel, Priyanka and Huang, Chun-Hao P. and Tesch, Joachim and Hoffmann, David T. and Tripathi, Shashank and Black, Michael J.}, + booktitle = {Proceedings IEEE/CVF Conf.~on Computer Vision and Pattern Recognition ({CVPR})}, + month = jun, + year = {2021}, + month_numeric = {6} +} +``` + +
+
+
+未来会添加更多关于处理AMASS数据集的细节。
+
+**或者**, 您可以直接下载处理好的.npz文件:
+- [amass_smplh.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/amass_smplh.npz?versionId=CAEQIhiBgICS4Mrt7xciIGU5MDBmZmE4Y2I0NjRiYTc4ZWY2NzY2MzU1ZmIwZTQ2)
+- [amass_smplx.npz](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/datasets/amass_smplx.npz?versionId=CAEQIhiBgIDh387t7xciIGRlN2JlZjA0ZGM0YzRkNmM5OWJhNmVjMmZlN2RiN2E1)
+
+### COCO
+
+
+
+AMASS (ICCV'2019)
+ +```bibtex +@inproceedings{AMASS:2019, + title={AMASS: Archive of Motion Capture as Surface Shapes}, + author={Mahmood, Naureen and Ghorbani, Nima and F. Troje, Nikolaus and Pons-Moll, Gerard and Black, Michael J.}, + booktitle = {The IEEE International Conference on Computer Vision (ICCV)}, + year={2019}, + month = {Oct}, + url = {https://amass.is.tue.mpg.de}, + month_numeric = {10} +} +``` + +
+
+
+请从[这里](http://cocodataset.org/#download)下载`COCO`数据集。其中，训练HMR需要`COCO2014`，训练HybrIK需要`COCO2017`。
+下载并解压至 `$MMHUMAN3D/data/datasets`, 使它们具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── coco
+ ├── annotations
+ | ├── person_keypoints_train2014.json
+ | ├── person_keypoints_val2014.json
+ ├── train2014
+ │ ├── COCO_train2014_000000000009.jpg
+ │ ├── COCO_train2014_000000000025.jpg
+ │ ├── COCO_train2014_000000000030.jpg
+ | └── ...
+ └── train_2017
+ │── annotations
+ │ ├── person_keypoints_train2017.json
+ │ └── person_keypoints_val2017.json
+ │── train2017
+ │ ├── 000000000009.jpg
+ │ ├── 000000000025.jpg
+ │ ├── 000000000030.jpg
+ │ └── ...
+ └── val2017
+ ├── 000000000139.jpg
+ ├── 000000000285.jpg
+ ├── 000000000632.jpg
+ └── ...
+```
+
+
+### COCO-WholeBody
+
+
+
+COCO (ECCV'2014)
+ +```bibtex +@inproceedings{lin2014microsoft, + title={Microsoft coco: Common objects in context}, + author={Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C Lawrence}, + booktitle={European conference on computer vision}, + pages={740--755}, + year={2014}, + organization={Springer} +} +``` + +
+
+
+请从[这里](http://cocodataset.org/#download)下载[COCO-WholeBody](https://github.com/jin-s13/COCO-WholeBody/)数据集(2017 train/val)中的图像，从[这里](https://github.com/jin-s13/COCO-WholeBody/)下载标注文件。
+解压至`$MMHUMAN3D/data/datasets`文件夹，并使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── coco
+ ├── annotations
+ | ├── coco_wholebody_train_v1.0.json
+ | └── coco_wholebody_val_v1.0.json
+ └── train_2017
+ │── train2017
+ │ ├── 000000000009.jpg
+ │ ├── 000000000025.jpg
+ │ ├── 000000000030.jpg
+ │ └── ...
+ └── val2017
+ ├── 000000000139.jpg
+ ├── 000000000285.jpg
+ ├── 000000000632.jpg
+ └── ...
+
+```
+
+
+
+
+### CrowdPose
+
+
+
+COCO-WholeBody (ECCV'2020)
+ +```bibtex +@inproceedings{jin2020whole, + title={Whole-Body Human Pose Estimation in the Wild}, + author={Jin, Sheng and Xu, Lumin and Xu, Jin and Wang, Can and Liu, Wentao and Qian, Chen and Ouyang, Wanli and Luo, Ping}, + booktitle={Proceedings of the European Conference on Computer Vision (ECCV)}, + year={2020} +} +``` + +
+
+
+下载[CrowdPose](https://github.com/Jeff-sjtu/CrowdPose)数据集，并解压至文件夹`$MMHUMAN3D/data/datasets`，使其具有如下结构：
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── crowdpose
+ ├── crowdpose_train.json
+ ├── crowdpose_val.json
+ ├── crowdpose_trainval.json
+ ├── crowdpose_test.json
+ └── images
+ ├── 100000.jpg
+ ├── 100001.jpg
+ ├── 100002.jpg
+ └── ...
+```
+
+### EFT
+
+
+
+CrowdPose (CVPR'2019)
+ +```bibtex +@article{li2018crowdpose, + title={CrowdPose: Efficient Crowded Scenes Pose Estimation and A New Benchmark}, + author={Li, Jiefeng and Wang, Can and Zhu, Hao and Mao, Yihuan and Fang, Hao-Shu and Lu, Cewu}, + journal={arXiv preprint arXiv:1812.00324}, + year={2018} +} +``` + +
+
+
+下载[EFT](https://github.com/facebookresearch/eft)数据集，解压至`$MMHUMAN3D/data/datasets`，并使其具有如下结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── eft
+ ├── coco_2014_train_fit
+ | ├── COCO2014-All-ver01.json
+ | └── COCO2014-Part-ver01.json
+ |── LSPet_fit
+ | └── LSPet_ver01.json
+ └── MPII_fit
+ └── MPII_ver01.json
+```
+
+### GTA-Human
+
+
+
+EFT (3DV'2021)
+ +```bibtex +@inproceedings{joo2020eft, + title={Exemplar Fine-Tuning for 3D Human Pose Fitting Towards In-the-Wild 3D Human Pose Estimation}, + author={Joo, Hanbyul and Neverova, Natalia and Vedaldi, Andrea}, + booktitle={3DV}, + year={2020} +} +``` + +
+
+
+### Human3.6M
+
+
+
+GTA-Human (arXiv'2021)
+ +```bibtex +@article{cai2021playing, + title={Playing for 3D Human Recovery}, + author={Cai, Zhongang and Zhang, Mingyuan and Ren, Jiawei and Wei, Chen and Ren, Daxuan and Li, Jiatong and Lin, Zhengyu and Zhao, Haiyu and Yi, Shuai and Yang, Lei and others}, + journal={arXiv preprint arXiv:2110.07588}, + year={2021} +} +``` + +More details are coming soon! + + +
+
+
+从官网下载[Human3.6M](http://vision.imar.ro/human3.6m/description.php)数据集，并使用[脚本](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/data/data_converters/h36m.py)进行预处理，间隔5帧提取标注。
+处理过的数据集具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── h36m
+ ├── annot
+ ├── S1
+ | ├── images
+ | | |── S1_Directions_1.54138969
+ | | | ├── S1_Directions_1.54138969_00001.jpg
+ | | | ├── S1_Directions_1.54138969_00002.jpg
+ | | | └── ...
+ | | └── ...
+ | ├── MyPoseFeatures
+ | | |── D2Positions
+ | | └── D3_Positions_Mono
+ | ├── MySegmentsMat
+ | | └── ground_truth_bs
+ | └── Videos
+ | |── Directions 1.54138969.mp4
+ | |── Directions 1.55011271.mp4
+ | └── ...
+ ├── S5
+ ├── S6
+ ├── S7
+ ├── S8
+ ├── S9
+ ├── S11
+ └── metadata.xml
+```
+
+修改[配置文件](https://github.com/open-mmlab/mmhuman3d/blob/main/tools/convert_datasets.py)中的`h36m_p1`，从原始的[Human3.6M](http://vision.imar.ro/human3.6m/description.php)数据集中的视频提取图像。
+
+```python
+h36m_p1=dict(
+ type='H36mConverter',
+ modes=['train', 'valid'],
+ protocol=1,
+ extract_img=True, # 从原视频中提取图像，设置为True
+ prefix='h36m'),
+```
+
+### Human3.6M Mosh
+
+
+
+我们使用[HMR](https://github.com/akanazawa/hmr)提供的[MoShed](https://mosh.is.tue.mpg.de/)数据集训练`HMR`、`SPIN`和`PARE`。由于版权的限制，我们无法上传该数据集。即使没有使用mosh参数的许可，仍可使用我们提供的[转换脚本](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/data/data_converters/h36m.py)生成h36m的.npz文件。
+
+修改[配置文件](https://github.com/open-mmlab/mmhuman3d/blob/main/tools/convert_datasets.py)中的`h36m_p1`，从原始的[Human3.6M](http://vision.imar.ro/human3.6m/description.php)数据集中的视频提取图像。
+
+不具有mosh数据的配置文件:
+```python
+h36m_p1=dict(
+ type='H36mConverter',
+ modes=['train', 'valid'],
+ protocol=1,
+ extract_img=True, # 从原视频中提取图像，设置为True
+ prefix='h36m'),
+```
+
+具有mosh数据的配置文件:
+```python
+h36m_p1=dict(
+ type='H36mConverter',
+ modes=['train', 'valid'],
+ protocol=1,
+ extract_img=True, # 从原视频中提取图像，设置为True
+ mosh_dir='data/datasets/h36m_mosh', # 如果拥有mosh数据，指定其的路径
+ prefix='h36m'),
+```
+
+如果您可以获取到Human3.6m的Mosh数据，整个文件夹应该具有如下的架构：
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── h36m_mosh
+ ├── annot
+ ├── S1
+ | ├── images
+ | | ├── Directions 1_cam0_aligned.pkl
+ | | ├── Directions 1_cam1_aligned.pkl
+ | | └── ...
+ ├── S5
+ ├── S6
+ ├── S7
+ ├── S8
+ ├── S9
+ └── S11
+```
+
+### HybrIK
+
+
+
+Human3.6M (TPAMI'2014)
+ +```bibtex +@article{h36m_pami, + author = {Ionescu, Catalin and Papava, Dragos and Olaru, Vlad and Sminchisescu, Cristian}, + title = {Human3.6M: Large Scale Datasets and Predictive Methods for 3D Human Sensing in Natural Environments}, + journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher = {IEEE Computer Society}, + volume = {36}, + number = {7}, + pages = {1325-1339}, + month = {jul}, + year = {2014} +} +``` + +
+
+
+下载[HybrIK](https://github.com/Jeff-sjtu/HybrIK)数据集的[标注](https://github.com/Jeff-sjtu/HybrIK#fetch-data), 并使其文件夹具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── hybrik_data
+ ├── Sample_5_train_Human36M_smpl_leaf_twist_protocol_2.json
+ ├── Sample_20_test_Human36M_smpl_protocol_2.json
+ ├── 3DPW_test_new.json
+ ├── annotation_mpi_inf_3dhp_train_v2.json
+ └── annotation_mpi_inf_3dhp_test.json
+```
+
+运行如下脚本，将.json文件处理成mmhuman3d中使用的.npz文件：
+
+ - [Human3.6M](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/data/data_converters/h36m_hybrik.py)
+ - [PW3D](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/data/data_converters/pw3d_hybrik.py)
+ - [Mpi-Inf-3dhp](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/data/data_converters/mpi_inf_3dhp_hybrik.py)
+ - [COCO](https://github.com/open-mmlab/mmhuman3d/tree/main/mmhuman3d/data/data_converters/coco_hybrik.py)
+
+
+### LSP
+
+
+
+HybrIK (CVPR'2021)
+ +```bibtex +@inproceedings{li2020hybrikg, + author = {Li, Jiefeng and Xu, Chao and Chen, Zhicun and Bian, Siyuan and Yang, Lixin and Lu, Cewu}, + title = {HybrIK: A Hybrid Analytical-Neural Inverse Kinematics Solution for 3D Human Pose and Shape Estimation}, + booktitle={CVPR 2021}, + pages={3383--3393}, + year={2021}, + organization={IEEE} +} +``` + +
+
+
+下载具有高分辨率的LSP数据集[LSP dataset original](http://sam.johnson.io/research/lsp_dataset_original.zip)，解压至文件夹`$MMHUMAN3D/data/datasets`，并使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── lsp
+ ├── images
+ | ├── im0001.jpg
+ | ├── im0002.jpg
+ | └── ...
+ └── joints.mat
+```
+
+### LSPET
+
+
+
+LSP (BMVC'2010)
+ +```bibtex +@inproceedings{johnson2010clustered, + title={Clustered Pose and Nonlinear Appearance Models for Human Pose Estimation.}, + author={Johnson, Sam and Everingham, Mark}, + booktitle={bmvc}, + volume={2}, + number={4}, + pages={5}, + year={2010}, + organization={Citeseer} +} +``` +
+
+
+下载具有高分辨率的LSPET数据集[HR-LSPET](http://datasets.d2.mpi-inf.mpg.de/hr-lspet/hr-lspet.zip)，解压至文件夹`$MMHUMAN3D/data/datasets`，并使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── lspet
+ ├── im00001.jpg
+ ├── im00002.jpg
+ ├── im00003.jpg
+ ├── ...
+ └── joints.mat
+```
+
+
+
+### MPI-INF-3DHP
+
+LSP-Extended (CVPR'2011)
+ +```bibtex +@inproceedings{johnson2011learning, + title={Learning effective human pose estimation from inaccurate annotation}, + author={Johnson, Sam and Everingham, Mark}, + booktitle={CVPR 2011}, + pages={1465--1472}, + year={2011}, + organization={IEEE} +} +``` + +
+
+
+修改[配置文件](https://github.com/open-mmlab/mmhuman3d/blob/main/tools/convert_datasets.py)中的`mpi_inf_3dhp`，从原始视频中提取图像。
+请注意，这会花费较长的时间。
+
+Config:
+```python
+mpi_inf_3dhp=dict(
+ type='MpiInf3dhpConverter',
+ modes=['train', 'test'],
+ extract_img=True), # 从原视频中提取图像，设置为True
+```
+
+下载[MPI-INF-3DHP](http://gvv.mpi-inf.mpg.de/3dhp-dataset/)数据集, 解压至文件夹`$MMHUMAN3D/data/datasets`, 使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── mpi_inf_3dhp
+ ├── mpi_inf_3dhp_test_set
+ │ ├── TS1
+ │ ├── TS2
+ │ ├── TS3
+ │ ├── TS4
+ │ ├── TS5
+ │ └── TS6
+ ├── S1
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S2
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S3
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S4
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S5
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S6
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S7
+ │ ├── Seq1
+ │ └── Seq2
+ └── S8
+ ├── Seq1
+ └── Seq2
+```
+
+
+
+### MPII
+
+
+
+MPI_INF_3DHP (3DV'2017)
+ +```bibtex +@inproceedings{mono-3dhp2017, + author = {Mehta, Dushyant and Rhodin, Helge and Casas, Dan and Fua, Pascal and Sotnychenko, Oleksandr and Xu, Weipeng and Theobalt, Christian}, + title = {Monocular 3D Human Pose Estimation In The Wild Using Improved CNN Supervision}, + booktitle = {3D Vision (3DV), 2017 Fifth International Conference on}, + url = {http://gvv.mpi-inf.mpg.de/3dhp_dataset}, + year = {2017}, + organization={IEEE}, + doi={10.1109/3dv.2017.00064}, +} +``` +
+
+
+下载[MPII](http://human-pose.mpi-inf.mpg.de/#download)数据集，并从[这里](https://github.com/princeton-vl/pose-hg-train/tree/master/data/mpii/annot?rgh-link-date=2020-07-05T04%3A14%3A02Z)下载标注。
+解压至文件夹`$MMHUMAN3D/data/datasets`, 使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── mpii
+ |── train.h5
+ └── images
+ |── 000001163.jpg
+ |── 000003072.jpg
+ └── ...
+```
+
+
+### PoseTrack18
+
+
+
+MPII (CVPR'2014)
+ +```bibtex +@inproceedings{andriluka14cvpr, + author = {Mykhaylo Andriluka and Leonid Pishchulin and Peter Gehler and Schiele, Bernt}, + title = {2D Human Pose Estimation: New Benchmark and State of the Art Analysis}, + booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2014}, + month = {June} +} +``` + +
+
+
+下载[PoseTrack18](https://posetrack.net/users/download.php)数据集，解压至文件夹`$MMHUMAN3D/data/datasets`，使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── posetrack
+ ├── images
+ │ ├── train
+ │ │ ├── 000001_bonn_train
+ │ │ │ ├── 000000.jpg
+ │ │ │ ├── 000001.jpg
+ │ │ │ └── ...
+ │ │ └── ...
+ │ ├── val
+ │ │ ├── 000342_mpii_test
+ │ │ │ ├── 000000.jpg
+ │ │ │ ├── 000001.jpg
+ │ │ │ └── ...
+ │ │ └── ...
+ │ └── test
+ │ ├── 000001_mpiinew_test
+ │ │ ├── 000000.jpg
+ │ │ ├── 000001.jpg
+ │ │ └── ...
+ │ └── ...
+ └── posetrack_data
+ └── annotations
+ ├── train
+ │ ├── 000001_bonn_train.json
+ │ ├── 000002_bonn_train.json
+ │ └── ...
+ ├── val
+ │ ├── 000342_mpii_test.json
+ │ ├── 000522_mpii_test.json
+ │ └── ...
+ └── test
+ ├── 000001_mpiinew_test.json
+ ├── 000002_mpiinew_test.json
+ └── ...
+```
+
+### Penn Action
+
+
+
+PoseTrack18 (CVPR'2018)
+ +```bibtex +@inproceedings{andriluka2018posetrack, + title={Posetrack: A benchmark for human pose estimation and tracking}, + author={Andriluka, Mykhaylo and Iqbal, Umar and Insafutdinov, Eldar and Pishchulin, Leonid and Milan, Anton and Gall, Juergen and Schiele, Bernt}, + booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, + pages={5167--5176}, + year={2018} +} +``` + +
+
+
+下载[Penn Action](https://upenn.box.com/PennAction)数据集，解压至文件夹`$MMHUMAN3D/data/datasets`，使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── penn_action
+ ├── frames
+ │ ├── 0001
+ │ │ ├── 000001.jpg
+ │ │ ├── 000002.jpg
+ │ │ └── ...
+ │ └── ...
+ └── labels
+ ├── 0001.mat
+ ├── 0002.mat
+ └── ...
+```
+
+### PW3D
+
+
+
+Penn Action (ICCV'2013)
+ +```bibtex +@inproceedings{zhang2013pennaction, + title={From Actemes to Action: A Strongly-supervised Representation for Detailed Action Understanding}, + author={Zhang, Weiyu and Zhu, Menglong and Derpanis, Konstantinos}, + booktitle={ICCV}, + year={2013} +} +``` + +
+
+
+下载[PW3D](https://virtualhumans.mpi-inf.mpg.de/3DPW/)数据集，解压至文件夹`$MMHUMAN3D/data/datasets`，并使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── pw3d
+ |── imageFiles
+ | | └── courtyard_arguing_00
+ | | ├── image_00000.jpg
+ | | ├── image_00001.jpg
+ | | └── ...
+ └── sequenceFiles
+ ├── train
+ │ ├── downtown_arguing_00.pkl
+ │ └── ...
+ ├── val
+ │ ├── courtyard_arguing_00.pkl
+ │ └── ...
+ └── test
+ ├── courtyard_basketball_00.pkl
+ └── ...
+
+```
+
+
+
+### SPIN
+
+
+
+PW3D (ECCV'2018)
+ +```bibtex +@inproceedings{vonMarcard2018, +title = {Recovering Accurate 3D Human Pose in The Wild Using IMUs and a Moving Camera}, +author = {von Marcard, Timo and Henschel, Roberto and Black, Michael and Rosenhahn, Bodo and Pons-Moll, Gerard}, +booktitle = {European Conference on Computer Vision (ECCV)}, +year = {2018}, +month = {sep} +} +``` + +
+
+
+下载经过处理的[.npz 文件](https://github.com/nkolot/SPIN/blob/master/fetch_data.sh)，使文件夹具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── spin_data
+ ├── coco_2014_train.npz
+ ├── hr-lspet_train.npz
+ ├── lsp_dataset_original_train.npz
+ ├── mpi_inf_3dhp_train.npz
+ └── mpii_train.npz
+```
+
+
+
+### SURREAL
+
+
+
+SPIN (ICCV'2019)
+ +```bibtex +@inproceedings{kolotouros2019spin, + author = {Kolotouros, Nikos and Pavlakos, Georgios and Black, Michael J and Daniilidis, Kostas}, + title = {Learning to Reconstruct 3D Human Pose and Shape via Model-fitting in the Loop}, + booktitle={ICCV}, + year={2019} +} +``` + +
+
+
+下载[SURREAL](https://www.di.ens.fr/willow/research/surreal/data/)数据集，并使其具有如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ └── datasets
+ └── surreal
+ ├── train
+ │ ├── run0
+ | | ├── 03_01
+ | | │ ├── 03_01_c0001_depth.mat
+ | | │ ├── 03_01_c0001_info.mat
+ | | │ ├── 03_01_c0001_segm.mat
+ | | │ ├── 03_01_c0001.mp4
+ | | │ └── ...
+ | | └── ...
+ │ ├── run1
+ │ └── run2
+ ├── val
+ │ ├── run0
+ │ ├── run1
+ │ └── run2
+ └── test
+ ├── run0
+ ├── run1
+ └── run2
+```
+
+
+### VIBE
+
+
+
+SURREAL (CVPR'2017)
+ +```bibtex +@inproceedings{varol17_surreal, + title = {Learning from Synthetic Humans}, + author = {Varol, G{\"u}l and Romero, Javier and Martin, Xavier and Mahmood, Naureen and Black, Michael J. and Laptev, Ivan and Schmid, Cordelia}, + booktitle = {CVPR}, + year = {2017} +} +``` + +
+
+
+请下载经过处理的`mpi_inf_3dhp`与`pw3d`的[.npz 文件](https://github.com/nkolot/SPIN/blob/master/fetch_data.sh)，以及预训练之后的特征提取权重 [spin.pth](https://openmmlab-share.oss-cn-hangzhou.aliyuncs.com/mmhuman3d/models/vibe/spin.pth?versionId=CAEQHhiBgIDrxqbU6xciIGIzOWFkMWYyNzMwMjRhMzBiYzM3NDFiMmVkY2JkZTVh)。 将文件夹整理成如下的结构:
+
+```text
+mmhuman3d
+├── mmhuman3d
+├── docs
+├── tests
+├── tools
+├── configs
+└── data
+ ├── checkpoints
+ | └── spin.pth
+ └── datasets
+ └── vibe_data
+ ├── mpi_inf_3dhp_train.npz
+ └── pw3d_test.npz
+```
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/render.md b/internlm_langchain/knowledge_base/MMHuman3D/content/render.md
new file mode 100644
index 00000000..2cb0b852
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/render.md
@@ -0,0 +1,148 @@
+# 渲染 Meshes
+
+## 渲染器初始化
+
+我们使用 `Pytorch3D` 渲染器。通过光栅化器、着色器和其他设定初始化渲染器。 `MMHuman3D`中的渲染器兼容`Pytorch3D`的渲染器，但功能更加丰富且更易用。 例如，您可以像`Pytorch3D`那样，通过传入光栅化器和着色器初始化渲染器，也可以传入包含相关设置的字典或使用默认的设置。
+在`mmhuman3d`中, 我们提供了不同的渲染器，包括 `MeshRenderer`, `DepthRenderer`, `NormalRenderer`, `PointCloudRenderer`, `SegmentationRenderer`, `SilhouetteRenderer` 和 `UVRenderer`。其中, `UVRenderer` 比较特别，请参考[UVRenderer](#uvrenderer)。
+
+上述所有的渲染器可以通过`MMCV.Registry`进行初始化。通过字典储存渲染器的配置会很方便。
+
+- **`pytorch3d`和`mmhuman3d`的比较:**
+```python
+### 通过Pytorch3D初始化
+import torch
+from pytorch3d.renderer import MeshRenderer, RasterizationSettings
+from pytorch3d.renderer.lighting import PointLights
+from pytorch3d.renderer.cameras import FoVPerspectiveCameras
+
+device = torch.device('cuda')
+R, T = look_at_view_transform(dist=2.7, elev=0, azim=0)
+cameras = FoVPerspectiveCameras(device=device, R=R, T=T)
+
+lights = PointLights(
+ device=device,
+ ambient_color=((0.5, 0.5, 0.5), ),
+ diffuse_color=((0.3, 0.3, 0.3), ),
+ specular_color=((0.2, 0.2, 0.2), ),
+ direction=((0, 1, 0), ),
+)
+raster_settings = RasterizationSettings(
+ image_size=128,
+ blur_radius=0.0,
+ faces_per_pixel=1,
+)
+renderer = MeshRenderer(
+ rasterizer=MeshRasterizer(
+ cameras=cameras, raster_settings=raster_settings),
+ shader=SoftPhongShader(device=device, cameras=cameras, lights=lights))
+
+### 通过mmhuman3d初始化
+from mmhuman3d.core.visualization.renderer import MeshRenderer
+# 可以通过nn.Module和dict初始化光栅化器
+rasterizer = dict(
+ image_size=128,
+ blur_radius=0.0,
+ faces_per_pixel=1,
+)
+# 可以通过nn.Module和dict初始化光线
+lights = dict(type='point', ambient_color=((0.5, 0.5, 0.5), ),
+ diffuse_color=((0.3, 0.3, 0.3), ),
+ specular_color=((0.2, 0.2, 0.2), ),
+ direction=((0, 1, 0), ),)
+
+# 可以通过camera和字典初始化光栅化器
+cameras = dict(type='fovperspective', R=R, T=T, device=device)
+
+# 可以通过nn.Module和dict初始化着色器
+shader = dict(type='SoftPhongShader')
+```
+
+这两种方式是等价的。
+```python
+import torch.nn as nn
+from mmhuman3d.core.visualization.renderer import MeshRenderer, build_renderer
+
+renderer = MeshRenderer(shader=shader, device=device, rasterizer=rasterizer, resolution=resolution)
+renderer = build_renderer(dict(type='mesh', device=device, shader=shader, rasterizer=rasterizer, resolution=resolution))
+
+# 使用默认的光栅化器和着色器的配置
+renderer = build_renderer(dict(type='mesh', device=device, resolution=resolution))
+assert isinstance(renderer.rasterizer, nn.Module)
+assert isinstance(renderer.shader, nn.Module)
+```
+
+我们提供了用于可视化的`tensor2rgba`函数，其返回的是可视化彩色图像的张量。
+对于不同的渲染器，该函数是不同的。例如，`DepthRenderer`渲染出的是一个形状为(N, H, W, 1)的张量，我们将其复制成形状为(N, H, W, 4)的图像张量。`SegmentationRenderer`渲染出的是一个形状为(N, H, W, C)的张量，我们根据色彩匹配关系将其转换成(N, H, W, 4)的图像张量。`NormalRenderer`渲染出的是一个形状为(N, H, W, 4)的张量，其取值范围为[-1, 1]，`tensor2rgba`会将其归一化到[0, 1]。
+
+```python
+import torch
+from mmhuman3d.core.visualization.renderer import build_renderer
+
+renderer = build_renderer(dict(type='mesh', device=device, resolution=resolution))
+rendered_tensor = renderer(meshes=meshes, cameras=cameras, lights=lights)
+rendered_rgba = renderer.tensor2rgba(rendered_tensor)
+```
+
+`MMHuman3D`中的渲染器可以更改输出设置，并且提供了文件的输入输出操作，`tensor2rgba`函数会对写入的图像和视频进行转换。
+
+```python
+# 写入视频
+renderer = build_renderer(dict(type='mesh', device=device, resolution=resolution, output_path='test.mp4'))
+backgrounds = torch.Tensor(N, H, W, 3)
+rendered_tensor = renderer(meshes=meshes, cameras=cameras, lights=lights, backgrounds=backgrounds)
+renderer.export() #这一步对于视频是必要的
+
+# 在文件夹中写入图像
+renderer = build_renderer(dict(type='mesh', device=device, resolution=resolution, output_path='test_folder', out_img_format='%06d.png'))
+backgrounds = torch.Tensor(N, H, W, 3)
+rendered_tensor = renderer(meshes=meshes, cameras=cameras, lights=lights, backgrounds=backgrounds)
+```
+
+
+## 使用 render_runner
+
+您可以通过`render_runner`传入用于渲染的数据。它会使用for循环批量渲染张量，因此可以对一长串视频序列进行渲染，而不会出现`CUDA out of memory`的报错。
+
+```python
+import torch
+from mmhuman3d.core.visualization.renderer import render_runner
+
+render_data = dict(cameras=cameras, lights=lights, meshes=meshes, backgrounds=backgrounds)
+# 对于不可微的渲染，指定no_grad=True
+rendered_tensor = render_runner.render(renderer=renderer, output_path=output_path, resolution=resolution, batch_size=batch_size, device=device, no_grad=True, return_tensor=True, **render_data)
+```
+
+## UVRenderer
+
+`UVRenderer` 不同于其他的渲染器，它是一个smpl uv拓扑定义的包装器和采样器。其包含有两个功能: 将顶点的属性包装为map, 从map上采样顶点属性。
+
+### 初始化
+UV 信息储存在`smpl_uv.npz`文件中。
+```python
+uv_renderer = build_renderer(dict(type='uv', resolution=resolution, device=device, model_type='smpl', uv_param_path='data/body_models/smpl/smpl_uv.npz'))
+```
+### 包装
+将灰色的纹理图像变形为smpl的mesh。
+
+```python
+import torch
+from mmhuman3d.models import build_body_model
+from pytorch3d.structures import meshes
+from mmhuman3d.core.visualization.renderer import build_renderer
+body_model = build_body_model(dict(type='smpl', model_path=model_path)).to(device)
+pose_dict = body_model.tensor2dict(torch.zeros(1, 72))
+verts = body_model(**pose_dict)['vertices']
+faces = body_model.faces_tensor[None]
+smpl_mesh = Meshes(verts=verts, faces=faces)
+texture_image = torch.ones(1, 512, 512, 3) * 0.5
+smpl_mesh.textures = uv_renderer.warp_texture(texture_image=texture_image)
+```
+### 采样
+从map采样顶点。
+
+```python
+normal_map = torch.ones(1, 512, 512, 3)
+vertex_normals = uv_renderer.vertex_resample(normal_map)
+assert vertex_normals.shape == (1 ,6890, 3)
+assert (vertex_normals == 1).all()
+```
diff --git a/internlm_langchain/knowledge_base/MMHuman3D/content/smc.md b/internlm_langchain/knowledge_base/MMHuman3D/content/smc.md
new file mode 100644
index 00000000..63aa629c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMHuman3D/content/smc.md
@@ -0,0 +1,159 @@
+# SMC(SenseMoCap) 文件格式描述
+
+SMC (SenseMoCap) 是一个设计用来存储多目多模态的文件格式。每一个SMC本质上是一个HDF5的数据库，支持不同平台，不同编程语言的读写。
+
+每个SMC的机构约定如下:
+
+- ### *.smc (File)
+
+ - Attributes
+
+ - actor_id: 演员编号, int32 字符
+ - action_id: 动作编号, int32 字符
+ - datetime_str: 数据采集时间戳, 字符串 (YYYY-MM-DD-hh-mm-ss)
+
+ - ### Extrinsics (Dataset):
+
+ - 一个存储N个Kinect和M个iPhone标定数据的JSON字符串
+ - Indexing cameras:
+ - Kinect RGB相机编号是偶数: i*2, 0<=iVIBE (CVPR'2020)
+ +```BibTeX +@inproceedings{VIBE, + author = {Muhammed Kocabas and + Nikos Athanasiou and + Michael J. Black}, + title = {{VIBE}: Video Inference for Human Body Pose and Shape Estimation}, + booktitle = {CVPR}, + year = {2020} +} +``` + +
+
+#### 数据集配置
+
+主要用于配置两个方向：
+
+- 数据集的图像与标注文件的位置。
+
+- 数据增强相关的配置。在 OCR 领域中，数据增强通常与模型强相关。
+
+更多参数配置可以参考[数据基类](#TODO)。
+
+数据集字段的命名规则在 MMOCR 中为：
+
+```Python
+{数据集名称缩写}_{算法任务}_{训练/测试/验证} = dict(...)
+```
+
+- 数据集缩写：见 [数据集名称对应表](#TODO)
+
+- 算法任务：文本检测-det，文字识别-rec，关键信息提取-kie
+
+- 训练/测试/验证：数据集用于训练，测试还是验证
+
+以识别为例，使用 Syn90k 作为训练集，以 icdar2013 和 icdar2015 作为测试集配置如下：
+
+```Python
+# 识别数据集配置
+mjsynth_textrecog_train = dict(
+ type='OCRDataset',
+ data_root='data/rec/Syn90k/',
+ data_prefix=dict(img_path='mnt/ramdisk/max/90kDICT32px'),
+ ann_file='train_labels.json',
+ test_mode=False,
+ pipeline=None)
+
+icdar2013_textrecog_test = dict(
+ type='OCRDataset',
+ data_root='data/rec/icdar_2013/',
+ data_prefix=dict(img_path='Challenge2_Test_Task3_Images/'),
+ ann_file='test_labels.json',
+ test_mode=True,
+ pipeline=None)
+
+icdar2015_textrecog_test = dict(
+ type='OCRDataset',
+ data_root='data/rec/icdar_2015/',
+ data_prefix=dict(img_path='ch4_test_word_images_gt/'),
+ ann_file='test_labels.json',
+ test_mode=True,
+ pipeline=None)
+```
+
+
+
+#### 数据流水线配置
+
+MMOCR 中，数据集的构建与数据准备是相互解耦的。也就是说，`OCRDataset` 等数据集构建类负责完成标注文件的读取与解析功能；而数据变换方法（Data Transforms）则进一步实现了数据读取、数据增强、数据格式化等相关功能。
+
+同时一般情况下训练和测试会存在不同的增强策略，因此一般会存在训练流水线（train_pipeline）和测试流水线（test_pipeline）。更多信息可以参考[数据流水线](../basic_concepts/transforms.md)
+
+- 训练流水线的数据增强流程通常为：数据读取(LoadImageFromFile)->标注信息读取(LoadXXXAnntation)->数据增强->数据格式化(PackXXXInputs)。
+
+- 测试流水线的数据增强流程通常为：数据读取(LoadImageFromFile)->数据增强->标注信息读取(LoadXXXAnntation)->数据格式化(PackXXXInputs)。
+
+由于 OCR 任务的特殊性，一般情况下不同模型有不同数据增强的方式，相同模型在不同数据集一般也会有不同的数据增强方式。以 CRNN 为例：
+
+```Python
+# 数据增强
+train_pipeline = [
+ dict(
+ type='LoadImageFromFile',
+ color_type='grayscale',
+ ignore_empty=True,
+ min_size=5),
+ dict(type='LoadOCRAnnotations', with_text=True),
+ dict(type='Resize', scale=(100, 32), keep_ratio=False),
+ dict(
+ type='PackTextRecogInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape', 'valid_ratio'))
+]
+test_pipeline = [
+ dict(
+ type='LoadImageFromFile',
+ color_type='grayscale'),
+ dict(
+ type='RescaleToHeight',
+ height=32,
+ min_width=32,
+ max_width=None,
+ width_divisor=16),
+ dict(type='LoadOCRAnnotations', with_text=True),
+ dict(
+ type='PackTextRecogInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape', 'valid_ratio'))
+]
+```
+
+
+
+#### Dataloader 配置
+
+主要为构造数据集加载器(dataloader)所需的配置信息，更多教程看参考 {external+torch:doc}`PyTorch 数据加载器 `。
+
+```Python
+# Dataloader 部分
+train_dataloader = dict(
+ batch_size=64,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=dict(
+ type='ConcatDataset',
+ datasets=[mjsynth_textrecog_train],
+ pipeline=train_pipeline))
+val_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type='ConcatDataset',
+ datasets=[icdar2013_textrecog_test, icdar2015_textrecog_test],
+ pipeline=test_pipeline))
+test_dataloader = val_dataloader
+```
+
+### 模型相关配置
+
+
+
+#### 网络配置
+
+用于配置模型的网络结构，不同的算法任务有不同的网络结构。更多信息可以参考[网络结构](../basic_concepts/structures.md)
+
+##### 文本检测
+
+文本检测主要包含几个部分:
+
+- `data_preprocessor`: [数据处理器](mmocr.models.textdet.data_preprocessors.TextDetDataPreprocessor)
+- `backbone`: 特征提取网络
+- `neck`: 颈网络配置
+- `det_head`: 检测头网络配置
+ - `module_loss`: 模型损失函数配置
+ - `postprocessor`: 模型预测结果后处理配置
+
+我们以 DBNet 为例，介绍文字检测中模型配置：
+
+```Python
+model = dict(
+ type='DBNet',
+ data_preprocessor=dict(
+ type='TextDetDataPreprocessor',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ bgr_to_rgb=True,
+ pad_size_divisor=32)
+ backbone=dict(
+ type='mmdet.ResNet',
+ depth=18,
+ num_stages=4,
+ out_indices=(0, 1, 2, 3),
+ frozen_stages=-1,
+ norm_cfg=dict(type='BN', requires_grad=True),
+ init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18'),
+ norm_eval=False,
+ style='caffe'),
+ neck=dict(
+ type='FPNC', in_channels=[64, 128, 256, 512], lateral_channels=256),
+ det_head=dict(
+ type='DBHead',
+ in_channels=256,
+ module_loss=dict(type='DBModuleLoss'),
+ postprocessor=dict(type='DBPostprocessor', text_repr_type='quad')))
+```
+
+##### 文本识别
+
+文本识别主要包含：
+
+- `data_processor`: [数据预处理配置](mmocr.models.textrec.data_processors.TextRecDataPreprocessor)
+- `preprocessor`: 网络预处理配置，如TPS等
+- `backbone`:特征提取配置
+- `encoder`: 编码器配置
+- `decoder`: 解码器配置
+ - `module_loss`: 解码器损失
+ - `postprocessor`: 解码器后处理
+ - `dictionary`: 字典配置
+
+以 CRNN 为例：
+
+```Python
+# 模型部分
+model = dict(
+ type='CRNN',
+ data_preprocessor=dict(
+ type='TextRecogDataPreprocessor', mean=[127], std=[127])
+ preprocessor=None,
+ backbone=dict(type='VeryDeepVgg', leaky_relu=False, input_channels=1),
+ encoder=None,
+ decoder=dict(
+ type='CRNNDecoder',
+ in_channels=512,
+ rnn_flag=True,
+ module_loss=dict(type='CTCModuleLoss', letter_case='lower'),
+ postprocessor=dict(type='CTCPostProcessor'),
+ dictionary=dict(
+ type='Dictionary',
+ dict_file='dicts/lower_english_digits.txt',
+ with_padding=True)))
+```
+
+
+
+#### 权重加载配置
+
+可以通过 `load_from` 参数加载检查点（checkpoint）文件中的模型权重，只需要将 `load_from` 参数设置为检查点文件的路径即可。
+
+用户也可通过设置 `resume=True` ，加载检查点中的训练状态信息来恢复训练。当 `load_from` 和 `resume=True` 同时被设置时，执行器将加载 `load_from` 路径对应的检查点文件中的训练状态。
+
+如果仅设置 `resume=True`，执行器将会尝试从 `work_dir` 文件夹中寻找并读取最新的检查点文件
+
+```Python
+load_from = None # 加载checkpoint的路径
+resume = False # 是否 resume
+```
+
+更多可以参考 {external+mmengine:ref}`MMEngine: 加载权重或恢复训练 <加载权重或恢复训练>` 与 [OCR 进阶技巧-断点恢复训练](train_test.md#从断点恢复训练)。
+
+
+
+### 评测配置
+
+在模型验证和模型测试中，通常需要对模型精度做定量评测。MMOCR 通过评测指标(Metric)和评测器(Evaluator)来完成这一功能。更多可以参考{external+mmengine:doc}`MMEngine: 评测指标(Metric)和评测器(Evaluator) ` 和 [评测器](../basic_concepts/evaluation.md)
+
+评测部分包含两个部分，评测器和评测指标。接下来我们分部分展开讲解。
+
+#### 评测器
+
+评测器主要用来管理多个数据集以及多个 `Metric`。针对单数据集与多数据集情况，评测器分为了单数据集评测器与多数据集评测器，这两种评测器均可管理多个 `Metric`.
+
+单数据集评测器配置如下：
+
+```Python
+# 单个数据集 单个 Metric 情况
+val_evaluator = dict(
+ type='Evaluator',
+ metrics=dict())
+
+# 单个数据集 多个 Metric 情况
+val_evaluator = dict(
+ type='Evaluator',
+ metrics=[...])
+```
+
+在实现中默认为单数据集评测器，因此对单数据集评测情况下，一般情况下只需配置评测器，即为
+
+```Python
+# 单个数据集 单个 Metric 情况
+val_evaluator = dict()
+
+# 单个数据集 多个 Metric 情况
+val_evaluator = [...]
+```
+
+多数据集评测与单数据集评测存在两个位置上的不同：评测器类别与前缀。评测器类别必须为`MultiDatasetsEvaluator`且不能省略，前缀主要用来区分不同数据集在相同评测指标下的结果，请参考[多数据集评测](../basic_concepts/evaluation.md)。
+
+假设我们需要在 IC13 和 IC15 情况下测试精度，则配置如下：
+
+```Python
+# 多个数据集，单个 Metric 情况
+val_evaluator = dict(
+ type='MultiDatasetsEvaluator',
+ metrics=dict(),
+ dataset_prefixes=['IC13', 'IC15'])
+
+# 多个数据集，多个 Metric 情况
+val_evaluator = dict(
+ type='MultiDatasetsEvaluator',
+ metrics=[...],
+ dataset_prefixes=['IC13', 'IC15'])
+```
+
+#### 评测指标
+
+评测指标指不同度量精度的方法，同时可以多个评测指标共同使用，更多评测指标原理参考 {external+mmengine:doc}`MMEngine: 评测指标 `，在 MMOCR 中不同算法任务有不同的评测指标。 更多 OCR 相关的评测指标可以参考 [评测指标](../basic_concepts/evaluation.md)。
+
+文字检测: [`HmeanIOUMetric`](mmocr.evaluation.metrics.HmeanIOUMetric)
+
+文字识别: [`WordMetric`](mmocr.evaluation.metrics.WordMetric)，[`CharMetric`](mmocr.evaluation.metrics.CharMetric)， [`OneMinusNEDMetric`](mmocr.evaluation.metrics.OneMinusNEDMetric)
+
+关键信息提取: [`F1Metric`](mmocr.evaluation.metrics.F1Metric)
+
+以文本检测为例说明，在单数据集评测情况下，使用单个 `Metric`：
+
+```Python
+val_evaluator = dict(type='HmeanIOUMetric')
+```
+
+以文本识别为例，对多个数据集(IC13 和 IC15)用多个 `Metric` (`WordMetric` 和 `CharMetric`)进行评测：
+
+```Python
+# 评测部分
+val_evaluator = dict(
+ type='MultiDatasetsEvaluator',
+ metrics=[
+ dict(
+ type='WordMetric',
+ mode=['exact', 'ignore_case', 'ignore_case_symbol']),
+ dict(type='CharMetric')
+ ],
+ dataset_prefixes=['IC13', 'IC15'])
+test_evaluator = val_evaluator
+```
+
+
+
+### 可视化配置
+
+每个任务配置该任务对应的可视化器。可视化器主要用于用户模型中间结果的可视化或存储，及 val 和 test 预测结果的可视化。同时可视化的结果可以通过可视化后端储存到不同的后端，比如 WandB，TensorBoard 等。常用修改操作可见[可视化](visualization.md)。
+
+文本检测的可视化默认配置如下：
+
+```Python
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+ type='TextDetLocalVisualizer', # 不同任务有不同的可视化器
+ vis_backends=vis_backends,
+ name='visualizer')
+```
+
+## 目录结构
+
+`MMOCR` 所有配置文件都放置在 `configs` 文件夹下。为了避免配置文件过长，同时提高配置文件的可复用性以及清晰性，MMOCR 利用 Config 文件的继承特性，将配置内容的八个部分做了拆分。因为每部分均与算法任务相关，因此 MMOCR 对每个任务在 Config 中提供了一个任务文件夹，即 `textdet` (文字检测任务)、`textrecog` (文字识别任务)、`kie` (关键信息提取)。同时各个任务算法配置文件夹下进一步划分为两个部分：`_base_` 文件夹与诸多算法文件夹：
+
+1. `_base_` 文件夹下主要存放与具体算法无关的一些通用配置文件，各部分依目录分为常用的数据集、常用的训练策略以及通用的运行配置。
+
+2. 算法配置文件夹中存放与算法强相关的配置项。算法配置文件夹主要分为两部分：
+
+ 1. 算法的模型与数据流水线：OCR 领域中一般情况下数据增强策略与算法强相关，因此模型与数据流水线通常置于统一位置。
+
+ 2. 算法在制定数据集上的特定配置：用于训练和测试的配置，将分散在不同位置的 *base* 配置汇总。同时可能会修改一些`_base_`中的变量，如batch size, 数据流水线，训练策略等
+
+最后的将配置内容中的各个模块分布在不同配置文件中，最终各配置文件内容如下:
+
+
+
+
+
+
+
+最终目录结构如下：
+
+```Python
+configs
+├── textdet
+│ ├── _base_
+│ │ ├── datasets
+│ │ │ ├── icdar2015.py
+│ │ │ ├── icdar2017.py
+│ │ │ └── totaltext.py
+│ │ ├── schedules
+│ │ │ └── schedule_adam_600e.py
+│ │ └── default_runtime.py
+│ └── dbnet
+│ ├── _base_dbnet_resnet18_fpnc.py
+│ └── dbnet_resnet18_fpnc_1200e_icdar2015.py
+├── textrecog
+│ ├── _base_
+│ │ ├── datasets
+│ │ │ ├── icdar2015.py
+│ │ │ ├── icdar2017.py
+│ │ │ └── totaltext.py
+│ │ ├── schedules
+│ │ │ └── schedule_adam_base.py
+│ │ └── default_runtime.py
+│ └── crnn
+│ ├── _base_crnn_mini-vgg.py
+│ └── crnn_mini-vgg_5e_mj.py
+└── kie
+ ├── _base_
+ │ ├──datasets
+ │ └── default_runtime.py
+ └── sgdmr
+ └── sdmgr_novisual_60e_wildreceipt_openset.py
+```
+
+## 配置文件以及权重命名规则
+
+MMOCR 按照以下风格进行配置文件命名，代码库的贡献者需要遵循相同的命名规则。文件名总体分为四部分：算法信息，模块信息，训练信息和数据信息。逻辑上属于不同部分的单词之间用下划线 `'_'` 连接，同一部分有多个单词用短横线 `'-'` 连接。
+
+```Python
+{{算法信息}}_{{模块信息}}_{{训练信息}}_{{数据信息}}.py
+```
+
+- 算法信息(algorithm info)：算法名称，如 dbnet, crnn 等
+
+- 模块信息(module info)：按照数据流的顺序列举一些中间的模块，其内容依赖于算法任务，同时为了避免Config过长，会省略一些与模型强相关的模块。下面举例说明：
+
+ - 对于文字检测任务和关键信息提取任务:
+
+ ```Python
+ {{算法信息}}_{{backbone}}_{{neck}}_{{head}}_{{训练信息}}_{{数据信息}}.py
+ ```
+
+ 一般情况下 head 位置一般为算法专有的 head，因此一般省略。
+
+ - 对于文本识别任务：
+
+ ```Python
+ {{算法信息}}_{{backbone}}_{{encoder}}_{{decoder}}_{{训练信息}}_{{数据信息}}.py
+ ```
+
+ 一般情况下 encoder 和 decoder 位置一般为算法专有，因此一般省略。
+
+- 训练信息(training info)：训练策略的一些设置，包括 batch size，schedule 等
+
+- 数据信息(data info)：数据集名称、模态、输入尺寸等，如 icdar2015，synthtext 等
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/contribution_guide.md b/internlm_langchain/knowledge_base/MMOCR/content/contribution_guide.md
new file mode 100644
index 00000000..90611e8a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/contribution_guide.md
@@ -0,0 +1,135 @@
+# 贡献指南
+
+OpenMMLab 欢迎所有人参与我们项目的共建。本文档将指导您如何通过拉取请求为 OpenMMLab 项目作出贡献。
+
+## 什么是拉取请求？
+
+`拉取请求` (Pull Request), [GitHub 官方文档](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests)定义如下。
+
+```
+拉取请求是一种通知机制。你修改了他人的代码，将你的修改通知原来作者，希望他合并你的修改。
+```
+
+## 基本的工作流：
+
+1. 获取最新的代码库
+2. 从最新的 `dev-1.x` 分支创建分支进行开发
+3. 提交修改 ([不要忘记使用 pre-commit hooks!](#3-提交你的修改))
+4. 推送你的修改并创建一个 `拉取请求`
+5. 讨论、审核代码
+6. 将开发分支合并到 `dev-1.x` 分支
+
+## 具体步骤
+
+### 1. 获取最新的代码库
+
+- 当你第一次提 PR 时
+
+ 复刻 OpenMMLab 原代码库，点击 GitHub 页面右上角的 **Fork** 按钮即可
+ 
+
+ 克隆复刻的代码库到本地
+
+ ```bash
+ git clone git@github.com:XXX/mmocr.git
+ ```
+
+ 添加原代码库为上游代码库
+
+ ```bash
+ git remote add upstream git@github.com:open-mmlab/mmocr
+ ```
+
+- 从第二个 PR 起
+
+ 检出本地代码库的主分支，然后从最新的原代码库的主分支拉取更新。这里假设你正基于 `dev-1.x` 开发。
+
+ ```bash
+ git checkout dev-1.x
+ git pull upstream dev-1.x
+ ```
+
+### 2. 从 `dev-1.x` 分支创建一个新的开发分支
+
+```bash
+git checkout -b branchname
+```
+
+```{tip}
+为了保证提交历史清晰可读，我们强烈推荐您先切换到 `dev-1.x` 分支，再创建新的分支。
+```
+
+### 3. 提交你的修改
+
+- 如果你是第一次尝试贡献，请在 MMOCR 的目录下安装并初始化 pre-commit hooks。
+
+ ```bash
+ pip install -U pre-commit
+ pre-commit install
+ ```
+
+- 提交修改。在每次提交前，pre-commit hooks 都会被触发并规范化你的代码格式。
+
+ ```bash
+ # coding
+ git add [files]
+ git commit -m 'messages'
+ ```
+
+ ```{note}
+ 有时你的文件可能会在提交时被 pre-commit hooks 自动修改。这时请重新添加并提交修改后的文件。
+ ```
+
+### 4. 推送你的修改到复刻的代码库，并创建一个拉取请求
+
+- 推送当前分支到远端复刻的代码库
+
+ ```bash
+ git push origin branchname
+ ```
+
+- 创建一个拉取请求
+
+ 
+
+- 修改拉取请求信息模板，描述修改原因和修改内容。还可以在 PR 描述中，手动关联到相关的议题 (issue),（更多细节，请参考[官方文档](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)）。
+
+- 另外，如果你正在往 `dev-1.x` 分支提交代码，你还需要在创建 PR 的界面中将基础分支改为 `dev-1.x`，因为现在默认的基础分支是 `main`。
+
+ 
+
+- 你同样可以把 PR 关联给相关人员进行评审。
+
+### 5. 讨论并评审你的代码
+
+- 根据评审人员的意见修改代码，并推送修改
+
+### 6. `拉取请求`合并之后删除该分支
+
+- 在 PR 合并之后，你就可以删除该分支了。
+
+ ```bash
+ git branch -d branchname # 删除本地分支
+ git push origin --delete branchname # 删除远程分支
+ ```
+
+## PR 规范
+
+1. 使用 [pre-commit hook](https://pre-commit.com)，尽量减少代码风格相关问题
+
+2. 一个 PR 对应一个短期分支
+
+3. 粒度要细，一个PR只做一件事情，避免超大的PR
+
+ - Bad：实现 Faster R-CNN
+ - Acceptable：给 Faster R-CNN 添加一个 box head
+ - Good：给 box head 增加一个参数来支持自定义的 conv 层数
+
+4. 每次 Commit 时需要提供清晰且有意义 commit 信息
+
+5. 提供清晰且有意义的`拉取请求`描述
+
+ - 标题写明白任务名称，一般格式:\[Prefix\] Short description of the pull request (Suffix)
+ - prefix: 新增功能 \[Feature\], 修 bug \[Fix\], 文档相关 \[Docs\], 开发中 \[WIP\] (暂时不会被review)
+ - 描述里介绍`拉取请求`的主要修改内容，结果，以及对其他部分的影响, 参考`拉取请求`模板
+ - 关联相关的`议题` (issue) 和其他`拉取请求`
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/convention.md b/internlm_langchain/knowledge_base/MMOCR/content/convention.md
new file mode 100644
index 00000000..a094becc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/convention.md
@@ -0,0 +1,3 @@
+# 开发默认约定\[待更新\]
+
+待更新
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/data_flow.md b/internlm_langchain/knowledge_base/MMOCR/content/data_flow.md
new file mode 100644
index 00000000..a07a158b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/data_flow.md
@@ -0,0 +1,3 @@
+# 数据流\[待更新\]
+
+待更新
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/dataset.md b/internlm_langchain/knowledge_base/MMOCR/content/dataset.md
new file mode 100644
index 00000000..ac69703b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/dataset.md
@@ -0,0 +1,254 @@
+# 数据集迁移
+
+在 OpenMMLab 2.0 系列算法库基于 [MMEngine](https://github.com/open-mmlab/mmengine) 设计了统一的数据集基类 [BaseDataset](mmengine.dataset.BaseDataset)，并制定了数据集标注文件规范。基于此，我们在 MMOCR 1.0 版本中重构了 OCR 任务数据集基类 [`OCRDataset`](mmocr.datasets.OCRDataset)。以下文档将介绍 MMOCR 中新旧数据集格式的区别，以及如何将旧数据集迁移至新版本中。对于暂不方便进行数据迁移的用户，我们也在[第三节](#兼容性)提供了临时的代码兼容方案。
+
+```{note}
+关键信息抽取任务仍采用原有的 WildReceipt 数据集标注格式。
+```
+
+## 旧版数据格式回顾
+
+针对不同任务，MMOCR 0.x 版本实现了多种不同的数据集类型，如文本检测任务的 `IcdarDataset`，`TextDetDataset`；文本识别任务的 `OCRDataset`，`OCRSegDataset` 等。而不同的数据集类型同时还可能存在多种不同的标注及文件存储后端，如 `.txt`、`.json`、`.jsonl` 等，使得用户在自定义数据集时需要配置各类数据加载器 (`Loader`) 以及数据解析器 (`Parser`)。这不仅增加了用户的使用难度，也带来了许多问题和隐患。例如，以 `.txt` 格式存储的简单 `OCDDataset` 在遇到包含空格的文本标注时将会报错。
+
+### 文本检测
+
+文本检测任务中，`IcdarDataset` 采用了与通用目标检测 COCO 数据集一致的标注格式。
+
+```json
+{
+ "images": [
+ {
+ "id": 1,
+ "width": 800,
+ "height": 600,
+ "file_name": "test.jpg"
+ }
+ ],
+ "annotations": [
+ {
+ "id": 1,
+ "image_id": 1,
+ "category_id": 1,
+ "bbox": [0,0,10,10],
+ "segmentation": [
+ [0,0,10,0,10,10,0,10]
+ ],
+ "area": 100,
+ "iscrowd": 0
+ }
+ ]
+}
+```
+
+而 `TextDetDataset` 则采用了 JSON Line 的存储格式，将类似 COCO 格式的标签转换成文本存放在 `.txt` 或 `.jsonl` 格式文件中。
+
+```text
+{"file_name": "test/img_2.jpg", "height": 720, "width": 1280, "annotations": [{"iscrowd": 0, "category_id": 1, "bbox": [602.0, 173.0, 33.0, 24.0], "segmentation": [[602, 173, 635, 175, 634, 197, 602, 196]]}, {"iscrowd": 0, "category_id": 1, "bbox": [734.0, 310.0, 58.0, 54.0], "segmentation": [[734, 310, 792, 320, 792, 364, 738, 361]]}]}
+{"file_name": "test/img_5.jpg", "height": 720, "width": 1280, "annotations": [{"iscrowd": 1, "category_id": 1, "bbox": [405.0, 409.0, 32.0, 52.0], "segmentation": [[408, 409, 437, 436, 434, 461, 405, 433]]}, {"iscrowd": 1, "category_id": 1, "bbox": [435.0, 434.0, 8.0, 33.0], "segmentation": [[437, 434, 443, 440, 441, 467, 435, 462]]}]}
+```
+
+### 文本识别
+
+对于文本识别任务，MMOCR 0.x 版本中存在两种数据标注格式。其中 `.txt` 格式的标注文件每一行共有两个字段，分别存放了图片名以及标注的文本内容，并以空格分隔。
+
+```text
+img1.jpg OpenMMLab
+img2.jpg MMOCR
+```
+
+而 JSON Line 格式则使用 `json.dumps` 将 JSON 格式的标注转换为文本内容后存放在 .jsonl 文件中，其内容形似一个字典，将文件名和文本标注信息分别存放在 `filename` 和 `text` 字段中。
+
+```json
+{"filename": "img1.jpg", "text": "OpenMMLab"}
+{"filename": "img2.jpg", "text": "MMOCR"}
+```
+
+## 新版数据格式
+
+为解决 0.x 版本中数据集格式过于混杂的情况，MMOCR 1.x 采用了基于 MMEngine 设计的统一数据标准。每一个数据标注文件存放在 `.json` 文件中，并使用类似字典的格式分别存放了数据集的元信息（`metainfo`）与具体的标注内容（`data_list`）。
+
+```json
+{
+ "metainfo":
+ {
+ "classes": ("cat", "dog"),
+ // ...
+ },
+ "data_list":
+ [
+ {
+ "img_path": "xxx/xxx_0.jpg",
+ "img_label": 0,
+ // ...
+ },
+ // ...
+ ]
+}
+```
+
+基于此，我们针对 MMOCR 特有的任务设计了 `TextDetDataset`、`TextRecogDataset`。
+
+### 文本检测
+
+#### 新版格式介绍
+
+`TextDetDataset` 中存放了文本检测任务所需的边界盒标注、文件名等信息。由于文本检测任务中只有 1 个类别，因此我们将其类别 id 默认设置为 0，而背景类则为 1。`tests/data/det_toy_dataset/instances_test.json` 中存放了一个文本检测任务的数据标注示例，用户可以参考该文件来将自己的数据集转换为我们支持的格式。
+
+```json
+{
+ "metainfo":
+ {
+ "dataset_type": "TextDetDataset",
+ "task_name": "textdet",
+ "category": [{"id": 0, "name": "text"}]
+ },
+ "data_list":
+ [
+ {
+ "img_path": "test_img.jpg",
+ "height": 640,
+ "width": 640,
+ "instances":
+ [
+ {
+ "polygon": [0, 0, 0, 10, 10, 20, 20, 0],
+ "bbox": [0, 0, 10, 20],
+ "bbox_label": 0,
+ "ignore": False
+ },
+ // ...
+ ]
+ }
+ ]
+}
+```
+
+其中，`bbox` 字段的格式为 `[min_x, min_y, max_x, max_y]`。
+
+#### 迁移脚本
+
+为帮助用户将旧版本标注文件迁移至新格式，我们提供了迁移脚本。使用方法如下：
+
+```bash
+python tools/dataset_converters/textdet/data_migrator.py ${IN_PATH} ${OUT_PATH}
+```
+
+| 参数 | 类型 | 说明 |
+| -------- | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| in_path | str | （必须）旧版标注的路径 |
+| out_path | str | （必须）新版标注的路径 |
+| --task | 'auto', 'textdet', 'textspotter' | 指定输出数据集标注的所兼容的任务。若指定为 textdet ，则不会转存 coco 格式中的 text 字段。默认为 auto，即根据旧版标注的格式自动决定输出的标注格式。 |
+
+### 文本识别
+
+#### 新版格式介绍
+
+`TextRecogDataset` 中存放了文本识别任务所需的文本内容，通常而言，文本识别数据集中的每一张图片都仅包含一个文本实例。我们在 `tests/data/rec_toy_dataset/labels.json` 提供了一个简单的识别数据格式示例，用户可以参考该文件以进一步了解其中的细节。
+
+```json
+{
+ "metainfo":
+ {
+ "dataset_type": "TextRecogDataset",
+ "task_name": "textrecog",
+ },
+ "data_list":
+ [
+ {
+ "img_path": "test_img.jpg",
+ "instances":
+ [
+ {
+ "text": "GRAND"
+ }
+ ]
+ }
+ ]
+}
+```
+
+#### 迁移脚本
+
+为帮助用户将旧版本标注文件迁移至新格式，我们提供了迁移脚本。使用方法如下：
+
+```bash
+python tools/dataset_converters/textrecog/data_migrator.py ${IN_PATH} ${OUT_PATH} --format ${txt, jsonl, lmdb}
+```
+
+| 参数 | 类型 | 说明 |
+| -------- | ---------------------- | -------------------------- |
+| in_path | str | （必须）旧版标注的路径 |
+| out_path | str | （必须）新版标注的路径 |
+| --format | 'txt', 'jsonl', 'lmdb' | 指定旧版数据集标注的格式。 |
+
+## 兼容性
+
+考虑到用户对数据迁移所需的成本，我们在 MMOCR 1.x 版本中暂时对 MMOCR 0.x 旧版本格式进行了兼容。
+
+```{note}
+用于兼容旧数据格式的代码和组件可能在未来的版本中被完全移除。因此，我们强烈建议用户将数据集迁移至新的数据格式标准。
+```
+
+具体而言，我们提供了三个临时的数据集类 [IcdarDataset](mmocr.datasets.IcdarDataset), [RecogTextDataset](mmocr.datasets.RecogTextDataset), [RecogLMDBDataset](mmocr.datasets.RecogLMDBDataset) 来兼容旧格式的标注文件。分别对应了 MMOCR 0.x 版本中的文本检测数据集 `IcdarDataset`，`.txt`、`.jsonl` 和 `LMDB` 格式的文本识别数据标注。其使用方式与 0.x 版本一致。
+
+1. [IcdarDataset](mmocr.datasets.IcdarDataset) 支持 0.x 版本文本检测任务的 COCO 标注格式。只需要在 `configs/textdet/_base_/datasets` 中添加新的数据集配置文件，并指定其数据集类型为 `IcdarDataset` 即可。
+
+ ```python
+ data_root = 'data/det/icdar2015'
+
+ train_dataset = dict(
+ type='IcdarDataset',
+ data_root=data_root,
+ ann_file='instances_training.json',
+ data_prefix=dict(img_path='imgs/'),
+ filter_cfg=dict(filter_empty_gt=True, min_size=32),
+ pipeline=None)
+ ```
+
+2. [RecogTextDataset](mmocr.datasets.RecogTextDataset) 支持 0.x 版本文本识别任务的 `txt` 和 `jsonl` 标注格式。只需要在 `configs/textrecog/_base_/datasets` 中添加新的数据集配置文件，并指定其数据集类型为 `RecogTextDataset` 即可。例如，以下示例展示了如何配置并读取 toy dataset 中的旧格式标签 `old_label.txt` 以及 `old_label.jsonl`。
+
+ ```python
+ data_root = 'tests/data/rec_toy_dataset/'
+
+ # 读取旧版 txt 格式识别数据标签
+ txt_dataset = dict(
+ type='RecogTextDataset',
+ data_root=data_root,
+ ann_file='old_label.txt',
+ data_prefix=dict(img_path='imgs'),
+ parser_cfg=dict(
+ type='LineStrParser',
+ keys=['filename', 'text'],
+ keys_idx=[0, 1]),
+ pipeline=[])
+
+ # 读取旧版 json line 格式识别数据标签
+ jsonl_dataset = dict(
+ type='RecogTextDataset',
+ data_root=data_root,
+ ann_file='old_label.jsonl',
+ data_prefix=dict(img_path='imgs'),
+ parser_cfg=dict(
+ type='LineJsonParser',
+ keys=['filename', 'text'],
+ pipeline=[])
+ ```
+
+3. [RecogLMDBDataset](mmocr.datasets.RecogLMDBDataset) 支持 0.x 版本文本识别任务**图像+文字**的 `LMDB` 标注格式。只需要在 `configs/textrecog/_base_/datasets` 中添加新的数据集配置文件，并指定其数据集类型为 `RecogLMDBDataset` 即可。例如，以下示例展示了如何配置并读取 toy dataset 中的 `imgs.lmdb`，该 `lmdb` 文件**包含标签和图像**。
+
+ ```python
+ # 将数据集类型设定为 RecogLMDBDataset
+ data_root = 'tests/data/rec_toy_dataset/'
+
+ lmdb_dataset = dict(
+ type='RecogLMDBDataset',
+ data_root=data_root,
+ ann_file='imgs.lmdb',
+ pipeline=None)
+ ```
+
+ 还需把 `train_pipeline` 及 `test_pipeline` 中的数据读取方法如 [`LoadImageFromFile`](mmocr.datasets.transforms.LoadImageFromFile) 替换为 [`LoadImageFromNDArray`](mmocr.datasets.transforms.LoadImageFromNDArray)：
+
+ ```python
+ train_pipeline = [dict(type='LoadImageFromNDArray')]
+ ```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/dataset_prepare.md b/internlm_langchain/knowledge_base/MMOCR/content/dataset_prepare.md
new file mode 100644
index 00000000..a0e3d0ba
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/dataset_prepare.md
@@ -0,0 +1,153 @@
+# 数据集准备
+
+## 前言
+
+经过数十年的发展，OCR 领域涌现出了一系列的相关数据集，这些数据集往往采用风格各异的格式来提供文本的标注文件，使得用户在使用这些数据集时不得不进行格式转换。因此，为了方便用户进行数据集准备，我们提供了[一键式的数据准备脚本](./data_prepare/dataset_preparer.md)，使得用户仅需使用一行命令即可完成数据集准备的全部步骤。
+
+在这一节，我们将介绍一个典型的数据集准备流程：
+
+1. [下载数据集并将其格式转换为 MMOCR 支持的格式](#数据集下载及格式转换)
+2. [修改配置文件](#修改配置文件)
+
+然而，如果你已经有了 MMOCR 支持的格式的数据集，那么第一步就不是必须的。你可以阅读[数据集类及标注格式](../basic_concepts/datasets.md#数据集类及标注格式)来了解更多细节。
+
+## 数据集下载及格式转换
+
+以 ICDAR 2015 数据集的文本检测任务准备步骤为例，你可以执行以下命令来完成数据集准备：
+
+```shell
+python tools/dataset_converters/prepare_dataset.py icdar2015 --task textdet
+```
+
+命令执行完成后，数据集将被下载并转换至 MMOCR 格式，文件目录结构如下：
+
+```text
+data/icdar2015
+├── textdet_imgs
+│ ├── test
+│ └── train
+├── textdet_test.json
+└── textdet_train.json
+```
+
+数据准备完毕以后，你也可以通过使用我们提供的数据集浏览工具 [browse_dataset.py](./useful_tools.md#数据集可视化工具) 来可视化数据集的标签是否被正确生成，例如：
+
+```bash
+python tools/analysis_tools/browse_dataset.py configs/textdet/_base_/datasets/icdar2015.py
+```
+
+## 修改配置文件
+
+### 单数据集训练
+
+在使用新的数据集时，我们需要对其图像、标注文件的路径等基础信息进行配置。`configs/xxx/_base_/datasets/` 路径下已预先配置了 MMOCR 中常用的数据集（当你使用 `prepare_dataset.py` 来准备数据集时，这个配置文件通常会在数据集准备就绪后自动生成），这里我们以 ICDAR 2015 数据集为例（见 `configs/textdet/_base_/datasets/icdar2015.py`）：
+
+```Python
+icdar2015_textdet_data_root = 'data/icdar2015' # 数据集根目录
+
+# 训练集配置
+icdar2015_textdet_train = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textdet_data_root, # 数据根目录
+ ann_file='textdet_train.json', # 标注文件名称
+ filter_cfg=dict(filter_empty_gt=True, min_size=32), # 数据过滤
+ pipeline=None)
+# 测试集配置
+icdar2015_textdet_test = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textdet_data_root,
+ ann_file='textdet_test.json',
+ test_mode=True,
+ pipeline=None)
+```
+
+在配置好数据集后，我们还需要在相应的算法模型配置文件中导入想要使用的数据集。例如，在 ICDAR 2015 数据集上训练 "DBNet_R18" 模型：
+
+```Python
+_base_ = [
+ '_base_dbnet_r18_fpnc.py',
+ '../_base_/datasets/icdar2015.py', # 导入数据集配置文件
+ '../_base_/default_runtime.py',
+ '../_base_/schedules/schedule_sgd_1200e.py',
+]
+
+icdar2015_textdet_train = _base_.icdar2015_textdet_train # 指定训练集
+icdar2015_textdet_train.pipeline = _base_.train_pipeline # 指定训练集使用的数据流水线
+icdar2015_textdet_test = _base_.icdar2015_textdet_test # 指定测试集
+icdar2015_textdet_test.pipeline = _base_.test_pipeline # 指定测试集使用的数据流水线
+
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=icdar2015_textdet_train) # 在 train_dataloader 中指定使用的训练数据集
+
+val_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=icdar2015_textdet_test) # 在 val_dataloader 中指定使用的验证数据集
+
+test_dataloader = val_dataloader
+```
+
+### 多数据集训练
+
+此外，基于 [`ConcatDataset`](mmocr.datasets.ConcatDataset)，用户还可以使用多个数据集组合来训练或测试模型。用户只需在配置文件中将 dataloader 中的 dataset 类型设置为 `ConcatDataset`，并指定对应的数据集列表即可。
+
+```Python
+train_list = [ic11, ic13, ic15]
+train_dataloader = dict(
+ dataset=dict(
+ type='ConcatDataset', datasets=train_list, pipeline=train_pipeline))
+```
+
+例如，以下配置使用了 MJSynth 数据集进行训练，并使用 6 个学术数据集（CUTE80, IIIT5K, SVT, SVTP, ICDAR2013, ICDAR2015）进行测试。
+
+```Python
+_base_ = [ # 导入所有需要使用的数据集配置
+ '../_base_/datasets/mjsynth.py',
+ '../_base_/datasets/cute80.py',
+ '../_base_/datasets/iiit5k.py',
+ '../_base_/datasets/svt.py',
+ '../_base_/datasets/svtp.py',
+ '../_base_/datasets/icdar2013.py',
+ '../_base_/datasets/icdar2015.py',
+ '../_base_/default_runtime.py',
+ '../_base_/schedules/schedule_adadelta_5e.py',
+ '_base_crnn_mini-vgg.py',
+]
+
+# 训练集列表
+train_list = [_base_.mjsynth_textrecog_train]
+# 测试集列表
+test_list = [
+ _base_.cute80_textrecog_test, _base_.iiit5k_textrecog_test, _base_.svt_textrecog_test,
+ _base_.svtp_textrecog_test, _base_.icdar2013_textrecog_test, _base_.icdar2015_textrecog_test
+]
+
+# 使用 ConcatDataset 来级联列表中的多个数据集
+train_dataset = dict(
+ type='ConcatDataset', datasets=train_list, pipeline=_base_.train_pipeline)
+test_dataset = dict(
+ type='ConcatDataset', datasets=test_list, pipeline=_base_.test_pipeline)
+
+train_dataloader = dict(
+ batch_size=192 * 4,
+ num_workers=32,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=train_dataset)
+
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=test_dataset)
+
+val_dataloader = test_dataloader
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/dataset_preparer.md b/internlm_langchain/knowledge_base/MMOCR/content/dataset_preparer.md
new file mode 100644
index 00000000..f7558336
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/dataset_preparer.md
@@ -0,0 +1,780 @@
+# 数据准备 (Beta)
+
+```{note}
+Dataset Preparer 目前仍处在公测阶段，欢迎尝鲜试用！如遇到任何问题，请及时向我们反馈。
+```
+
+## 一键式数据准备脚本
+
+MMOCR 提供了统一的一站式数据集准备脚本 `prepare_dataset.py`。
+
+仅需一行命令即可完成数据的下载、解压、格式转换，及基础配置的生成。
+
+```bash
+python tools/dataset_converters/prepare_dataset.py [-h] [--nproc NPROC] [--task {textdet,textrecog,textspotting,kie}] [--splits SPLITS [SPLITS ...]] [--lmdb] [--overwrite-cfg] [--dataset-zoo-path DATASET_ZOO_PATH] datasets [datasets ...]
+```
+
+| 参数 | 类型 | 说明 |
+| ------------------ | -------------------------- | ----------------------------------------------------------------------------------------------------- |
+| dataset_name | str | （必须）需要准备的数据集名称。 |
+| --nproc | str | 使用的进程数，默认为 4。 |
+| --task | str | 将数据集格式转换为指定任务的 MMOCR 格式。可选项为： 'textdet', 'textrecog', 'textspotting' 和 'kie'。 |
+| --splits | \['train', 'val', 'test'\] | 希望准备的数据集分割，可以接受多个参数。默认为 `train val test`。 |
+| --lmdb | str | 把数据储存为 LMDB 格式，仅当任务为 `textrecog` 时生效。 |
+| --overwrite-cfg | str | 若数据集的基础配置已经在 `configs/{task}/_base_/datasets` 中存在，依然重写该配置 |
+| --dataset-zoo-path | str | 存放数据库配置文件的路径。若不指定，则默认为 `./dataset_zoo` |
+
+例如，以下命令展示了如何使用该脚本为 ICDAR2015 数据集准备文本检测任务所需的数据。
+
+```bash
+python tools/dataset_converters/prepare_dataset.py icdar2015 --task textdet --overwrite-cfg
+```
+
+该脚本也支持同时准备多个数据集，例如，以下命令展示了如何使用该脚本同时为 ICDAR2015 和 TotalText 数据集准备文本识别任务所需的数据。
+
+```bash
+python tools/dataset_converters/prepare_dataset.py icdar2015 totaltext --task textrecog --overwrite-cfg
+```
+
+进一步了解 Dataset Preparer 支持的数据集，您可以浏览[支持的数据集文档](./datasetzoo.md)。一些需要手动准备的数据集也列在了 [文字检测](./det.md) 和 [文字识别](./recog.md) 内。
+
+对于中国境内的用户，我们也推荐通过开源数据平台[OpenDataLab](https://opendatalab.com/)来下载数据，以获得更好的下载体验。数据下载后，参考脚本中 `data_obtainer` 的 `save_name` 字段，将文件放在 `data/cache/` 下并重新运行脚本即可。
+
+## 进阶用法
+
+### LMDB 格式
+
+在文本识别任务中，通常使用 LMDB 格式来存储数据，以加快数据的读取速度。在使用 `prepare_dataset.py` 脚本准备数据时，可以通过 `--lmdb` 参数来指定将数据转换为 LMDB 格式。例如：
+
+```bash
+python tools/dataset_converters/prepare_dataset.py icdar2015 --task textrecog --lmdb
+```
+
+数据集准备完成后，Dataset Preparer 会在 `configs/textrecog/_base_/datasets/` 中生成 `icdar2015_lmdb.py` 配置。你可以继承该配置，并将 `dataloader` 指向 LMDB 数据集。然而，LMDB 数据集的读取需要配合 [`LoadImageFromNDArray`](mmocr.datasets.transforms.LoadImageFromNDArray)，因此你也同样需要修改 `pipeline`。
+
+例如，想要将 `configs/textrecog/crnn/crnn_mini-vgg_5e_mj.py` 的训练集改为刚刚生成的 icdar2015，则需要作如下修改：
+
+1. 修改 `configs/textrecog/crnn/crnn_mini-vgg_5e_mj.py`:
+
+ ```python
+ _base_ = [
+ '../_base_/datasets/icdar2015_lmdb.py', # 指向 icdar2015 lmdb 数据集
+ ... # 省略
+ ]
+
+ train_list = [_base_.icdar2015_lmdb_textrecog_train]
+ ...
+ ```
+
+2. 修改 `configs/textrecog/crnn/_base_crnn_mini-vgg.py` 中的 `train_pipeline`, 将 `LoadImageFromFile` 改为 `LoadImageFromNDArray`：
+
+ ```python
+ train_pipeline = [
+ dict(
+ type='LoadImageFromNDArray',
+ color_type='grayscale',
+ file_client_args=file_client_args,
+ ignore_empty=True,
+ min_size=2),
+ ...
+ ]
+ ```
+
+## 设计
+
+OCR 数据集数量众多，不同的数据集有着不同的语言，不同的标注格式，不同的场景等。 数据集的使用情况一般有两种，一种是快速的了解数据集的相关信息，另一种是在使用数据集训练模型。为了满足这两种使用场景MMOCR 提供数据集自动化准备脚本，数据集自动化准备脚本使用了模块化的设计，极大地增强了扩展性，用户能够很方便地配置其他公开数据集或私有数据集。数据集自动化准备脚本的配置文件被统一存储在 `dataset_zoo/` 目录下，用户可以在该目录下找到所有已由 MMOCR 官方支持的数据集准备脚本配置文件。该文件夹的目录结构如下：
+
+```text
+dataset_zoo/
+├── icdar2015
+│ ├── metafile.yml
+│ ├── sample_anno.md
+│ ├── textdet.py
+│ ├── textrecog.py
+│ └── textspotting.py
+└── wildreceipt
+ ├── metafile.yml
+ ├── sample_anno.md
+ ├── kie.py
+ ├── textdet.py
+ ├── textrecog.py
+ └── textspotting.py
+```
+
+### 数据集相关信息
+
+数据集的相关信息包括数据集的标注格式、数据集的标注示例、数据集的基本统计信息等。虽然在每个数据集的官网中都有这些信息，但是这些信息分散在各个数据集的官网中，用户需要花费大量的时间来挖掘数据集的基本信息。因此，MMOCR 设计了一些范式，它可以帮助用户快速了解数据集的基本信息。 MMOCR 将数据集的相关信息分为两个部分，一部分是数据集的基本信息包括包括发布年份，论文作者，以及版权等其他信息，另一部分是数据集的标注信息，包括数据集的标注格式、数据集的标注示例。每一部分 MMOCR 都会提供一个范式，贡献者可以根据范式来填写数据集的基本信息，使用用户就可以快速了解数据集的基本信息。 根据数据集的基本信息 MMOCR 提供了一个 `metafile.yml` 文件，其中存放了对应数据集的基本信息，包括发布年份，论文作者，以及版权等其他信息，这样用户就可以快速了解数据集的基本信息。该文件在数据集准备过程中并不是强制要求的（因此用户在使用添加自己的私有数据集时可以忽略该文件），但为了用户更好地了解各个公开数据集的信息，MMOCR 建议用户在使用数据集准备脚本前阅读对应的元文件信息，以了解该数据集的特征是否符合用户需求。MMOCR 以 ICDAR2015 作为示例， 其示例内容如下所示：
+
+```yaml
+Name: 'Incidental Scene Text IC15'
+Paper:
+ Title: ICDAR 2015 Competition on Robust Reading
+ URL: https://rrc.cvc.uab.es/files/short_rrc_2015.pdf
+ Venue: ICDAR
+ Year: '2015'
+ BibTeX: '@inproceedings{karatzas2015icdar,
+ title={ICDAR 2015 competition on robust reading},
+ author={Karatzas, Dimosthenis and Gomez-Bigorda, Lluis and Nicolaou, Anguelos and Ghosh, Suman and Bagdanov, Andrew and Iwamura, Masakazu and Matas, Jiri and Neumann, Lukas and Chandrasekhar, Vijay Ramaseshan and Lu, Shijian and others},
+ booktitle={2015 13th international conference on document analysis and recognition (ICDAR)},
+ pages={1156--1160},
+ year={2015},
+ organization={IEEE}}'
+Data:
+ Website: https://rrc.cvc.uab.es/?ch=4
+ Language:
+ - English
+ Scene:
+ - Natural Scene
+ Granularity:
+ - Word
+ Tasks:
+ - textdet
+ - textrecog
+ - textspotting
+ License:
+ Type: CC BY 4.0
+ Link: https://creativecommons.org/licenses/by/4.0/
+```
+
+具体地，MMOCR 在下表中列出每个字段对应的含义：
+
+| 字段名 | 含义 |
+| :--------------- | :-------------------------------------------------------------------- |
+| Name | 数据集的名称 |
+| Paper.Title | 数据集论文的标题 |
+| Paper.URL | 数据集论文的链接 |
+| Paper.Venue | 数据集论文发表的会议/期刊名称 |
+| Paper.Year | 数据集论文发表的年份 |
+| Paper.BibTeX | 数据集论文的引用的 BibTex |
+| Data.Website | 数据集的官方网站 |
+| Data.Language | 数据集支持的语言 |
+| Data.Scene | 数据集支持的场景，如 `Natural Scene`, `Document`, `Handwritten` 等 |
+| Data.Granularity | 数据集支持的粒度，如 `Character`, `Word`, `Line` 等 |
+| Data.Tasks | 数据集支持的任务，如 `textdet`, `textrecog`, `textspotting`, `kie` 等 |
+| Data.License | 数据集的许可证信息，如果不存在许可证，则使用 `N/A` 填充 |
+| Data.Format | 数据集标注文件的格式，如 `.txt`, `.xml`, `.json` 等 |
+| Data.Keywords | 数据集的特性关键词，如 `Horizontal`, `Vertical`, `Curved` 等 |
+
+对于数据集的标注信息，MMOCR 提供了一个 `sample_anno.md` 文件，用户可以根据范式来填写数据集的标注信息，这样用户就可以快速了解数据集的标注信息。MMOCR 以 ICDAR2015 作为示例， 其示例内容如下所示：
+
+````markdown
+ **Text Detection**
+
+ ```text
+ # x1,y1,x2,y2,x3,y3,x4,y4,trans
+
+ 377,117,463,117,465,130,378,130,Genaxis Theatre
+ 493,115,519,115,519,131,493,131,[06]
+ 374,155,409,155,409,170,374,170,###
+ ```
+````
+
+`sample_anno.md` 中包含数据集针对不同任务的标注信息，包含标注文件的格式(text 对应的是 txt 文件，标注文件的格式也可以在 meta.yml 中找到)，标注的示例。
+
+通过上述两个文件的信息，用户就可以快速了解数据集的基本信息，同时 MMOCR 汇总了所有数据集的基本信息，用户可以在 [Overview](.overview.md) 中查看所有数据集的基本信息。
+
+### 数据集使用
+
+经过数十年的发展，OCR 领域涌现出了一系列的相关数据集，这些数据集往往采用风格各异的格式来提供文本的标注文件，使得用户在使用这些数据集时不得不进行格式转换。因此，为了方便用户进行数据集准备，我们设计了 Dataset Preaprer，帮助用户快速将数据集准备为 MMOCR 支持的格式, 详见[数据格式文档](../../basic_concepts/datasets.md)。下图展示了 Dataset Preparer 的典型运行流程。
+
+
+
+由图可见，Dataset Preparer 在运行时，会依次执行以下操作：
+
+1. 对训练集、验证集和测试集，由各 preparer 进行：
+
+ 1. [数据集的下载、解压、移动（Obtainer）](#数据集下载解压移动-obtainer)
+ 2. [匹配标注与图像（Gatherer）](#数据集收集-gatherer)
+ 3. [解析原标注（Parser）](#数据集解析-parser)
+ 4. [打包标注为统一格式（Packer）](#数据集转换-packer)
+ 5. [保存标注（Dumper）](#标注保存-dumper)
+
+2. 删除文件（Delete）
+
+3. 生成数据集的配置文件（Config Generator）
+
+为了便于应对各种数据集的情况，MMOCR 将每个部分均设计为可插拔的模块，并允许用户通过 dataset_zoo/ 下的配置文件对数据集准备流程进行配置。这些配置文件采用了 Python 格式，其使用方法与 MMOCR 算法库的其他配置文件完全一致，详见[配置文件文档](../config.md)。
+
+在 `dataset_zoo/` 下，每个数据集均占有一个文件夹，文件夹下会以任务名命名配置文件，以区分不同任务下的配置。以 ICDAR2015 文字检测部分为例，示例配置 `dataset_zoo/icdar2015/textdet.py` 如下所示：
+
+```python
+data_root = 'data/icdar2015'
+cache_path = 'data/cache'
+train_preparer = dict(
+ obtainer=dict(
+ type='NaiveDataObtainer',
+ cache_path=cache_path,
+ files=[
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/ch4_training_images.zip',
+ save_name='ic15_textdet_train_img.zip',
+ md5='c51cbace155dcc4d98c8dd19d378f30d',
+ content=['image'],
+ mapping=[['ic15_textdet_train_img', 'textdet_imgs/train']]),
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/'
+ 'ch4_training_localization_transcription_gt.zip',
+ save_name='ic15_textdet_train_gt.zip',
+ md5='3bfaf1988960909014f7987d2343060b',
+ content=['annotation'],
+ mapping=[['ic15_textdet_train_gt', 'annotations/train']]),
+ ]),
+ gatherer=dict(
+ type='PairGatherer',
+ img_suffixes=['.jpg', '.JPG'],
+ rule=[r'img_(\d+)\.([jJ][pP][gG])', r'gt_img_\1.txt']),
+ parser=dict(type='ICDARTxtTextDetAnnParser', encoding='utf-8-sig'),
+ packer=dict(type='TextDetPacker'),
+ dumper=dict(type='JsonDumper'),
+)
+
+test_preparer = dict(
+ obtainer=dict(
+ type='NaiveDataObtainer',
+ cache_path=cache_path,
+ files=[
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/ch4_test_images.zip',
+ save_name='ic15_textdet_test_img.zip',
+ md5='97e4c1ddcf074ffcc75feff2b63c35dd',
+ content=['image'],
+ mapping=[['ic15_textdet_test_img', 'textdet_imgs/test']]),
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/'
+ 'Challenge4_Test_Task4_GT.zip',
+ save_name='ic15_textdet_test_gt.zip',
+ md5='8bce173b06d164b98c357b0eb96ef430',
+ content=['annotation'],
+ mapping=[['ic15_textdet_test_gt', 'annotations/test']]),
+ ]),
+ gatherer=dict(
+ type='PairGatherer',
+ img_suffixes=['.jpg', '.JPG'],
+ rule=[r'img_(\d+)\.([jJ][pP][gG])', r'gt_img_\1.txt']),
+ parser=dict(type='ICDARTxtTextDetAnnParser', encoding='utf-8-sig'),
+ packer=dict(type='TextDetPacker'),
+ dumper=dict(type='JsonDumper'),
+)
+
+delete = ['annotations', 'ic15_textdet_test_img', 'ic15_textdet_train_img']
+config_generator = dict(type='TextDetConfigGenerator')
+```
+
+#### 数据集下载、解压、移动 (Obtainer)
+
+Dataset Preparer 中，`obtainer` 模块负责了数据集的下载、解压和移动。如今，MMOCR 暂时只提供了 `NaiveDataObtainer`。通常来说，内置的 `NaiveDataObtainer` 即可完成绝大部分可以通过直链访问的数据集的下载，并支持解压、移动文件和重命名等操作。然而，MMOCR 暂时不支持自动下载存储在百度或谷歌网盘等需要登陆才能访问资源的数据集。 这里简要介绍一下 `NaiveDataObtainer`.
+
+| 字段名 | 含义 |
+| ---------- | ---------------------------------------------------------- |
+| cache_path | 数据集缓存路径，用于存储数据集准备过程中下载的压缩包等文件 |
+| data_root | 数据集存储的根目录 |
+| files | 数据集文件列表，用于描述数据集的下载信息 |
+
+`files` 字段是一个列表，列表中的每个元素都是一个字典，用于描述一个数据集文件的下载信息。如下表所示：
+
+| 字段名 | 含义 |
+| ----------------- | -------------------------------------------------------------------- |
+| url | 数据集文件的下载链接 |
+| save_name | 数据集文件的保存名称 |
+| md5 (可选) | 数据集文件的 md5 值，用于校验下载的文件是否完整 |
+| split （可选） | 数据集文件所属的数据集划分，如 `train`，`test` 等，该字段可以空缺 |
+| content （可选） | 数据集文件的内容，如 `image`，`annotation` 等，该字段可以空缺 |
+| mapping （可选） | 数据集文件的解压映射，用于指定解压后的文件存储的位置，该字段可以空缺 |
+
+同时，Dataset Preparer 存在以下约定：
+
+- 不同类型的数据集的图片统一移动到对应类别 `{taskname}_imgs/{split}/`文件夹下，如 `textdet_imgs/train/`。
+- 对于一个标注文件包含所有图像的标注信息的情况，标注移到到`annotations/{split}.*`文件中。 如 `annotations/train.json`。
+- 对于一个标注文件包含一个图像的标注信息的情况，所有的标注文件移动到`annotations/{split}/`文件中。 如 `annotations/train/`。
+- 对于一些其他的特殊情况，比如所有训练、测试、验证的图像都在一个文件夹下，可以将图像移动到自己设定的文件夹下，比如 `{taskname}_imgs/imgs/`，同时要在后续的 `gatherer` 模块中指定图像的存储位置。
+
+示例配置如下：
+
+```python
+ obtainer=dict(
+ type='NaiveDataObtainer',
+ cache_path=cache_path,
+ files=[
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/ch4_training_images.zip',
+ save_name='ic15_textdet_train_img.zip',
+ md5='c51cbace155dcc4d98c8dd19d378f30d',
+ content=['image'],
+ mapping=[['ic15_textdet_train_img', 'textdet_imgs/train']]),
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/'
+ 'ch4_training_localization_transcription_gt.zip',
+ save_name='ic15_textdet_train_gt.zip',
+ md5='3bfaf1988960909014f7987d2343060b',
+ content=['annotation'],
+ mapping=[['ic15_textdet_train_gt', 'annotations/train']]),
+ ]),
+```
+
+#### 数据集收集 (Gatherer)
+
+`gatherer` 遍历数据集目录下的文件，将图像与标注文件一一对应，并整理出一份文件列表供 `parser` 读取。因此，首先需要知道当前数据集下，图片文件与标注文件匹配的规则。OCR 数据集有两种常用标注保存形式，一种为多个标注文件对应多张图片，一种则为单个标注文件对应多张图片，如：
+
+```text
+多对多
+├── {taskname}_imgs/{split}/img_img_1.jpg
+├── annotations/{split}/gt_img_1.txt
+├── {taskname}_imgs/{split}/img_2.jpg
+├── annotations/{split}/gt_img_2.txt
+├── {taskname}_imgs/{split}/img_3.JPG
+├── annotations/{split}/gt_img_3.txt
+
+单对多
+├── {taskname}/{split}/img_1.jpg
+├── {taskname}/{split}/img_2.jpg
+├── {taskname}/{split}/img_3.JPG
+├── annotations/gt.txt
+```
+
+具体设计如下所示
+
+
+MMOCR 内置了 `PairGatherer` 与 `MonoGatherer` 来处理以上这两种常用情况。其中 `PairGatherer` 用于多对多的情况，`MonoGatherer` 用于单对多的情况。
+
+```{note}
+为了简化处理，gatherer 约定数据集的图片和标注需要分别储存在 `{taskname}_imgs/{split}/` 和 `annotations/` 下。特别地，对于多对多的情况，标注文件需要放置于 `annotations/{split}`。
+```
+
+- 在多对多的情况下，`PairGatherer` 需要按照一定的命名规则找到图片文件和对应的标注文件。首先，需要通过 `img_suffixes` 参数指定图片的后缀名，如上述例子中的 `img_suffixes=[.jpg,.JPG]`。此外，还需要通过[正则表达式](https://docs.python.org/3/library/re.html) `rule`, 来指定图片与标注文件的对应关系，其中，规则 `rule` 是一个**正则表达式对**，例如 `rule=[r'img_(\d+)\.([jJ][pP][gG])'，r'gt_img_\1.txt']`。 第一个正则表达式用于匹配图片文件名，`\d+` 用于匹配图片的序号，`([jJ][pP][gG])` 用于匹配图片的后缀名。 第二个正则表达式用于匹配标注文件名，其中 `\1` 则将匹配到的图片序号与标注文件序号对应起来。示例配置为
+
+```python
+ gatherer=dict(
+ type='PairGatherer',
+ img_suffixes=['.jpg', '.JPG'],
+ rule=[r'img_(\d+)\.([jJ][pP][gG])', r'gt_img_\1.txt']),
+```
+
+- 单对多的情况通常比较简单，用户只需要指定标注文件名即可。对于训练集示例配置为
+
+```python
+ gatherer=dict(type='MonoGatherer', ann_name='train.txt'),
+```
+
+MMOCR 同样对 `Gatherer` 的返回值做了约定，`Gatherer` 会返回两个元素的元组，第一个元素为图像路径列表(包含所有图像路径) 或者所有图像所在的文件夹， 第二个元素为标注文件路径列表(包含所有标注文件路径)或者标注文件的路径(该标注文件包含所有图像标注信息)。
+具体而言，`PairGatherer` 的返回值为(图像路径列表， 标注文件路径列表)，示例如下：
+
+```python
+ (['{taskname}_imgs/{split}/img_1.jpg', '{taskname}_imgs/{split}/img_2.jpg', '{taskname}_imgs/{split}/img_3.JPG'],
+ ['annotations/{split}/gt_img_1.txt', 'annotations/{split}/gt_img_2.txt', 'annotations/{split}/gt_img_3.txt'])
+```
+
+`MonoGatherer` 的返回值为(图像文件夹路径， 标注文件路径)， 示例为：
+
+```python
+ ('{taskname}/{split}', 'annotations/gt.txt')
+```
+
+#### 数据集解析 (Parser)
+
+`Parser` 主要用于解析原始的标注文件，因为原始标注情况多种多样，因此 MMOCR 提供了 `BaseParser` 作为基类，用户可以继承该类来实现自己的 `Parser`。在 `BaseParser` 中，MMOCR 设计了两个接口：`parse_files` 和 `parse_file`，约定在其中进行标注的解析。而对于 `Gatherer` 的两种不同输入情况（多对多、单对多），这两个接口的实现则应有所不同。
+
+- `BaseParser` 默认处理**多对多**的情况。其中，由 `parer_files` 将数据并行分发至多个 `parse_file` 进程，并由每个 `parse_file` 分别进行单个图像标注的解析。
+- 对于**单对多**的情况，用户则需要重写 `parse_files`，以实现加载标注，并返回规范的结果。
+
+`BaseParser` 的接口定义如下所示：
+
+```python
+class BaseParser:
+
+ def __call__(self, img_paths, ann_paths):
+ return self.parse_files(img_paths, ann_paths)
+
+ def parse_files(self, img_paths: Union[List[str], str],
+ ann_paths: Union[List[str], str]) -> List[Tuple]:
+ samples = track_parallel_progress_multi_args(
+ self.parse_file, (img_paths, ann_paths), nproc=self.nproc)
+ return samples
+
+ @abstractmethod
+ def parse_file(self, img_path: str, ann_path: str) -> Tuple:
+
+ raise NotImplementedError
+```
+
+为了保证后续模块的统一性，MMOCR 对 `parse_files` 与 `parse_file` 的返回值做了约定。 `parse_file` 的返回值为一个元组，元组中的第一个元素为图像路径，第二个元素为标注信息。标注信息为一个列表，列表中的每个元素为一个字典，字典中的字段为`poly`, `text`, `ignore`，如下所示：
+
+```python
+# An example of returned values:
+(
+ 'imgs/train/xxx.jpg',
+ [
+ dict(
+ poly=[0, 1, 1, 1, 1, 0, 0, 0],
+ text='hello',
+ ignore=False),
+ ...
+ ]
+)
+```
+
+`parse_files` 的输出为一个列表，列表中的每个元素为 `parse_file` 的返回值。 示例为：
+
+```python
+[
+ (
+ 'imgs/train/xxx.jpg',
+ [
+ dict(
+ poly=[0, 1, 1, 1, 1, 0, 0, 0],
+ text='hello',
+ ignore=False),
+ ...
+ ]
+ ),
+ ...
+]
+```
+
+#### 数据集转换 (Packer)
+
+`packer` 主要是将数据转化到统一的标注格式, 因为输入的数据为 Parsers 的输出，格式已经固定， 因此 Packer 只需要将输入的格式转化为每种任务统一的标注格式即可。如今 MMOCR 支持的任务有文本检测、文本识别、端对端OCR 以及关键信息提取，MMOCR 针对每个任务均有对应的 Packer，如下所示：
+
+
+对于文字检测、端对端OCR及关键信息提取，MMOCR 均有唯一对应的 `Packer`。而在文字识别领域， MMOCR 则提供了两种 `Packer`，分别为 `TextRecogPacker` 和 `TextRecogCropPacker`，其原因在与文字识别的数据集存在两种情况：
+
+- 每个图像均为一个识别样本，`parser` 返回的标注信息仅为一个`dict(text='xxx')`，此时使用 `TextRecogPacker` 即可。
+- 数据集没有将文字从图像中裁剪出来，本质是一个端对端OCR的标注，包含了文字的位置信息以及对应的文本信息，`TextRecogCropPacker` 会将文字从图像中裁剪出来，然后再转化成文字识别的统一格式。
+
+#### 标注保存 (Dumper)
+
+`dumper` 来决定要将数据保存为何种格式。目前，MMOCR 支持 `JsonDumper`， `WildreceiptOpensetDumper`，及 `TextRecogLMDBDumper`。他们分别用于将数据保存为标准的 MMOCR Json 格式、Wildreceipt 格式，及文本识别领域学术界常用的 LMDB 格式。
+
+#### 临时文件清理 (Delete)
+
+在处理数据集时，往往会产生一些不需要的临时文件。这里可以以列表的形式传入这些文件或文件夹，在结束转换时即会删除。
+
+#### 生成基础配置 (ConfigGenerator)
+
+为了在数据集准备完毕后可以自动生成基础配置，目前，MMOCR 按任务实现了 `TextDetConfigGenerator`、`TextRecogConfigGenerator` 和 `TextSpottingConfigGenerator`。它们支持的主要参数如下：
+
+| 字段名 | 含义 |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| data_root | 数据集存储的根目录 |
+| train_anns | 配置文件内训练集标注的路径。若不指定，则默认为 `[dict(ann_file='{taskname}_train.json', dataset_postfix='']`。 |
+| val_anns | 配置文件内验证集标注的路径。若不指定，则默认为空。 |
+| test_anns | 配置文件内测试集标注的路径。若不指定，则默认指向 `[dict(ann_file='{taskname}_test.json', dataset_postfix='']`。 |
+| config_path | 算法库存放配置文件的路径，配置生成器会将默认配置写入 `{config_path}/{taskname}/_base_/datasets/{dataset_name}.py` 下。若不指定，则默认为 `configs/` |
+
+在准备好数据集的所有文件后，配置生成器就会自动生成调用该数据集所需要的基础配置文件。下面给出了一个最小化的 `TextDetConfigGenerator` 配置示例：
+
+```python
+config_generator = dict(type='TextDetConfigGenerator')
+```
+
+生成后的文件默认会被置于 `configs/{task}/_base_/datasets/` 下。例如，本例中，icdar 2015 的基础配置文件就会被生成在 `configs/textdet/_base_/datasets/icdar2015.py` 下：
+
+```python
+icdar2015_textdet_data_root = 'data/icdar2015'
+
+icdar2015_textdet_train = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textdet_data_root,
+ ann_file='textdet_train.json',
+ filter_cfg=dict(filter_empty_gt=True, min_size=32),
+ pipeline=None)
+
+icdar2015_textdet_test = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textdet_data_root,
+ ann_file='textdet_test.json',
+ test_mode=True,
+ pipeline=None)
+```
+
+假如数据集比较特殊，标注存在着几个变体，配置生成器也支持在基础配置中生成指向各自变体的变量，但这需要用户在设置时用不同的 `dataset_postfix` 区分。例如，ICDAR 2015 文字识别数据的测试集就存在着原版和 1811 两种标注版本，可以在 `test_anns` 中指定它们，如下所示：
+
+```python
+config_generator = dict(
+ type='TextRecogConfigGenerator',
+ test_anns=[
+ dict(ann_file='textrecog_test.json'),
+ dict(dataset_postfix='857', ann_file='textrecog_test_857.json')
+ ])
+```
+
+配置生成器会生成以下配置：
+
+```python
+icdar2015_textrecog_data_root = 'data/icdar2015'
+
+icdar2015_textrecog_train = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textrecog_data_root,
+ ann_file='textrecog_train.json',
+ pipeline=None)
+
+icdar2015_textrecog_test = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textrecog_data_root,
+ ann_file='textrecog_test.json',
+ test_mode=True,
+ pipeline=None)
+
+icdar2015_1811_textrecog_test = dict(
+ type='OCRDataset',
+ data_root=icdar2015_textrecog_data_root,
+ ann_file='textrecog_test_1811.json',
+ test_mode=True,
+ pipeline=None)
+```
+
+有了该文件后，MMOCR 就能从模型的配置文件中直接导入该数据集到 `dataloader` 中使用（以下样例节选自 [`configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py`](/configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py)）：
+
+```python
+_base_ = [
+ '../_base_/datasets/icdar2015.py',
+ # ...
+]
+
+# dataset settings
+icdar2015_textdet_train = _base_.icdar2015_textdet_train
+icdar2015_textdet_test = _base_.icdar2015_textdet_test
+# ...
+
+train_dataloader = dict(
+ dataset=icdar2015_textdet_train)
+
+val_dataloader = dict(
+ dataset=icdar2015_textdet_test)
+
+test_dataloader = val_dataloader
+```
+
+```{note}
+除非用户在运行脚本的时候手动指定了 `overwrite-cfg`，配置生成器默认不会自动覆盖已经存在的基础配置文件。
+```
+
+## 向 Dataset Preparer 添加新的数据集
+
+### 添加公开数据集
+
+MMOCR 已经支持了许多[常用的公开数据集](./datasetzoo.md)。如果你想用的数据集还没有被支持，并且你也愿意为 MMOCR 开源社区[贡献代码](../../notes/contribution_guide.md)，你可以按照以下步骤来添加一个新的数据集。
+
+接下来以添加 **ICDAR2013** 数据集为例，展示如何一步一步地添加一个新的公开数据集。
+
+#### 添加 `metafile.yml`
+
+首先，确认 `dataset_zoo/` 中不存在准备添加的数据集。然后我们先新建以待添加数据集命名的文件夹，如 `icdar2013/`（通常，使用不包含符号的小写英文字母及数字来命名数据集）。在 `icdar2013/` 文件夹中，新建 `metafile.yml` 文件，并按照以下模板来填充数据集的基本信息：
+
+```yaml
+Name: 'Incidental Scene Text IC13'
+Paper:
+ Title: ICDAR 2013 Robust Reading Competition
+ URL: https://www.imlab.jp/publication_data/1352/icdar_competition_report.pdf
+ Venue: ICDAR
+ Year: '2013'
+ BibTeX: '@inproceedings{karatzas2013icdar,
+ title={ICDAR 2013 robust reading competition},
+ author={Karatzas, Dimosthenis and Shafait, Faisal and Uchida, Seiichi and Iwamura, Masakazu and i Bigorda, Lluis Gomez and Mestre, Sergi Robles and Mas, Joan and Mota, David Fernandez and Almazan, Jon Almazan and De Las Heras, Lluis Pere},
+ booktitle={2013 12th international conference on document analysis and recognition},
+ pages={1484--1493},
+ year={2013},
+ organization={IEEE}}'
+Data:
+ Website: https://rrc.cvc.uab.es/?ch=2
+ Language:
+ - English
+ Scene:
+ - Natural Scene
+ Granularity:
+ - Word
+ Tasks:
+ - textdet
+ - textrecog
+ - textspotting
+ License:
+ Type: N/A
+ Link: N/A
+ Format: .txt
+ Keywords:
+ - Horizontal
+```
+
+#### 添加标注示例
+
+最后，可以在 `dataset_zoo/icdar2013/` 目录下添加标注示例文件 `sample_anno.md` 以帮助文档脚本在生成文档时添加标注示例，标注示例文件是一个 Markdown 文件，其内容通常包含了单个样本的原始数据格式。例如，以下代码块展示了 ICDAR2013 数据集的数据样例文件：
+
+````markdown
+ **Text Detection**
+
+ ```text
+ # train split
+ # x1 y1 x2 y2 "transcript"
+
+ 158 128 411 181 "Footpath"
+ 443 128 501 169 "To"
+ 64 200 363 243 "Colchester"
+
+ # test split
+ # x1, y1, x2, y2, "transcript"
+
+ 38, 43, 920, 215, "Tiredness"
+ 275, 264, 665, 450, "kills"
+ 0, 699, 77, 830, "A"
+ ```
+````
+
+#### 添加对应任务的配置文件
+
+在 `dataset_zoo/icdar2013` 中，接着添加以任务名称命名的 `.py` 配置文件。如 `textdet.py`，`textrecog.py`，`textspotting.py`，`kie.py` 等。配置模板如下所示：
+
+```python
+data_root = ''
+data_cache = 'data/cache'
+train_prepare = dict(
+ obtainer=dict(
+ type='NaiveObtainer',
+ data_cache=data_cache,
+ files=[
+ dict(
+ url='xx',
+ md5='',
+ save_name='xxx',
+ mapping=list())
+ ]),
+ gatherer=dict(type='xxxGatherer', **kwargs),
+ parser=dict(type='xxxParser', **kwargs),
+ packer=dict(type='TextxxxPacker'), # 对应任务的 Packer
+ dumper=dict(type='JsonDumper'),
+)
+test_prepare = dict(
+ obtainer=dict(
+ type='NaiveObtainer',
+ data_cache=data_cache,
+ files=[
+ dict(
+ url='xx',
+ md5='',
+ save_name='xxx',
+ mapping=list())
+ ]),
+ gatherer=dict(type='xxxGatherer', **kwargs),
+ parser=dict(type='xxxParser', **kwargs),
+ packer=dict(type='TextxxxPacker'), # 对应任务的 Packer
+ dumper=dict(type='JsonDumper'),
+)
+```
+
+以文件检测任务为例，来介绍配置文件的具体内容。
+一般情况下用户无需重新实现新的 `obtainer`, `gatherer`, `packer` 或 `dumper`，但是通常需要根据数据集的标注格式实现新的 `parser`。
+对于 `obtainer` 的配置这里不在做过的介绍，可以参考 [数据集下载、解压、移动](#数据集下载解压移动-obtainer)。
+针对 `gatherer`，通过观察获取的 ICDAR2013 数据集文件发现，其每一张图片都有一个对应的 `.txt` 格式的标注文件：
+
+```text
+data_root
+├── textdet_imgs/train/
+│ ├── img_1.jpg
+│ ├── img_2.jpg
+│ └── ...
+├── annotations/train/
+│ ├── gt_img_1.txt
+│ ├── gt_img_2.txt
+│ └── ...
+```
+
+且每个标注文件名与图片的对应关系为：`gt_img_1.txt` 对应 `img_1.jpg`，以此类推。因此可以使用 `PairGatherer` 来进行匹配。
+
+```python
+gatherer=dict(
+ type='PairGatherer',
+ img_suffixes=['.jpg'],
+ rule=[r'(\w+)\.jpg', r'gt_\1.txt'])
+```
+
+规则 `rule` 第一个正则表达式用于匹配图片文件名，第二个正则表达式用于匹配标注文件名。在这里，使用 `(\w+)` 来匹配图片文件名，使用 `gt_\1.txt` 来匹配标注文件名，其中 `\1` 表示第一个正则表达式匹配到的内容。即，实现了将 `img_xx.jpg` 替换为 `gt_img_xx.txt` 的功能。
+
+接下来，需要实现 `parser`，即将原始标注文件解析为标准格式。通常来说，用户在添加新的数据集前，可以浏览已支持数据集的[详情页](./datasetzoo.md)，并查看是否已有相同格式的数据集。如果已有相同格式的数据集，则可以直接使用该数据集的 `parser`。否则，则需要实现新的格式解析器。
+
+数据格式解析器被统一存储在 `mmocr/datasets/preparers/parsers` 目录下。所有的 `parser` 都需要继承 `BaseParser`，并实现 `parse_file` 或 `parse_files` 方法。具体可以参考[数据集解析](#数据集解析)
+
+通过观察 ICDAR2013 数据集的标注文件：
+
+```text
+158 128 411 181 "Footpath"
+443 128 501 169 "To"
+64 200 363 243 "Colchester"
+542, 710, 938, 841, "break"
+87, 884, 457, 1021, "could"
+517, 919, 831, 1024, "save"
+```
+
+我们发现内置的 `ICDARTxtTextDetAnnParser` 已经可以满足需求，因此可以直接使用该 `parser`，并将其配置到 `preparer` 中。
+
+```python
+parser=dict(
+ type='ICDARTxtTextDetAnnParser',
+ remove_strs=[',', '"'],
+ encoding='utf-8',
+ format='x1 y1 x2 y2 trans',
+ separator=' ',
+ mode='xyxy')
+```
+
+其中，由于标注文件中混杂了多余的引号 `“”` 和逗号 `,`，可以通过指定 `remove_strs=[',', '"']` 来进行移除。另外在 `format` 中指定了标注文件的格式，其中 `x1 y1 x2 y2 trans` 表示标注文件中的每一行包含了四个坐标和一个文本内容，且坐标和文本内容之间使用空格分隔（`separator`=' '）。另外，需要指定 `mode` 为 `xyxy`，表示标注文件中的坐标是左上角和右下角的坐标，这样以来，`ICDARTxtTextDetAnnParser` 即可将该格式的标注解析为统一格式。
+
+对于 `packer`，以文件检测任务为例，其 `packer` 为 `TextDetPacker`，其配置如下：
+
+```python
+packer=dict(type='TextDetPacker')
+```
+
+最后，指定 `dumper`，这里一般情况下保存为json格式，其配置如下：
+
+```python
+dumper=dict(type='JsonDumper')
+```
+
+经过上述配置后，针对 ICDAR2013 训练集的配置文件如下：
+
+```python
+train_preparer = dict(
+ obtainer=dict(
+ type='NaiveDataObtainer',
+ cache_path=cache_path,
+ files=[
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/'
+ 'Challenge2_Training_Task12_Images.zip',
+ save_name='ic13_textdet_train_img.zip',
+ md5='a443b9649fda4229c9bc52751bad08fb',
+ content=['image'],
+ mapping=[['ic13_textdet_train_img', 'textdet_imgs/train']]),
+ dict(
+ url='https://rrc.cvc.uab.es/downloads/'
+ 'Challenge2_Training_Task1_GT.zip',
+ save_name='ic13_textdet_train_gt.zip',
+ md5='f3a425284a66cd67f455d389c972cce4',
+ content=['annotation'],
+ mapping=[['ic13_textdet_train_gt', 'annotations/train']]),
+ ]),
+ gatherer=dict(
+ type='PairGatherer',
+ img_suffixes=['.jpg'],
+ rule=[r'(\w+)\.jpg', r'gt_\1.txt']),
+ parser=dict(
+ type='ICDARTxtTextDetAnnParser',
+ remove_strs=[',', '"'],
+ format='x1 y1 x2 y2 trans',
+ separator=' ',
+ mode='xyxy'),
+ packer=dict(type='TextDetPacker'),
+ dumper=dict(type='JsonDumper'),
+)
+```
+
+为了在数据集准备完毕后可以自动生成基础配置， 还需要配置一下对应任务的 `config_generator`。
+
+在本例中，因为为文字检测任务，仅需要设置 Generator 为 `TextDetConfigGenerator`即可
+
+```python
+config_generator = dict(type='TextDetConfigGenerator', )
+```
+
+### 添加私有数据集
+
+待更新...
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/datasets.md b/internlm_langchain/knowledge_base/MMOCR/content/datasets.md
new file mode 100644
index 00000000..16e6162d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/datasets.md
@@ -0,0 +1,489 @@
+# 数据集类
+
+## 概览
+
+在 MMOCR 中，所有的数据集都通过不同的基于 [mmengine.BaseDataset](mmengine.dataset.BaseDataset) 的 Dataset 类进行处理。 Dataset 类负责加载数据并进行初始解析，然后将其馈送到 [数据流水线](./transforms.md) 进行数据预处理、增强、格式化等操作。
+
+` 了解更多详细信息。
+```
+
+## 常见接口
+
+现在，让我们看一个具体的示例并学习 Dataset 类的一些典型接口。`OCRDataset` 是 MMOCR 中默认使用的 Dataset 实现，因为它的标注格式足够灵活，支持 *所有* OCR 任务（详见 [OCRDataset](#ocrdataset)）。现在我们将实例化一个 `OCRDataset` 对象，其中将加载 `tests/data/det_toy_dataset` 中的玩具数据集。
+
+```python
+from mmocr.datasets import OCRDataset
+from mmengine.registry import init_default_scope
+init_default_scope('mmocr')
+
+train_pipeline = [
+ dict(
+ type='LoadImageFromFile'),
+ dict(
+ type='LoadOCRAnnotations',
+ with_polygon=True,
+ with_bbox=True,
+ with_label=True,
+ ),
+ dict(type='RandomCrop', min_side_ratio=0.1),
+ dict(type='Resize', scale=(640, 640), keep_ratio=True),
+ dict(type='Pad', size=(640, 640)),
+ dict(
+ type='PackTextDetInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape'))
+]
+dataset = OCRDataset(
+ data_root='tests/data/det_toy_dataset',
+ ann_file='textdet_test.json',
+ test_mode=False,
+ pipeline=train_pipeline)
+
+```
+
+让我们查看一下这个数据集的大小：
+
+```python
+>>> print(len(dataset))
+
+10
+```
+
+通常，Dataset 类加载并存储两种类型的信息：（1）**元信息**：储存数据集的属性，例如此数据集中可用的对象类别。 （2）**标注**：图像的路径及其标签。我们可以通过 `dataset.metainfo` 访问元信息：
+
+```python
+>>> from pprint import pprint
+>>> pprint(dataset.metainfo)
+
+{'category': [{'id': 0, 'name': 'text'}],
+ 'dataset_type': 'TextDetDataset',
+ 'task_name': 'textdet'}
+```
+
+对于标注，我们可以通过 `dataset.get_data_info(idx)` 访问它。该方法返回一个字典，其中包含数据集中第 `idx` 个样本的信息。该样本已经经过初步解析，但尚未由 [数据流水线](./transforms.md) 处理。
+
+```python
+>>> from pprint import pprint
+>>> pprint(dataset.get_data_info(0))
+
+{'height': 720,
+ 'img_path': 'tests/data/det_toy_dataset/test/img_10.jpg',
+ 'instances': [{'bbox': [260.0, 138.0, 284.0, 158.0],
+ 'bbox_label': 0,
+ 'ignore': True,
+ 'polygon': [261, 138, 284, 140, 279, 158, 260, 158]},
+ ...,
+ {'bbox': [1011.0, 157.0, 1079.0, 173.0],
+ 'bbox_label': 0,
+ 'ignore': True,
+ 'polygon': [1011, 157, 1079, 160, 1076, 173, 1011, 170]}],
+ 'sample_idx': 0,
+ 'seg_map': 'test/gt_img_10.txt',
+ 'width': 1280}
+```
+
+另一方面，我们可以通过 `dataset[idx]` 或 `dataset.__getitem__(idx)` 获取由数据流水线完整处理过后的样本，该样本可以直接馈入模型并执行完整的训练/测试循环。它有两个字段：
+
+- `inputs`：经过数据增强后的图像；
+- `data_samples`：包含经过数据增强后的标注和元信息的 [DataSample](./structures.md)，这些元信息可能由一些数据变换产生，并用以记录该样本的某些关键属性。
+
+```python
+>>> pprint(dataset[0])
+
+{'data_samples':
+) at 0x7f735a0508e0>,
+ 'inputs': tensor([[[129, 111, 131, ..., 0, 0, 0], ...
+ [ 19, 18, 15, ..., 0, 0, 0]]], dtype=torch.uint8)}
+```
+
+## 数据集类及标注格式
+
+每个数据集实现只能加载特定格式的数据集。这里列出了所有支持的数据集类及其兼容的格式，以及一个示例配置，以演示如何在实践中使用它们。
+
+```{note}
+如果您不熟悉配置系统，可以阅读 [数据集配置文件](../user_guides/dataset_prepare.md#数据集配置文件)。
+```
+
+### OCRDataset
+
+通常，OCR 数据集中有许多不同类型的标注，在不同的子任务（如文本检测和文本识别）中，格式也经常会有所不同。这些差异可能会导致在使用不同数据集时需要不同的数据加载代码，增加了用户的学习和维护成本。
+
+在 MMOCR 中，我们提出了一种统一的数据集格式，可以适应 OCR 的所有三个子任务：文本检测、文本识别和端到端 OCR。这种设计最大程度地提高了数据集的一致性，允许在不同任务之间重复使用数据标注，也使得数据集管理更加方便。考虑到流行的数据集格式并不一致，MMOCR 提供了 [Dataset Preparer](../user_guides/data_prepare/dataset_preparer.md) 来帮助用户将其数据集转换为 MMOCR 格式。我们也十分鼓励研究人员基于此数据格式开发自己的数据集。
+
+#### 标注格式
+
+此标注文件是一个 `.json` 文件，存储一个包含 `metainfo` 和 `data_list` 的 `dict`，前者包括有关数据集的基本信息，后者由每个图片的标注组成。这里呈现了标注文件中的所有字段的列表，但其中某些字段仅会在特定任务中被用到。
+
+```python
+{
+ "metainfo":
+ {
+ "dataset_type": "TextDetDataset", # 可选项: TextDetDataset/TextRecogDataset/TextSpotterDataset
+ "task_name": "textdet", # 可选项: textdet/textspotter/textrecog
+ "category": [{"id": 0, "name": "text"}] # 在 textdet/textspotter 里用到
+ },
+ "data_list":
+ [
+ {
+ "img_path": "test_img.jpg",
+ "height": 604,
+ "width": 640,
+ "instances": # 一图内的多个实例
+ [
+ {
+ "bbox": [0, 0, 10, 20], # textdet/textspotter 内用到, [x1, y1, x2, y2]。
+ "bbox_label": 0, # 对象类别, 在 MMOCR 中恒为 0 (文本)
+ "polygon": [0, 0, 0, 10, 10, 20, 20, 0], # textdet/textspotter 内用到。 [x1, y1, x2, y2, ....]
+ "text": "mmocr", # textspotter/textrecog 内用到
+ "ignore": False # textspotter/textdet 内用到，决定是否在训练时忽略该实例
+ },
+ #...
+ ],
+ }
+ #... 多图片
+ ]
+}
+```
+
+#### 示例配置
+
+以下是配置的一部分，我们在 `train_dataloader` 中使用 `OCRDataset` 加载用于文本检测模型的 ICDAR2015 数据集。请注意，`OCRDataset` 可以加载由 Dataset Preparer 准备的任何 OCR 数据集。也就是说，您可以将其用于文本识别和文本检测，但您仍然需要根据不同任务的需求修改 `pipeline` 中的数据变换。
+
+```python
+pipeline = [
+ dict(
+ type='LoadImageFromFile'),
+ dict(
+ type='LoadOCRAnnotations',
+ with_polygon=True,
+ with_bbox=True,
+ with_label=True,
+ ),
+ dict(
+ type='PackTextDetInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape'))
+]
+
+icdar2015_textdet_train = dict(
+ type='OCRDataset',
+ data_root='data/icdar2015',
+ ann_file='textdet_train.json',
+ filter_cfg=dict(filter_empty_gt=True, min_size=32),
+ pipeline=pipeline)
+
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=icdar2015_textdet_train)
+```
+
+### RecogLMDBDataset
+
+当数据量非常大时，从文件中读取图像或标签可能会很慢。此外，在学术界，大多数场景文本识别数据集的图像和标签都以 lmdb 格式存储。（[示例](https://github.com/clovaai/deep-text-recognition-benchmark)）
+
+为了更接近主流实践并提高数据存储效率，MMOCR支持通过 `RecogLMDBDataset` 从 lmdb 数据集加载图像和标签。
+
+#### 标注格式
+
+MMOCR 会读取 lmdb 数据集中的以下键：
+
+- `num_samples`：描述数据集的数据量的参数。
+- 图像和标签的键分别以 `image-000000001` 和 `label-000000001` 的格式命名，索引从1开始。
+
+MMOCR 在 `tests/data/rec_toy_dataset/imgs.lmdb` 中提供了一个 toy lmdb 数据集。您可以使用以下代码片段了解其格式。
+
+```python
+>>> import lmdb
+>>>
+>>> env = lmdb.open('tests/data/rec_toy_dataset/imgs.lmdb')
+>>> txn = env.begin()
+>>> for k, v in txn.cursor():
+>>> print(k, v)
+
+b'image-000000001' b'\xff...'
+b'image-000000002' b'\xff...'
+b'image-000000003' b'\xff...'
+b'image-000000004' b'\xff...'
+b'image-000000005' b'\xff...'
+b'image-000000006' b'\xff...'
+b'image-000000007' b'\xff...'
+b'image-000000008' b'\xff...'
+b'image-000000009' b'\xff...'
+b'image-000000010' b'\xff...'
+b'label-000000001' b'GRAND'
+b'label-000000002' b'HOTEL'
+b'label-000000003' b'HOTEL'
+b'label-000000004' b'PACIFIC'
+b'label-000000005' b'03/09/2009'
+b'label-000000006' b'ANING'
+b'label-000000007' b'Virgin'
+b'label-000000008' b'america'
+b'label-000000009' b'ATTACK'
+b'label-000000010' b'DAVIDSON'
+b'num-samples' b'10'
+
+```
+
+#### 示例配置
+
+以下是示例配置的一部分，我们在其中使用 `RecogLMDBDataset` 加载 toy 数据集。由于 `RecogLMDBDataset` 会将图像加载为 numpy 数组，因此如果要在数据管道中成功加载图像，应该记得把`LoadImageFromFile` 替换成 `LoadImageFromNDArray` 。
+
+```python
+pipeline = [
+ dict(
+ type='LoadImageFromNDArray'),
+ dict(
+ type='LoadOCRAnnotations',
+ with_text=True,
+ ),
+ dict(
+ type='PackTextRecogInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape'))
+]
+
+toy_textrecog_train = dict(
+ type='RecogLMDBDataset',
+ data_root='tests/data/rec_toy_dataset/',
+ ann_file='imgs.lmdb',
+ pipeline=pipeline)
+
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=toy_textrecog_train)
+```
+
+### RecogTextDataset
+
+在 MMOCR 1.0 之前，MMOCR 0.x 的文本识别任务的输入是文本文件。这些格式已在 MMOCR 1.0 中弃用，这个类随时可能被删除。[更多信息](../migration/dataset.md)
+
+#### 标注格式
+
+文本文件可以是 `txt` 格式或 `jsonl` 格式。简单的 `.txt` 标注通过空格将图像名称和词语标注分隔开，因此这种格式并无法处理文本实例中包含空格的情况。
+
+```text
+img1.jpg OpenMMLab
+img2.jpg MMOCR
+```
+
+`jsonl` 格式使用类似字典的结构来表示标注，其中键 `filename` 和 `text` 存储图像名称和单词标签。
+
+```json
+{"filename": "img1.jpg", "text": "OpenMMLab"}
+{"filename": "img2.jpg", "text": "MMOCR"}
+```
+
+#### 示例配置
+
+以下是一个示例配置，我们在训练中使用 `RecogTextDataset` 加载 txt 标签，而在测试中使用 jsonl 标签。
+
+```python
+pipeline = [
+ dict(
+ type='LoadImageFromFile'),
+ dict(
+ type='LoadOCRAnnotations',
+ with_polygon=True,
+ with_bbox=True,
+ with_label=True,
+ ),
+ dict(
+ type='PackTextDetInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape'))
+]
+
+ # loading 0.x txt format annos
+ txt_dataset = dict(
+ type='RecogTextDataset',
+ data_root=data_root,
+ ann_file='old_label.txt',
+ data_prefix=dict(img_path='imgs'),
+ parser_cfg=dict(
+ type='LineStrParser',
+ keys=['filename', 'text'],
+ keys_idx=[0, 1]),
+ pipeline=pipeline)
+
+
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=txt_dataset)
+
+ # loading 0.x json line format annos
+ jsonl_dataset = dict(
+ type='RecogTextDataset',
+ data_root=data_root,
+ ann_file='old_label.jsonl',
+ data_prefix=dict(img_path='imgs'),
+ parser_cfg=dict(
+ type='LineJsonParser',
+ keys=['filename', 'text'],
+ pipeline=pipeline))
+
+test_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=jsonl_dataset)
+```
+
+### IcdarDataset
+
+在 MMOCR 1.0 之前，MMOCR 0.x 的文本检测输入采用了类似 COCO 格式的注释。这些格式已在 MMOCR 1.0 中弃用，这个类在将来的任何时候都可能被删除。[更多信息](../migration/dataset.md)
+
+#### 标注格式
+
+```json
+{
+ "images": [
+ {
+ "id": 1,
+ "width": 800,
+ "height": 600,
+ "file_name": "test.jpg"
+ }
+ ],
+ "annotations": [
+ {
+ "id": 1,
+ "image_id": 1,
+ "category_id": 1,
+ "bbox": [0,0,10,10],
+ "segmentation": [
+ [0,0,10,0,10,10,0,10]
+ ],
+ "area": 100,
+ "iscrowd": 0
+ }
+ ]
+}
+
+```
+
+#### 配置示例
+
+这是配置示例的一部分，其中我们令 `train_dataloader` 使用 `IcdarDataset` 来加载旧标签。
+
+```python
+pipeline = [
+ dict(
+ type='LoadImageFromFile'),
+ dict(
+ type='LoadOCRAnnotations',
+ with_polygon=True,
+ with_bbox=True,
+ with_label=True,
+ ),
+ dict(
+ type='PackTextDetInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape'))
+]
+
+icdar2015_textdet_train = dict(
+ type='IcdarDatasetDataset',
+ data_root='data/det/icdar2015',
+ ann_file='instances_training.json',
+ filter_cfg=dict(filter_empty_gt=True, min_size=32),
+ pipeline=pipeline)
+
+train_dataloader = dict(
+ batch_size=16,
+ num_workers=8,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=True),
+ dataset=icdar2015_textdet_train)
+```
+
+### WildReceiptDataset
+
+该类为 [WildReceipt](https://mmocr.readthedocs.io/en/dev-1.x/user_guides/data_prepare/datasetzoo.html#wildreceipt) 数据集定制。
+
+#### 标注格式
+
+```json
+// Close Set
+{
+ "file_name": "image_files/Image_16/11/d5de7f2a20751e50b84c747c17a24cd98bed3554.jpeg",
+ "height": 1200,
+ "width": 1600,
+ "annotations":
+ [
+ {
+ "box": [550.0, 190.0, 937.0, 190.0, 937.0, 104.0, 550.0, 104.0],
+ "text": "SAFEWAY",
+ "label": 1
+ },
+ {
+ "box": [1048.0, 211.0, 1074.0, 211.0, 1074.0, 196.0, 1048.0, 196.0],
+ "text": "TM",
+ "label": 25
+ }
+ ], //...
+}
+
+// Open Set
+{
+ "file_name": "image_files/Image_12/10/845be0dd6f5b04866a2042abd28d558032ef2576.jpeg",
+ "height": 348,
+ "width": 348,
+ "annotations":
+ [
+ {
+ "box": [114.0, 19.0, 230.0, 19.0, 230.0, 1.0, 114.0, 1.0],
+ "text": "CHOEUN",
+ "label": 2,
+ "edge": 1
+ },
+ {
+ "box": [97.0, 35.0, 236.0, 35.0, 236.0, 19.0, 97.0, 19.0],
+ "text": "KOREANRESTAURANT",
+ "label": 2,
+ "edge": 1
+ }
+ ]
+}
+```
+
+#### 配置示例
+
+请参考 [SDMGR 的配置](https://github.com/open-mmlab/mmocr/blob/f30c16ce96bd2393570c04eeb9cf48a7916315cc/configs/kie/sdmgr/sdmgr_novisual_60e_wildreceipt.py)。
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/engine.md b/internlm_langchain/knowledge_base/MMOCR/content/engine.md
new file mode 100644
index 00000000..57cb62ae
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/engine.md
@@ -0,0 +1,3 @@
+# 引擎\[待更新\]
+
+待更新
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/evaluation.md b/internlm_langchain/knowledge_base/MMOCR/content/evaluation.md
new file mode 100644
index 00000000..15eab4da
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/evaluation.md
@@ -0,0 +1,198 @@
+# 模型评测
+
+```{note}
+阅读此文档前，建议您先了解 {external+mmengine:doc}`MMEngine: 模型精度评测基本概念 `。
+```
+
+## 评测指标
+
+MMOCR 基于 {external+mmengine:doc}`MMEngine: BaseMetric ` 基类实现了常用的文本检测、文本识别以及关键信息抽取任务的评测指标，用户可以通过修改配置文件中的 `val_evaluator` 与 `test_evaluator` 字段来便捷地指定验证与测试阶段采用的评测方法。例如，以下配置展示了如何在文本检测算法中使用 `HmeanIOUMetric` 来评测模型性能。
+
+```python
+# 文本检测任务中通常使用 HmeanIOUMetric 来评测模型性能
+val_evaluator = [dict(type='HmeanIOUMetric')]
+
+# 此外，MMOCR 也支持相同任务下的多种指标组合评测，如同时使用 WordMetric 及 CharMetric
+val_evaluator = [
+ dict(type='WordMetric', mode=['exact', 'ignore_case', 'ignore_case_symbol']),
+ dict(type='CharMetric')
+]
+```
+
+```{tip}
+更多评测相关配置请参考[评测配置教程](../user_guides/config.md#评测配置)。
+```
+
+如下表所示，MMOCR 目前针对文本检测、识别、及关键信息抽取等任务共内置了 5 种评测指标，分别为 `HmeanIOUMetric`，`WordMetric`，`CharMetric`，`OneMinusNEDMetric`，和 `F1Metric`。
+
+| | | | |
+| --------------------------------------- | ------------ | ------------------------------------------------- | --------------------------------------------------------------------- |
+| 评测指标 | 任务类型 | 输入字段 | 输出字段 |
+| [HmeanIOUMetric](#hmeanioumetric) | 文本检测 | `pred_polygons`
`pred_scores`
`gt_polygons` | `recall`
`precision`
`hmean` | +| [WordMetric](#wordmetric) | 文本识别 | `pred_text`
`gt_text` | `word_acc`
`word_acc_ignore_case`
`word_acc_ignore_case_symbol` | +| [CharMetric](#charmetric) | 文本识别 | `pred_text`
`gt_text` | `char_recall`
`char_precision` | +| [OneMinusNEDMetric](#oneminusnedmetric) | 文本识别 | `pred_text`
`gt_text` | `1-N.E.D` | +| [F1Metric](#f1metric) | 关键信息抽取 | `pred_labels`
`gt_labels` | `macro_f1`
`micro_f1` | + +通常来说，每一类任务所采用的评测标准是约定俗成的，用户一般无须深入了解或手动修改评测方法的内部实现。然而，为了方便用户实现更加定制化的需求，本文档将进一步介绍了 MMOCR 内置评测算法的具体实现策略，以及可配置参数。 + +### HmeanIOUMetric + +[HmeanIOUMetric](mmocr.evaluation.metrics.hmean_iou_metric.HmeanIOUMetric) 是文本检测任务中应用最广泛的评测指标之一，因其计算了检测精度（Precision）与召回率（Recall）之间的调和平均数（Harmonic mean, H-mean），故得名 `HmeanIOUMetric`。记精度为 *P*，召回率为 *R*，则 `HmeanIOUMetric` 可由下式计算得到： + +```{math} +H = \frac{2}{\frac{1}{P} + \frac{1}{R}} = \frac{2PR}{P+R} +``` + +另外，由于其等价于 {math}`\beta = 1` 时的 F-score (又称 F-measure 或 F-metric)，`HmeanIOUMetric` 有时也被写作 `F1Metric` 或 `f1-score` 等： + +```{math} +F_1=(1+\beta^2)\cdot\frac{PR}{\beta^2\cdot P+R} = \frac{2PR}{P+R} +``` + +在 MMOCR 的设计中，`HmeanIOUMetric` 的计算可以概括为以下几个步骤： + +1. 过滤无效的预测边界盒 + + - 依据置信度阈值 `pred_score_thrs` 过滤掉得分较低的预测边界盒 + - 依据 `ignore_precision_thr` 阈值过滤掉与 `ignored` 样本重合度过高的预测边界盒 + + 值得注意的是，`pred_score_thrs` 默认将**自动搜索**一定范围内的**最佳阈值**，用户也可以通过手动修改配置文件来自定义搜索范围： + + ```python + # HmeanIOUMetric 默认以 0.1 为步长搜索 [0.3, 0.9] 范围内的最佳得分阈值 + val_evaluator = dict(type='HmeanIOUMetric', pred_score_thrs=dict(start=0.3, stop=0.9, step=0.1)) + ``` + +2. 计算 IoU 矩阵 + + - 在数据处理阶段，`HmeanIOUMetric` 会计算并维护一个 {math}`M \times N` 的 IoU 矩阵 `iou_metric`，以方便后续的边界盒配对步骤。其中，M 和 N 分别为标签边界盒与过滤后预测边界盒的数量。由此，该矩阵的每个元素都存放了第 m 个标签边界盒与第 n 个预测边界盒之间的交并比（IoU）。 + +3. 基于相应的配对策略统计能被准确匹配的 GT 样本数 + + 尽管 `HmeanIOUMetric` 可以由固定的公式计算取得，不同的任务或算法库内部的具体实现仍可能存在一些细微差别。这些差异主要体现在采用不同的策略来匹配真实与预测边界盒，从而导致最终得分的差距。目前，MMOCR 内部的 `HmeanIOUMetric` 共支持两种不同的匹配策略，即 `vanilla` 与 `max_matching`。如下所示，用户可以通过修改配置文件来指定不同的匹配策略。 + + - `vanilla` 匹配策略 + + `HmeanIOUMetric` 默认采用 `vanilla` 匹配策略，该实现与 MMOCR 0.x 版本中的 `hmean-iou` 及 ICDAR 系列**官方文本检测竞赛的评测标准保持一致**，采用先到先得的匹配方式对标签边界盒（Ground-truth bbox）与预测边界盒（Predicted bbox）进行配对。 + + ```python + # 不指定 strategy 时，HmeanIOUMetric 默认采用 'vanilla' 匹配策略 + val_evaluator = dict(type='HmeanIOUMetric') + ``` + + - `max_matching` 匹配策略 + + 针对现有匹配机制中的不完善之处，MMOCR 算法库实现了一套更高效的匹配策略，用以最大化匹配数目。 + + ```python + # 指定采用 'max_matching' 匹配策略 + val_evaluator = dict(type='HmeanIOUMetric', strategy='max_matching') + ``` + + ```{note} + 我们建议面向学术研究的开发用户采用默认的 `vanilla` 匹配策略，以保证与其他论文的对比结果保持一致。而面向工业应用的开发用户则可以采用 `max_matching` 匹配策略，以获得精准的结果。 + ``` + +4. 根据上文介绍的 `HmeanIOUMetric` 公式计算最终的评测得分 + +### WordMetric + +[WordMetric](mmocr.evaluation.metrics.recog_metric.WordMetric) 实现了**单词级别**的文本识别评测指标，并内置了 `exact`，`ignore_case`，及 `ignore_case_symbol` 三种文本匹配模式，用户可以在配置文件中修改 `mode` 字段来自由组合输出一种或多种文本匹配模式下的 `WordMetric` 得分。 + +```python +# 在文本识别任务中使用 WordMetric 评测 +val_evaluator = [ + dict(type='WordMetric', mode=['exact', 'ignore_case', 'ignore_case_symbol']) +] +``` + +- `exact`：全匹配模式，即，预测与标签完全一致才能被记录为正确样本。 +- `ignore_case`：忽略大小写的匹配模式。 +- `ignore_case_symbol`：忽略大小写及符号的匹配模式，这也是大部分学术论文中报告的文本识别准确率；MMOCR 报告的识别模型性能默认采用该匹配模式。 + +假设真实标签为 `MMOCR!`，模型的输出结果为 `mmocr`，则三种匹配模式下的 `WordMetric` 得分分别为：`{'exact': 0, 'ignore_case': 0, 'ignore_case_symbol': 1}`。 + +### CharMetric + +[CharMetric](mmocr.evaluation.metrics.recog_metric.CharMetric) 实现了**不区分大小写**的**字符级别**的文本识别评测指标。 + +```python +# 在文本识别任务中使用 CharMetric 评测 +val_evaluator = [dict(type='CharMetric')] +``` + +具体而言，`CharMetric` 会输出两个评测评测指标，即字符精度 `char_precision` 和字符召回率 `char_recall`。设正确预测的字符（True Positive）数量为 {math}`\sigma_{tp}`，则精度 *P* 和召回率 *R* 可由下式计算取得： + +```{math} +P=\frac{\sigma_{tp}}{\sigma_{pred}}, R = \frac{\sigma_{tp}}{\sigma_{gt}} +``` + +其中，{math}`\sigma_{gt}` 与 {math}`\sigma_{pred}` 分别为标签文本与预测文本所包含的字符总数。 + +例如，假设标签文本为 "MM**O**CR"，预测文本为 "mm**0**cR**1**"，则使用 `CharMetric` 评测指标的得分为： + +```{math} +P=\frac{4}{6}, R=\frac{4}{5} +``` + +### OneMinusNEDMetric + +[`OneMinusNEDMetric(1-N.E.D)`](mmocr.evaluation.metrics.recog_metric.OneMinusNEDMetric) 常用于中文或英文**文本行级别**标注的文本识别评测，不同于全匹配的评测标准要求预测与真实样本完全一致，该评测指标使用归一化的[编辑距离](https://en.wikipedia.org/wiki/Edit_distance)（Edit Distance，又名莱温斯坦距离 Levenshtein Distance）来测量预测文本与真实文本之间的差异性，从而在评测长文本样本时能够更好地区分出模型的性能差异。假设真实和预测文本分别为 {math}`s_i` 和 {math}`\hat{s_i}`，其长度分别为 {math}`l_{i}` 和 {math}`\hat{l_i}`，则 `OneMinusNEDMetric` 得分可由下式计算得到： + +```{math} +score = 1 - \frac{1}{N}\sum_{i=1}^{N}\frac{D(s_i, \hat{s_{i}})}{max(l_{i},\hat{l_{i}})} +``` + +其中，*N* 是样本总数，{math}`D(s_1, s_2)` 为两个字符串之间的编辑距离。 + +例如，假设真实标签为 "OpenMMLabMMOCR"，模型 A 的预测结果为 "0penMMLabMMOCR", 模型 B 的预测结果为 "uvwxyz"，则采用全匹配和 `OneMinusNEDMetric` 评测指标的结果分别为: + +| | | | +| ------ | ------ | ---------- | +| | 全匹配 | 1 - N.E.D. | +| 模型 A | 0 | 0.92857 | +| 模型 B | 0 | 0 | + +由上表可以发现，尽管模型 A 仅预测错了一个字母，而模型 B 全部预测错误，在使用全匹配的评测指标时，这两个模型的得分都为0；而使用 `OneMinuesNEDMetric` 的评测指标则能够更好地区分模型在**长文本**上的性能差异。 + +### F1Metric + +[F1Metric](mmocr.evaluation.metrics.f_metric.F1Metric) 实现了针对 KIE 任务的 F1-Metric 评测指标，并提供了 `micro` 和 `macro` 两种评测模式。 + +```python +val_evaluator = [ + dict(type='F1Metric', mode=['micro', 'macro'], +] +``` + +- `micro` 模式：依据 True Positive，False Negative，及 False Positive 总数来计算全局 F1-Metric 得分。 + +- `macro` 模式：依据类别标签计算每一类的 F1-Metric，并求平均值。 + +### 自定义评测指标 + +对于追求更高定制化功能的用户，MMOCR 也支持自定义实现不同类型的评测指标。一般来说，用户只需要新建自定义评测指标类 `CustomizedMetric` 并继承 {external+mmengine:doc}`MMEngine: BaseMetric`，然后分别重写数据格式处理方法 `process` 以及指标计算方法 `compute_metrics`。最后，将其加入 `METRICS` 注册器即可实现任意定制化的评测指标。
+
+```python
+from mmengine.evaluator import BaseMetric
+from mmocr.registry import METRICS
+
+@METRICS.register_module()
+class CustomizedMetric(BaseMetric):
+
+ def process(self, data_batch: Sequence[Dict], predictions: Sequence[Dict]):
+ """ process 接收两个参数，分别为 data_batch 存放真实标签信息，以及 predictions
+ 存放预测结果。process 方法负责将标签信息转换并存放至 self.results 变量中
+ """
+ pass
+
+ def compute_metrics(self, results: List):
+ """ compute_metric 使用经过 process 方法处理过的标签数据计算最终评测得分
+ """
+ pass
+```
+
+```{note}
+更多内容可参见 {external+mmengine:doc}`MMEngine 文档: BaseMetric `。
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/inference.md b/internlm_langchain/knowledge_base/MMOCR/content/inference.md
new file mode 100644
index 00000000..7b69dcee
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/inference.md
@@ -0,0 +1,534 @@
+# 推理
+
+在 OpenMMLab 中，所有的推理操作都被统一到了推理器 `Inferencer` 中。推理器被设计成为一个简洁易用的 API，它在不同的 OpenMMLab 库中都有着非常相似的接口。
+
+MMOCR 中存在两种不同的推理器：
+
+- **标准推理器**：MMOCR 中的每个基本任务都有一个标准推理器，即 `TextDetInferencer`（文本检测），`TextRecInferencer`（文本识别），`TextSpottingInferencer`（端到端 OCR） 和 `KIEInferencer`（关键信息提取）。它们具有非常相似的接口，具有标准的输入/输出协议，并且总体遵循 OpenMMLab 的设计。这些推理器也可以被串联在一起，以便对一系列任务进行推理。
+- **MMOCRInferencer**：我们还提供了 `MMOCRInferencer`，一个专门为 MMOCR 设计的便捷推理接口。它封装和链接了 MMOCR 中的所有推理器，因此用户可以使用此推理器对图像执行一系列任务，并直接获得最终结果。*但是，它的接口与标准推理器有一些不同，并且为了简单起见，可能会牺牲一些标准的推理器功能。*
+
+对于新用户，我们建议使用 **MMOCRInferencer** 来测试不同模型的组合。
+
+如果你是开发人员并希望将模型集成到自己的项目中，我们建议使用**标准推理器**，因为它们更灵活且标准化，并具有完整的功能。
+
+## 基础用法
+
+`````{tabs}
+
+````{group-tab} MMOCRInferencer
+
+目前，`MMOCRInferencer` 可以对以下任务进行推理：
+
+- 文本检测
+- 文本识别
+- OCR（文本检测 + 文本识别）
+- 关键信息提取（文本检测 + 文本识别 + 关键信息提取）
+- *OCR（text spotting）*（即将推出）
+
+为了便于使用，`MMOCRInferencer` 向用户提供了 Python 接口和命令行接口。例如，如果你想要对 demo/demo_text_ocr.jpg 进行 OCR 推理，使用 `DBNet` 作为文本检测模型，`CRNN` 作为文本识别模型，只需执行以下命令:
+
+::::{tabs}
+
+:::{code-tab} python
+>>> from mmocr.apis import MMOCRInferencer
+>>> # 读取模型
+>>> ocr = MMOCRInferencer(det='DBNet', rec='SAR')
+>>> # 进行推理并可视化结果
+>>> ocr('demo/demo_text_ocr.jpg', show=True)
+:::
+
+:::{code-tab} bash 命令行
+python tools/infer.py demo/demo_text_ocr.jpg --det DBNet --rec SAR --show
+:::
+::::
+
+可视化结果将被显示在一个新窗口中：
+
+
+ +可以见到，MMOCRInferencer 的 Python 接口与命令行接口的使用方法非常相似。下文将以 Python 接口为例，介绍 MMOCRInferencer 的具体用法。关于命令行接口的更多信息，请参考 [命令行接口](#命令行接口)。 + + +```` + +````{group-tab} 标准推理器 + +通常，OpenMMLab 中的所有标准推理器都具有非常相似的接口。下面的例子展示了如何使用 `TextDetInferencer` 对单个图像进行推理。 + +```python +>>> from mmocr.apis import TextDetInferencer +>>> # 读取模型 +>>> inferencer = TextDetInferencer(model='DBNet') +>>> # 推理 +>>> inferencer('demo/demo_text_ocr.jpg', show=True) +``` + +可视化结果如图： + +
+ +此处列举了一些常见的初始化模型的方法。 + +- 你可以通过传递模型的名称给 `model` 来推理 MMOCR 的预训练模型。权重将会自动从 OpenMMLab 的模型库中下载并加载。 + + ```python + >>> from mmocr.apis import TextDetInferencer + >>> inferencer = TextDetInferencer(model='DBNet') + ``` + + ```{note} + 模型与推理器的任务种类必须匹配。 + ``` + + 你可以通过将权重的路径或 URL 传递给 `weights` 来让推理器加载自定义的权重。 + + ```python + >>> inferencer = TextDetInferencer(model='DBNet', weights='path/to/dbnet.pth') + ``` + +- 如果有自定义的配置和权重，你可以将配置文件的路径传递给 `model`，将权重的路径传递给 `weights`。 + + ```python + >>> inferencer = TextDetInferencer(model='path/to/dbnet_config.py', weights='path/to/dbnet.pth') + ``` + +- 默认情况下，[MMEngine](https://github.com/open-mmlab/mmengine/) 会在训练模型时自动将配置文件转储到权重文件中。如果你有一个在 MMEngine 上训练的权重，你也可以将权重文件的路径传递给 `weights`，而不需要指定 `model`： + + ```python + >>> # 如果无法在权重中找到配置文件，则会引发错误 + >>> inferencer = TextDetInferencer(weights='path/to/dbnet.pth') + ``` + +- 传递配置文件到 `model` 而不指定 `weight` 则会产生一个随机初始化的模型。 + +```` +````` + +### 推理设备 + +每个推理器实例都会跟一个设备绑定。默认情况下，最佳设备是由 [MMEngine](https://github.com/open-mmlab/mmengine/) 自动决定的。你也可以通过指定 `device` 参数来改变设备。例如，你可以使用以下代码在 GPU 1上创建一个推理器。 + +`````{tabs} + +````{group-tab} MMOCRInferencer + +```python +>>> inferencer = MMOCRInferencer(det='DBNet', device='cuda:1') +``` + +```` + +````{group-tab} 标准推理器 + +```python +>>> inferencer = TextDetInferencer(model='DBNet', device='cuda:1') +``` + +```` + +````` + +如要在 CPU 上创建一个推理器： + +`````{tabs} + +````{group-tab} MMOCRInferencer + +```python +>>> inferencer = MMOCRInferencer(det='DBNet', device='cpu') +``` + +```` + +````{group-tab} 标准推理器 + +```python +>>> inferencer = TextDetInferencer(model='DBNet', device='cpu') +``` + +```` + +````` + +请参考 [torch.device](torch.device) 了解 `device` 参数支持的所有形式。 + +## 推理 + +当推理器初始化后，你可以直接传入要推理的原始数据，从返回值中获取推理结果。 + +### 输入 + +`````{tabs} + +````{tab} MMOCRInferencer / TextDetInferencer / TextRecInferencer / TextSpottingInferencer + +输入可以是以下任意一种格式： + +- str: 图像的路径/URL。 + + ```python + >>> inferencer('demo/demo_text_ocr.jpg') + ``` + +- array: 图像的 numpy 数组。它应该是 BGR 格式。 + + ```python + >>> import mmcv + >>> array = mmcv.imread('demo/demo_text_ocr.jpg') + >>> inferencer(array) + ``` + +- list: 基本类型的列表。列表中的每个元素都将单独处理。 + + ```python + >>> inferencer(['img_1.jpg', 'img_2.jpg]) + >>> # 列表内混合类型也是允许的 + >>> inferencer(['img_1.jpg', array]) + ``` + +- str: 目录的路径。目录中的所有图像都将被处理。 + + ```python + >>> inferencer('tests/data/det_toy_dataset/imgs/test/') + ``` + +```` + +````{tab} KIEInferencer + +输入可以是一个字典或者一个字典列表，其中每个字典包含以下键： + +- `img` (str 或者 ndarray): 图像的路径或图像本身。如果 KIE 推理器在无可视模式下使用，则不需要此键。如果它是一个 numpy 数组，则应该是 BGR 顺序编码的图片。 +- `img_shape` (tuple(int, int)): 图像的形状 (H, W)。仅在 KIE 推理器在无可视模式下使用且没有提供 `img` 时才需要。 +- `instances` (list[dict]): 实例列表。 + +每个 `instance` 都应该包含以下键： + +```python +{ + # 一个嵌套列表，其中包含 4 个数字，表示实例的边界框，顺序为 (x1, y1, x2, y2) + "bbox": np.array([[x1, y1, x2, y2], [x1, y1, x2, y2], ...], + dtype=np.int32), + + # 文本列表 + "texts": ['text1', 'text2', ...], +} +``` + +```` +````` + +### 输出 + +默认情况下，每个推理器都以字典格式返回预测结果。 + +- `visualization` 包含可视化的预测结果。但默认情况下，它是一个空列表，除非 `return_vis=True`。 + +- `predictions` 包含以 json-可序列化格式返回的预测结果。如下所示，内容因任务类型而异。 + + `````{tabs} + + :::{group-tab} MMOCRInferencer + + ```python + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'det_polygons': [...], # 2d 列表，长度为 (N,)，格式为 [x1, y1, x2, y2, ...] + 'det_scores': [...], # 浮点列表，长度为（N, ） + 'det_bboxes': [...], # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y] + 'rec_texts': [...], # 字符串列表，长度为（N, ） + 'rec_scores': [...], # 浮点列表，长度为（N, ） + 'kie_labels': [...], # 节点标签，长度为 (N, ) + 'kie_scores': [...], # 节点置信度，长度为 (N, ) + 'kie_edge_scores': [...], # 边预测置信度, 形状为 (N, N) + 'kie_edge_labels': [...] # 边标签, 形状为 (N, N) + }, + ... + ], + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ``` + + ::: + + ````{group-tab} 标准推理器 + + ::::{tabs} + :::{code-tab} python TextDetInferencer + + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'polygons': [...], # 2d 列表，长度为 (N,)，格式为 [x1, y1, x2, y2, ...] + 'bboxes': [...], # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y] + 'scores': [...] # 浮点列表，长度为（N, ） + }, + ... + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + + :::{code-tab} python TextRecInferencer + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'text': '...', # 字符串 + 'scores': 0.1, # 浮点 + }, + ... + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + + :::{code-tab} python TextSpottingInferencer + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'polygons': [...], # 2d 列表，长度为 (N,)，格式为 [x1, y1, x2, y2, ...] + 'bboxes': [...], # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y] + 'scores': [...] # 浮点列表，长度为（N, ） + 'texts': ['...',] # 字符串列表，长度为（N, ） + }, + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + + :::{code-tab} python KIEInferencer + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'labels': [...], # 节点标签，长度为 (N, ) + 'scores': [...], # 节点置信度，长度为 (N, ) + 'edge_scores': [...], # 边预测置信度, 形状为 (N, N) + 'edge_labels': [...], # 边标签, 形状为 (N, N) + }, + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + :::: + ```` + + ````` + +如果你想要从模型中获取原始输出，可以将 `return_datasamples` 设置为 `True` 来获取原始的 [DataSample](structures.md)，它将存储在 `predictions` 中。 + +### 储存结果 + +除了从返回值中获取预测结果，你还可以通过设置 `out_dir` 和 `save_pred`/`save_vis` 参数将预测结果和可视化结果导出到文件中。 + +```python +>>> inferencer('img_1.jpg', out_dir='outputs/', save_pred=True, save_vis=True) +``` + +结果目录结构如下： + +```text +outputs +├── preds +│ └── img_1.json +└── vis + └── img_1.jpg +``` + +文件名与对应的输入图像文件名相同。 如果输入图像是数组，则文件名将是从0开始的数字。 + +### 批量推理 + +你可以通过设置 `batch_size` 来自定义批量推理的批大小。 默认批大小为 1。 + +## API + +这里列出了推理器详尽的参数列表。 + +````{tabs} + +```{group-tab} MMOCRInferencer + +**MMOCRInferencer.\_\_init\_\_():** + +| 参数 | 类型 | 默认值 | 描述 | +| ------------- | ----------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------ | +| `det` | str 或 [权重](../modelzoo.html#id2), 可选 | None | 预训练的文本检测算法。它是配置文件的路径或者是 metafile 中定义的模型名称。 | +| `det_weights` | str, 可选 | None | det 模型的权重文件的路径。 | +| `rec` | str 或 [权重](../modelzoo.html#id2), 可选 | None | 预训练的文本识别算法。它是配置文件的路径或者是 metafile 中定义的模型名称。 | +| `rec_weights` | str, 可选 | None | rec 模型的权重文件的路径。 | +| `kie` \[1\] | str 或 [权重](../modelzoo.html#id2), 可选 | None | 预训练的关键信息提取算法。它是配置文件的路径或者是 metafile 中定义的模型名称。 | +| `kie_weights` | str, 可选 | None | kie 模型的权重文件的路径。 | +| `device` | str, 可选 | None | 推理使用的设备，接受 `torch.device` 允许的所有字符串。例如，'cuda:0' 或 'cpu'。如果为 None，将自动使用可用设备。 默认为 None。 | + +\[1\]: 当同时指定了文本检测和识别模型时，`kie` 才会生效。 + +**MMOCRInferencer.\_\_call\_\_()** + +| 参数 | 类型 | 默认值 | 描述 | +| -------------------- | ----------------------- | ---------- | ---------------------------------------------------------------------------------------------- | +| `inputs` | str/list/tuple/np.array | **必需** | 它可以是一个图片/文件夹的路径，一个 numpy 数组，或者是一个包含图片路径或 numpy 数组的列表/元组 | +| `return_datasamples` | bool | False | 是否将结果作为 DataSample 返回。如果为 False，结果将被打包成一个字典。 | +| `batch_size` | int | 1 | 推理的批大小。 | +| `det_batch_size` | int, 可选 | None | 推理的批大小 (文本检测模型)。如果不为 None，则覆盖 batch_size。 | +| `rec_batch_size` | int, 可选 | None | 推理的批大小 (文本识别模型)。如果不为 None，则覆盖 batch_size。 | +| `kie_batch_size` | int, 可选 | None | 推理的批大小 (关键信息提取模型)。如果不为 None，则覆盖 batch_size。 | +| `return_vis` | bool | False | 是否返回可视化结果。 | +| `print_result` | bool | False | 是否将推理结果打印到控制台。 | +| `show` | bool | False | 是否在弹出窗口中显示可视化结果。 | +| `wait_time` | float | 0 | 弹窗展示可视化结果的时间间隔。 | +| `out_dir` | str | `results/` | 结果的输出目录。 | +| `save_vis` | bool | False | 是否将可视化结果保存到 `out_dir`。 | +| `save_pred` | bool | False | 是否将推理结果保存到 `out_dir`。 | + +``` + +```{group-tab} 标准推理器 + +**Inferencer.\_\_init\_\_():** + +| 参数 | 类型 | 默认值 | 描述 | +| --------- | ----------------------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------- | +| `model` | str 或 [权重](../modelzoo.html#id2), 可选 | None | 路径到配置文件或者在 metafile 中定义的模型名称。 | +| `weights` | str, 可选 | None | 权重文件的路径。 | +| `device` | str, 可选 | None | 推理使用的设备，接受 `torch.device` 允许的所有字符串。 例如，'cuda:0' 或 'cpu'。 如果为 None，则将自动使用可用设备。 默认为 None。 | + +**Inferencer.\_\_call\_\_()** + +| 参数 | 类型 | 默认值 | 描述 | +| -------------------- | ----------------------- | ---------- | ----------------------------------------------------------------------------------- | +| `inputs` | str/list/tuple/np.array | **必需** | 可以是图像的路径/文件夹，np 数组或列表/元组（带有图像路径或 np 数组） | +| `return_datasamples` | bool | False | 是否将结果作为 DataSamples 返回。 如果为 False，则结果将被打包到一个 dict 中。 | +| `batch_size` | int | 1 | 推理批大小。 | +| `progress_bar` | bool | True | 是否显示进度条。 | +| `return_vis` | bool | False | 是否返回可视化结果。 | +| `print_result` | bool | False | 是否将推理结果打印到控制台。 | +| `show` | bool | False | 是否在弹出窗口中显示可视化结果。 | +| `wait_time` | float | 0 | 弹窗展示可视化结果的时间间隔。 | +| `draw_pred` | bool | True | 是否绘制预测的边界框。 *仅适用于 `TextDetInferencer` 和 `TextSpottingInferencer`。* | +| `out_dir` | str | `results/` | 结果的输出目录。 | +| `save_vis` | bool | False | 是否将可视化结果保存到 `out_dir`。 | +| `save_pred` | bool | False | 是否将推理结果保存到 `out_dir`。 | + +``` +```` + +## 命令行接口 + +```{note} +该节仅适用于 `MMOCRInferencer`. +``` + +`MMOCRInferencer` 的命令行形式可以通过 `tools/infer.py` 调用，大致形式如下： + +```bash +python tools/infer.py INPUT_PATH [--det DET] [--det-weights ...] ... +``` + +其中，`INPUT_PATH` 为必须字段，内容应当为指向图片或文件目录的路径。其他参数与 Python 接口遵循的映射关系如下： + +- 在命令行中调用参数时，需要在 Python 接口的参数前面加上两个`-`，然后把下划线`_`替换成连字符`-`。例如， `out_dir` 会变成 `--out-dir`。 +- 对于布尔类型的参数，将参数放在命令中就相当于将其指定为 True。例如， `--show` 会将 `show` 参数指定为 True。 + +此外，命令行中默认不会回显推理结果，你可以通过 `--print-result` 参数来查看推理结果。 + +下面是一个例子： + +```bash +python tools/infer.py demo/demo_text_ocr.jpg --det DBNet --rec SAR --show --print-result +``` + +运行该命令，可以得到如下结果： + +```bash +{'predictions': [{'rec_texts': ['CBank', 'Docbcba', 'GROUP', 'MAUN', 'CROBINSONS', 'AOCOC', '916M3', 'BOO9', 'Oven', 'BRANDS', 'ARETAIL', '14', '70S', 'ROUND', 'SALE', 'YEAR', 'ALLY', 'SALE', 'SALE'],
+'rec_scores': [0.9753464579582214, ...], 'det_polygons': [[551.9930285844646, 411.9138765335083, 553.6153911653112,
+383.53195309638977, 620.2410061195247, 387.33785033226013, 618.6186435386782, 415.71977376937866], ...], 'det_scores': [0.8230461478233337, ...]}]}
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/install.md b/internlm_langchain/knowledge_base/MMOCR/content/install.md
new file mode 100644
index 00000000..47e2da19
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/install.md
@@ -0,0 +1,244 @@
+# 安装
+
+## 环境依赖
+
+- Linux | Windows | macOS
+- Python 3.7
+- PyTorch 1.6 或更高版本
+- torchvision 0.7.0
+- CUDA 10.1
+- NCCL 2
+- GCC 5.4.0 或更高版本
+
+## 准备环境
+
+```{note}
+如果你已经在本地安装了 PyTorch，请直接跳转到[安装步骤](#安装步骤)。
+```
+
+**第一步** 下载并安装 [Miniconda](https://docs.conda.io/en/latest/miniconda.html).
+
+**第二步** 创建并激活一个 conda 环境：
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**第三步** 依照[官方指南](https://pytorch.org/get-started/locally/)，安装 PyTorch。
+
+````{tabs}
+
+```{code-tab} shell GPU 平台
+conda install pytorch torchvision -c pytorch
+```
+
+```{code-tab} shell CPU 平台
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+````
+
+## 安装步骤
+
+我们建议大多数用户采用我们的推荐方式安装 MMOCR。倘若你需要更灵活的安装过程，则可以参考[自定义安装](#自定义安装)一节。
+
+### 推荐步骤
+
+**第一步** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine)， [MMCV](https://github.com/open-mmlab/mmcv) 和 [MMDetection](https://github.com/open-mmlab/mmdetection)。
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install mmcv
+mim install mmdet
+```
+
+**第二步** 安装 MMOCR.
+
+若你需要直接运行 MMOCR 或在其基础上进行开发，则通过源码安装（推荐）。
+
+如果你将 MMOCR 作为一个外置依赖库使用，则可以通过 MIM 安装。
+
+`````{tabs}
+
+````{group-tab} 源码安装
+
+```shell
+git clone https://github.com/open-mmlab/mmocr.git
+cd mmocr
+pip install -v -e .
+# "-v" 会让安装过程产生更详细的输出
+# "-e" 会以可编辑的方式安装该代码库，你对该代码库所作的任何更改都会立即生效
+```
+
+````
+
+````{group-tab} MIM 安装
+
+```shell
+
+mim install mmocr
+
+```
+
+````
+
+`````
+
+**第三步（可选）** 如果你需要使用与 `albumentations` 有关的变换（如 ABINet 数据流水线中的 `Albu`），或需要构建文档、运行单元测试的依赖，请使用以下命令安装依赖：
+
+`````{tabs}
+
+````{group-tab} 源码安装
+
+```shell
+# 安装 albu
+pip install -r requirements/albu.txt
+# 安装文档、测试等依赖
+pip install -r requirements.txt
+```
+
+````
+
+````{group-tab} MIM 安装
+
+```shell
+pip install albumentations>=1.1.0 --no-binary qudida,albumentations
+```
+
+````
+
+`````
+
+```{note}
+
+我们建议在安装 `albumentations` 之后检查当前环境，确保 `opencv-python` 和 `opencv-python-headless` 没有同时被安装，否则有可能会产生一些无法预知的错误。如果它们不巧同时存在于环境当中，请卸载 `opencv-python-headless` 以确保 MMOCR 的可视化工具可以正常运行。
+
+查看 [`albumentations` 的官方文档](https://albumentations.ai/docs/getting_started/installation/#note-on-opencv-dependencies)以获知详情。
+
+```
+
+### 检验
+
+你可以通过运行一个简单的推理任务来检验 MMOCR 的安装是否成功。
+
+`````{tabs}
+
+````{tab} Python
+
+在 Python 中运行以下代码：
+
+```python
+>>> from mmocr.apis import MMOCRInferencer
+>>> ocr = MMOCRInferencer(det='DBNet', rec='CRNN')
+>>> ocr('demo/demo_text_ocr.jpg', show=True, print_result=True)
+```
+````
+
+````{tab} Shell
+
+如果你是通过源码安装的 MMOCR，你可以在 MMOCR 的根目录下运行以下命令：
+
+```shell
+python tools/infer.py demo/demo_text_ocr.jpg --det DBNet --rec CRNN --show --print-result
+```
+````
+
+`````
+
+若 MMOCR 的安装无误，你在这一节完成后应当能看到以图片和文字形式表示的识别结果：
+
+
+ +```bash +# 识别结果 +{'predictions': [{'rec_texts': ['cbanks', 'docecea', 'grouf', 'pwate', 'chobnsonsg', 'soxee', 'oeioh', 'c', 'sones', 'lbrandec', 'sretalg', '11', 'to8', 'round', 'sale', 'year', +'ally', 'sie', 'sall'], 'rec_scores': [...], 'det_polygons': [...], 'det_scores': +[...]}]} +``` + +```{note} +如果你在没有 GUI 的服务器上运行 MMOCR，或者通过没有开启 X11 转发的 SSH 隧道运行 MMOCR，你可能无法看到弹出的窗口。 +``` + +## 自定义安装 + +### CUDA 版本 + +安装 PyTorch 时，需要指定 CUDA 版本。如果您不清楚选择哪个，请遵循我们的建议： + +- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 series 以及 NVIDIA A100，CUDA 11 是必需的。 +- 对于更早的 NVIDIA GPU，CUDA 11 是向前兼容的，但 CUDA 10.2 能够提供更好的兼容性，也更加轻量。 + +请确保你的 GPU 驱动版本满足最低的版本需求，参阅[这张表](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。 + +```{note} +如果按照我们的最佳实践进行安装，CUDA 运行时库就足够了，因为我们提供相关 CUDA 代码的预编译，你不需要进行本地编译。 +但如果你希望从源码进行 MMCV 的编译，或是进行其他 CUDA 算子的开发，那么就必须安装完整的 CUDA 工具链，参见 +[NVIDIA 官网](https://developer.nvidia.com/cuda-downloads)，另外还需要确保该 CUDA 工具链的版本与 PyTorch 安装时 +的配置相匹配（如用 `conda install` 安装 PyTorch 时指定的 cudatoolkit 版本）。 +``` + +### 不使用 MIM 安装 MMCV + +MMCV 包含 C++ 和 CUDA 扩展，因此其对 PyTorch 的依赖比较复杂。MIM 会自动解析这些 +依赖，选择合适的 MMCV 预编译包，使安装更简单，但它并不是必需的。 + +要使用 pip 而不是 MIM 来安装 MMCV，请遵照 [MMCV 安装指南](https://mmcv.readthedocs.io/zh_CN/latest/get_started/installation.html)。 +它需要你用指定 url 的形式手动指定对应的 PyTorch 和 CUDA 版本。 + +举个例子，如下命令将会安装基于 PyTorch 1.10.x 和 CUDA 11.3 编译的 mmcv-full。 + +```shell +pip install 'mmcv>=2.0.0rc1' -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html +``` + +### 在 CPU 环境中安装 + +MMOCR 可以仅在 CPU 环境中安装，在 CPU 模式下，你可以完成训练（需要 MMCV 版本 >= 1.4.4）、测试和模型推理等所有操作。 + +在 CPU 模式下，MMCV 中的以下算子将不可用： + +- Deformable Convolution +- Modulated Deformable Convolution +- ROI pooling +- SyncBatchNorm + +如果你尝试使用用到了以上算子的模型进行训练、测试或推理，程序将会报错。以下为可能受到影响的模型列表： + +| 算子 | 模型 | +| :-----------------------------------------------------: | :-----------------------------------------------------: | +| Deformable Convolution/Modulated Deformable Convolution | DBNet (r50dcnv2), DBNet++ (r50dcnv2), FCENet (r50dcnv2) | +| SyncBatchNorm | PANet, PSENet | + +### 通过 Docker 使用 MMOCR + +我们提供了一个 [Dockerfile](https://github.com/open-mmlab/mmocr/blob/master/docker/Dockerfile) 文件以建立 docker 镜像 。 + +```shell +# build an image with PyTorch 1.6, CUDA 10.1 +docker build -t mmocr docker/ +``` + +使用以下命令运行。 + +```shell +docker run --gpus all --shm-size=8g -it -v {实际数据目录}:/mmocr/data mmocr +``` + +## 对 MMEngine、MMCV 和 MMDetection 的版本依赖 + +为了确保代码实现的正确性，MMOCR 每个版本都有可能改变对 MMEngine、MMCV 和 MMDetection 版本的依赖。请根据以下表格确保版本之间的相互匹配。 + +| MMOCR | MMEngine | MMCV | MMDetection | +| -------------- | --------------------------- | -------------------------- | --------------------------- | +| dev-1.x | 0.7.1 \<= mmengine \< 1.1.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.2.0 | +| 1.0.1 | 0.7.1 \<= mmengine \< 1.1.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.2.0 | +| 1.0.0 | 0.7.1 \<= mmengine \< 1.0.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.1.0 | +| 1.0.0rc6 | 0.6.0 \<= mmengine \< 1.0.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.1.0 | +| 1.0.0rc\[4-5\] | 0.1.0 \<= mmengine \< 1.0.0 | 2.0.0rc1 \<= mmcv \< 2.1.0 | 3.0.0rc0 \<= mmdet \< 3.1.0 | +| 1.0.0rc\[0-3\] | 0.0.0 \<= mmengine \< 0.2.0 | 2.0.0rc1 \<= mmcv \< 2.1.0 | 3.0.0rc0 \<= mmdet \< 3.1.0 | diff --git a/internlm_langchain/knowledge_base/MMOCR/content/kie.md b/internlm_langchain/knowledge_base/MMOCR/content/kie.md new file mode 100644 index 00000000..ce8d1462 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/kie.md @@ -0,0 +1,40 @@ +# 关键信息提取 + +```{note} +我们正努力往 [Dataset Preparer](./dataset_preparer.md) 中增加更多数据集。对于 [Dataset Preparer](./dataset_preparer.md) 暂未能完整支持的数据集，本页提供了一系列手动下载的步骤，供有需要的用户使用。 +``` + +## 概览 + +关键信息提取任务的数据集，文件目录应按如下配置： + +```text +└── wildreceipt + ├── class_list.txt + ├── dict.txt + ├── image_files + ├── test.txt + └── train.txt +``` + +## 准备步骤 + +### WildReceipt + +- 下载并解压 [wildreceipt.tar](https://download.openmmlab.com/mmocr/data/wildreceipt.tar) + +### WildReceiptOpenset + +- 准备好 [WildReceipt](#WildReceipt)。 +- 转换 WildReceipt 成 OpenSet 格式: + +```bash +# 你可以运行以下命令以获取更多可用参数： +# python tools/data/kie/closeset_to_openset.py -h +python tools/data/kie/closeset_to_openset.py data/wildreceipt/train.txt data/wildreceipt/openset_train.txt +python tools/data/kie/closeset_to_openset.py data/wildreceipt/test.txt data/wildreceipt/openset_test.txt +``` + +```{note} +[这篇教程](../tutorials/kie_closeset_openset.md)里讲述了更多 CloseSet 和 OpenSet 数据格式之间的区别。 +``` diff --git a/internlm_langchain/knowledge_base/MMOCR/content/model.md b/internlm_langchain/knowledge_base/MMOCR/content/model.md new file mode 100644 index 00000000..0e276513 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/model.md @@ -0,0 +1,5 @@ +# 预训练模型迁移指南 + +由于在新版本中我们对模型的结构进行了大量的重构和修复，MMOCR 1.x 并不能直接读入旧版的预训练权重。我们在网站上同步更新了所有模型的预训练权重和log，供有需要的用户使用。 + +此外，我们正在进行针对文本检测任务的权重迁移工具的开发，并计划于近期版本内发布。由于文本识别和关键信息提取模型改动过大，且迁移是有损的，我们暂时不计划作相应支持。如果您有具体的需求，欢迎通过 [Issue](https://github.com/open-mmlab/mmocr/issues) 向我们提问。 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/models.md b/internlm_langchain/knowledge_base/MMOCR/content/models.md new file mode 100644 index 00000000..7ec449d5 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/models.md @@ -0,0 +1,3 @@ +# 模型\[待更新\] + +待更新 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/news.md b/internlm_langchain/knowledge_base/MMOCR/content/news.md new file mode 100644 index 00000000..e1ca6f91 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/news.md @@ -0,0 +1,19 @@ +# MMOCR 1.x 更新汇总 + +此处列出了 MMOCR 1.x 相对于 0.x 版本的重大更新。 + +1. 架构升级：MMOCR 1.x 是基于 [MMEngine](https://github.com/open-mmlab/mmengine)，提供了一个通用的、强大的执行器，允许更灵活的定制，提供了统一的训练和测试入口。 + +2. 统一接口：MMOCR 1.x 统一了数据集、模型、评估和可视化的接口和内部逻辑。支持更强的扩展性。 + +3. 跨项目调用：受益于统一的设计，你可以使用其他OpenMMLab项目中实现的模型，如MMDet。 我们提供了一个例子，说明如何通过MMDetWrapper使用MMDetection的Mask R-CNN。查看我们的文档以了解更多细节。更多的包装器将在未来发布。 + +4. 更强的可视化：我们提供了一系列可视化工具， 用户现在可以更方便可视化数据。 + +5. 更多的文档和教程：我们增加了更多的教程，降低用户的学习门槛。 + +6. 一站式数据准备：准备数据集已经不再是难事。使用我们的 [Dataset Preparer](https://mmocr.readthedocs.io/zh_CN/dev-1.x/user_guides/data_prepare/dataset_preparer.html)，一行命令即可让多个数据集准备就绪。 + +7. 拥抱更多 `projects/`: 我们推出了 `projects/` 文件夹，用于存放一些实验性的新特性、框架和模型。我们对这个文件夹下的代码规范不作过多要求，力求让社区的所有想法第一时间得到实现和展示。请查看我们的[样例 project](https://github.com/open-mmlab/mmocr/blob/dev-1.x/projects/example_project/) 以了解更多。 + +8. 更多新模型：MMOCR 1.0 支持了更多模型和模型种类。 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/overview.md b/internlm_langchain/knowledge_base/MMOCR/content/overview.md new file mode 100644 index 00000000..bbd72139 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/overview.md @@ -0,0 +1,3 @@ +# 设计理念与特性\[待更新\] + +待更新 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/quick_run.md b/internlm_langchain/knowledge_base/MMOCR/content/quick_run.md new file mode 100644 index 00000000..bcca7370 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/quick_run.md @@ -0,0 +1,201 @@ +# 快速运行 + +这个章节会介绍 MMOCR 的一些基本功能。我们假设你已经[从源码安装了 MMOCR](install.md#best-practices)。此外，你也可以通过[教程 Notebook](https://colab.research.google.com/github/open-mmlab/mmocr/blob/dev-1.x/demo/tutorial.ipynb)来了解如何在交互式环境下实现推理、训练和测试。 + +## 推理 + +在 MMOCR 的根目录下运行以下命令： + +```shell +python tools/infer.py demo/demo_text_ocr.jpg --det DBNet --rec CRNN --show --print-result +``` + +你可以看到弹出的预测结果，以及在控制台中打印出的推理结果。 + +
+ +```bash +# 识别结果 +{'predictions': [{'rec_texts': ['cbanks', 'docecea', 'grouf', 'pwate', 'chobnsonsg', 'soxee', 'oeioh', 'c', 'sones', 'lbrandec', 'sretalg', '11', 'to8', 'round', 'sale', 'year', +'ally', 'sie', 'sall'], 'rec_scores': [...], 'det_polygons': [...], 'det_scores': +[...]}]} +``` + +```{note} +如果你在没有 GUI 的服务器上运行 MMOCR，或者通过没有开启 X11 转发的 SSH 隧道运行 MMOCR，你可能无法看到弹出的窗口。 +``` + +对 MMOCR 中推理接口更为详细的说明，可以在[这里](../user_guides/inference.md)找到。 + +除了使用我们提供好的预训练模型，用户也可以在自己的数据集上训练流行模型。接下来我们以在迷你的 [ICDAR 2015](https://rrc.cvc.uab.es/?ch=4&com=downloads) 数据集上训练 DBNet 为例，带大家熟悉 MMOCR 的基本功能。 + +## 准备数据集 + +由于 OCR 任务的数据集种类多样，格式不一，不利于多数据集的切换和联合训练，因此 MMOCR 约定了一种[统一的数据格式](../user_guides/dataset_prepare.md)，并针对常用的 OCR 数据集提供了[一键式数据准备脚本](../user_guides/data_prepare/dataset_preparer.md)。通常，要在 MMOCR 中使用数据集，你只需要按照对应步骤运行指令即可。 + +```{note} +但我们亦深知，效率就是生命——尤其对想要快速上手 MMOCR 的你来说。 +``` + +在这里，我们准备了一个用于演示的精简版 ICDAR 2015 数据集。下载我们预先准备好的[压缩包](https://download.openmmlab.com/mmocr/data/icdar2015/mini_icdar2015.tar.gz)，解压到 mmocr 的 `data/` 目录下，就能得到我们准备好的图片和标注文件。 + +```Bash +wget https://download.openmmlab.com/mmocr/data/icdar2015/mini_icdar2015.tar.gz +mkdir -p data/ +tar xzvf mini_icdar2015.tar.gz -C data/ +``` + +## 修改配置 + +准备好数据集后，我们接下来就需要通过修改配置的方式指定训练集的位置和训练参数。 + +在这个例子中，我们将会训练一个以 resnet18 作为骨干网络（backbone）的 DBNet。由于 MMOCR 已经有针对完整 ICDAR 2015 数据集的配置 （`configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py`），我们只需要在它的基础上作出一点修改。 + +我们首先需要修改数据集的路径。在这个配置中，大部分关键的配置文件都在 `_base_` 中被导入，如数据库的配置就来自 `configs/textdet/_base_/datasets/icdar2015.py`。打开该文件，把第一行 `icdar2015_textdet_data_root` 指向的路径替换： + +```Python +icdar2015_textdet_data_root = 'data/mini_icdar2015' +``` + +另外，因为数据集尺寸缩小了，我们也要相应地减少训练的轮次到 400，缩短验证和储存权重的间隔到10轮，并放弃学习率衰减策略。直接把以下几行配置放入 `configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py`即可生效： + +```Python +# 每 10 个 epoch 储存一次权重，且只保留最后一个权重 +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=10, + max_keep_ckpts=1, + )) +# 设置最大 epoch 数为 400，每 10 个 epoch 运行一次验证 +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=400, val_interval=10) +# 令学习率为常量，即不进行学习率衰减 +param_scheduler = [dict(type='ConstantLR', factor=1.0),] +``` + +这里，我们通过配置的继承 ({external+mmengine:doc}`MMEngine: Config`) 机制将基础配置中的相应参数直接进行了改写。原本的字段分布在 `configs/textdet/_base_/schedules/schedule_sgd_1200e.py` 和 `configs/textdet/_base_/default_runtime.py` 中，感兴趣的读者可以自行查看。
+
+```{note}
+关于配置文件更加详尽的说明，请参考[此处](../user_guides/config.md)。
+```
+
+## 可视化数据集
+
+在正式开始训练前，我们还可以可视化一下经过训练过程中[数据变换（transforms）](../basic_concepts/transforms.md)后的图像。方法也很简单，把我们需要可视化的配置传入 [browse_dataset.py](/tools/analysis_tools/browse_dataset.py) 脚本即可：
+
+```Bash
+python tools/analysis_tools/browse_dataset.py configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py
+```
+
+数据变换后的图片和标签会在弹窗中逐张被展示出来。
+
+
+ 
+
+
+```{note}
+有关该脚本更详细的指南，请参考[此处](../user_guides/useful_tools.md).
+```
+
+```{tip}
+除了满足好奇心之外，可视化还可以帮助我们在训练前检查可能影响到模型表现的部分，如配置文件、数据集及数据变换中的问题。
+```
+
+## 训练
+
+万事俱备，只欠东风。运行以下命令启动训练：
+
+```Bash
+python tools/train.py configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py
+```
+
+根据系统情况，MMOCR 会自动使用最佳的设备进行训练。如果有 GPU，则会默认在第一张卡启动单卡训练。当开始看到 loss 的输出，就说明你已经成功启动了训练。
+
+```Bash
+2022/08/22 18:42:22 - mmengine - INFO - Epoch(train) [1][5/7] lr: 7.0000e-03 memory: 7730 data_time: 0.4496 loss_prob: 14.6061 loss_thr: 2.2904 loss_db: 0.9879 loss: 17.8843 time: 1.8666
+2022/08/22 18:42:24 - mmengine - INFO - Exp name: dbnet_resnet18_fpnc_1200e_icdar2015
+2022/08/22 18:42:28 - mmengine - INFO - Epoch(train) [2][5/7] lr: 7.0000e-03 memory: 6695 data_time: 0.2052 loss_prob: 6.7840 loss_thr: 1.4114 loss_db: 0.9855 loss: 9.1809 time: 0.7506
+2022/08/22 18:42:29 - mmengine - INFO - Exp name: dbnet_resnet18_fpnc_1200e_icdar2015
+2022/08/22 18:42:33 - mmengine - INFO - Epoch(train) [3][5/7] lr: 7.0000e-03 memory: 6690 data_time: 0.2101 loss_prob: 3.0700 loss_thr: 1.1800 loss_db: 0.9967 loss: 5.2468 time: 0.6244
+2022/08/22 18:42:33 - mmengine - INFO - Exp name: dbnet_resnet18_fpnc_1200e_icdar2015
+```
+
+在不指定额外参数时，训练的权重默认会被保存到 `work_dirs/dbnet_resnet18_fpnc_1200e_icdar2015/` 下面，而日志则会保存在`work_dirs/dbnet_resnet18_fpnc_1200e_icdar2015/开始训练的时间戳/`里。接下来，我们只需要耐心等待模型训练完成即可。
+
+```{note}
+若需要了解训练的高级用法，如 CPU 训练、多卡训练及集群训练等，请查阅[训练与测试](../user_guides/train_test.md)。
+```
+
+## 测试
+
+经过数十分钟的等待，模型顺利完成了400 epochs的训练。我们通过控制台的输出，观察到 DBNet 在最后一个 epoch 的表现最好，`hmean` 达到了 60.86（你可能会得到一个不太一样的结果）：
+
+```Bash
+08/22 19:24:52 - mmengine - INFO - Epoch(val) [400][100/100] icdar/precision: 0.7285 icdar/recall: 0.5226 icdar/hmean: 0.6086
+```
+
+```{note}
+它或许还没被训练到最优状态，但对于一个演示而言已经足够了。
+```
+
+然而，这个数值只反映了 DBNet 在迷你 ICDAR 2015 数据集上的性能。要想更加客观地评判它的检测能力，我们还要看看它在分布外数据集上的表现。例如，`tests/data/det_toy_dataset` 就是一个很小的真实数据集，我们可以用它来验证一下 DBNet 的实际性能。
+
+在测试前，我们同样需要对数据集的位置做一下修改。打开 `configs/textdet/_base_/datasets/icdar2015.py`，修改 `icdar2015_textdet_test` 的 `data_root` 为 `tests/data/det_toy_dataset`:
+
+```Python
+# ...
+icdar2015_textdet_test = dict(
+ type='OCRDataset',
+ data_root='tests/data/det_toy_dataset',
+ # ...
+ )
+```
+
+修改完毕，运行命令启动测试。
+
+```Bash
+python tools/test.py configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py work_dirs/dbnet_resnet18_fpnc_1200e_icdar2015/epoch_400.pth
+```
+
+得到输出：
+
+```Bash
+08/21 21:45:59 - mmengine - INFO - Epoch(test) [5/10] memory: 8562
+08/21 21:45:59 - mmengine - INFO - Epoch(test) [10/10] eta: 0:00:00 time: 0.4893 data_time: 0.0191 memory: 283
+08/21 21:45:59 - mmengine - INFO - Evaluating hmean-iou...
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.30, recall: 0.6190, precision: 0.4815, hmean: 0.5417
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.40, recall: 0.6190, precision: 0.5909, hmean: 0.6047
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.50, recall: 0.6190, precision: 0.6842, hmean: 0.6500
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.60, recall: 0.6190, precision: 0.7222, hmean: 0.6667
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.70, recall: 0.3810, precision: 0.8889, hmean: 0.5333
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.80, recall: 0.0000, precision: 0.0000, hmean: 0.0000
+08/21 21:45:59 - mmengine - INFO - prediction score threshold: 0.90, recall: 0.0000, precision: 0.0000, hmean: 0.0000
+08/21 21:45:59 - mmengine - INFO - Epoch(test) [10/10] icdar/precision: 0.7222 icdar/recall: 0.6190 icdar/hmean: 0.6667
+```
+
+可以发现，模型在这个数据集上能达到的 hmean 为 0.6667，效果还是不错的。
+
+```{note}
+若需要了解测试的高级用法，如 CPU 测试、多卡测试及集群测试等，请查阅[训练与测试](../user_guides/train_test.md)。
+```
+
+## 可视化输出
+
+为了对模型的输出有一个更直观的感受，我们还可以直接可视化它的预测输出。在 `test.py` 中，用户可以通过 `show` 参数打开弹窗可视化；也可以通过 `show-dir` 参数指定预测结果图导出的目录。
+
+```Bash
+python tools/test.py configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py work_dirs/dbnet_resnet18_fpnc_1200e_icdar2015/epoch_400.pth --show-dir imgs/
+```
+
+真实标签和预测值会在可视化结果中以平铺的方式展示。左图的绿框表示真实标签，右图的红框表示预测值。
+
+` 将各任务所需的数据统一封装入 `data_sample` 中。MMEngine 的抽象数据接口实现了基础的增/删/改/查功能，且支持不同设备间的数据迁移，也支持了类字典和张量的操作，充分满足了数据的日常使用需求，这也使得不同算法的数据接口可以得到统一。
+
+得益于统一的数据封装，算法库内的 [`visualizer`](./visualizers.md)，[`evaluator`](./evaluation.md)，[`dataset`](./datasets.md) 等各个模块间的数据流通都得到了极大的简化。在 MMOCR 中，我们对数据接口类型作出以下约定：
+
+- **xxxData**: 单一粒度的数据标注或模型输出。目前 MMEngine 内置了三种粒度的{external+mmengine:doc}`数据元素 `，包括实例级数据（`InstanceData`），像素级数据（`PixelData`）以及图像级的标签数据（`LabelData`）。在 MMOCR 目前支持的任务中，文本检测以及关键信息抽取任务使用 `InstanceData` 来封装文本实例的检测框及对应标签，而文本识别任务则使用了 `LabelData` 来封装文本内容。
+- **xxxDataSample**: 继承自 {external+mmengine:doc}`MMEngine: 数据基类 ` `BaseDataElement`，用于保存单个任务的训练或测试样本的**所有**标注及预测信息。如文本检测任务的数据样本类 [`TextDetDataSample`](mmocr.structures.textdet_data_sample.TextDetDataSample)，文本识别任务的数据样本类 [`TextRecogDataSample`](mmocr.structures.textrecog_data_sample.TextRecogDataSample)，以及关键信息抽任务的数据样本类 [`KIEDataSample`](mmocr.structures.kie_data_sample.KIEDataSample)。
+
+下面，我们将分别介绍数据元素 **xxxData** 与数据样本 **xxxDataSample** 在 MMOCR 中的实际应用。
+
+## 数据元素 xxxData
+
+`InstanceData` 和 `LabelData` 是 `MMEngine`中定义的基础数据元素，用于封装不同粒度的标注数据或模型输出。在 MMOCR 中，我们针对不同任务中实际使用的数据类型，分别采用了 `InstanceData` 与 `LabelData` 进行了封装。
+
+### InstanceData
+
+在**文本检测**任务中，检测器关注的是实例级别的文字样本，因此我们使用 `InstanceData` 来封装该任务所需的数据。其所需的训练标注和预测输出通常包含了矩形或多边形边界盒，以及边界盒标签。由于文本检测任务只有一种正样本类，即 “text”，在 MMOCR 中我们默认使用 `0` 来编号该类别。以下代码示例展示了如何使用 `InstanceData` 数据抽象接口来封装文本检测任务中使用的数据类型。
+
+```python
+import torch
+from mmengine.structures import InstanceData
+
+# 定义 gt_instance 用于封装边界盒的标注信息
+gt_instance = InstanceData()
+gt_instance.bbox = torch.Tensor([[0, 0, 10, 10], [10, 10, 20, 20]])
+gt_instance.polygons = torch.Tensor([[[0, 0], [10, 0], [10, 10], [0, 10]],
+ [[10, 10], [20, 10], [20, 20], [10, 20]]])
+gt_instance.label = torch.Tensor([0, 0])
+
+# 定义 pred_instance 用于封装模型的输出信息
+pred_instances = InstanceData()
+pred_polygons, scores = model(input)
+pred_instances.polygons = pred_polygons
+pred_instances.scores = scores
+```
+
+MMOCR 中对 `InstanceData` 字段的约定如下表所示。值得注意的是，`InstanceData` 中的各字段的长度必须为与样本中的实例个数 `N` 相等。
+
+| | | |
+| ----------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| 字段 | 类型 | 说明 |
+| bboxes | `torch.FloatTensor` | 文本边界框 `[x1, y1, x2, y2]`，形状为 `(N, 4)`。 |
+| labels | `torch.LongTensor` | 实例的类别，长度为 `(N, )`。MMOCR 中默认使用 `0` 来表示正样本类，即 “text” 类。 |
+| polygons | `list[np.array(dtype=np.float32)]` | 表示文本实例的多边形，列表长度为 `(N, )`。 |
+| scores | `torch.Tensor` | 文本实例检测框的置信度，长度为 `(N, )`。 |
+| ignored | `torch.BoolTensor` | 是否在训练中忽略当前文本实例，长度为 `(N, )`。 |
+| texts | `list[str]` | 实例对应的文本，长度为 `(N, )`，用于端到端 OCR 任务和 KIE。 |
+| text_scores | `torch.FloatTensor` | 文本预测的置信度，长度为`(N, )`，用于端到端 OCR 任务。 |
+| edge_labels | `torch.IntTensor` | 节点的邻接矩阵，形状为 `(N, N)`。在 KIE 任务中，节点之间状态的可选值为 `-1` （忽略，不参与 loss 计算），`0` （断开）和 `1`（连接）。 |
+| edge_scores | `torch.FloatTensor` | 用于 KIE 任务中每条边的预测置信度，形状为 `(N, N)`。 |
+
+### LabelData
+
+对于**文字识别**任务，标注内容和预测内容都会使用 `LabelData` 进行封装。
+
+```python
+import torch
+from mmengine.data import LabelData
+
+# 定义一个 gt_text 用于封装标签文本内容
+gt_text = LabelData()
+gt_text.item = 'MMOCR'
+
+# 定义一个 pred_text 对象用于封装预测文本以及置信度
+pred_text = LabelData()
+index, score = model(input)
+text = dictionary.idx2str(index)
+pred_text.score = score
+pred_text.item = text
+```
+
+MMOCR 中对 `LabelData` 字段的约定如下表所示：
+
+| | | |
+| -------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------- |
+| 字段 | 类型 | 说明 |
+| item | `str` | 文本内容。 |
+| score | `list[float]` | 预测的文本内容的置信度。 |
+| indexes | `torch.LongTensor` | 文本字符经过[字典](../basic_concepts/models.md#dictionary)编码后的序列，且包含了除 `` 以外的所有特殊字符。 |
+| padded_indexes | `torch.LongTensor` | 如果 indexes 的长度小于最大序列长度，且 `pad_idx` 存在时，该字段保存了填充至最大序列长度 `max_seq_len`的编码后的文本序列。 |
+
+## 数据样本 xxxDataSample
+
+通过定义统一的数据结构，我们可以方便地将标注数据和预测结果进行统一封装，使代码库不同模块间的数据传递更加便捷。在 MMOCR 中，我们基于现在支持的三个任务及其所需要的数据分别封装了三种数据抽象，包括文本检测任务数据抽象 [`TextDetDataSample`](mmocr.structures.textdet_data_sample.TextDetDataSample)，文本识别任务数据抽象 [`TextRecogDataSample`](mmocr.structures.textrecog_data_sample.TextRecogDataSample)，以及关键信息抽取任务数据抽象 [`KIEDataSample`](mmocr.structures.kie_data_sample.KIEDataSample)。这些数据抽象均继承自 {external+mmengine:doc}`MMEngine: 数据基类 ` `BaseDataElement`，用于保存单个任务的训练或测试样本的所有标注及预测信息。
+
+### 文本检测任务数据抽象 TextDetDataSample
+
+[TextDetDataSample](mmocr.structures.textdet_data_sample.TextDetDataSample) 用于封装文字检测任务所需的数据，其主要包含了两个字段 `gt_instances` 与 `pred_instances`，分别用于存放标注信息与预测结果。
+
+| | | |
+| -------------- | ------------------------------- | ---------- |
+| 字段 | 类型 | 说明 |
+| gt_instances | [`InstanceData`](#instancedata) | 标注信息。 |
+| pred_instances | [`InstanceData`](#instancedata) | 预测结果。 |
+
+其中会用到的 [`InstanceData`](#instancedata) 约定字段有：
+
+| | | |
+| -------- | ---------------------------------- | -------------------------------------------------------------------------------- |
+| 字段 | 类型 | 说明 |
+| bboxes | `torch.FloatTensor` | 文本边界框 `[x1, y1, x2, y2]`，形状为 `(N, 4)`。 |
+| labels | `torch.LongTensor` | 实例的类别，长度为 `(N, )`。在 MMOCR 中通常使用 `0` 来表示正样本类，即 “text” 类 |
+| polygons | `list[np.array(dtype=np.float32)]` | 表示文本实例的多边形，列表长度为 `(N, )`。 |
+| scores | `torch.Tensor` | 文本实例任务预测的检测框的置信度，长度为 `(N, )`。 |
+| ignored | `torch.BoolTensor` | 是否在训练中忽略当前文本实例，长度为 `(N, )`。 |
+
+由于文本检测模型通常只会输出 bboxes/polygons 中的一项，因此我们只需确保这两项中的一个被赋值即可。
+
+以下示例代码展示了 `TextDetDataSample` 的使用方法：
+
+```python
+import torch
+from mmengine.data import TextDetDataSample
+
+data_sample = TextDetDataSample()
+# 指定当前图片的标注信息
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+gt_instances = InstanceData(metainfo=img_meta)
+gt_instances.bboxes = torch.rand((5, 4))
+gt_instances.labels = torch.zeros((5,), dtype=torch.long)
+data_sample.gt_instances = gt_instances
+
+# 指定当前图片的预测信息
+pred_instances = InstanceData()
+pred_instances.bboxes = torch.rand((5, 4))
+pred_instances.labels = torch.zeros((5,), dtype=torch.long)
+data_sample.pred_instances = pred_instances
+```
+
+### 文本识别任务数据抽象 TextRecogDataSample
+
+[`TextRecogDataSample`](mmocr.structures.textrecog_data_sample.TextRecogDataSample) 用于封装文字识别任务的数据。它有两个属性，`gt_text` 和 `pred_text` , 分别用于存放标注信息和预测结果。
+
+| | | |
+| --------- | ------------------------- | ---------- |
+| 字段 | 类型 | 说明 |
+| gt_text | [`LabelData`](#labeldata) | 标注信息。 |
+| pred_text | [`LabelData`](#labeldata) | 预测结果。 |
+
+以下示例代码展示了 [`TextRecogDataSample`](mmocr.structures.textrecog_data_sample.TextRecogDataSample) 的使用方法：
+
+```python
+import torch
+from mmengine.data import TextRecogDataSample
+
+data_sample = TextRecogDataSample()
+# 指定当前图片的标注信息
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+gt_text = LabelData(metainfo=img_meta)
+gt_text.item = 'mmocr'
+data_sample.gt_text = gt_text
+
+# 指定当前图片的预测结果
+pred_text = LabelData(metainfo=img_meta)
+pred_text.item = 'mmocr'
+data_sample.pred_text = pred_text
+```
+
+其中会用到的 `LabelData` 字段有：
+
+| | | |
+| -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| 字段 | 类型 | 说明 |
+| item | `list[str]` | 实例对应的文本，长度为 (N, ) ，用于端到端 OCR 任务和 KIE |
+| score | `torch.FloatTensor` | 文本预测的置信度，长度为 (N, )，用于端到端 OCR 任务 |
+| indexes | `torch.LongTensor` | 文本字符经过[字典](../basic_concepts/models.md#dictionary)编码后的序列，且包含了除 `` 以外的所有特殊字符。 |
+| padded_indexes | `torch.LongTensor` | 如果 indexes 的长度小于最大序列长度，且 `pad_idx` 存在时，该字段保存了填充至最大序列长度 `max_seq_len`的编码后的文本序列。 |
+
+### 关键信息抽取任务数据抽象 KIEDataSample
+
+[`KIEDataSample`](mmocr.structures.kie_data_sample.KIEDataSample) 用于封装 KIE 任务所需的数据，其同样约定了两个属性，即 `gt_instances` 与 `pred_instances`，分别用于存放标注信息与预测结果。
+
+| | | |
+| -------------- | ------------------------------- | ---------- |
+| 字段 | 类型 | 说明 |
+| gt_instances | [`InstanceData`](#instancedata) | 标注信息。 |
+| pred_instances | [`InstanceData`](#instancedata) | 预测结果。 |
+
+该任务会用到的 [`InstanceData`](#instancedata) 字段如下表所示：
+
+| | | |
+| ----------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| 字段 | 类型 | 说明 |
+| bboxes | `torch.Tensor` | 文本边界框 `[x1, y1, x2, y2]`，形状为 `(N, 4)`。 |
+| labels | `torch.LongTensor` | 实例的类别，长度为 `(N, )`。在 MMOCR 中通常为 0，即 “text” 类。 |
+| texts | `list[str]` | 实例对应的文本，长度为 `(N, )` ，用于端到端 OCR 任务和 KIE 任务。 |
+| edge_labels | `torch.IntTensor` | 节点之间的邻接矩阵，形状为 `(N, N)`。在 KIE 任务中，节点之间状态的可选值为 `-1` （不关心，且不参与 loss 计算），`0` （断开）和 `1` （连接）。 |
+| edge_scores | `torch.FloatTensor` | 每条边的预测置信度，形状为 `(N, N)`。 |
+| scores | `torch.FloatTensor` | 节点标签的预测置信度, 形状为 `(N,)`。 |
+
+```{warning}
+由于 KIE 任务的模型实现尚未有统一标准，该设计目前仅考虑了 [SDMGR](../../../configs/kie/sdmgr/README.md) 模型的使用场景。因此，该设计有可能在我们支持更多 KIE 模型后产生变动。
+```
+
+以下示例代码展示了 [`KIEDataSample`](mmocr.structures.kie_data_sample.KIEDataSample) 的使用方法。
+
+```python
+import torch
+from mmengine.data import KIEDataSample
+
+data_sample = KIEDataSample()
+# 指定当前图片的标注信息
+img_meta = dict(img_shape=(800, 1196, 3),pad_shape=(800, 1216, 3))
+gt_instances = InstanceData(metainfo=img_meta)
+gt_instances.bboxes = torch.rand((5, 4))
+gt_instances.labels = torch.zeros((5,), dtype=torch.long)
+gt_instances.texts = ['text1', 'text2', 'text3', 'text4', 'text5']
+gt_instances.edge_lebels = torch.randint(-1, 2, (5, 5))
+data_sample.gt_instances = gt_instances
+
+# 指定当前图片的预测信息
+pred_instances = InstanceData()
+pred_instances.bboxes = torch.rand((5, 4))
+pred_instances.labels = torch.rand((5,))
+pred_instances.edge_labels = torch.randint(-1, 2, (10, 10))
+pred_instances.edge_scores = torch.rand((10, 10))
+data_sample.pred_instances = pred_instances
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/train_test.md b/internlm_langchain/knowledge_base/MMOCR/content/train_test.md
new file mode 100644
index 00000000..7ab634f8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/train_test.md
@@ -0,0 +1,324 @@
+# 训练与测试
+
+为了适配多样化的用户需求，MMOCR 实现了多种不同操作系统及设备上的模型训练及测试。无论是使用本地机器进行单机单卡训练测试，还是在部署了 slurm 系统的大规模集群上进行训练测试，MMOCR 都提供了便捷的解决方案。
+
+## 单卡机器训练及测试
+
+### 训练
+
+`tools/train.py` 实现了基础的训练服务。MMOCR 推荐用户使用 GPU 进行模型训练和测试，但是，用户也可以通过指定 `CUDA_VISIBLE_DEVICES=-1` 来使用 CPU 设备进行模型训练及测试。例如，以下命令演示了如何使用 CPU 或单卡 GPU 来训练 DBNet 文本检测器。
+
+```bash
+# 通过调用 tools/train.py 来训练指定的 MMOCR 模型
+CUDA_VISIBLE_DEVICES= python tools/train.py ${CONFIG_FILE} [PY_ARGS]
+
+# 训练
+# 示例 1：使用 CPU 训练 DBNet
+CUDA_VISIBLE_DEVICES=-1 python tools/train.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py
+
+# 示例 2：指定使用 gpu:0 训练 DBNet，指定工作目录为 dbnet/，并打开混合精度（amp）训练
+CUDA_VISIBLE_DEVICES=0 python tools/train.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py --work-dir dbnet/ --amp
+```
+
+```{note}
+此外，如需使用指定编号的 GPU 进行训练或测试，例如使用3号 GPU，则可以通过设定 CUDA_VISIBLE_DEVICES=3 来实现。
+```
+
+下表列出了 `train.py` 支持的所有参数。其中，不带 `--` 前缀的参数为必须的位置参数，带 `--` 前缀的参数为可选参数。
+
+| 参数 | 类型 | 说明 |
+| --------------- | ---- | -------------------------------------------------------------- |
+| config | str | （必须）配置文件路径。 |
+| --work-dir | str | 指定工作目录，用于存放训练日志以及模型 checkpoints。 |
+| --resume | bool | 是否从断点处恢复训练。 |
+| --amp | bool | 是否使用混合精度。 |
+| --auto-scale-lr | bool | 是否使用学习率自动缩放。 |
+| --cfg-options | str | 用于覆写配置文件中的指定参数。[示例](#添加示例) |
+| --launcher | str | 启动器选项，可选项目为 \['none', 'pytorch', 'slurm', 'mpi'\]。 |
+| --local_rank | int | 本地机器编号，用于多机多卡分布式训练，默认为 0。 |
+
+### 测试
+
+`tools/test.py` 提供了基础的测试服务，其使用原理和训练脚本类似。例如，以下命令演示了 CPU 或 GPU 单卡测试 DBNet 模型。
+
+```bash
+# 通过调用 tools/test.py 来测试指定的 MMOCR 模型
+CUDA_VISIBLE_DEVICES= python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [PY_ARGS]
+
+# 测试
+# 示例 1：使用 CPU 测试 DBNet
+CUDA_VISIBLE_DEVICES=-1 python tools/test.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth
+# 示例 2：使用 gpu:0 测试 DBNet
+CUDA_VISIBLE_DEVICES=0 python tools/test.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth
+```
+
+下表列出了 `test.py` 支持的所有参数。其中，不带 `--` 前缀的参数为必须的位置参数，带 `--` 前缀的参数为可选参数。
+
+| 参数 | 类型 | 说明 |
+| ------------- | ----- | -------------------------------------------------------------- |
+| config | str | （必须）配置文件路径。 |
+| checkpoint | str | （必须）待测试模型路径。 |
+| --work-dir | str | 工作目录，用于存放训练日志以及模型 checkpoints。 |
+| --save-preds | bool | 是否将预测结果写入 pkl 文件并保存。 |
+| --show | bool | 是否可视化预测结果。 |
+| --show-dir | str | 将可视化的预测结果保存至指定路径。 |
+| --wait-time | float | 可视化间隔时间（秒），默认为 2 秒。 |
+| --cfg-options | str | 用于覆写配置文件中的指定参数。[示例](#添加示例) |
+| --launcher | str | 启动器选项，可选项目为 \['none', 'pytorch', 'slurm', 'mpi'\]。 |
+| --local_rank | int | 本地机器编号，用于多机多卡分布式训练，默认为 0。 |
+| --tta | bool | 是否使用测试时数据增强 |
+
+## 多卡机器训练及测试
+
+对于大规模模型，采用多 GPU 训练和测试可以极大地提升操作的效率。为此，MMOCR 提供了基于 [MMDistributedDataParallel](mmengine.model.wrappers.MMDistributedDataParallel) 实现的分布式脚本 `tools/dist_train.sh` 和 `tools/dist_test.sh`。
+
+```bash
+# 训练
+NNODES=${NNODES} NODE_RANK=${NODE_RANK} PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [PY_ARGS]
+# 测试
+NNODES=${NNODES} NODE_RANK=${NODE_RANK} PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} ./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [PY_ARGS]
+```
+
+下表列出了 `dist_*.sh` 支持的参数：
+
+| 参数 | 类型 | 说明 |
+| --------------- | ---- | ---------------------------------------------------------------------------------- |
+| NNODES | int | 总共使用的机器节点个数，默认为 1。 |
+| NODE_RANK | int | 节点编号，默认为 0。 |
+| PORT | int | 在 RANK 0 机器上使用的 MASTER_PORT 端口号，取值范围是 0 至 65535，默认值为 29500。 |
+| MASTER_ADDR | str | RANK 0 机器的 IP 地址，默认值为 127.0.0.1。 |
+| CONFIG_FILE | str | （必须）指定配置文件的地址。 |
+| CHECKPOINT_FILE | str | （必须，仅在 dist_test.sh 中适用）指定模型权重的地址。 |
+| GPU_NUM | int | （必须）指定 GPU 的数量。 |
+| \[PY_ARGS\] | str | 该部分一切的参数都会被直接传入 tools/train.py 或 tools/test.py 中。 |
+
+这两个脚本可以实现**单机多卡**或**多机多卡**的训练和测试，下面演示了它们在不同场景下的用法。
+
+### 单机多卡
+
+以下命令演示了如何在搭载多块 GPU 的**单台机器**上使用指定数目的 GPU 进行训练及测试：
+
+1. **训练**
+
+ 使用单台机器上的 4 块 GPU 训练 DBNet。
+
+ ```bash
+ # 单机 4 卡训练 DBNet
+ tools/dist_train.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py 4
+ ```
+
+2. **测试**
+
+ 使用单台机器上的 4 块 GPU 测试 DBNet。
+
+ ```bash
+ # 单机 4 卡测试 DBNet
+ tools/dist_test.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth 4
+ ```
+
+### 单机多任务训练及测试
+
+对于搭载多块 GPU 的单台服务器而言，用户可以通过指定 GPU 的形式来同时执行不同的训练任务。例如，以下命令演示了如何在一台 8 卡 GPU 服务器上分别使用 `[0, 1, 2, 3]` 卡测试 DBNet 及 `[4, 5, 6, 7]` 卡训练 CRNN：
+
+```bash
+# 指定使用 gpu:0,1,2,3 测试 DBNet，并分配端口号 29500
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_test.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth 4
+# 指定使用 gpu:4,5,6,7 训练 CRNN，并分配端口号 29501
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh configs/textrecog/crnn/crnn_academic_dataset.py 4
+```
+
+```{note}
+`dist_train.sh` 默认将 `MASTER_PORT` 设置为 `29500`，当单台机器上有其它进程已占用该端口时，程序则会出现运行时错误 `RuntimeError: Address already in use`。此时，用户需要将 `MASTER_PORT` 设置为 `(0~65535)` 范围内的其它空闲端口号。
+```
+
+### 多机多卡训练及测试
+
+MMOCR 基于[torch.distributed](https://pytorch.org/docs/stable/distributed.html#launch-utility) 提供了相同局域网下的多台机器间的多卡分布式训练。
+
+1. **训练**
+
+ 以下命令演示了如何在两台机器上分别使用 2 张 GPU 合计 4 卡训练 DBNet：
+
+ ```bash
+ # 示例：在两台机器上分别使用 2 张 GPU 合计 4 卡训练 DBNet
+ # 在 “机器1” 上运行以下命令
+ NNODES=2 NODE_RANK=0 PORT=29501 MASTER_ADDR=10.140.0.169 tools/dist_train.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py 2
+ # 在 “机器2” 上运行以下命令
+ NNODES=2 NODE_RANK=1 PORT=29501 MASTER_ADDR=10.140.0.169 tools/dist_train.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py 2
+ ```
+
+2. **测试**
+
+ 以下命令演示了如何在两台机器上分别使用 2 张 GPU 合计 4 卡测试：
+
+ ```bash
+ # 示例：在两台机器上分别使用 2 张 GPU 合计 4 卡测试
+ # 在 “机器1” 上运行以下命令
+ NNODES=2 NODE_RANK=0 PORT=29500 MASTER_ADDR=10.140.0.169 tools/dist_test.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth 2
+ # 在 “机器2” 上运行以下命令
+ NNODES=2 NODE_RANK=1 PORT=29501 MASTER_ADDR=10.140.0.169 tools/dist_test.sh configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth 2
+ ```
+
+ ```{note}
+ 需要注意的是，采用多机多卡训练时，机器间的网络传输速度可能成为训练速度的瓶颈。
+ ```
+
+## 集群训练及测试
+
+针对 [Slurm](https://slurm.schedmd.com/) 调度系统管理的计算集群，MMOCR 提供了对应的训练和测试任务提交脚本 `tools/slurm_train.sh` 及 `tools/slurm_test.sh`。
+
+```bash
+# tools/slurm_train.sh 提供基于 slurm 调度系统管理的计算集群上提交训练任务的脚本
+GPUS=${GPUS} GPUS_PER_NODE=${GPUS_PER_NODE} CPUS_PER_TASK=${CPUS_PER_TASK} SRUN_ARGS=${SRUN_ARGS} ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR} [PY_ARGS]
+
+# tools/slurm_test.sh 提供基于 slurm 调度系统管理的计算集群上提交测试任务的脚本
+GPUS=${GPUS} GPUS_PER_NODE=${GPUS_PER_NODE} CPUS_PER_TASK=${CPUS_PER_TASK} SRUN_ARGS=${SRUN_ARGS} ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${WORK_DIR} [PY_ARGS]
+```
+
+| 参数 | 类型 | 说明 |
+| --------------- | ---- | ------------------------------------------------------------------------- |
+| GPUS | int | 使用的 GPU 数目，默认为8。 |
+| GPUS_PER_NODE | int | 每台节点机器上搭载的 GPU 数目，默认为8。 |
+| CPUS_PER_TASK | int | 任务使用的 CPU 个数，默认为5。 |
+| SRUN_ARGS | str | 其他 srun 支持的参数。详见[这里](https://slurm.schedmd.com/srun.html) |
+| PARTITION | str | （必须）指定使用的集群分区。 |
+| JOB_NAME | str | （必须）提交任务的名称。 |
+| WORK_DIR | str | （必须）任务的工作目录，训练日志以及模型的 checkpoints 将被保存至该目录。 |
+| CHECKPOINT_FILE | str | （必须，仅在 slurm_test.sh 中适用）指向模型权重的地址。 |
+| \[PY_ARGS\] | str | tools/train.py 以及 tools/test.py 支持的参数。 |
+
+这两个脚本可以实现 slurm 集群上的训练和测试，下面演示了它们在不同场景下的用法。
+
+1. 训练
+
+ 以下示例为在 slurm 集群 dev 分区申请 1 块 GPU 进行 DBNet 训练。
+
+```bash
+# 示例：在 slurm 集群 dev 分区申请 1块 GPU 资源进行 DBNet 训练任务
+GPUS=1 GPUS_PER_NODE=1 CPUS_PER_TASK=5 tools/slurm_train.sh dev db_r50 configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py work_dir
+```
+
+2. 测试
+
+ 同理， 则提供了测试任务提交脚本。以下示例为在 slurm 集群 dev 分区申请 1 块 GPU 资源进行 DBNet 测试。
+
+```bash
+# 示例：在 slurm 集群 dev 分区申请 1块 GPU 资源进行 DBNet 测试任务
+GPUS=1 GPUS_PER_NODE=1 CPUS_PER_TASK=5 tools/slurm_test.sh dev db_r50 configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth work_dir
+```
+
+## 进阶技巧
+
+### 从断点恢复训练
+
+`tools/train.py` 提供了从断点恢复训练的功能，用户仅需在命令中指定 `--resume` 参数，即可自动从断点恢复训练。
+
+```bash
+# 示例：从断点恢复训练
+python tools/train.py configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py 4 --resume
+```
+
+默认地，程序将自动从上次训练过程中最后成功保存的断点，即 `latest.pth` 处开始继续训练。如果用户希望指定从特定的断点处开始恢复训练，则可以按如下格式在模型的配置文件中设定该断点的路径。
+
+```python
+# 示例：在配置文件中设置想要加载的断点路径
+load_from = 'work_dir/dbnet/models/epoch_10000.pth'
+```
+
+### 混合精度训练
+
+混合精度训练可以在缩减内存占用的同时提升训练速度，为此，MMOCR 提供了一键式的混合精度训练方案，仅需在训练时添加 `--amp` 参数即可。
+
+```bash
+# 示例：使用自动混合精度训练
+python tools/train.py configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py 4 --amp
+```
+
+下表列出了 MMOCR 中各算法对自动混合精度训练的支持情况：
+
+| | 是否支持混合精度训练 | 备注 |
+| ------------- | :------------------: | :---------------------------: |
+| | 文本检测 | |
+| DBNet | 是 | |
+| DBNetpp | 是 | |
+| DRRG | 否 | roi_align_rotated 不支持 fp16 |
+| FCENet | 否 | BCELoss 不支持 fp16 |
+| Mask R-CNN | 是 | |
+| PANet | 是 | |
+| PSENet | 是 | |
+| TextSnake | 否 | |
+| | 文本识别 | |
+| ABINet | 是 | |
+| ASTER | 是 | |
+| CRNN | 是 | |
+| MASTER | 是 | |
+| NRTR | 是 | |
+| RobustScanner | 是 | |
+| SAR | 是 | |
+| SATRN | 是 | |
+
+### 自动学习率缩放
+
+MMOCR 在配置文件中为每一个模型设置了默认的初始学习率，然而，当用户使用的 `batch_size` 不同于我们预设的 `base_batch_size` 时，这些初始学习率可能不再完全适用。因此，我们提供了自动学习率缩放工具。当使用不同于 MMOCR 预设的 `base_batch_size` 进行训练时，用户仅需添加 `--auto-scale-lr` 参数即可自动依据新的 `batch_size` 将学习率缩放至对应尺度。
+
+```bash
+# 示例：使用自动学习率缩放
+python tools/train.py configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py 4 --auto-scale-lr
+```
+
+### 可视化模型测试结果
+
+`tools/test.py` 提供了可视化接口，以方便用户对模型进行定性分析。
+
+
textdet_transforms.py
textrecog_transforms.py | 实现了不同任务下的各类数据增强方法。 | +| 包装类 | wrappers.py | 实现了对 ImgAug 等常用算法库的包装，使其适配 MMOCR 的内部数据格式。 | + +由于每一个数据变换类之间都是相互独立的，因此，在约定好固定的数据存储字段后，我们可以便捷地采用任意的数据变换组合来构建数据流水线（Pipeline）。如下图所示，在 MMOCR 中，一个典型的训练数据流水线主要由**数据读取**、**图像增强**以及**数据格式化**三部分构成，用户只需要在配置文件中定义相关的数据流水线列表，并指定具体所需的数据变换类及其参数即可： + +
`img_shape`
`ori_shape` | 从图片路径读取图片，支持多种文件存储后端（如 `disk`, `http`, `petrel` 等）及图片解码后端（如 `cv2`, `turbojpeg`, `pillow`, `tifffile`等）。 | +| LoadOCRAnnotations | `bbox`
`bbox_label`
`polygon`
`ignore`
`text` | `gt_bboxes`
`gt_bboxes_labels`
`gt_polygons`
`gt_ignored`
`gt_texts` | 解析 OCR 任务所需的标注信息。 | +| LoadKIEAnnotations | `bboxes` `bbox_labels` `edge_labels`
`texts` | `gt_bboxes`
`gt_bboxes_labels`
`gt_edge_labels`
`gt_texts`
`ori_shape` | 解析 KIE 任务所需的标注信息。 | + +## 数据增强 - xxx_transforms.py + +数据增强是文本检测、识别等任务中必不可少的流程之一。目前，MMOCR 中共实现了数十种文本领域内常用的数据增强模块，依据其任务类型，分别为通用 OCR 数据增强模块 [ocr_transforms.py](/mmocr/datasets/transforms/ocr_transforms.py)，文本检测数据增强模块 [textdet_transforms.py](/mmocr/datasets/transforms/textdet_transforms.py)，以及文本识别数据增强模块 [textrecog_transforms.py](/mmocr/datasets/transforms/textrecog_transforms.py)。 + +具体而言，`ocr_transforms.py` 中实现了随机剪裁、随机旋转等各任务通用的数据增强模块： + +| | | | | +| -------------- | -------------------------------------------------------------- | -------------------------------------------------------------- | -------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| RandomCrop | `img`
`gt_bboxes`
`gt_bboxes_labels`
`gt_polygons`
`gt_ignored`
`gt_texts` (optional) | `img`
`img_shape`
`gt_bboxes`
`gt_bboxes_labels`
`gt_polygons`
`gt_ignored`
`gt_texts` (optional) | 随机裁剪，并确保裁剪后的图片至少包含一个文本实例。可选参数为 `min_side_ratio`，用以控制裁剪图片的短边占原始图片的比例，默认值为 `0.4`。 | +| RandomRotate | `img`
`img_shape`
`gt_bboxes` (optional)
`gt_polygons` (optional) | `img`
`img_shape`
`gt_bboxes` (optional)
`gt_polygons` (optional)
`rotated_angle` | 随机旋转，并可选择对旋转后图像的黑边进行填充。 | +| | | | | + +`textdet_transforms.py` 则实现了文本检测任务中常用的数据增强模块： + +| | | | | +| ----------------- | ------------------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| RandomFlip | `img`
`gt_bboxes`
`gt_polygons` | `img`
`gt_bboxes`
`gt_polygons`
`flip`
`flip_direction` | 随机翻转，支持水平、垂直和对角三种方向的图像翻转。默认使用水平翻转。 | +| FixInvalidPolygon | `gt_polygons`
`gt_ignored` | `gt_polygons`
`gt_ignored` | 自动修复或忽略非法多边形标注。 | + +`textrecog_transforms.py` 中实现了文本识别任务中常用的数据增强模块： + +| | | | | +| --------------- | -------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| RescaleToHeight | `img` | `img`
`img_shape`
`scale`
`scale_factor`
`keep_ratio` | 缩放图像至指定高度，并尽可能保持长宽比不变。当 `min_width` 及 `max_width` 被指定时，长宽比则可能会被改变。 | +| | | | | + +```{warning} +以上表格仅选择性地对部分数据增强方法作简要介绍，更多数据增强方法介绍请参考[API 文档](../api.rst)或阅读代码内的文档注释。 +``` + +## 数据格式化 - formatting.py + +数据格式化负责将图像、真实标签以及其它常用信息等打包成一个字典。不同的任务通常依赖于不同的数据格式化数据变换类。例如： + +| | | | | +| ------------------- | -------- | ------------- | ------------------------------------------ | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| PackTextDetInputs | - | - | 用于打包文本检测任务所需要的输入信息。 | +| PackTextRecogInputs | - | - | 用于打包文本识别任务所需要的输入信息。 | +| PackKIEInputs | - | - | 用于打包关键信息抽取任务所需要的输入信息。 | + +## 跨库数据适配器 - adapters.py + +跨库数据适配器打通了 MMOCR 与其他 OpenMMLab 系列算法库如 [MMDetection](https://github.com/open-mmlab/mmdetection) 之间的数据格式，使得跨项目调用其它开源算法库的配置文件及算法成为了可能。目前，MMOCR 实现了 `MMDet2MMOCR` 以及 `MMOCR2MMDet`，使得数据可以在 MMDetection 与 MMOCR 的格式之间自由转换；借助这些适配转换器，用户可以在 MMOCR 算法库内部轻松调用任何 MMDetection 已支持的检测算法，并在 OCR 相关数据集上进行训练。例如，我们以 Mask R-CNN 为例提供了[教程](#todo)，展示了如何在 MMOCR 中使用 MMDetection 的检测算法训练文本检测器。 + +| | | | | +| -------------- | -------------------------------------------- | ----------------------------- | ---------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| MMDet2MMOCR | `gt_masks` `gt_ignore_flags` | `gt_polygons`
`gt_ignored` | 将 MMDet 中采用的字段转换为对应的 MMOCR 字段。 | +| MMOCR2MMDet | `img_shape`
`gt_polygons`
`gt_ignored` | `gt_masks` `gt_ignore_flags` | 将 MMOCR 中采用的字段转换为对应的 MMDet 字段。 | + +## 包装类 - wrappers.py + +为了方便用户在 MMOCR 内部无缝调用常用的 CV 算法库，我们在 wrappers.py 中提供了相应的包装类。其主要打通了 MMOCR 与其它第三方算法库之间的数据格式和转换标准，使得用户可以在 MMOCR 的配置文件内直接配置使用这些第三方库提供的数据变换方法。目前支持的包装类有： + +| | | | | +| ------------------ | ------------------------------------------------------------ | ------------------------------------------------------------- | ------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| ImgAugWrapper | `img`
`gt_polygons` (optional for text recognition)
`gt_bboxes` (optional for text recognition)
`gt_bboxes_labels` (optional for text recognition)
`gt_ignored` (optional for text recognition)
`gt_texts` (optional) | `img`
`gt_polygons` (optional for text recognition)
`gt_bboxes` (optional for text recognition)
`gt_bboxes_labels` (optional for text recognition)
`gt_ignored` (optional for text recognition)
`img_shape` (optional)
`gt_texts` (optional) | [ImgAug](https://github.com/aleju/imgaug) 包装类，用于打通 ImgAug 与 MMOCR 的数据格式及配置，方便用户调用 ImgAug 实现的一系列数据增强方法。 | +| TorchVisionWrapper | `img` | `img`
`img_shape` | [TorchVision](https://github.com/pytorch/vision) 包装类，用于打通 TorchVision 与 MMOCR 的数据格式及配置，方便用户调用 `torchvision.transforms` 中实现的一系列数据变换方法。 | + +### `ImgAugWrapper` 示例 + +例如，在原生的 ImgAug 中，我们可以按照如下代码定义一个 `Sequential` 类型的数据增强流程，对图像分别进行随机翻转、随机旋转和随机缩放： + +```python +import imgaug.augmenters as iaa + +aug = iaa.Sequential( + iaa.Fliplr(0.5), # 以概率 0.5 进行水平翻转 + iaa.Affine(rotate=(-10, 10)), # 随机旋转 -10 到 10 度 + iaa.Resize((0.5, 3.0)) # 随机缩放到 50% 到 300% 的尺寸 +) +``` + +而在 MMOCR 中，我们可以通过 `ImgAugWrapper` 包装类，将上述数据增强流程直接配置到 `train_pipeline` 中： + +```python +dict( + type='ImgAugWrapper', + args=[ + ['Fliplr', 0.5], + dict(cls='Affine', rotate=[-10, 10]), + ['Resize', [0.5, 3.0]], + ] +) +``` + +其中，`args` 参数接收一个列表，列表中的每个元素可以是一个列表，也可以是一个字典。如果是列表，则列表的第一个元素为 `imgaug.augmenters` 中的类名，后面的元素为该类的初始化参数；如果是字典，则字典的 `cls` 键对应 `imgaug.augmenters` 中的类名，其他键值对则对应该类的初始化参数。 + +### `TorchVisionWrapper` 示例 + +例如，在原生的 TorchVision 中，我们可以按照如下代码定义一个 `Compose` 类型的数据变换流程，对图像进行色彩抖动： + +```python +import torchvision.transforms as transforms + +aug = transforms.Compose([ + transforms.ColorJitter( + brightness=32.0 / 255, # 亮度抖动范围 + saturation=0.5) # 饱和度抖动范围 +]) +``` + +而在 MMOCR 中，我们可以通过 `TorchVisionWrapper` 包装类，将上述数据变换流程直接配置到 `train_pipeline` 中： + +```python +dict( + type='TorchVisionWrapper', + op='ColorJitter', + brightness=32.0 / 255, + saturation=0.5 +) +``` + +其中，`op` 参数为 `torchvision.transforms` 中的类名，后面的参数则对应该类的初始化参数。 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/useful_tools.md b/internlm_langchain/knowledge_base/MMOCR/content/useful_tools.md new file mode 100644 index 00000000..2a607245 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/useful_tools.md @@ -0,0 +1,241 @@ +# 常用工具 + +## 可视化工具 + +### 数据集可视化工具 + +MMOCR 提供了数据集可视化工具 `tools/visualizations/browse_datasets.py` 以辅助用户排查可能遇到的数据集相关的问题。用户只需要指定所使用的训练配置文件（通常存放在如 `configs/textdet/dbnet/xxx.py` 文件中）或数据集配置（通常存放在 `configs/textdet/_base_/datasets/xxx.py` 文件中）路径。该工具将依据输入的配置文件类型自动将经过数据流水线（data pipeline）处理过的图像及其对应的标签，或原始图片及其对应的标签绘制出来。 + +#### 支持参数 + +```bash +python tools/visualizations/browse_dataset.py \ + ${CONFIG_FILE} \ + [-o, --output-dir ${OUTPUT_DIR}] \ + [-p, --phase ${DATASET_PHASE}] \ + [-m, --mode ${DISPLAY_MODE}] \ + [-t, --task ${DATASET_TASK}] \ + [-n, --show-number ${NUMBER_IMAGES_DISPLAY}] \ + [-i, --show-interval ${SHOW_INTERRVAL}] \ + [--cfg-options ${CFG_OPTIONS}] +``` + +| 参数名 | 类型 | 描述 | +| ------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | +| config | str | (必须) 配置文件路径。 | +| -o, --output-dir | str | 如果图形化界面不可用，请指定一个输出路径来保存可视化结果。 | +| -p, --phase | str | 用于指定需要可视化的数据集切片，如 "train", "test", "val"。当数据集存在多个变种时，也可以通过该参数来指定待可视化的切片。 | +| -m, --mode | `original`, `transformed`, `pipeline` | 用于指定数据可视化的模式。`original`：原始模式，仅可视化数据集的原始标注；`transformed`：变换模式，展示经过所有数据变换步骤的最终图像；`pipeline`：流水线模式，展示数据变换过程中每一个中间步骤的变换图像。默认使用 `transformed` 变换模式。 | +| -t, --task | `auto`, `textdet`, `textrecog` | 用于指定可视化数据集的任务类型。`auto`：自动模式，将依据给定的配置文件自动选择合适的任务类型，如果无法自动获取任务类型，则需要用户手动指定为 `textdet` 文本检测任务 或 `textrecog` 文本识别任务。默认采用 `auto` 自动模式。 | +| -n, --show-number | int | 指定需要可视化的样本数量。若该参数缺省则默认将可视化全部图片。 | +| -i, --show-interval | float | 可视化图像间隔时间，默认为 2 秒。 | +| --cfg-options | float | 用于覆盖配置文件中的参数，详见[示例](./config.md#command-line-modification)。 | + +#### 用法示例 + +以下示例演示了如何使用该工具可视化 "DBNet_R50_icdar2015" 模型使用的训练数据。 + +```Bash +# 使用默认参数可视化 "dbnet_r50dcn_v2_fpnc_1200e_icadr2015" 模型的训练数据 +python tools/visualizations/browse_dataset.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py +``` + +默认情况下，可视化模式为 "transformed"，您将看到经由数据流水线变换过后的图像和标注： + +
+
+
+
+如果您只想可视化原始数据集，只需将模式设置为 "original"：
+
+```Bash
+python tools/visualizations/browse_dataset.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py -m original
+```
+
+
+
+或者，您也可以使用 "pipeline" 模式来可视化整个数据流水线的中间结果：
+
+```Bash
+python tools/visualizations/browse_dataset.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py -m pipeline
+```
+
+
+
+另外，用户还可以通过指定数据集配置文件的路径来可视化数据集的原始图像及其对应的标注，例如：
+
+```Bash
+python tools/visualizations/browse_dataset.py configs/textrecog/_base_/datasets/icdar2015.py
+```
+
+部分数据集可能有多个变体。例如，`icdar2015` 文本识别数据集的[配置文件](/configs/textrecog/_base_/datasets/icdar2015.py)中包含两个测试集变体，分别为 `icdar2015_textrecog_test` 和 `icdar2015_1811_textrecog_test`，如下所示：
+
+```python
+icdar2015_textrecog_test = dict(
+ ann_file='textrecog_test.json',
+ # ...
+ )
+
+icdar2015_1811_textrecog_test = dict(
+ ann_file='textrecog_test_1811.json',
+ # ...
+)
+```
+
+在这种情况下，用户可以通过指定 `-p` 参数来可视化不同的变体，例如，使用以下命令可视化 `icdar2015_1811_textrecog_test` 变体：
+
+```Bash
+python tools/visualizations/browse_dataset.py configs/textrecog/_base_/datasets/icdar2015.py -p icdar2015_1811_textrecog_test
+```
+
+基于该工具，用户可以轻松地查看数据集的原始图像及其对应的标注，以便于检查数据集的标注是否正确。
+
+### 优化器参数策略可视化工具
+
+MMOCR提供了优化器参数可视化工具 `tools/visualizations/vis_scheduler.py` 以辅助用户排查优化器的超参数调度器（无需训练），支持学习率（learning rate）和动量（momentum）。
+
+#### 工具简介
+
+```bash
+python tools/visualizations/vis_scheduler.py \
+ ${CONFIG_FILE} \
+ [-p, --parameter ${PARAMETER_NAME}] \
+ [-d, --dataset-size ${DATASET_SIZE}] \
+ [-n, --ngpus ${NUM_GPUs}] \
+ [-s, --save-path ${SAVE_PATH}] \
+ [--title ${TITLE}] \
+ [--style ${STYLE}] \
+ [--window-size ${WINDOW_SIZE}] \
+ [--cfg-options]
+```
+
+**所有参数的说明**：
+
+- `config` : 模型配置文件的路径。
+- **`-p, parameter`**: 可视化参数名，只能为 `["lr", "momentum"]` 之一， 默认为 `"lr"`.
+- **`-d, --dataset-size`**: 数据集的大小。如果指定，`build_dataset` 将被跳过并使用这个大小作为数据集大小，默认使用 `build_dataset` 所得数据集的大小。
+- **`-n, --ngpus`**: 使用 GPU 的数量, 默认为1。
+- **`-s, --save-path`**: 保存的可视化图片的路径，默认不保存。
+- `--title`: 可视化图片的标题，默认为配置文件名。
+- `--style`: 可视化图片的风格，默认为 `whitegrid`。
+- `--window-size`: 可视化窗口大小，如果没有指定，默认为 `12*7`。如果需要指定，按照格式 \`W\*H'。
+- `--cfg-options`: 对配置文件的修改，参考[学习配置文件](../user_guides/config.md)。
+
+```{note}
+部分数据集在解析标注阶段比较耗时，可直接将 `-d, dataset-size` 指定数据集的大小，以节约时间。
+```
+
+#### 如何在开始训练前可视化学习率曲线
+
+你可以使用如下命令来绘制配置文件 `configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py` 将会使用的变化率曲线：
+
+```bash
+python tools/visualizations/vis_scheduler.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py -d 100
+```
+
+
+
+## 分析工具
+
+### 离线评测工具
+
+对于已保存的预测结果，我们提供了离线评测脚本 `tools/analysis_tools/offline_eval.py`。例如，以下代码演示了如何使用该工具对 "PSENet" 模型的输出结果进行离线评估：
+
+```Bash
+# 初次运行测试脚本时，用户可以通过指定 --save-preds 参数来保存模型的输出结果
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --save-preds
+# 示例：对 PSENet 进行测试
+python tools/test.py configs/textdet/psenet/psenet_r50_fpnf_600e_icdar2015.py epoch_600.pth --save-preds
+
+# 之后即可使用已保存的输出文件进行离线评估
+python tools/analysis_tool/offline_eval.py ${CONFIG_FILE} ${PRED_FILE}
+# 示例：对已保存的 PSENet 结果进行离线评估
+python tools/analysis_tools/offline_eval.py configs/textdet/psenet/psenet_r50_fpnf_600e_icdar2015.py work_dirs/psenet_r50_fpnf_600e_icdar2015/epoch_600.pth_predictions.pkl
+```
+
+`--save-preds` 默认将输出结果保存至 `work_dir/CONFIG_NAME/MODEL_NAME_predictions.pkl`
+
+此外，基于此工具，用户也可以将其他算法库获取的预测结果转换成 MMOCR 支持的格式，从而使用 MMOCR 内置的评估指标来对其他算法库的模型进行评测。
+
+| 参数 | 类型 | 说明 |
+| ------------- | ----- | ---------------------------------------------------------------- |
+| config | str | （必须）配置文件路径。 |
+| pkl_results | str | （必须）预先保存的预测结果文件。 |
+| --cfg-options | float | 用于覆写配置文件中的指定参数。[示例](./config.md#命令行修改配置) |
+
+### 计算 FLOPs 和参数量
+
+我们提供一个计算 FLOPs 和参数量的方法，首先我们使用以下命令安装依赖。
+
+```shell
+pip install fvcore
+```
+
+计算 FLOPs 和参数量的脚本使用方法如下：
+
+```shell
+python tools/analysis_tools/get_flops.py ${config} --shape ${IMAGE_SHAPE}
+```
+
+| 参数 | 类型 | 说明 |
+| ------- | ------ | ------------------------------------------------------------------ |
+| config | str | （必须) 配置文件路径。 |
+| --shape | int\*2 | 计算 FLOPs 使用的图片尺寸，如 `--shape 320 320`。 默认为 `640 640` |
+
+获取 `dbnet_resnet18_fpnc_100k_synthtext.py` FLOPs 和参数量的示例命令如下。
+
+```shell
+python tools/analysis_tools/get_flops.py configs/textdet/dbnet/dbnet_resnet18_fpnc_100k_synthtext.py --shape 1024 1024
+```
+
+输出如下：
+
+```shell
+input shape is (1, 3, 1024, 1024)
+| module | #parameters or shape | #flops |
+| :------------------------ | :------------------- | :------ |
+| model | 12.341M | 63.955G |
+| backbone | 11.177M | 38.159G |
+| backbone.conv1 | 9.408K | 2.466G |
+| backbone.conv1.weight | (64, 3, 7, 7) | |
+| backbone.bn1 | 0.128K | 83.886M |
+| backbone.bn1.weight | (64,) | |
+| backbone.bn1.bias | (64,) | |
+| backbone.layer1 | 0.148M | 9.748G |
+| backbone.layer1.0 | 73.984K | 4.874G |
+| backbone.layer1.1 | 73.984K | 4.874G |
+| backbone.layer2 | 0.526M | 8.642G |
+| backbone.layer2.0 | 0.23M | 3.79G |
+| backbone.layer2.1 | 0.295M | 4.853G |
+| backbone.layer3 | 2.1M | 8.616G |
+| backbone.layer3.0 | 0.919M | 3.774G |
+| backbone.layer3.1 | 1.181M | 4.842G |
+| backbone.layer4 | 8.394M | 8.603G |
+| backbone.layer4.0 | 3.673M | 3.766G |
+| backbone.layer4.1 | 4.721M | 4.837G |
+| neck | 0.836M | 14.887G |
+| neck.lateral_convs | 0.246M | 2.013G |
+| neck.lateral_convs.0.conv | 16.384K | 1.074G |
+| neck.lateral_convs.1.conv | 32.768K | 0.537G |
+| neck.lateral_convs.2.conv | 65.536K | 0.268G |
+| neck.lateral_convs.3.conv | 0.131M | 0.134G |
+| neck.smooth_convs | 0.59M | 12.835G |
+| neck.smooth_convs.0.conv | 0.147M | 9.664G |
+| neck.smooth_convs.1.conv | 0.147M | 2.416G |
+| neck.smooth_convs.2.conv | 0.147M | 0.604G |
+| neck.smooth_convs.3.conv | 0.147M | 0.151G |
+| det_head | 0.329M | 10.909G |
+| det_head.binarize | 0.164M | 10.909G |
+| det_head.binarize.0 | 0.147M | 9.664G |
+| det_head.binarize.1 | 0.128K | 20.972M |
+| det_head.binarize.3 | 16.448K | 1.074G |
+| det_head.binarize.4 | 0.128K | 83.886M |
+| det_head.binarize.6 | 0.257K | 67.109M |
+| det_head.threshold | 0.164M | |
+| det_head.threshold.0 | 0.147M | |
+| det_head.threshold.1 | 0.128K | |
+| det_head.threshold.3 | 16.448K | |
+| det_head.threshold.4 | 0.128K | |
+| det_head.threshold.6 | 0.257K | |
+!!!Please be cautious if you use the results in papers. You may need to check if all ops are supported and verify that the flops computation is correct.
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/visualization.md b/internlm_langchain/knowledge_base/MMOCR/content/visualization.md
new file mode 100644
index 00000000..79a9d7e3
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/visualization.md
@@ -0,0 +1,107 @@
+# 可视化
+
+阅读本文前建议先阅读 {external+mmengine:doc}`MMEngine: 可视化 ` 以初步了解 Visualizer 的定义及相关用法。
+
+简单来说，MMEngine 中实现了用于满足日常可视化需求的可视化器件 [`Visualizer`](mmengine.visualization.Visualizer)，其主要包含三个功能：
+
+- 实现了常用的绘图 API，例如 [`draw_bboxes`](mmengine.visualization.Visualizer.draw_bboxes) 实现了边界盒的绘制功能，[`draw_lines`](mmengine.visualization.Visualizer.draw_lines) 实现了线条的绘制功能。
+- 支持将可视化结果、学习率曲线、损失函数曲线以及验证精度曲线等写入多种后端中，包括本地磁盘以及常用的深度学习训练日志记录工具，如 [TensorBoard](https://www.tensorflow.org/tensorboard) 和 [WandB](https://wandb.ai/site)。
+- 支持在代码中的任意位置进行调用，例如在训练或测试过程中可视化或记录模型的中间状态，如特征图及验证结果等。
+
+基于 MMEngine 的 Visualizer，MMOCR 内预置了多种可视化工具，用户仅需简单修改配置文件即可使用：
+
+- `tools/analysis_tools/browse_dataset.py` 脚本提供了数据集可视化功能，其可以绘制经过数据变换（Data Transforms）之后的图像及对应的标注内容，详见 [`browse_dataset.py`](useful_tools.md)。
+- MMEngine 中实现了 `LoggerHook`，该 Hook 利用 `Visualizer` 将学习率、损失以及评估结果等数据写入 `Visualizer` 设置的后端中，因此通过修改配置文件中的 `Visualizer` 后端，比如修改为`TensorBoardVISBackend` 或 `WandbVISBackend`，可以实现将日志到 `TensorBoard` 或 `WandB` 等常见的训练日志记录工具中，从而方便用户使用这些可视化工具来分析和监控训练流程。
+- MMOCR 中实现了`VisualizerHook`，该 Hook 利用 `Visualizer` 将验证阶段或预测阶段的预测结果进行可视化或储存至 `Visualizer` 设置的后端中，因此通过修改配置文件中的 `Visualizer` 后端，比如修改为`TensorBoardVISBackend` 或 `WandbVISBackend`，可以实现将预测的图像存储到 `TensorBoard` 或 `Wandb`中。
+
+## 配置
+
+得益于注册机制的使用，在 MMOCR 中，我们可以通过修改配置文件来设置可视化器件 `Visualizer` 的行为。通常，我们在 `task/_base_/default_runtime.py` 中定义可视化相关的默认配置， 详见[配置教程](config.md)。
+
+```Python
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+ type='TextxxxLocalVisualizer', # 不同任务使用不同的可视化器
+ vis_backends=vis_backends,
+ name='visualizer')
+```
+
+依据以上示例，我们可以看出 `Visualizer` 的配置主要由两个部分组成，即，`Visualizer`的类型以及其采用的可视化后端 `vis_backends`。
+
+- 针对不同的 OCR 任务，MMOCR 中预置了多种可视化器件，包括 [`TextDetLocalVisualizer`](mmocr.visualization.TextDetLocalVisualizer)，[`TextRecogLocalVisualizer`](mmocr.visualization.TextRecogLocalVisualizer)，[`TextSpottingLocalVisualizer`](mmocr.visualization.TextSpottingLocalVisualizer) 以及[`KIELocalVisualizer`](mmocr.visualization.KIELocalVisualizer)。这些可视化器件依照自身任务的特点对基础的 Visulizer API 进行了拓展，并实现了相应的标签信息接口 `add_datasamples`。例如，用户可以直接使用 `TextDetLocalVisualizer` 来可视化文本检测任务的标签或预测结果。
+- MMOCR 默认将可视化后端 `vis_backend` 设置为本地可视化后端 `LocalVisBackend`，将所有可视化结果及其他训练信息保存在本地文件夹中。
+
+## 存储
+
+MMOCR 默认使用本地可视化后端 [`LocalVisBackend`](mmengine.visualization.LocalVisBackend)，`VisualizerHook` 和`LoggerHook` 中存储的模型损失、学习率、模型评估精度以及可视化结果等信息将被默认保存至`{work_dir}/{config_name}/{time}/{vis_data}` 文件夹。此外，MMOCR 也支持其它常用的可视化后端，如 `TensorboardVisBackend` 以及 `WandbVisBackend`用户只需要将配置文件中的 `vis_backends` 类型修改为对应的可视化后端即可。例如，用户只需要在配置文件中插入以下代码块，即可将数据存储至 `TensorBoard` 以及 `WandB`中。
+
+```Python
+_base_.visualizer.vis_backends = [
+ dict(type='LocalVisBackend'),
+ dict(type='TensorboardVisBackend'),
+ dict(type='WandbVisBackend'),]
+```
+
+## 绘制
+
+### 绘制预测结果信息
+
+MMOCR 主要利用 [`VisualizationHook`](mmocr.engine.hooks.VisualizationHook)validation 和 test 的预测结果, 默认情况下 `VisualizationHook`为关闭状态，默认配置如下：
+
+```Python
+visualization=dict( # 用户可视化 validation 和 test 的结果
+ type='VisualizationHook',
+ enable=False,
+ interval=1,
+ show=False,
+ draw_gt=False,
+ draw_pred=False)
+```
+
+下表为 `VisualizationHook` 支持的参数：
+
+| 参数 | 说明 |
+| :-------: | :---------------------------------------------------------------------------------: |
+| enable | VisualizationHook 的开启和关闭由参数enable控制默认是关闭的状态， |
+| interval | 在VisualizationHook开启的情况下,用以控制多少iteration 存储或展示 val 或 test 的结果 |
+| show | 控制是否可视化 val 或 test 的结果 |
+| draw_gt | val 或 test 的结果是否绘制标注信息 |
+| draw_pred | val 或 test 的结果是否绘制预测结果 |
+
+如果在训练或者测试过程中想开启 `VisualizationHook` 相关功能和配置，仅需修改配置即可，以 `dbnet_resnet18_fpnc_1200e_icdar2015.py`为例， 同时绘制标注和预测，并且将图像展示，配置可进行如下修改
+
+```Python
+visualization = _base_.default_hooks.visualization
+visualization.update(
+ dict(enable=True, show=True, draw_gt=True, draw_pred=True))
+```
+
+
+
+... # Convert bbox from xywh to center-scale center, scale = self.\_xywh2cs(\*obj\['clean_bbox'\]\[:4\]) # Data sample contains center and scale rec.append({ 'bbox': obj\['clean_bbox\]\[:4\], 'center': center, 'scale': scale, ... })
+
+
+
+
+
+
+
+Pipeline Config
+
+(e.g. [HRNet+COCO](https://github.com/open-mmlab/mmpose/blob/master/configs/body/2d_kpt_sview_rgb_img/topdown_heatmap/coco/hrnet_w32_coco_256x192.py))
+
+
+
+... train_pipeline = \[ dict(type='LoadImageFromFile'), # Convert bbox from xywh to center-scale dict(type='TopDownGetBboxCenterScale', padding=1.25), # Randomly shift bbox center dict(type='TopDownRandomShiftBboxCenter', shift_factor=0.16, prob=0.3), ... \]
+
+
+
+
+
+... train_pipeline = \[ dict(type='LoadImageFromFile'), ... \]
+
+
+
+
+
+
+
+Advantage
+
+
+
+Simpler data sample content
+
+Flexible bbox format conversion and augmentation
+
+Apply bbox random translation every epoch (instead of only applying once at the annotation loading)
+
+
+
+-
+
+
+
+
+
+BC Breaking
+
+The method `_xywh2cs` of dataset base classes (e.g. [Kpt2dSviewRgbImgTopDownDataset](https://github.com/open-mmlab/mmpose/blob/master/mmpose/datasets/datasets/base/kpt_2d_sview_rgb_img_top_down_dataset.py)) will be deprecated in the future. Custom datasets will need modifications to move the bbox format conversion to pipelines.
+
+-
+
+
+
+
+
+
+
+## **v0.25.0 (02/04/2022)**
+
+**Highlights**
+
+- Support Shelf and Campus datasets with pre-trained VoxelPose models, ["3D Pictorial Structures for Multiple Human Pose Estimation"](http://campar.in.tum.de/pub/belagiannis2014cvpr/belagiannis2014cvpr.pdf), CVPR'2014 ([#1225](https://github.com/open-mmlab/mmpose/pull/1225)) @liqikai9, @wusize
+
+- Add `Smoother` module for temporal smoothing of the pose estimation with configurable filters ([#1127](https://github.com/open-mmlab/mmpose/pull/1127)) @ailingzengzzz, @ly015
+
+- Support SmoothNet for pose smoothing, ["SmoothNet: A Plug-and-Play Network for Refining Human Poses in Videos"](https://arxiv.org/abs/2112.13715), arXiv'2021 ([#1279](https://github.com/open-mmlab/mmpose/pull/1279)) @ailingzengzzz, @ly015
+
+- Add multiview 3D pose estimation demo ([#1270](https://github.com/open-mmlab/mmpose/pull/1270)) @wusize
+
+**New Features**
+
+- Support Shelf and Campus datasets with pre-trained VoxelPose models, ["3D Pictorial Structures for Multiple Human Pose Estimation"](http://campar.in.tum.de/pub/belagiannis2014cvpr/belagiannis2014cvpr.pdf), CVPR'2014 ([#1225](https://github.com/open-mmlab/mmpose/pull/1225)) @liqikai9, @wusize
+
+- Add `Smoother` module for temporal smoothing of the pose estimation with configurable filters ([#1127](https://github.com/open-mmlab/mmpose/pull/1127)) @ailingzengzzz, @ly015
+
+- Support SmoothNet for pose smoothing, ["SmoothNet: A Plug-and-Play Network for Refining Human Poses in Videos"](https://arxiv.org/abs/2112.13715), arXiv'2021 ([#1279](https://github.com/open-mmlab/mmpose/pull/1279)) @ailingzengzzz, @ly015
+
+- Add multiview 3D pose estimation demo ([#1270](https://github.com/open-mmlab/mmpose/pull/1270)) @wusize
+
+- Support multi-machine distributed training ([#1248](https://github.com/open-mmlab/mmpose/pull/1248)) @ly015
+
+**Improvements**
+
+- Update HRFormer configs and checkpoints with relative position bias ([#1245](https://github.com/open-mmlab/mmpose/pull/1245)) @zengwang430521
+
+- Support using different random seed for each distributed node ([#1257](https://github.com/open-mmlab/mmpose/pull/1257), [#1229](https://github.com/open-mmlab/mmpose/pull/1229)) @ly015
+
+- Improve documentation quality ([#1275](https://github.com/open-mmlab/mmpose/pull/1275), [#1255](https://github.com/open-mmlab/mmpose/pull/1255), [#1258](https://github.com/open-mmlab/mmpose/pull/1258), [#1249](https://github.com/open-mmlab/mmpose/pull/1249), [#1247](https://github.com/open-mmlab/mmpose/pull/1247), [#1240](https://github.com/open-mmlab/mmpose/pull/1240), [#1235](https://github.com/open-mmlab/mmpose/pull/1235)) @ly015, @jin-s13, @YoniChechik
+
+**Bug Fixes**
+
+- Fix keypoint index in RHD dataset meta information ([#1265](https://github.com/open-mmlab/mmpose/pull/1265)) @liqikai9
+
+- Fix pre-commit hook unexpected behavior on Windows ([#1282](https://github.com/open-mmlab/mmpose/pull/1282)) @liqikai9
+
+- Remove python-dev installation in CI ([#1276](https://github.com/open-mmlab/mmpose/pull/1276)) @ly015
+
+- Unify hyphens in argument names in tools and demos ([#1271](https://github.com/open-mmlab/mmpose/pull/1271)) @ly015
+
+- Fix ambiguous channel size in `channel_shuffle` that may cause exporting failure (#1242) @PINTO0309
+
+- Fix a bug in Webcam API that causes single-class detectors fail ([#1239](https://github.com/open-mmlab/mmpose/pull/1239)) @674106399
+
+- Fix the issue that `custom_hook` can not be set in configs ([#1236](https://github.com/open-mmlab/mmpose/pull/1236)) @bladrome
+
+- Fix incompatible MMCV version in DockerFile ([#raykindle](https://github.com/open-mmlab/mmpose/pull/raykindle))
+
+- Skip invisible joints in visualization ([#1228](https://github.com/open-mmlab/mmpose/pull/1228)) @womeier
+
+## **v0.24.0 (07/03/2022)**
+
+**Highlights**
+
+- Support HRFormer ["HRFormer: High-Resolution Vision Transformer for Dense Predict"](https://proceedings.neurips.cc/paper/2021/hash/3bbfdde8842a5c44a0323518eec97cbe-Abstract.html), NeurIPS'2021 ([#1203](https://github.com/open-mmlab/mmpose/pull/1203)) @zengwang430521
+
+- Support Windows installation with pip ([#1213](https://github.com/open-mmlab/mmpose/pull/1213)) @jin-s13, @ly015
+
+- Add WebcamAPI documents ([#1187](https://github.com/open-mmlab/mmpose/pull/1187)) @ly015
+
+**New Features**
+
+- Support HRFormer ["HRFormer: High-Resolution Vision Transformer for Dense Predict"](https://proceedings.neurips.cc/paper/2021/hash/3bbfdde8842a5c44a0323518eec97cbe-Abstract.html), NeurIPS'2021 ([#1203](https://github.com/open-mmlab/mmpose/pull/1203)) @zengwang430521
+
+- Support Windows installation with pip ([#1213](https://github.com/open-mmlab/mmpose/pull/1213)) @jin-s13, @ly015
+
+- Support CPU training with mmcv \< v1.4.4 ([#1161](https://github.com/open-mmlab/mmpose/pull/1161)) @EasonQYS, @ly015
+
+- Add "Valentine Magic" demo with WebcamAPI ([#1189](https://github.com/open-mmlab/mmpose/pull/1189), [#1191](https://github.com/open-mmlab/mmpose/pull/1191)) @liqikai9
+
+**Improvements**
+
+- Refactor multi-view 3D pose estimation framework towards better modularization and expansibility ([#1196](https://github.com/open-mmlab/mmpose/pull/1196)) @wusize
+
+- Add WebcamAPI documents and tutorials ([#1187](https://github.com/open-mmlab/mmpose/pull/1187)) @ly015
+
+- Refactor dataset evaluation interface to align with other OpenMMLab codebases ([#1209](https://github.com/open-mmlab/mmpose/pull/1209)) @ly015
+
+- Add deprecation message for deploy tools since [MMDeploy](https://github.com/open-mmlab/mmdeploy) has supported MMPose ([#1207](https://github.com/open-mmlab/mmpose/pull/1207)) @QwQ2000
+
+- Improve documentation quality ([#1206](https://github.com/open-mmlab/mmpose/pull/1206), [#1161](https://github.com/open-mmlab/mmpose/pull/1161)) @ly015
+
+- Switch to OpenMMLab official pre-commit-hook for copyright check ([#1214](https://github.com/open-mmlab/mmpose/pull/1214)) @ly015
+
+**Bug Fixes**
+
+- Fix hard-coded data collating and scattering in inference ([#1175](https://github.com/open-mmlab/mmpose/pull/1175)) @ly015
+
+- Fix model configs on JHMDB dataset ([#1188](https://github.com/open-mmlab/mmpose/pull/1188)) @jin-s13
+
+- Fix area calculation in pose tracking inference ([#1197](https://github.com/open-mmlab/mmpose/pull/1197)) @pallgeuer
+
+- Fix registry scope conflict of module wrapper ([#1204](https://github.com/open-mmlab/mmpose/pull/1204)) @ly015
+
+- Update MMCV installation in CI and documents ([#1205](https://github.com/open-mmlab/mmpose/pull/1205))
+
+- Fix incorrect color channel order in visualization functions ([#1212](https://github.com/open-mmlab/mmpose/pull/1212)) @ly015
+
+## **v0.23.0 (11/02/2022)**
+
+**Highlights**
+
+- Add [MMPose Webcam API](https://github.com/open-mmlab/mmpose/tree/master/tools/webcam): A simple yet powerful tools to develop interactive webcam applications with MMPose functions. ([#1178](https://github.com/open-mmlab/mmpose/pull/1178), [#1173](https://github.com/open-mmlab/mmpose/pull/1173), [#1173](https://github.com/open-mmlab/mmpose/pull/1173), [#1143](https://github.com/open-mmlab/mmpose/pull/1143), [#1094](https://github.com/open-mmlab/mmpose/pull/1094), [#1133](https://github.com/open-mmlab/mmpose/pull/1133), [#1098](https://github.com/open-mmlab/mmpose/pull/1098), [#1160](https://github.com/open-mmlab/mmpose/pull/1160)) @ly015, @jin-s13, @liqikai9, @wusize, @luminxu, @zengwang430521 @mzr1996
+
+**New Features**
+
+- Add [MMPose Webcam API](https://github.com/open-mmlab/mmpose/tree/master/tools/webcam): A simple yet powerful tools to develop interactive webcam applications with MMPose functions. ([#1178](https://github.com/open-mmlab/mmpose/pull/1178), [#1173](https://github.com/open-mmlab/mmpose/pull/1173), [#1173](https://github.com/open-mmlab/mmpose/pull/1173), [#1143](https://github.com/open-mmlab/mmpose/pull/1143), [#1094](https://github.com/open-mmlab/mmpose/pull/1094), [#1133](https://github.com/open-mmlab/mmpose/pull/1133), [#1098](https://github.com/open-mmlab/mmpose/pull/1098), [#1160](https://github.com/open-mmlab/mmpose/pull/1160)) @ly015, @jin-s13, @liqikai9, @wusize, @luminxu, @zengwang430521 @mzr1996
+
+- Support ConcatDataset ([#1139](https://github.com/open-mmlab/mmpose/pull/1139)) @Canwang-sjtu
+
+- Support CPU training and testing ([#1157](https://github.com/open-mmlab/mmpose/pull/1157)) @ly015
+
+**Improvements**
+
+- Add multi-processing configurations to speed up distributed training and testing ([#1146](https://github.com/open-mmlab/mmpose/pull/1146)) @ly015
+
+- Add default runtime config ([#1145](https://github.com/open-mmlab/mmpose/pull/1145))
+
+- Upgrade isort in pre-commit hook ([#1179](https://github.com/open-mmlab/mmpose/pull/1179)) @liqikai9
+
+- Update README and documents ([#1171](https://github.com/open-mmlab/mmpose/pull/1171), [#1167](https://github.com/open-mmlab/mmpose/pull/1167), [#1153](https://github.com/open-mmlab/mmpose/pull/1153), [#1149](https://github.com/open-mmlab/mmpose/pull/1149), [#1148](https://github.com/open-mmlab/mmpose/pull/1148), [#1147](https://github.com/open-mmlab/mmpose/pull/1147), [#1140](https://github.com/open-mmlab/mmpose/pull/1140)) @jin-s13, @wusize, @TommyZihao, @ly015
+
+**Bug Fixes**
+
+- Fix undeterministic behavior in pre-commit hooks ([#1136](https://github.com/open-mmlab/mmpose/pull/1136)) @jin-s13
+
+- Deprecate the support for "python setup.py test" ([#1179](https://github.com/open-mmlab/mmpose/pull/1179)) @ly015
+
+- Fix incompatible settings with MMCV on HSigmoid default parameters ([#1132](https://github.com/open-mmlab/mmpose/pull/1132)) @ly015
+
+- Fix albumentation installation ([#1184](https://github.com/open-mmlab/mmpose/pull/1184)) @BIGWangYuDong
+
+## **v0.22.0 (04/01/2022)**
+
+**Highlights**
+
+- Support VoxelPose ["VoxelPose: Towards Multi-Camera 3D Human Pose Estimation in Wild Environment"](https://arxiv.org/abs/2004.06239), ECCV'2020 ([#1050](https://github.com/open-mmlab/mmpose/pull/1050)) @wusize
+
+- Support Soft Wing loss ["Structure-Coherent Deep Feature Learning for Robust Face Alignment"](https://linchunze.github.io/papers/TIP21_Structure_coherent_FA.pdf), TIP'2021 ([#1077](https://github.com/open-mmlab/mmpose/pull/1077)) @jin-s13
+
+- Support Adaptive Wing loss ["Adaptive Wing Loss for Robust Face Alignment via Heatmap Regression"](https://arxiv.org/abs/1904.07399), ICCV'2019 ([#1072](https://github.com/open-mmlab/mmpose/pull/1072)) @jin-s13
+
+**New Features**
+
+- Support VoxelPose ["VoxelPose: Towards Multi-Camera 3D Human Pose Estimation in Wild Environment"](https://arxiv.org/abs/2004.06239), ECCV'2020 ([#1050](https://github.com/open-mmlab/mmpose/pull/1050)) @wusize
+
+- Support Soft Wing loss ["Structure-Coherent Deep Feature Learning for Robust Face Alignment"](https://linchunze.github.io/papers/TIP21_Structure_coherent_FA.pdf), TIP'2021 ([#1077](https://github.com/open-mmlab/mmpose/pull/1077)) @jin-s13
+
+- Support Adaptive Wing loss ["Adaptive Wing Loss for Robust Face Alignment via Heatmap Regression"](https://arxiv.org/abs/1904.07399), ICCV'2019 ([#1072](https://github.com/open-mmlab/mmpose/pull/1072)) @jin-s13
+
+- Add LiteHRNet-18 Checkpoints trained on COCO. ([#1120](https://github.com/open-mmlab/mmpose/pull/1120)) @jin-s13
+
+**Improvements**
+
+- Improve documentation quality ([#1115](https://github.com/open-mmlab/mmpose/pull/1115), [#1111](https://github.com/open-mmlab/mmpose/pull/1111), [#1105](https://github.com/open-mmlab/mmpose/pull/1105), [#1087](https://github.com/open-mmlab/mmpose/pull/1087), [#1086](https://github.com/open-mmlab/mmpose/pull/1086), [#1085](https://github.com/open-mmlab/mmpose/pull/1085), [#1084](https://github.com/open-mmlab/mmpose/pull/1084), [#1083](https://github.com/open-mmlab/mmpose/pull/1083), [#1124](https://github.com/open-mmlab/mmpose/pull/1124), [#1070](https://github.com/open-mmlab/mmpose/pull/1070), [#1068](https://github.com/open-mmlab/mmpose/pull/1068)) @jin-s13, @liqikai9, @ly015
+
+- Support CircleCI ([#1074](https://github.com/open-mmlab/mmpose/pull/1074)) @ly015
+
+- Skip unit tests in CI when only document files were changed ([#1074](https://github.com/open-mmlab/mmpose/pull/1074), [#1041](https://github.com/open-mmlab/mmpose/pull/1041)) @QwQ2000, @ly015
+
+- Support file_client_args in LoadImageFromFile ([#1076](https://github.com/open-mmlab/mmpose/pull/1076)) @jin-s13
+
+**Bug Fixes**
+
+- Fix a bug in Dark UDP postprocessing that causes error when the channel number is large. ([#1079](https://github.com/open-mmlab/mmpose/pull/1079), [#1116](https://github.com/open-mmlab/mmpose/pull/1116)) @X00123, @jin-s13
+
+- Fix hard-coded `sigmas` in bottom-up image demo ([#1107](https://github.com/open-mmlab/mmpose/pull/1107), [#1101](https://github.com/open-mmlab/mmpose/pull/1101)) @chenxinfeng4, @liqikai9
+
+- Fix unstable checks in unit tests ([#1112](https://github.com/open-mmlab/mmpose/pull/1112)) @ly015
+
+- Do not destroy NULL windows if `args.show==False` in demo scripts ([#1104](https://github.com/open-mmlab/mmpose/pull/1104)) @bladrome
+
+## **v0.21.0 (06/12/2021)**
+
+**Highlights**
+
+- Support ["Learning Temporal Pose Estimation from Sparsely-Labeled Videos"](https://arxiv.org/abs/1906.04016), NeurIPS'2019 ([#932](https://github.com/open-mmlab/mmpose/pull/932), [#1006](https://github.com/open-mmlab/mmpose/pull/1006), [#1036](https://github.com/open-mmlab/mmpose/pull/1036), [#1060](https://github.com/open-mmlab/mmpose/pull/1060)) @liqikai9
+
+- Add ViPNAS-MobileNetV3 models ([#1025](https://github.com/open-mmlab/mmpose/pull/1025)) @luminxu, @jin-s13
+
+- Add inference speed benchmark ([#1028](https://github.com/open-mmlab/mmpose/pull/1028), [#1034](https://github.com/open-mmlab/mmpose/pull/1034), [#1044](https://github.com/open-mmlab/mmpose/pull/1044)) @liqikai9
+
+**New Features**
+
+- Support ["Learning Temporal Pose Estimation from Sparsely-Labeled Videos"](https://arxiv.org/abs/1906.04016), NeurIPS'2019 ([#932](https://github.com/open-mmlab/mmpose/pull/932), [#1006](https://github.com/open-mmlab/mmpose/pull/1006), [#1036](https://github.com/open-mmlab/mmpose/pull/1036)) @liqikai9
+
+- Add ViPNAS-MobileNetV3 models ([#1025](https://github.com/open-mmlab/mmpose/pull/1025)) @luminxu, @jin-s13
+
+- Add light-weight top-down models for whole-body keypoint detection ([#1009](https://github.com/open-mmlab/mmpose/pull/1009), [#1020](https://github.com/open-mmlab/mmpose/pull/1020), [#1055](https://github.com/open-mmlab/mmpose/pull/1055)) @luminxu, @ly015
+
+- Add HRNet checkpoints with various settings on PoseTrack18 ([#1035](https://github.com/open-mmlab/mmpose/pull/1035)) @liqikai9
+
+**Improvements**
+
+- Add inference speed benchmark ([#1028](https://github.com/open-mmlab/mmpose/pull/1028), [#1034](https://github.com/open-mmlab/mmpose/pull/1034), [#1044](https://github.com/open-mmlab/mmpose/pull/1044)) @liqikai9
+
+- Update model metafile format ([#1001](https://github.com/open-mmlab/mmpose/pull/1001)) @ly015
+
+- Support minus output feature index in mobilenet_v3 ([#1005](https://github.com/open-mmlab/mmpose/pull/1005)) @luminxu
+
+- Improve documentation quality ([#1018](https://github.com/open-mmlab/mmpose/pull/1018), [#1026](https://github.com/open-mmlab/mmpose/pull/1026), [#1027](https://github.com/open-mmlab/mmpose/pull/1027), [#1031](https://github.com/open-mmlab/mmpose/pull/1031), [#1038](https://github.com/open-mmlab/mmpose/pull/1038), [#1046](https://github.com/open-mmlab/mmpose/pull/1046), [#1056](https://github.com/open-mmlab/mmpose/pull/1056), [#1057](https://github.com/open-mmlab/mmpose/pull/1057)) @edybk, @luminxu, @ly015, @jin-s13
+
+- Set default random seed in training initialization ([#1030](https://github.com/open-mmlab/mmpose/pull/1030)) @ly015
+
+- Skip CI when only specific files changed ([#1041](https://github.com/open-mmlab/mmpose/pull/1041), [#1059](https://github.com/open-mmlab/mmpose/pull/1059)) @QwQ2000, @ly015
+
+- Automatically cancel uncompleted action runs when new commit arrives ([#1053](https://github.com/open-mmlab/mmpose/pull/1053)) @ly015
+
+**Bug Fixes**
+
+- Update pose tracking demo to be compatible with latest mmtracking ([#1014](https://github.com/open-mmlab/mmpose/pull/1014)) @jin-s13
+
+- Fix symlink creation failure when installed in Windows environments ([#1039](https://github.com/open-mmlab/mmpose/pull/1039)) @QwQ2000
+
+- Fix AP-10K dataset sigmas ([#1040](https://github.com/open-mmlab/mmpose/pull/1040)) @jin-s13
+
+## **v0.20.0 (01/11/2021)**
+
+**Highlights**
+
+- Add AP-10K dataset for animal pose estimation ([#987](https://github.com/open-mmlab/mmpose/pull/987)) @Annbless, @AlexTheBad, @jin-s13, @ly015
+
+- Support TorchServe ([#979](https://github.com/open-mmlab/mmpose/pull/979)) @ly015
+
+**New Features**
+
+- Add AP-10K dataset for animal pose estimation ([#987](https://github.com/open-mmlab/mmpose/pull/987)) @Annbless, @AlexTheBad, @jin-s13, @ly015
+
+- Add HRNetv2 checkpoints on 300W and COFW datasets ([#980](https://github.com/open-mmlab/mmpose/pull/980)) @jin-s13
+
+- Support TorchServe ([#979](https://github.com/open-mmlab/mmpose/pull/979)) @ly015
+
+**Bug Fixes**
+
+- Fix some deprecated or risky settings in configs ([#963](https://github.com/open-mmlab/mmpose/pull/963), [#976](https://github.com/open-mmlab/mmpose/pull/976), [#992](https://github.com/open-mmlab/mmpose/pull/992)) @jin-s13, @wusize
+
+- Fix issues of default arguments of training and testing scripts ([#970](https://github.com/open-mmlab/mmpose/pull/970), [#985](https://github.com/open-mmlab/mmpose/pull/985)) @liqikai9, @wusize
+
+- Fix heatmap and tag size mismatch in bottom-up with UDP ([#994](https://github.com/open-mmlab/mmpose/pull/994)) @wusize
+
+- Fix python3.9 installation in CI ([#983](https://github.com/open-mmlab/mmpose/pull/983)) @ly015
+
+- Fix model zoo document integrity issue ([#990](https://github.com/open-mmlab/mmpose/pull/990)) @jin-s13
+
+**Improvements**
+
+- Support non-square input shape for bottom-up ([#991](https://github.com/open-mmlab/mmpose/pull/991)) @wusize
+
+- Add image and video resources for demo ([#971](https://github.com/open-mmlab/mmpose/pull/971)) @liqikai9
+
+- Use CUDA docker images to accelerate CI ([#973](https://github.com/open-mmlab/mmpose/pull/973)) @ly015
+
+- Add codespell hook and fix detected typos ([#977](https://github.com/open-mmlab/mmpose/pull/977)) @ly015
+
+## **v0.19.0 (08/10/2021)**
+
+**Highlights**
+
+- Add models for Associative Embedding with Hourglass network backbone ([#906](https://github.com/open-mmlab/mmpose/pull/906), [#955](https://github.com/open-mmlab/mmpose/pull/955)) @jin-s13, @luminxu
+
+- Support COCO-Wholebody-Face and COCO-Wholebody-Hand datasets ([#813](https://github.com/open-mmlab/mmpose/pull/813)) @jin-s13, @innerlee, @luminxu
+
+- Upgrade dataset interface ([#901](https://github.com/open-mmlab/mmpose/pull/901), [#924](https://github.com/open-mmlab/mmpose/pull/924)) @jin-s13, @innerlee, @ly015, @liqikai9
+
+- New style of documentation ([#945](https://github.com/open-mmlab/mmpose/pull/945)) @ly015
+
+**New Features**
+
+- Add models for Associative Embedding with Hourglass network backbone ([#906](https://github.com/open-mmlab/mmpose/pull/906), [#955](https://github.com/open-mmlab/mmpose/pull/955)) @jin-s13, @luminxu
+
+- Support COCO-Wholebody-Face and COCO-Wholebody-Hand datasets ([#813](https://github.com/open-mmlab/mmpose/pull/813)) @jin-s13, @innerlee, @luminxu
+
+- Add pseudo-labeling tool to generate COCO style keypoint annotations with given bounding boxes ([#928](https://github.com/open-mmlab/mmpose/pull/928)) @soltkreig
+
+- New style of documentation ([#945](https://github.com/open-mmlab/mmpose/pull/945)) @ly015
+
+**Bug Fixes**
+
+- Fix segmentation parsing in Macaque dataset preprocessing ([#948](https://github.com/open-mmlab/mmpose/pull/948)) @jin-s13
+
+- Fix dependencies that may lead to CI failure in downstream projects ([#936](https://github.com/open-mmlab/mmpose/pull/936), [#953](https://github.com/open-mmlab/mmpose/pull/953)) @RangiLyu, @ly015
+
+- Fix keypoint order in Human3.6M dataset ([#940](https://github.com/open-mmlab/mmpose/pull/940)) @ttxskk
+
+- Fix unstable image loading for Interhand2.6M ([#913](https://github.com/open-mmlab/mmpose/pull/913)) @zengwang430521
+
+**Improvements**
+
+- Upgrade dataset interface ([#901](https://github.com/open-mmlab/mmpose/pull/901), [#924](https://github.com/open-mmlab/mmpose/pull/924)) @jin-s13, @innerlee, @ly015, @liqikai9
+
+- Improve demo usability and stability ([#908](https://github.com/open-mmlab/mmpose/pull/908), [#934](https://github.com/open-mmlab/mmpose/pull/934)) @ly015
+
+- Standardize model metafile format ([#941](https://github.com/open-mmlab/mmpose/pull/941)) @ly015
+
+- Support `persistent_worker` and several other arguments in configs ([#946](https://github.com/open-mmlab/mmpose/pull/946)) @jin-s13
+
+- Use MMCV root model registry to enable cross-project module building ([#935](https://github.com/open-mmlab/mmpose/pull/935)) @RangiLyu
+
+- Improve the document quality ([#916](https://github.com/open-mmlab/mmpose/pull/916), [#909](https://github.com/open-mmlab/mmpose/pull/909), [#942](https://github.com/open-mmlab/mmpose/pull/942), [#913](https://github.com/open-mmlab/mmpose/pull/913), [#956](https://github.com/open-mmlab/mmpose/pull/956)) @jin-s13, @ly015, @bit-scientist, @zengwang430521
+
+- Improve pull request template ([#952](https://github.com/open-mmlab/mmpose/pull/952), [#954](https://github.com/open-mmlab/mmpose/pull/954)) @ly015
+
+**Breaking Changes**
+
+- Upgrade dataset interface ([#901](https://github.com/open-mmlab/mmpose/pull/901)) @jin-s13, @innerlee, @ly015
+
+## **v0.18.0 (01/09/2021)**
+
+**Bug Fixes**
+
+- Fix redundant model weight loading in pytorch-to-onnx conversion ([#850](https://github.com/open-mmlab/mmpose/pull/850)) @ly015
+
+- Fix a bug in update_model_index.py that may cause pre-commit hook failure([#866](https://github.com/open-mmlab/mmpose/pull/866)) @ly015
+
+- Fix a bug in interhand_3d_head ([#890](https://github.com/open-mmlab/mmpose/pull/890)) @zengwang430521
+
+- Fix pose tracking demo failure caused by out-of-date configs ([#891](https://github.com/open-mmlab/mmpose/pull/891))
+
+**Improvements**
+
+- Add automatic benchmark regression tools ([#849](https://github.com/open-mmlab/mmpose/pull/849), [#880](https://github.com/open-mmlab/mmpose/pull/880), [#885](https://github.com/open-mmlab/mmpose/pull/885)) @liqikai9, @ly015
+
+- Add copyright information and checking hook ([#872](https://github.com/open-mmlab/mmpose/pull/872))
+
+- Add PR template ([#875](https://github.com/open-mmlab/mmpose/pull/875)) @ly015
+
+- Add citation information ([#876](https://github.com/open-mmlab/mmpose/pull/876)) @ly015
+
+- Add python3.9 in CI ([#877](https://github.com/open-mmlab/mmpose/pull/877), [#883](https://github.com/open-mmlab/mmpose/pull/883)) @ly015
+
+- Improve the quality of the documents ([#845](https://github.com/open-mmlab/mmpose/pull/845), [#845](https://github.com/open-mmlab/mmpose/pull/845), [#848](https://github.com/open-mmlab/mmpose/pull/848), [#867](https://github.com/open-mmlab/mmpose/pull/867), [#870](https://github.com/open-mmlab/mmpose/pull/870), [#873](https://github.com/open-mmlab/mmpose/pull/873), [#896](https://github.com/open-mmlab/mmpose/pull/896)) @jin-s13, @ly015, @zhiqwang
+
+## **v0.17.0 (06/08/2021)**
+
+**Highlights**
+
+1. Support ["Lite-HRNet: A Lightweight High-Resolution Network"](https://arxiv.org/abs/2104.06403) CVPR'2021 ([#733](https://github.com/open-mmlab/mmpose/pull/733),[#800](https://github.com/open-mmlab/mmpose/pull/800)) @jin-s13
+
+2. Add 3d body mesh demo ([#771](https://github.com/open-mmlab/mmpose/pull/771)) @zengwang430521
+
+3. Add Chinese documentation ([#787](https://github.com/open-mmlab/mmpose/pull/787), [#798](https://github.com/open-mmlab/mmpose/pull/798), [#799](https://github.com/open-mmlab/mmpose/pull/799), [#802](https://github.com/open-mmlab/mmpose/pull/802), [#804](https://github.com/open-mmlab/mmpose/pull/804), [#805](https://github.com/open-mmlab/mmpose/pull/805), [#815](https://github.com/open-mmlab/mmpose/pull/815), [#816](https://github.com/open-mmlab/mmpose/pull/816), [#817](https://github.com/open-mmlab/mmpose/pull/817), [#819](https://github.com/open-mmlab/mmpose/pull/819), [#839](https://github.com/open-mmlab/mmpose/pull/839)) @ly015, @luminxu, @jin-s13, @liqikai9, @zengwang430521
+
+4. Add Colab Tutorial ([#834](https://github.com/open-mmlab/mmpose/pull/834)) @ly015
+
+**New Features**
+
+- Support ["Lite-HRNet: A Lightweight High-Resolution Network"](https://arxiv.org/abs/2104.06403) CVPR'2021 ([#733](https://github.com/open-mmlab/mmpose/pull/733),[#800](https://github.com/open-mmlab/mmpose/pull/800)) @jin-s13
+
+- Add 3d body mesh demo ([#771](https://github.com/open-mmlab/mmpose/pull/771)) @zengwang430521
+
+- Add Chinese documentation ([#787](https://github.com/open-mmlab/mmpose/pull/787), [#798](https://github.com/open-mmlab/mmpose/pull/798), [#799](https://github.com/open-mmlab/mmpose/pull/799), [#802](https://github.com/open-mmlab/mmpose/pull/802), [#804](https://github.com/open-mmlab/mmpose/pull/804), [#805](https://github.com/open-mmlab/mmpose/pull/805), [#815](https://github.com/open-mmlab/mmpose/pull/815), [#816](https://github.com/open-mmlab/mmpose/pull/816), [#817](https://github.com/open-mmlab/mmpose/pull/817), [#819](https://github.com/open-mmlab/mmpose/pull/819), [#839](https://github.com/open-mmlab/mmpose/pull/839)) @ly015, @luminxu, @jin-s13, @liqikai9, @zengwang430521
+
+- Add Colab Tutorial ([#834](https://github.com/open-mmlab/mmpose/pull/834)) @ly015
+
+- Support training for InterHand v1.0 dataset ([#761](https://github.com/open-mmlab/mmpose/pull/761)) @zengwang430521
+
+**Bug Fixes**
+
+- Fix mpii pckh@0.1 index ([#773](https://github.com/open-mmlab/mmpose/pull/773)) @jin-s13
+
+- Fix multi-node distributed test ([#818](https://github.com/open-mmlab/mmpose/pull/818)) @ly015
+
+- Fix docstring and init_weights error of ShuffleNetV1 ([#814](https://github.com/open-mmlab/mmpose/pull/814)) @Junjun2016
+
+- Fix imshow_bbox error when input bboxes is empty ([#796](https://github.com/open-mmlab/mmpose/pull/796)) @ly015
+
+- Fix model zoo doc generation ([#778](https://github.com/open-mmlab/mmpose/pull/778)) @ly015
+
+- Fix typo ([#767](https://github.com/open-mmlab/mmpose/pull/767)), ([#780](https://github.com/open-mmlab/mmpose/pull/780), [#782](https://github.com/open-mmlab/mmpose/pull/782)) @ly015, @jin-s13
+
+**Breaking Changes**
+
+- Use MMCV EvalHook ([#686](https://github.com/open-mmlab/mmpose/pull/686)) @ly015
+
+**Improvements**
+
+- Add pytest.ini and fix docstring ([#812](https://github.com/open-mmlab/mmpose/pull/812)) @jin-s13
+
+- Update MSELoss ([#829](https://github.com/open-mmlab/mmpose/pull/829)) @Ezra-Yu
+
+- Move process_mmdet_results into inference.py ([#831](https://github.com/open-mmlab/mmpose/pull/831)) @ly015
+
+- Update resource limit ([#783](https://github.com/open-mmlab/mmpose/pull/783)) @jin-s13
+
+- Use COCO 2D pose model in 3D demo examples ([#785](https://github.com/open-mmlab/mmpose/pull/785)) @ly015
+
+- Change model zoo titles in the doc from center-aligned to left-aligned ([#792](https://github.com/open-mmlab/mmpose/pull/792), [#797](https://github.com/open-mmlab/mmpose/pull/797)) @ly015
+
+- Support MIM ([#706](https://github.com/open-mmlab/mmpose/pull/706), [#794](https://github.com/open-mmlab/mmpose/pull/794)) @ly015
+
+- Update out-of-date configs ([#827](https://github.com/open-mmlab/mmpose/pull/827)) @jin-s13
+
+- Remove opencv-python-headless dependency by albumentations ([#833](https://github.com/open-mmlab/mmpose/pull/833)) @ly015
+
+- Update QQ QR code in README_CN.md ([#832](https://github.com/open-mmlab/mmpose/pull/832)) @ly015
+
+## **v0.16.0 (02/07/2021)**
+
+**Highlights**
+
+1. Support ["ViPNAS: Efficient Video Pose Estimation via Neural Architecture Search"](https://arxiv.org/abs/2105.10154) CVPR'2021 ([#742](https://github.com/open-mmlab/mmpose/pull/742),[#755](https://github.com/open-mmlab/mmpose/pull/755)).
+
+2. Support MPI-INF-3DHP dataset ([#683](https://github.com/open-mmlab/mmpose/pull/683),[#746](https://github.com/open-mmlab/mmpose/pull/746),[#751](https://github.com/open-mmlab/mmpose/pull/751)).
+
+3. Add webcam demo tool ([#729](https://github.com/open-mmlab/mmpose/pull/729))
+
+4. Add 3d body and hand pose estimation demo ([#704](https://github.com/open-mmlab/mmpose/pull/704), [#727](https://github.com/open-mmlab/mmpose/pull/727)).
+
+**New Features**
+
+- Support ["ViPNAS: Efficient Video Pose Estimation via Neural Architecture Search"](https://arxiv.org/abs/2105.10154) CVPR'2021 ([#742](https://github.com/open-mmlab/mmpose/pull/742),[#755](https://github.com/open-mmlab/mmpose/pull/755))
+
+- Support MPI-INF-3DHP dataset ([#683](https://github.com/open-mmlab/mmpose/pull/683),[#746](https://github.com/open-mmlab/mmpose/pull/746),[#751](https://github.com/open-mmlab/mmpose/pull/751))
+
+- Support Webcam demo ([#729](https://github.com/open-mmlab/mmpose/pull/729))
+
+- Support Interhand 3d demo ([#704](https://github.com/open-mmlab/mmpose/pull/704))
+
+- Support 3d pose video demo ([#727](https://github.com/open-mmlab/mmpose/pull/727))
+
+- Support H36m dataset for 2d pose estimation ([#709](https://github.com/open-mmlab/mmpose/pull/709), [#735](https://github.com/open-mmlab/mmpose/pull/735))
+
+- Add scripts to generate mim metafile ([#749](https://github.com/open-mmlab/mmpose/pull/749))
+
+**Bug Fixes**
+
+- Fix typos ([#692](https://github.com/open-mmlab/mmpose/pull/692),[#696](https://github.com/open-mmlab/mmpose/pull/696),[#697](https://github.com/open-mmlab/mmpose/pull/697),[#698](https://github.com/open-mmlab/mmpose/pull/698),[#712](https://github.com/open-mmlab/mmpose/pull/712),[#718](https://github.com/open-mmlab/mmpose/pull/718),[#728](https://github.com/open-mmlab/mmpose/pull/728))
+
+- Change model download links from `http` to `https` ([#716](https://github.com/open-mmlab/mmpose/pull/716))
+
+**Breaking Changes**
+
+- Switch to MMCV MODEL_REGISTRY ([#669](https://github.com/open-mmlab/mmpose/pull/669))
+
+**Improvements**
+
+- Refactor MeshMixDataset ([#752](https://github.com/open-mmlab/mmpose/pull/752))
+
+- Rename 'GaussianHeatMap' to 'GaussianHeatmap' ([#745](https://github.com/open-mmlab/mmpose/pull/745))
+
+- Update out-of-date configs ([#734](https://github.com/open-mmlab/mmpose/pull/734))
+
+- Improve compatibility for breaking changes ([#731](https://github.com/open-mmlab/mmpose/pull/731))
+
+- Enable to control radius and thickness in visualization ([#722](https://github.com/open-mmlab/mmpose/pull/722))
+
+- Add regex dependency ([#720](https://github.com/open-mmlab/mmpose/pull/720))
+
+## **v0.15.0 (02/06/2021)**
+
+**Highlights**
+
+1. Support 3d video pose estimation (VideoPose3D).
+
+2. Support 3d hand pose estimation (InterNet).
+
+3. Improve presentation of modelzoo.
+
+**New Features**
+
+- Support "InterHand2.6M: A Dataset and Baseline for 3D Interacting Hand Pose Estimation from a Single RGB Image" (ECCV‘20) ([#624](https://github.com/open-mmlab/mmpose/pull/624))
+
+- Support "3D human pose estimation in video with temporal convolutions and semi-supervised training" (CVPR'19) ([#602](https://github.com/open-mmlab/mmpose/pull/602), [#681](https://github.com/open-mmlab/mmpose/pull/681))
+
+- Support 3d pose estimation demo ([#653](https://github.com/open-mmlab/mmpose/pull/653), [#670](https://github.com/open-mmlab/mmpose/pull/670))
+
+- Support bottom-up whole-body pose estimation ([#689](https://github.com/open-mmlab/mmpose/pull/689))
+
+- Support mmcli ([#634](https://github.com/open-mmlab/mmpose/pull/634))
+
+**Bug Fixes**
+
+- Fix opencv compatibility ([#635](https://github.com/open-mmlab/mmpose/pull/635))
+
+- Fix demo with UDP ([#637](https://github.com/open-mmlab/mmpose/pull/637))
+
+- Fix bottom-up model onnx conversion ([#680](https://github.com/open-mmlab/mmpose/pull/680))
+
+- Fix `GPU_IDS` in distributed training ([#668](https://github.com/open-mmlab/mmpose/pull/668))
+
+- Fix MANIFEST.in ([#641](https://github.com/open-mmlab/mmpose/pull/641), [#657](https://github.com/open-mmlab/mmpose/pull/657))
+
+- Fix docs ([#643](https://github.com/open-mmlab/mmpose/pull/643),[#684](https://github.com/open-mmlab/mmpose/pull/684),[#688](https://github.com/open-mmlab/mmpose/pull/688),[#690](https://github.com/open-mmlab/mmpose/pull/690),[#692](https://github.com/open-mmlab/mmpose/pull/692))
+
+**Breaking Changes**
+
+- Reorganize configs by tasks, algorithms, datasets, and techniques ([#647](https://github.com/open-mmlab/mmpose/pull/647))
+
+- Rename heads and detectors ([#667](https://github.com/open-mmlab/mmpose/pull/667))
+
+**Improvements**
+
+- Add `radius` and `thickness` parameters in visualization ([#638](https://github.com/open-mmlab/mmpose/pull/638))
+
+- Add `trans_prob` parameter in `TopDownRandomTranslation` ([#650](https://github.com/open-mmlab/mmpose/pull/650))
+
+- Switch to `MMCV MODEL_REGISTRY` ([#669](https://github.com/open-mmlab/mmpose/pull/669))
+
+- Update dependencies ([#674](https://github.com/open-mmlab/mmpose/pull/674), [#676](https://github.com/open-mmlab/mmpose/pull/676))
+
+## **v0.14.0 (06/05/2021)**
+
+**Highlights**
+
+1. Support animal pose estimation with 7 popular datasets.
+
+2. Support "A simple yet effective baseline for 3d human pose estimation" (ICCV'17).
+
+**New Features**
+
+- Support "A simple yet effective baseline for 3d human pose estimation" (ICCV'17) ([#554](https://github.com/open-mmlab/mmpose/pull/554),[#558](https://github.com/open-mmlab/mmpose/pull/558),[#566](https://github.com/open-mmlab/mmpose/pull/566),[#570](https://github.com/open-mmlab/mmpose/pull/570),[#589](https://github.com/open-mmlab/mmpose/pull/589))
+
+- Support animal pose estimation ([#559](https://github.com/open-mmlab/mmpose/pull/559),[#561](https://github.com/open-mmlab/mmpose/pull/561),[#563](https://github.com/open-mmlab/mmpose/pull/563),[#571](https://github.com/open-mmlab/mmpose/pull/571),[#603](https://github.com/open-mmlab/mmpose/pull/603),[#605](https://github.com/open-mmlab/mmpose/pull/605))
+
+- Support Horse-10 dataset ([#561](https://github.com/open-mmlab/mmpose/pull/561)), MacaquePose dataset ([#561](https://github.com/open-mmlab/mmpose/pull/561)), Vinegar Fly dataset ([#561](https://github.com/open-mmlab/mmpose/pull/561)), Desert Locust dataset ([#561](https://github.com/open-mmlab/mmpose/pull/561)), Grevy's Zebra dataset ([#561](https://github.com/open-mmlab/mmpose/pull/561)), ATRW dataset ([#571](https://github.com/open-mmlab/mmpose/pull/571)), and Animal-Pose dataset ([#603](https://github.com/open-mmlab/mmpose/pull/603))
+
+- Support bottom-up pose tracking demo ([#574](https://github.com/open-mmlab/mmpose/pull/574))
+
+- Support FP16 training ([#584](https://github.com/open-mmlab/mmpose/pull/584),[#616](https://github.com/open-mmlab/mmpose/pull/616),[#626](https://github.com/open-mmlab/mmpose/pull/626))
+
+- Support NMS for bottom-up ([#609](https://github.com/open-mmlab/mmpose/pull/609))
+
+**Bug Fixes**
+
+- Fix bugs in the top-down demo, when there are no people in the images ([#569](https://github.com/open-mmlab/mmpose/pull/569)).
+
+- Fix the links in the doc ([#612](https://github.com/open-mmlab/mmpose/pull/612))
+
+**Improvements**
+
+- Speed up top-down inference ([#560](https://github.com/open-mmlab/mmpose/pull/560))
+
+- Update github CI ([#562](https://github.com/open-mmlab/mmpose/pull/562), [#564](https://github.com/open-mmlab/mmpose/pull/564))
+
+- Update Readme ([#578](https://github.com/open-mmlab/mmpose/pull/578),[#579](https://github.com/open-mmlab/mmpose/pull/579),[#580](https://github.com/open-mmlab/mmpose/pull/580),[#592](https://github.com/open-mmlab/mmpose/pull/592),[#599](https://github.com/open-mmlab/mmpose/pull/599),[#600](https://github.com/open-mmlab/mmpose/pull/600),[#607](https://github.com/open-mmlab/mmpose/pull/607))
+
+- Update Faq ([#587](https://github.com/open-mmlab/mmpose/pull/587), [#610](https://github.com/open-mmlab/mmpose/pull/610))
+
+## **v0.13.0 (31/03/2021)**
+
+**Highlights**
+
+1. Support Wingloss.
+
+2. Support RHD hand dataset.
+
+**New Features**
+
+- Support Wingloss ([#482](https://github.com/open-mmlab/mmpose/pull/482))
+
+- Support RHD hand dataset ([#523](https://github.com/open-mmlab/mmpose/pull/523), [#551](https://github.com/open-mmlab/mmpose/pull/551))
+
+- Support Human3.6m dataset for 3d keypoint detection ([#518](https://github.com/open-mmlab/mmpose/pull/518), [#527](https://github.com/open-mmlab/mmpose/pull/527))
+
+- Support TCN model for 3d keypoint detection ([#521](https://github.com/open-mmlab/mmpose/pull/521), [#522](https://github.com/open-mmlab/mmpose/pull/522))
+
+- Support Interhand3D model for 3d hand detection ([#536](https://github.com/open-mmlab/mmpose/pull/536))
+
+- Support Multi-task detector ([#480](https://github.com/open-mmlab/mmpose/pull/480))
+
+**Bug Fixes**
+
+- Fix PCKh@0.1 calculation ([#516](https://github.com/open-mmlab/mmpose/pull/516))
+
+- Fix unittest ([#529](https://github.com/open-mmlab/mmpose/pull/529))
+
+- Fix circular importing ([#542](https://github.com/open-mmlab/mmpose/pull/542))
+
+- Fix bugs in bottom-up keypoint score ([#548](https://github.com/open-mmlab/mmpose/pull/548))
+
+**Improvements**
+
+- Update config & checkpoints ([#525](https://github.com/open-mmlab/mmpose/pull/525), [#546](https://github.com/open-mmlab/mmpose/pull/546))
+
+- Fix typos ([#514](https://github.com/open-mmlab/mmpose/pull/514), [#519](https://github.com/open-mmlab/mmpose/pull/519), [#532](https://github.com/open-mmlab/mmpose/pull/532), [#537](https://github.com/open-mmlab/mmpose/pull/537), )
+
+- Speed up post processing ([#535](https://github.com/open-mmlab/mmpose/pull/535))
+
+- Update mmcv version dependency ([#544](https://github.com/open-mmlab/mmpose/pull/544))
+
+## **v0.12.0 (28/02/2021)**
+
+**Highlights**
+
+1. Support DeepPose algorithm.
+
+**New Features**
+
+- Support DeepPose algorithm ([#446](https://github.com/open-mmlab/mmpose/pull/446), [#461](https://github.com/open-mmlab/mmpose/pull/461))
+
+- Support interhand3d dataset ([#468](https://github.com/open-mmlab/mmpose/pull/468))
+
+- Support Albumentation pipeline ([#469](https://github.com/open-mmlab/mmpose/pull/469))
+
+- Support PhotometricDistortion pipeline ([#485](https://github.com/open-mmlab/mmpose/pull/485))
+
+- Set seed option for training ([#493](https://github.com/open-mmlab/mmpose/pull/493))
+
+- Add demos for face keypoint detection ([#502](https://github.com/open-mmlab/mmpose/pull/502))
+
+**Bug Fixes**
+
+- Change channel order according to configs ([#504](https://github.com/open-mmlab/mmpose/pull/504))
+
+- Fix `num_factors` in UDP encoding ([#495](https://github.com/open-mmlab/mmpose/pull/495))
+
+- Fix configs ([#456](https://github.com/open-mmlab/mmpose/pull/456))
+
+**Breaking Changes**
+
+- Refactor configs for wholebody pose estimation ([#487](https://github.com/open-mmlab/mmpose/pull/487), [#491](https://github.com/open-mmlab/mmpose/pull/491))
+
+- Rename `decode` function for heads ([#481](https://github.com/open-mmlab/mmpose/pull/481))
+
+**Improvements**
+
+- Update config & checkpoints ([#453](https://github.com/open-mmlab/mmpose/pull/453),[#484](https://github.com/open-mmlab/mmpose/pull/484),[#487](https://github.com/open-mmlab/mmpose/pull/487))
+
+- Add README in Chinese ([#462](https://github.com/open-mmlab/mmpose/pull/462))
+
+- Add tutorials about configs ([#465](https://github.com/open-mmlab/mmpose/pull/465))
+
+- Add demo videos for various tasks ([#499](https://github.com/open-mmlab/mmpose/pull/499), [#503](https://github.com/open-mmlab/mmpose/pull/503))
+
+- Update docs about MMPose installation ([#467](https://github.com/open-mmlab/mmpose/pull/467), [#505](https://github.com/open-mmlab/mmpose/pull/505))
+
+- Rename `stat.py` to `stats.py` ([#483](https://github.com/open-mmlab/mmpose/pull/483))
+
+- Fix typos ([#463](https://github.com/open-mmlab/mmpose/pull/463), [#464](https://github.com/open-mmlab/mmpose/pull/464), [#477](https://github.com/open-mmlab/mmpose/pull/477), [#481](https://github.com/open-mmlab/mmpose/pull/481))
+
+- latex to bibtex ([#471](https://github.com/open-mmlab/mmpose/pull/471))
+
+- Update FAQ ([#466](https://github.com/open-mmlab/mmpose/pull/466))
+
+## **v0.11.0 (31/01/2021)**
+
+**Highlights**
+
+1. Support fashion landmark detection.
+
+2. Support face keypoint detection.
+
+3. Support pose tracking with MMTracking.
+
+**New Features**
+
+- Support fashion landmark detection (DeepFashion) ([#413](https://github.com/open-mmlab/mmpose/pull/413))
+
+- Support face keypoint detection (300W, AFLW, COFW, WFLW) ([#367](https://github.com/open-mmlab/mmpose/pull/367))
+
+- Support pose tracking demo with MMTracking ([#427](https://github.com/open-mmlab/mmpose/pull/427))
+
+- Support face demo ([#443](https://github.com/open-mmlab/mmpose/pull/443))
+
+- Support AIC dataset for bottom-up methods ([#438](https://github.com/open-mmlab/mmpose/pull/438), [#449](https://github.com/open-mmlab/mmpose/pull/449))
+
+**Bug Fixes**
+
+- Fix multi-batch training ([#434](https://github.com/open-mmlab/mmpose/pull/434))
+
+- Fix sigmas in AIC dataset ([#441](https://github.com/open-mmlab/mmpose/pull/441))
+
+- Fix config file ([#420](https://github.com/open-mmlab/mmpose/pull/420))
+
+**Breaking Changes**
+
+- Refactor Heads ([#382](https://github.com/open-mmlab/mmpose/pull/382))
+
+**Improvements**
+
+- Update readme ([#409](https://github.com/open-mmlab/mmpose/pull/409), [#412](https://github.com/open-mmlab/mmpose/pull/412), [#415](https://github.com/open-mmlab/mmpose/pull/415), [#416](https://github.com/open-mmlab/mmpose/pull/416), [#419](https://github.com/open-mmlab/mmpose/pull/419), [#421](https://github.com/open-mmlab/mmpose/pull/421), [#422](https://github.com/open-mmlab/mmpose/pull/422), [#424](https://github.com/open-mmlab/mmpose/pull/424), [#425](https://github.com/open-mmlab/mmpose/pull/425), [#435](https://github.com/open-mmlab/mmpose/pull/435), [#436](https://github.com/open-mmlab/mmpose/pull/436), [#437](https://github.com/open-mmlab/mmpose/pull/437), [#444](https://github.com/open-mmlab/mmpose/pull/444), [#445](https://github.com/open-mmlab/mmpose/pull/445))
+
+- Add GAP (global average pooling) neck ([#414](https://github.com/open-mmlab/mmpose/pull/414))
+
+- Speed up ([#411](https://github.com/open-mmlab/mmpose/pull/411), [#423](https://github.com/open-mmlab/mmpose/pull/423))
+
+- Support COCO test-dev test ([#433](https://github.com/open-mmlab/mmpose/pull/433))
+
+## **v0.10.0 (31/12/2020)**
+
+**Highlights**
+
+1. Support more human pose estimation methods.
+
+ 1. [UDP](https://arxiv.org/abs/1911.07524)
+
+2. Support pose tracking.
+
+3. Support multi-batch inference.
+
+4. Add some useful tools, including `analyze_logs`, `get_flops`, `print_config`.
+
+5. Support more backbone networks.
+
+ 1. [ResNest](https://arxiv.org/pdf/2004.08955.pdf)
+ 2. [VGG](https://arxiv.org/abs/1409.1556)
+
+**New Features**
+
+- Support UDP ([#353](https://github.com/open-mmlab/mmpose/pull/353), [#371](https://github.com/open-mmlab/mmpose/pull/371), [#402](https://github.com/open-mmlab/mmpose/pull/402))
+
+- Support multi-batch inference ([#390](https://github.com/open-mmlab/mmpose/pull/390))
+
+- Support MHP dataset ([#386](https://github.com/open-mmlab/mmpose/pull/386))
+
+- Support pose tracking demo ([#380](https://github.com/open-mmlab/mmpose/pull/380))
+
+- Support mpii-trb demo ([#372](https://github.com/open-mmlab/mmpose/pull/372))
+
+- Support mobilenet for hand pose estimation ([#377](https://github.com/open-mmlab/mmpose/pull/377))
+
+- Support ResNest backbone ([#370](https://github.com/open-mmlab/mmpose/pull/370))
+
+- Support VGG backbone ([#370](https://github.com/open-mmlab/mmpose/pull/370))
+
+- Add some useful tools, including `analyze_logs`, `get_flops`, `print_config` ([#324](https://github.com/open-mmlab/mmpose/pull/324))
+
+**Bug Fixes**
+
+- Fix bugs in pck evaluation ([#328](https://github.com/open-mmlab/mmpose/pull/328))
+
+- Fix model download links in README ([#396](https://github.com/open-mmlab/mmpose/pull/396), [#397](https://github.com/open-mmlab/mmpose/pull/397))
+
+- Fix CrowdPose annotations and update benchmarks ([#384](https://github.com/open-mmlab/mmpose/pull/384))
+
+- Fix modelzoo stat ([#354](https://github.com/open-mmlab/mmpose/pull/354), [#360](https://github.com/open-mmlab/mmpose/pull/360), [#362](https://github.com/open-mmlab/mmpose/pull/362))
+
+- Fix config files for aic datasets ([#340](https://github.com/open-mmlab/mmpose/pull/340))
+
+**Breaking Changes**
+
+- Rename `image_thr` to `det_bbox_thr` for top-down methods.
+
+**Improvements**
+
+- Organize the readme files ([#398](https://github.com/open-mmlab/mmpose/pull/398), [#399](https://github.com/open-mmlab/mmpose/pull/399), [#400](https://github.com/open-mmlab/mmpose/pull/400))
+
+- Check linting for markdown ([#379](https://github.com/open-mmlab/mmpose/pull/379))
+
+- Add faq.md ([#350](https://github.com/open-mmlab/mmpose/pull/350))
+
+- Remove PyTorch 1.4 in CI ([#338](https://github.com/open-mmlab/mmpose/pull/338))
+
+- Add pypi badge in readme ([#329](https://github.com/open-mmlab/mmpose/pull/329))
+
+## **v0.9.0 (30/11/2020)**
+
+**Highlights**
+
+1. Support more human pose estimation methods.
+
+ 1. [MSPN](https://arxiv.org/abs/1901.00148)
+ 2. [RSN](https://arxiv.org/abs/2003.04030)
+
+2. Support video pose estimation datasets.
+
+ 1. [sub-JHMDB](http://jhmdb.is.tue.mpg.de/dataset)
+
+3. Support Onnx model conversion.
+
+**New Features**
+
+- Support MSPN ([#278](https://github.com/open-mmlab/mmpose/pull/278))
+
+- Support RSN ([#221](https://github.com/open-mmlab/mmpose/pull/221), [#318](https://github.com/open-mmlab/mmpose/pull/318))
+
+- Support new post-processing method for MSPN & RSN ([#288](https://github.com/open-mmlab/mmpose/pull/288))
+
+- Support sub-JHMDB dataset ([#292](https://github.com/open-mmlab/mmpose/pull/292))
+
+- Support urls for pre-trained models in config files ([#232](https://github.com/open-mmlab/mmpose/pull/232))
+
+- Support Onnx ([#305](https://github.com/open-mmlab/mmpose/pull/305))
+
+**Bug Fixes**
+
+- Fix model download links in README ([#255](https://github.com/open-mmlab/mmpose/pull/255), [#315](https://github.com/open-mmlab/mmpose/pull/315))
+
+**Breaking Changes**
+
+- `post_process=True|False` and `unbiased_decoding=True|False` are deprecated, use `post_process=None|default|unbiased` etc. instead ([#288](https://github.com/open-mmlab/mmpose/pull/288))
+
+**Improvements**
+
+- Enrich the model zoo ([#256](https://github.com/open-mmlab/mmpose/pull/256), [#320](https://github.com/open-mmlab/mmpose/pull/320))
+
+- Set the default map_location as 'cpu' to reduce gpu memory cost ([#227](https://github.com/open-mmlab/mmpose/pull/227))
+
+- Support return heatmaps and backbone features for bottom-up models ([#229](https://github.com/open-mmlab/mmpose/pull/229))
+
+- Upgrade mmcv maximum & minimum version ([#269](https://github.com/open-mmlab/mmpose/pull/269), [#313](https://github.com/open-mmlab/mmpose/pull/313))
+
+- Automatically add modelzoo statistics to readthedocs ([#252](https://github.com/open-mmlab/mmpose/pull/252))
+
+- Fix Pylint issues ([#258](https://github.com/open-mmlab/mmpose/pull/258), [#259](https://github.com/open-mmlab/mmpose/pull/259), [#260](https://github.com/open-mmlab/mmpose/pull/260), [#262](https://github.com/open-mmlab/mmpose/pull/262), [#265](https://github.com/open-mmlab/mmpose/pull/265), [#267](https://github.com/open-mmlab/mmpose/pull/267), [#268](https://github.com/open-mmlab/mmpose/pull/268), [#270](https://github.com/open-mmlab/mmpose/pull/270), [#271](https://github.com/open-mmlab/mmpose/pull/271), [#272](https://github.com/open-mmlab/mmpose/pull/272), [#273](https://github.com/open-mmlab/mmpose/pull/273), [#275](https://github.com/open-mmlab/mmpose/pull/275), [#276](https://github.com/open-mmlab/mmpose/pull/276), [#283](https://github.com/open-mmlab/mmpose/pull/283), [#285](https://github.com/open-mmlab/mmpose/pull/285), [#293](https://github.com/open-mmlab/mmpose/pull/293), [#294](https://github.com/open-mmlab/mmpose/pull/294), [#295](https://github.com/open-mmlab/mmpose/pull/295))
+
+- Improve README ([#226](https://github.com/open-mmlab/mmpose/pull/226), [#257](https://github.com/open-mmlab/mmpose/pull/257), [#264](https://github.com/open-mmlab/mmpose/pull/264), [#280](https://github.com/open-mmlab/mmpose/pull/280), [#296](https://github.com/open-mmlab/mmpose/pull/296))
+
+- Support PyTorch 1.7 in CI ([#274](https://github.com/open-mmlab/mmpose/pull/274))
+
+- Add docs/tutorials for running demos ([#263](https://github.com/open-mmlab/mmpose/pull/263))
+
+## **v0.8.0 (31/10/2020)**
+
+**Highlights**
+
+1. Support more human pose estimation datasets.
+
+ 1. [CrowdPose](https://github.com/Jeff-sjtu/CrowdPose)
+ 2. [PoseTrack18](https://posetrack.net/)
+
+2. Support more 2D hand keypoint estimation datasets.
+
+ 1. [InterHand2.6](https://github.com/facebookresearch/InterHand2.6M)
+
+3. Support adversarial training for 3D human shape recovery.
+
+4. Support multi-stage losses.
+
+5. Support mpii demo.
+
+**New Features**
+
+- Support [CrowdPose](https://github.com/Jeff-sjtu/CrowdPose) dataset ([#195](https://github.com/open-mmlab/mmpose/pull/195))
+
+- Support [PoseTrack18](https://posetrack.net/) dataset ([#220](https://github.com/open-mmlab/mmpose/pull/220))
+
+- Support [InterHand2.6](https://github.com/facebookresearch/InterHand2.6M) dataset ([#202](https://github.com/open-mmlab/mmpose/pull/202))
+
+- Support adversarial training for 3D human shape recovery ([#192](https://github.com/open-mmlab/mmpose/pull/192))
+
+- Support multi-stage losses ([#204](https://github.com/open-mmlab/mmpose/pull/204))
+
+**Bug Fixes**
+
+- Fix config files ([#190](https://github.com/open-mmlab/mmpose/pull/190))
+
+**Improvements**
+
+- Add mpii demo ([#216](https://github.com/open-mmlab/mmpose/pull/216))
+
+- Improve README ([#181](https://github.com/open-mmlab/mmpose/pull/181), [#183](https://github.com/open-mmlab/mmpose/pull/183), [#208](https://github.com/open-mmlab/mmpose/pull/208))
+
+- Support return heatmaps and backbone features ([#196](https://github.com/open-mmlab/mmpose/pull/196), [#212](https://github.com/open-mmlab/mmpose/pull/212))
+
+- Support different return formats of mmdetection models ([#217](https://github.com/open-mmlab/mmpose/pull/217))
+
+## **v0.7.0 (30/9/2020)**
+
+**Highlights**
+
+1. Support HMR for 3D human shape recovery.
+
+2. Support WholeBody human pose estimation.
+
+ 1. [COCO-WholeBody](https://github.com/jin-s13/COCO-WholeBody)
+
+3. Support more 2D hand keypoint estimation datasets.
+
+ 1. [Frei-hand](https://lmb.informatik.uni-freiburg.de/projects/freihand/)
+ 2. [CMU Panoptic HandDB](http://domedb.perception.cs.cmu.edu/handdb.html)
+
+4. Add more popular backbones & enrich the [modelzoo](https://mmpose.readthedocs.io/en/latest/model_zoo.html)
+
+ 1. ShuffleNetv2
+
+5. Support hand demo and whole-body demo.
+
+**New Features**
+
+- Support HMR for 3D human shape recovery ([#157](https://github.com/open-mmlab/mmpose/pull/157), [#160](https://github.com/open-mmlab/mmpose/pull/160), [#161](https://github.com/open-mmlab/mmpose/pull/161), [#162](https://github.com/open-mmlab/mmpose/pull/162))
+
+- Support [COCO-WholeBody](https://github.com/jin-s13/COCO-WholeBody) dataset ([#133](https://github.com/open-mmlab/mmpose/pull/133))
+
+- Support [Frei-hand](https://lmb.informatik.uni-freiburg.de/projects/freihand/) dataset ([#125](https://github.com/open-mmlab/mmpose/pull/125))
+
+- Support [CMU Panoptic HandDB](http://domedb.perception.cs.cmu.edu/handdb.html) dataset ([#144](https://github.com/open-mmlab/mmpose/pull/144))
+
+- Support H36M dataset ([#159](https://github.com/open-mmlab/mmpose/pull/159))
+
+- Support ShuffleNetv2 ([#139](https://github.com/open-mmlab/mmpose/pull/139))
+
+- Support saving best models based on key indicator ([#127](https://github.com/open-mmlab/mmpose/pull/127))
+
+**Bug Fixes**
+
+- Fix typos in docs ([#121](https://github.com/open-mmlab/mmpose/pull/121))
+
+- Fix assertion ([#142](https://github.com/open-mmlab/mmpose/pull/142))
+
+**Improvements**
+
+- Add tools to transform .mat format to .json format ([#126](https://github.com/open-mmlab/mmpose/pull/126))
+
+- Add hand demo ([#115](https://github.com/open-mmlab/mmpose/pull/115))
+
+- Add whole-body demo ([#163](https://github.com/open-mmlab/mmpose/pull/163))
+
+- Reuse mmcv utility function and update version files ([#135](https://github.com/open-mmlab/mmpose/pull/135), [#137](https://github.com/open-mmlab/mmpose/pull/137))
+
+- Enrich the modelzoo ([#147](https://github.com/open-mmlab/mmpose/pull/147), [#169](https://github.com/open-mmlab/mmpose/pull/169))
+
+- Improve docs ([#174](https://github.com/open-mmlab/mmpose/pull/174), [#175](https://github.com/open-mmlab/mmpose/pull/175), [#178](https://github.com/open-mmlab/mmpose/pull/178))
+
+- Improve README ([#176](https://github.com/open-mmlab/mmpose/pull/176))
+
+- Improve version.py ([#173](https://github.com/open-mmlab/mmpose/pull/173))
+
+## **v0.6.0 (31/8/2020)**
+
+**Highlights**
+
+1. Add more popular backbones & enrich the [modelzoo](https://mmpose.readthedocs.io/en/latest/model_zoo.html)
+
+ 1. ResNext
+ 2. SEResNet
+ 3. ResNetV1D
+ 4. MobileNetv2
+ 5. ShuffleNetv1
+ 6. CPM (Convolutional Pose Machine)
+
+2. Add more popular datasets:
+
+ 1. [AIChallenger](https://arxiv.org/abs/1711.06475?context=cs.CV)
+ 2. [MPII](http://human-pose.mpi-inf.mpg.de/)
+ 3. [MPII-TRB](https://github.com/kennymckormick/Triplet-Representation-of-human-Body)
+ 4. [OCHuman](http://www.liruilong.cn/projects/pose2seg/index.html)
+
+3. Support 2d hand keypoint estimation.
+
+ 1. [OneHand10K](https://www.yangangwang.com/papers/WANG-MCC-2018-10.html)
+
+4. Support bottom-up inference.
+
+**New Features**
+
+- Support [OneHand10K](https://www.yangangwang.com/papers/WANG-MCC-2018-10.html) dataset ([#52](https://github.com/open-mmlab/mmpose/pull/52))
+
+- Support [MPII](http://human-pose.mpi-inf.mpg.de/) dataset ([#55](https://github.com/open-mmlab/mmpose/pull/55))
+
+- Support [MPII-TRB](https://github.com/kennymckormick/Triplet-Representation-of-human-Body) dataset ([#19](https://github.com/open-mmlab/mmpose/pull/19), [#47](https://github.com/open-mmlab/mmpose/pull/47), [#48](https://github.com/open-mmlab/mmpose/pull/48))
+
+- Support [OCHuman](http://www.liruilong.cn/projects/pose2seg/index.html) dataset ([#70](https://github.com/open-mmlab/mmpose/pull/70))
+
+- Support [AIChallenger](https://arxiv.org/abs/1711.06475?context=cs.CV) dataset ([#87](https://github.com/open-mmlab/mmpose/pull/87))
+
+- Support multiple backbones ([#26](https://github.com/open-mmlab/mmpose/pull/26))
+
+- Support CPM model ([#56](https://github.com/open-mmlab/mmpose/pull/56))
+
+**Bug Fixes**
+
+- Fix configs for MPII & MPII-TRB datasets ([#93](https://github.com/open-mmlab/mmpose/pull/93))
+
+- Fix the bug of missing `test_pipeline` in configs ([#14](https://github.com/open-mmlab/mmpose/pull/14))
+
+- Fix typos ([#27](https://github.com/open-mmlab/mmpose/pull/27), [#28](https://github.com/open-mmlab/mmpose/pull/28), [#50](https://github.com/open-mmlab/mmpose/pull/50), [#53](https://github.com/open-mmlab/mmpose/pull/53), [#63](https://github.com/open-mmlab/mmpose/pull/63))
+
+**Improvements**
+
+- Update benchmark ([#93](https://github.com/open-mmlab/mmpose/pull/93))
+
+- Add Dockerfile ([#44](https://github.com/open-mmlab/mmpose/pull/44))
+
+- Improve unittest coverage and minor fix ([#18](https://github.com/open-mmlab/mmpose/pull/18))
+
+- Support CPUs for train/val/demo ([#34](https://github.com/open-mmlab/mmpose/pull/34))
+
+- Support bottom-up demo ([#69](https://github.com/open-mmlab/mmpose/pull/69))
+
+- Add tools to publish model ([#62](https://github.com/open-mmlab/mmpose/pull/62))
+
+- Enrich the modelzoo ([#64](https://github.com/open-mmlab/mmpose/pull/64), [#68](https://github.com/open-mmlab/mmpose/pull/68), [#82](https://github.com/open-mmlab/mmpose/pull/82))
+
+## **v0.5.0 (21/7/2020)**
+
+**Highlights**
+
+- MMPose is released.
+
+**Main Features**
+
+- Support both top-down and bottom-up pose estimation approaches.
+
+- Achieve higher training efficiency and higher accuracy than other popular codebases (e.g. AlphaPose, HRNet)
+
+- Support various backbone models: ResNet, HRNet, SCNet, Houglass and HigherHRNet.
diff --git a/internlm_langchain/knowledge_base/MMPose/content/codecs.md b/internlm_langchain/knowledge_base/MMPose/content/codecs.md
new file mode 100644
index 00000000..85d4d2e5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/codecs.md
@@ -0,0 +1,227 @@
+# 编解码器
+
+在关键点检测任务中，根据算法的不同，需要利用标注信息，生成不同格式的训练目标，比如归一化的坐标值、一维向量、高斯热图等。同样的，对于模型输出的结果，也需要经过处理转换成标注信息格式。我们一般将标注信息到训练目标的处理过程称为编码，模型输出到标注信息的处理过程称为解码。
+
+编码和解码是一对紧密相关的互逆处理过程。在 MMPose 早期版本中，编码和解码过程往往分散在不同模块里，使其不够直观和统一，增加了学习和维护成本。
+
+MMPose 1.0 中引入了新模块 **编解码器（Codec）** ，将关键点数据的编码和解码过程进行集成，以增加代码的友好度和复用性。
+
+编解码器在工作流程中所处的位置如下所示：
+
+
+
+一个编解码器主要包含两个部分：
+
+- 编码器
+- 解码器
+
+### 编码器
+
+编码器主要负责将处于输入图片尺度的坐标值，编码为模型训练所需要的目标格式，主要包括：
+
+- 归一化的坐标值：用于 Regression-based 方法
+- 一维向量：用于 SimCC-based 方法
+- 高斯热图：用于 Heatmap-based 方法
+
+以 Regression-based 方法的编码器为例：
+
+```Python
+def encode(self,
+ keypoints: np.ndarray,
+ keypoints_visible: Optional[np.ndarray] = None) -> dict:
+ """Encoding keypoints from input image space to normalized space.
+
+ Args:
+ keypoints (np.ndarray): Keypoint coordinates in shape (N, K, D)
+ keypoints_visible (np.ndarray): Keypoint visibilities in shape
+ (N, K)
+
+ Returns:
+ dict:
+ - keypoint_labels (np.ndarray): The normalized regression labels in
+ shape (N, K, D) where D is 2 for 2d coordinates
+ - keypoint_weights (np.ndarray): The target weights in shape
+ (N, K)
+ """
+ if keypoints_visible is None:
+ keypoints_visible = np.ones(keypoints.shape[:2], dtype=np.float32)
+
+ w, h = self.input_size
+ valid = ((keypoints >= 0) &
+ (keypoints <= [w - 1, h - 1])).all(axis=-1) & (
+ keypoints_visible > 0.5)
+
+ keypoint_labels = (keypoints / np.array([w, h])).astype(np.float32)
+ keypoint_weights = np.where(valid, 1., 0.).astype(np.float32)
+
+ encoded = dict(
+ keypoint_labels=keypoint_labels, keypoint_weights=keypoint_weights)
+
+ return encoded
+```
+
+编码后的数据会在 `PackPoseInputs` 中被转换为 Tensor 格式，并封装到 `data_sample.gt_instance_labels` 中供模型调用，一般主要用于 loss 计算，下面以 `RegressionHead` 中的 `loss()` 为例：
+
+```Python
+def loss(self,
+ inputs: Tuple[Tensor],
+ batch_data_samples: OptSampleList,
+ train_cfg: ConfigType = {}) -> dict:
+ """Calculate losses from a batch of inputs and data samples."""
+
+ pred_outputs = self.forward(inputs)
+
+ keypoint_labels = torch.cat(
+ [d.gt_instance_labels.keypoint_labels for d in batch_data_samples])
+ keypoint_weights = torch.cat([
+ d.gt_instance_labels.keypoint_weights for d in batch_data_samples
+ ])
+
+ # calculate losses
+ losses = dict()
+ loss = self.loss_module(pred_outputs, keypoint_labels,
+ keypoint_weights.unsqueeze(-1))
+
+ losses.update(loss_kpt=loss)
+ ### 后续内容省略 ###
+```
+
+### 解码器
+
+解码器主要负责将模型的输出解码为输入图片尺度的坐标值，处理过程与编码器相反。
+
+以 Regression-based 方法的解码器为例：
+
+```Python
+def decode(self, encoded: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+ """Decode keypoint coordinates from normalized space to input image
+ space.
+
+ Args:
+ encoded (np.ndarray): Coordinates in shape (N, K, D)
+
+ Returns:
+ tuple:
+ - keypoints (np.ndarray): Decoded coordinates in shape (N, K, D)
+ - scores (np.ndarray): The keypoint scores in shape (N, K).
+ It usually represents the confidence of the keypoint prediction
+
+ """
+
+ if encoded.shape[-1] == 2:
+ N, K, _ = encoded.shape
+ normalized_coords = encoded.copy()
+ scores = np.ones((N, K), dtype=np.float32)
+ elif encoded.shape[-1] == 4:
+ # split coords and sigma if outputs contain output_sigma
+ normalized_coords = encoded[..., :2].copy()
+ output_sigma = encoded[..., 2:4].copy()
+ scores = (1 - output_sigma).mean(axis=-1)
+ else:
+ raise ValueError(
+ 'Keypoint dimension should be 2 or 4 (with sigma), '
+ f'but got {encoded.shape[-1]}')
+
+ w, h = self.input_size
+ keypoints = normalized_coords * np.array([w, h])
+
+ return keypoints, scores
+```
+
+默认情况下，`decode()` 方法只提供单个目标数据的解码过程，你也可以通过 `batch_decode()` 来实现批量解码提升执行效率。
+
+## 常见用法
+
+在 MMPose 配置文件中，主要有三处涉及编解码器：
+
+- 定义编解码器
+- 生成训练目标
+- 模型头部
+
+### 定义编解码器
+
+以回归方法生成归一化的坐标值为例，在配置文件中，我们通过如下方式定义编解码器：
+
+```Python
+codec = dict(type='RegressionLabel', input_size=(192, 256))
+```
+
+### 生成训练目标
+
+在数据处理阶段生成训练目标时，需要传入编解码器用于编码：
+
+```Python
+dict(type='GenerateTarget', encoder=codec)
+```
+
+### 模型头部
+
+在 MMPose 中，我们在模型头部对模型的输出进行解码，需要传入编解码器用于解码：
+
+```Python
+head=dict(
+ type='RLEHead',
+ in_channels=2048,
+ num_joints=17,
+ loss=dict(type='RLELoss', use_target_weight=True),
+ decoder=codec
+)
+```
+
+它们在配置文件中的具体位置如下:
+
+```Python
+
+# codec settings
+codec = dict(type='RegressionLabel', input_size=(192, 256)) ## 定义 ##
+
+# model settings
+model = dict(
+ type='TopdownPoseEstimator',
+ data_preprocessor=dict(
+ type='PoseDataPreprocessor',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ bgr_to_rgb=True),
+ backbone=dict(
+ type='ResNet',
+ depth=50,
+ init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
+ ),
+ neck=dict(type='GlobalAveragePooling'),
+ head=dict(
+ type='RLEHead',
+ in_channels=2048,
+ num_joints=17,
+ loss=dict(type='RLELoss', use_target_weight=True),
+ decoder=codec), ## 模型头部 ##
+ test_cfg=dict(
+ flip_test=True,
+ shift_coords=True,
+ ))
+
+# base dataset settings
+dataset_type = 'CocoDataset'
+data_mode = 'topdown'
+data_root = 'data/coco/'
+
+backend_args = dict(backend='local')
+
+# pipelines
+train_pipeline = [
+ dict(type='LoadImage', backend_args=backend_args),
+ dict(type='GetBBoxCenterScale'),
+ dict(type='RandomFlip', direction='horizontal'),
+ dict(type='RandomHalfBody'),
+ dict(type='RandomBBoxTransform'),
+ dict(type='TopdownAffine', input_size=codec['input_size']),
+ dict(type='GenerateTarget', encoder=codec), ## 生成训练目标 ##
+ dict(type='PackPoseInputs')
+]
+test_pipeline = [
+ dict(type='LoadImage', backend_args=backend_args),
+ dict(type='GetBBoxCenterScale'),
+ dict(type='TopdownAffine', input_size=codec['input_size']),
+ dict(type='PackPoseInputs')
+]
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/configs.md b/internlm_langchain/knowledge_base/MMPose/content/configs.md
new file mode 100644
index 00000000..0bcb7aa1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/configs.md
@@ -0,0 +1,466 @@
+# 配置文件
+
+MMPose 使用 Python 文件作为配置文件，将模块化设计和继承设计结合到配置系统中，便于进行各种实验。
+
+## 简介
+
+MMPose 拥有一套强大的配置系统，在注册器的配合下，用户可以通过一个配置文件来定义整个项目需要用到的所有内容，以 Python 字典形式组织配置信息，传递给注册器完成对应模块的实例化。
+
+下面是一个常见的 Pytorch 模块定义的例子：
+
+```Python
+# 在loss_a.py中定义Loss_A类
+Class Loss_A(nn.Module):
+ def __init__(self, param1, param2):
+ self.param1 = param1
+ self.param2 = param2
+ def forward(self, x):
+ return x
+
+# 在需要的地方进行实例化
+loss = Loss_A(param1=1.0, param2=True)
+```
+
+只需要通过一行代码对这个类进行注册：
+
+```Python
+# 在loss_a.py中定义Loss_A类
+from mmpose.registry import MODELS
+
+@MODELS.register_module() # 注册该类到 MODELS 下
+Class Loss_A(nn.Module):
+ def __init__(self, param1, param2):
+ self.param1 = param1
+ self.param2 = param2
+ def forward(self, x):
+ return x
+```
+
+并在对应目录下的 `__init__.py` 中进行 `import`：
+
+```Python
+# __init__.py of mmpose/models/losses
+from .loss_a.py import Loss_A
+
+__all__ = ['Loss_A']
+```
+
+我们就可以通过如下方式来从配置文件定义并进行实例化：
+
+```Python
+# 在config_file.py中定义
+loss_cfg = dict(
+ type='Loss_A', # 通过type指定类名
+ param1=1.0, # 传递__init__所需的参数
+ param2=True
+)
+
+# 在需要的地方进行实例化
+loss = MODELS.build(loss_cfg) # 等价于 loss = Loss_A(param1=1.0, param2=True)
+```
+
+MMPose 预定义的 Registry 在 `$MMPOSE/mmpose/registry.py` 中，目前支持的有：
+
+- `DATASETS`：数据集
+
+- `TRANSFORMS`：数据变换
+
+- `MODELS`：模型模块（Backbone、Neck、Head、Loss等）
+
+- `VISUALIZERS`：可视化工具
+
+- `VISBACKENDS`：可视化后端
+
+- `METRICS`：评测指标
+
+- `KEYPOINT_CODECS`：编解码器
+
+- `HOOKS`：钩子类
+
+```{note}
+需要注意的是，所有新增的模块都需要使用注册器（Registry）进行注册，并在对应目录的 `__init__.py` 中进行 `import`，以便能够使用配置文件构建其实例。
+```
+
+## 配置系统
+
+具体而言，一个配置文件主要包含如下五个部分：
+
+- 通用配置：与训练或测试无关的通用配置，如时间统计，模型存储与加载，可视化等相关 Hook，以及一些分布式相关的环境配置
+
+- 数据配置：数据增强策略，Dataset和Dataloader相关配置
+
+- 训练配置：断点恢复、模型权重加载、优化器、学习率调整、训练轮数和测试间隔等
+
+- 模型配置：模型模块、参数、损失函数等
+
+- 评测配置：模型性能评测指标
+
+你可以在 `$MMPOSE/configs` 下找到我们提供的配置文件，配置文件之间通过继承来避免冗余。为了保持配置文件简洁易读，我们将一些必要但不常改动的配置存放到了 `$MMPOSE/configs/_base_` 目录下，如果希望查阅完整的配置信息，你可以运行如下指令：
+
+```Bash
+python tools/analysis/print_config.py /PATH/TO/CONFIG
+```
+
+### 通用配置
+
+通用配置指与训练或测试无关的必要配置，主要包括：
+
+- **默认Hook**：迭代时间统计，训练日志，参数更新，checkpoint 等
+
+- **环境配置**：分布式后端，cudnn，多进程配置等
+
+- **可视化器**：可视化后端和策略设置
+
+- **日志配置**：日志等级，格式，打印和记录间隔等
+
+下面是通用配置的样例说明：
+
+```Python
+# 通用配置
+default_scope = 'mmpose'
+default_hooks = dict(
+ timer=dict(type='IterTimerHook'), # 迭代时间统计，包括数据耗时和模型耗时
+ logger=dict(type='LoggerHook', interval=50), # 日志打印间隔
+ param_scheduler=dict(type='ParamSchedulerHook'), # 用于调度学习率更新
+ checkpoint=dict(
+ type='CheckpointHook', interval=1, save_best='coco/AP', # ckpt保存间隔，最优ckpt参考指标
+ rule='greater'), # 最优ckpt指标评价规则
+ sampler_seed=dict(type='DistSamplerSeedHook')) # 分布式随机种子设置
+env_cfg = dict(
+ cudnn_benchmark=False, # cudnn benchmark开关
+ mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0), # opencv多线程配置
+ dist_cfg=dict(backend='nccl')) # 分布式训练后端设置
+vis_backends = [dict(type='LocalVisBackend')] # 可视化器后端设置
+visualizer = dict( # 可视化器设置
+ type='PoseLocalVisualizer',
+ vis_backends=[dict(type='LocalVisBackend')],
+ name='visualizer')
+log_processor = dict( # 训练日志格式、间隔
+ type='LogProcessor', window_size=50, by_epoch=True, num_digits=6)
+log_level = 'INFO' # 日志记录等级
+```
+
+通用配置一般单独存放到`$MMPOSE/configs/_base_`目录下，通过如下方式进行继承：
+
+```Python
+_base_ = ['../../../_base_/default_runtime.py'] # 以运行时的config文件位置为相对路径起点
+```
+
+```{note}
+CheckpointHook:
+
+- save_best: `'coco/AP'` 用于 `CocoMetric`, `'PCK'` 用于 `PCKAccuracy`
+- max_keep_ckpts: 最大保留ckpt数量，默认为-1，代表不限制
+
+样例:
+
+`default_hooks = dict(checkpoint=dict(save_best='PCK', rule='greater', max_keep_ckpts=1))`
+```
+
+### 数据配置
+
+数据配置指数据处理相关的配置，主要包括：
+
+- **数据后端**：数据供给后端设置，默认为本地硬盘，我们也支持从 LMDB，S3 Bucket 等加载
+
+- **数据集**：图像与标注文件路径
+
+- **加载**：加载策略，批量大小等
+
+- **流水线**：数据增强策略
+
+- **编码器**：根据标注生成特定格式的监督信息
+
+下面是数据配置的样例说明：
+
+```Python
+backend_args = dict(backend='local') # 数据加载后端设置，默认从本地硬盘加载
+dataset_type = 'CocoDataset' # 数据集类名
+data_mode = 'topdown' # 算法结构类型，用于指定标注信息加载策略
+data_root = 'data/coco/' # 数据存放路径
+ # 定义数据编解码器，用于生成target和对pred进行解码，同时包含了输入图片和输出heatmap尺寸等信息
+codec = dict(
+ type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)
+train_pipeline = [ # 训练时数据增强
+ dict(type='LoadImage', backend_args=backend_args, # 加载图片
+ dict(type='GetBBoxCenterScale'), # 根据bbox获取center和scale
+ dict(type='RandomBBoxTransform'), # 生成随机位移、缩放、旋转变换矩阵
+ dict(type='RandomFlip', direction='horizontal'), # 生成随机翻转变换矩阵
+ dict(type='RandomHalfBody'), # 随机半身增强
+ dict(type='TopdownAffine', input_size=codec['input_size']), # 根据变换矩阵更新目标数据
+ dict(
+ type='GenerateTarget', # 根据目标数据生成监督信息
+ # 监督信息类型
+ encoder=codec, # 传入编解码器，用于数据编码，生成特定格式的监督信息
+ dict(type='PackPoseInputs') # 对target进行打包用于训练
+]
+test_pipeline = [ # 测试时数据增强
+ dict(type='LoadImage', backend_args=backend_args), # 加载图片
+ dict(type='GetBBoxCenterScale'), # 根据bbox获取center和scale
+ dict(type='TopdownAffine', input_size=codec['input_size']), # 根据变换矩阵更新目标数据
+ dict(type='PackPoseInputs') # 对target进行打包用于训练
+]
+train_dataloader = dict( # 训练数据加载
+ batch_size=64, # 批次大小
+ num_workers=2, # 数据加载进程数
+ persistent_workers=True, # 在不活跃时维持进程不终止，避免反复启动进程的开销
+ sampler=dict(type='DefaultSampler', shuffle=True), # 采样策略，打乱数据
+ dataset=dict(
+ type=dataset_type , # 数据集类名
+ data_root=data_root, # 数据集路径
+ data_mode=data_mode, # 算法类型
+ ann_file='annotations/person_keypoints_train2017.json', # 标注文件路径
+ data_prefix=dict(img='train2017/'), # 图像路径
+ pipeline=train_pipeline # 数据流水线
+ ))
+val_dataloader = dict(
+ batch_size=32,
+ num_workers=2,
+ persistent_workers=True, # 在不活跃时维持进程不终止，避免反复启动进程的开销
+ drop_last=False,
+ sampler=dict(type='DefaultSampler', shuffle=False), # 采样策略，不进行打乱
+ dataset=dict(
+ type=dataset_type , # 数据集类名
+ data_root=data_root, # 数据集路径
+ data_mode=data_mode, # 算法类型
+ ann_file='annotations/person_keypoints_val2017.json', # 标注文件路径
+ bbox_file=
+ 'data/coco/person_detection_results/COCO_val2017_detections_AP_H_56_person.json', # 检测框标注文件，topdown方法专用
+ data_prefix=dict(img='val2017/'), # 图像路径
+ test_mode=True, # 测试模式开关
+ pipeline=test_pipeline # 数据流水线
+ ))
+test_dataloader = val_dataloader # 默认情况下不区分验证集和测试集，用户根据需要来自行定义
+```
+
+```{note}
+
+常用功能可以参考以下教程:
+- [恢复训练](../common_usages/resume_training.md)
+- [自动混合精度训练](../common_usages/amp_training.md)
+- [设置随机种子](../common_usages/set_random_seed.md)
+
+```
+
+### 训练配置
+
+训练配置指训练策略相关的配置，主要包括：
+
+- 从断点恢复训练
+
+- 模型权重加载
+
+- 训练轮数和测试间隔
+
+- 学习率调整策略，如 warmup，scheduler
+
+- 优化器和学习率
+
+- 高级训练策略设置，如自动学习率缩放
+
+下面是训练配置的样例说明：
+
+```Python
+resume = False # 断点恢复
+load_from = None # 模型权重加载
+train_cfg = dict(by_epoch=True, max_epochs=210, val_interval=10) # 训练轮数，测试间隔
+param_scheduler = [
+ dict( # warmup策略
+ type='LinearLR', begin=0, end=500, start_factor=0.001, by_epoch=False),
+ dict( # scheduler
+ type='MultiStepLR',
+ begin=0,
+ end=210,
+ milestones=[170, 200],
+ gamma=0.1,
+ by_epoch=True)
+]
+optim_wrapper = dict(optimizer=dict(type='Adam', lr=0.0005)) # 优化器和学习率
+auto_scale_lr = dict(base_batch_size=512) # 根据batch_size自动缩放学习率
+```
+
+### 模型配置
+
+模型配置指模型训练和推理相关的配置，主要包括：
+
+- 模型结构
+
+- 损失函数
+
+- 数据解码策略
+
+- 测试时增强策略
+
+下面是模型配置的样例说明，定义了一个基于 HRNetw32 的 Top-down Heatmap-based 模型：
+
+```Python
+# 定义数据编解码器，如果在数据配置部分已经定义过则无需重复定义
+codec = dict(
+ type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)
+# 模型配置
+model = dict(
+ type='TopdownPoseEstimator', # 模型结构决定了算法流程
+ data_preprocessor=dict( # 数据归一化和通道顺序调整，作为模型的一部分
+ type='PoseDataPreprocessor',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ bgr_to_rgb=True),
+ backbone=dict( # 骨干网络定义
+ type='HRNet',
+ in_channels=3,
+ extra=dict(
+ stage1=dict(
+ num_modules=1,
+ num_branches=1,
+ block='BOTTLENECK',
+ num_blocks=(4, ),
+ num_channels=(64, )),
+ stage2=dict(
+ num_modules=1,
+ num_branches=2,
+ block='BASIC',
+ num_blocks=(4, 4),
+ num_channels=(32, 64)),
+ stage3=dict(
+ num_modules=4,
+ num_branches=3,
+ block='BASIC',
+ num_blocks=(4, 4, 4),
+ num_channels=(32, 64, 128)),
+ stage4=dict(
+ num_modules=3,
+ num_branches=4,
+ block='BASIC',
+ num_blocks=(4, 4, 4, 4),
+ num_channels=(32, 64, 128, 256))),
+ init_cfg=dict(
+ type='Pretrained', # 预训练参数，只加载backbone权重用于迁移学习
+ checkpoint='https://download.openmmlab.com/mmpose'
+ '/pretrain_models/hrnet_w32-36af842e.pth'),
+ ),
+ head=dict( # 模型头部
+ type='HeatmapHead',
+ in_channels=32,
+ out_channels=17,
+ deconv_out_channels=None,
+ loss=dict(type='KeypointMSELoss', use_target_weight=True), # 损失函数
+ decoder=codec), # 解码器，将heatmap解码成坐标值
+ test_cfg=dict(
+ flip_test=True, # 开启测试时水平翻转集成
+ flip_mode='heatmap', # 对heatmap进行翻转
+ shift_heatmap=True, # 对翻转后的结果进行平移提高精度
+ ))
+```
+
+### 评测配置
+
+评测配置指公开数据集中关键点检测任务常用的评测指标，主要包括：
+
+- AR, AP and mAP
+
+- PCK, PCKh, tPCK
+
+- AUC
+
+- EPE
+
+- NME
+
+下面是评测配置的样例说明，定义了一个COCO指标评测器：
+
+```Python
+val_evaluator = dict(
+ type='CocoMetric', # coco 评测指标
+ ann_file=data_root + 'annotations/person_keypoints_val2017.json') # 加载评测标注数据
+test_evaluator = val_evaluator # 默认情况下不区分验证集和测试集，用户根据需要来自行定义
+```
+
+## 配置文件命名规则
+
+MMPose 配置文件命名风格如下：
+
+```Python
+{{算法信息}}_{{模块信息}}_{{训练信息}}_{{数据信息}}.py
+```
+
+文件名总体分为四部分：算法信息，模块信息，训练信息和数据信息。不同部分的单词之间用下划线 `'_'` 连接，同一部分有多个单词用短横线 `'-'` 连接。
+
+- **算法信息**：算法名称，如 `topdown-heatmap`，`topdown-rle` 等
+
+- **模块信息**：按照数据流的顺序列举一些中间的模块，其内容依赖于算法任务，如 `res101`，`hrnet-w48`等
+
+- **训练信息**：训练策略的一些设置，包括 `batch size`，`schedule` 等，如 `8xb64-210e`
+
+- **数据信息**：数据集名称、模态、输入尺寸等，如 `ap10k-256x256`，`zebra-160x160` 等
+
+有时为了避免文件名过长，会省略模型信息中一些强相关的模块，只保留关键信息，如RLE-based算法中的`GAP`，Heatmap-based算法中的 `deconv` 等。
+
+如果你希望向MMPose添加新的方法，你的配置文件同样需要遵守该命名规则。
+
+## 常见用法
+
+### 配置文件的继承
+
+该用法常用于隐藏一些必要但不需要修改的配置，以提高配置文件的可读性。假如有如下两个配置文件：
+
+`optimizer_cfg.py`:
+
+```Python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+`resnet50.py`:
+
+```Python
+_base_ = ['optimizer_cfg.py']
+model = dict(type='ResNet', depth=50)
+```
+
+虽然我们在 `resnet50.py` 中没有定义 optimizer 字段，但由于我们写了 `_base_ = ['optimizer_cfg.py']`，会使这个配置文件获得 `optimizer_cfg.py` 中的所有字段：
+
+```Python
+cfg = Config.fromfile('resnet50.py')
+cfg.optimizer # ConfigDict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+### 继承字段的修改
+
+对于继承过来的已经定义好的字典，可以直接指定对应字段进行修改，而不需要重新定义完整的字典：
+
+`resnet50_lr0.01.py`:
+
+```Python
+_base_ = ['optimizer_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(lr=0.01) # 直接修改对应字段
+```
+
+这个配置文件只修改了对应字段`lr`的信息：
+
+```Python
+cfg = Config.fromfile('resnet50_lr0.01.py')
+cfg.optimizer # ConfigDict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+```
+
+### 删除字典中的字段
+
+如果不仅是需要修改某些字段，还需要删除已定义的一些字段，需要在重新定义这个字典时指定`_delete_=True`，表示将没有在新定义中出现的字段全部删除：
+
+`resnet50.py`:
+
+```Python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(_delete_=True, type='SGD', lr=0.01) # 重新定义字典
+```
+
+此时字典中除了 `type` 和 `lr` 以外的内容（`momentum`和`weight_decay`）将被全部删除：
+
+```Python
+cfg = Config.fromfile('resnet50_lr0.01.py')
+cfg.optimizer # ConfigDict(type='SGD', lr=0.01)
+```
+
+```{note}
+如果你希望更深入地了解配置系统的高级用法，可以查看 [MMEngine 教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/config.html)。
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/contribution_guide.md b/internlm_langchain/knowledge_base/MMPose/content/contribution_guide.md
new file mode 100644
index 00000000..96be7d17
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/contribution_guide.md
@@ -0,0 +1,207 @@
+# 如何给 MMPose 贡献代码
+
+欢迎加入 MMPose 社区，我们致力于打造最前沿的计算机视觉基础库，我们欢迎任何形式的贡献，包括但不限于：
+
+- **修复错误**
+ 1. 如果提交的代码改动较大，我们鼓励你先开一个 issue 并正确描述现象、原因和复现方式，讨论后确认修复方案。
+ 2. 修复错误并补充相应的单元测试，提交 PR 。
+- **新增功能或组件**
+ 1. 如果新功能或模块涉及较大的代码改动，我们建议先提交 issue，与我们确认功能的必要性。
+ 2. 实现新增功能并添加单元测试，提交 PR 。
+- **文档补充或翻译**
+ - 如果发现文档有错误或不完善的地方，欢迎直接提交 PR 。
+
+```{note}
+- 如果你希望向 MMPose 1.0 贡献代码，请从 dev-1.x 上创建新分支，并提交 PR 到 dev-1.x 分支上。
+- 如果你是论文作者，并希望将你的方法加入到 MMPose 中，欢迎联系我们，我们将非常感谢你的贡献。
+- 如果你希望尽快将你的项目分享到 MMPose 开源社区，欢迎将 PR 提到 Projects 目录下，该目录下的项目将简化 Review 流程并尽快合入。
+- 如果你希望加入 MMPose 的维护者，欢迎联系我们，我们将邀请你加入 MMPose 的维护者群。
+```
+
+## 准备工作
+
+PR 操作所使用的命令都是用 Git 去实现的，该章节将介绍如何进行 Git 配置与 GitHub 绑定。
+
+### Git 配置
+
+首先，你需要在本地安装 Git，然后配置你的 Git 用户名和邮箱：
+
+```Shell
+# 在命令提示符（cmd）或终端（terminal）中输入以下命令，查看 Git 版本
+git --version
+```
+
+然后，你需要检查自己的 Git Config 是否正确配置，如果 `user.name` 和 `user.email` 为空，你需要配置你的 Git 用户名和邮箱：
+
+```Shell
+# 在命令提示符（cmd）或终端（terminal）中输入以下命令，查看 Git 配置
+git config --global --list
+# 设置 Git 用户名和邮箱
+git config --global user.name "这里填入你的用户名"
+git config --global user.email "这里填入你的邮箱"
+```
+
+## PR 流程
+
+如果你对 PR 流程不熟悉，接下来将会从零开始，一步一步地教你如何提交 PR。如果你想深入了解 PR 开发模式，可以参考 [GitHub 官方文档](https://docs.github.com/cn/github/collaborating-with-issues-and-pull-requests/about-pull-requests)。
+
+### 1. Fork 项目
+
+当你第一次提交 PR 时，需要先 Fork 项目到自己的 GitHub 账号下。点击项目右上角的 Fork 按钮，将项目 Fork 到自己的 GitHub 账号下。
+
+
+
+接着，你需要将你的 Fork 仓库 Clone 到本地，然后添加官方仓库作为远程仓库：
+
+```Shell
+
+# Clone 你的 Fork 仓库到本地
+git clone https://github.com/username/mmpose.git
+
+# 添加官方仓库作为远程仓库
+cd mmpose
+git remote add upstream https://github.com/open-mmlab/mmpose.git
+```
+
+在终端中输入以下命令，查看远程仓库是否成功添加：
+
+```Shell
+git remote -v
+```
+
+如果出现以下信息，说明你已经成功添加了远程仓库：
+
+```Shell
+origin https://github.com/{username}/mmpose.git (fetch)
+origin https://github.com/{username}/mmpose.git (push)
+upstream https://github.com/open-mmlab/mmpose.git (fetch)
+upstream https://github.com/open-mmlab/mmpose.git (push)
+```
+
+```{note}
+这里对 origin 和 upstream 进行一个简单的介绍，当我们使用 git clone 来克隆代码时，会默认创建一个 origin 的 remote，它指向我们克隆的代码库地址，而 upstream 则是我们自己添加的，用来指向原始代码库地址。当然如果你不喜欢他叫 upstream，也可以自己修改，比如叫 open-mmlab。我们通常向 origin 提交代码（即 fork 下来的远程仓库），然后向 upstream 提交一个 pull request。如果提交的代码和最新的代码发生冲突，再从 upstream 拉取最新的代码，和本地分支解决冲突，再提交到 origin。
+```
+
+### 2. 配置 pre-commit
+
+在本地开发环境中，我们使用 pre-commit 来检查代码风格，以确保代码风格的统一。在提交代码前，你需要先安装 pre-commit：
+
+```Shell
+pip install -U pre-commit
+
+# 在 mmpose 根目录下安装 pre-commit
+pre-commit install
+```
+
+检查 pre-commit 是否配置成功，并安装 `.pre-commit-config.yaml` 中的钩子：
+
+```Shell
+pre-commit run --all-files
+```
+
+
+
+```{note}
+如果你是中国大陆用户，由于网络原因，可能会出现 pre-commit 安装失败的情况。
+
+这时你可以使用清华源来安装 pre-commit：
+pip install -U pre-commit -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+或者使用国内镜像来安装 pre-commit：
+pip install -U pre-commit -i https://pypi.mirrors.ustc.edu.cn/simple
+```
+
+如果安装过程被中断，可以重复执行上述命令，直到安装成功。
+
+如果你提交的代码中有不符合规范的地方，pre-commit 会发出警告，并自动修复部分错误。
+
+
+
+### 3. 创建开发分支
+
+安装完 pre-commit 之后，我们需要基于 dev 分支创建一个新的开发分支，建议以 `username/pr_name` 的形式命名，例如：
+
+```Shell
+git checkout -b username/refactor_contributing_doc
+```
+
+在后续的开发中，如果本地仓库的 dev 分支落后于官方仓库的 dev 分支，需要先拉取 upstream 的 dev 分支，然后 rebase 到本地的开发分支上：
+
+```Shell
+git checkout username/refactor_contributing_doc
+git fetch upstream
+git rebase upstream/dev-1.x
+```
+
+在 rebase 时，如果出现冲突，需要手动解决冲突，然后执行 `git add` 命令，再执行 `git rebase --continue` 命令，直到 rebase 完成。
+
+### 4. 提交代码并在本地通过单元测试
+
+在本地开发完成后，我们需要在本地通过单元测试，然后提交代码。
+
+```shell
+# 运行单元测试
+pytest tests/
+
+# 提交代码
+git add .
+git commit -m "commit message"
+```
+
+### 5. 推送代码到远程仓库
+
+在本地开发完成后，我们需要将代码推送到远程仓库。
+
+```Shell
+git push origin username/refactor_contributing_doc
+```
+
+### 6. 提交 Pull Request (PR)
+
+#### (1) 在 GitHub 上创建 PR
+
+
+
+#### (2) 在 PR 中根据指引修改描述，添加必要的信息
+
+
+
+```{note}
+- 在 PR branch 左侧选择 `dev` 分支，否则 PR 会被拒绝。
+- 如果你是第一次向 OpenMMLab 提交 PR，需要签署 CLA。
+```
+
+
+
+## 代码风格
+
+### Python
+
+我们采用[PEP8](https://www.python.org/dev/peps/pep-0008/)作为代码风格。
+
+使用下面的工具来对代码进行整理和格式化：
+
+- [flake8](http://flake8.pycqa.org/en/latest/)：代码提示
+- [isort](https://github.com/timothycrosley/isort)：import 排序
+- [yapf](https://github.com/google/yapf)：格式化工具
+- [codespell](https://github.com/codespell-project/codespell)： 单词拼写检查
+- [mdformat](https://github.com/executablebooks/mdformat): markdown 文件格式化工具
+- [docformatter](https://github.com/myint/docformatter): docstring 格式化工具
+
+`yapf`和`isort`的样式配置可以在[setup.cfg](/setup.cfg)中找到。
+
+我们使用[pre-commit hook](https://pre-commit.com/)来：
+
+- 检查和格式化 `flake8`、`yapf`、`isort`、`trailing whitespaces`
+- 修复 `end-of-files`
+- 在每次提交时自动排序 `requirments.txt`
+
+`pre-commit`的配置存储在[.pre-commit-config](/.pre-commit-config.yaml)中。
+
+```{note}
+在你创建PR之前，请确保你的代码格式符合规范，且经过了 yapf 格式化。
+```
+
+### C++与CUDA
+
+遵循[Google C++风格指南](https://google.github.io/styleguide/cppguide.html)
diff --git a/internlm_langchain/knowledge_base/MMPose/content/customize_datasets.md b/internlm_langchain/knowledge_base/MMPose/content/customize_datasets.md
new file mode 100644
index 00000000..61b58dc9
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/customize_datasets.md
@@ -0,0 +1,264 @@
+# 自定义数据集
+
+MMPose 目前已支持了多个任务和相应的数据集。您可以在 [数据集](https://mmpose.readthedocs.io/zh_CN/latest/dataset_zoo.html) 找到它们。请按照相应的指南准备数据。
+
+
+
+- [自定义数据集-将数据组织为 COCO 格式](#自定义数据集-将数据组织为-coco-格式)
+- [创建自定义数据集的元信息文件](#创建自定义数据集的元信息文件)
+- [创建自定义数据集类](#创建自定义数据集类)
+- [创建自定义配置文件](#创建自定义配置文件)
+- [数据集封装](#数据集封装)
+
+
+
+## 将数据组织为 COCO 格式
+
+最简单的使用自定义数据集的方法是将您的注释格式转换为 COCO 数据集格式。
+
+COCO 格式的注释 JSON 文件具有以下必要键：
+
+```python
+'images': [
+ {
+ 'file_name': '000000001268.jpg',
+ 'height': 427,
+ 'width': 640,
+ 'id': 1268
+ },
+ ...
+],
+'annotations': [
+ {
+ 'segmentation': [[426.36,
+ ...
+ 424.34,
+ 223.3]],
+ 'keypoints': [0,0,0,
+ 0,0,0,
+ 0,0,0,
+ 427,220,2,
+ 443,222,2,
+ 414,228,2,
+ 449,232,2,
+ 408,248,1,
+ 454,261,2,
+ 0,0,0,
+ 0,0,0,
+ 411,287,2,
+ 431,287,2,
+ 0,0,0,
+ 458,265,2,
+ 0,0,0,
+ 466,300,1],
+ 'num_keypoints': 10,
+ 'area': 3894.5826,
+ 'iscrowd': 0,
+ 'image_id': 1268,
+ 'bbox': [402.34, 205.02, 65.26, 88.45],
+ 'category_id': 1,
+ 'id': 215218
+ },
+ ...
+],
+'categories': [
+ {'id': 1, 'name': 'person'},
+ ]
+```
+
+JSON 标注文件中有三个关键词是必需的：
+
+- `images`：包含所有图像信息的列表，每个图像都有一个 `file_name`、`height`、`width` 和 `id` 键。
+- `annotations`：包含所有实例标注信息的列表，每个实例都有一个 `segmentation`、`keypoints`、`num_keypoints`、`area`、`iscrowd`、`image_id`、`bbox`、`category_id` 和 `id` 键。
+- `categories`：包含所有类别信息的列表，每个类别都有一个 `id` 和 `name` 键。以人体姿态估计为例，`id` 为 1，`name` 为 `person`。
+
+如果您的数据集已经是 COCO 格式的，那么您可以直接使用 `CocoDataset` 类来读取该数据集。
+
+## 创建自定义数据集的元信息文件
+
+对于一个新的数据集而言，您需要创建一个新的数据集元信息文件。该文件包含了数据集的基本信息，如关键点个数、排列顺序、可视化颜色、骨架连接关系等。元信息文件通常存放在 `config/_base_/datasets/` 目录下，例如：
+
+```
+config/_base_/datasets/custom.py
+```
+
+元信息文件中需要包含以下信息：
+
+- `keypoint_info`：每个关键点的信息：
+ 1. `name`: 关键点名称，必须是唯一的，例如 `nose`、`left_eye` 等。
+ 2. `id`: 关键点 ID，必须是唯一的，从 0 开始。
+ 3. `color`: 关键点可视化时的颜色，以 (\[B, G, R\]) 格式组织起来，用于可视化。
+ 4. `type`: 关键点类型，可以是 `upper`、`lower` 或 \`\`，用于数据增强。
+ 5. `swap`: 关键点交换关系，用于水平翻转数据增强。
+- `skeleton_info`：骨架连接关系，用于可视化。
+- `joint_weights`：每个关键点的权重，用于损失函数计算。
+- `sigma`：标准差，用于计算 OKS 分数，详细信息请参考 [keypoints-eval](https://cocodataset.org/#keypoints-eval)。
+
+下面是一个简化版本的元信息文件（[完整版](/configs/_base_/datasets/coco.py)）：
+
+```python
+dataset_info = dict(
+ dataset_name='coco',
+ paper_info=dict(
+ author='Lin, Tsung-Yi and Maire, Michael and '
+ 'Belongie, Serge and Hays, James and '
+ 'Perona, Pietro and Ramanan, Deva and '
+ r'Doll{\'a}r, Piotr and Zitnick, C Lawrence',
+ title='Microsoft coco: Common objects in context',
+ container='European conference on computer vision',
+ year='2014',
+ homepage='http://cocodataset.org/',
+ ),
+ keypoint_info={
+ 0:
+ dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''),
+ 1:
+ dict(
+ name='left_eye',
+ id=1,
+ color=[51, 153, 255],
+ type='upper',
+ swap='right_eye'),
+ ...
+ 16:
+ dict(
+ name='right_ankle',
+ id=16,
+ color=[255, 128, 0],
+ type='lower',
+ swap='left_ankle')
+ },
+ skeleton_info={
+ 0:
+ dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]),
+ ...
+ 18:
+ dict(
+ link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255])
+ },
+ joint_weights=[
+ 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5,
+ 1.5
+ ],
+ sigmas=[
+ 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062,
+ 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089
+ ])
+```
+
+## 创建自定义数据集类
+
+如果标注信息不是用 COCO 格式存储的，那么您需要创建一个新的数据集类。数据集类需要继承自 `BaseDataset` 类，并且需要按照以下步骤实现：
+
+1. 在 `mmpose/datasets/datasets` 目录下找到该数据集符合的 package，如果没有符合的，则创建一个新的 package。
+
+2. 在该 package 下创建一个新的数据集类，在对应的注册器中进行注册：
+
+ ```python
+ from mmengine.dataset import BaseDataset
+ from mmpose.registry import DATASETS
+
+ @DATASETS.register_module(name='MyCustomDataset')
+ class MyCustomDataset(BaseDataset):
+ ```
+
+ 如果未注册，你会在运行时遇到 `KeyError: 'XXXXX is not in the dataset registry'`。
+ 关于 `mmengine.BaseDataset` 的更多信息，请参考 [这个文档](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html)。
+
+3. 确保你在 package 的 `__init__.py` 中导入了该数据集类。
+
+4. 确保你在 `mmpose/datasets/__init__.py` 中导入了该 package。
+
+## 创建自定义配置文件
+
+在配置文件中，你需要修改跟数据集有关的部分，例如：
+
+```python
+...
+# 自定义数据集类
+dataset_type = 'MyCustomDataset' # or 'CocoDataset'
+
+train_dataloader = dict(
+ batch_size=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root='root/of/your/train/data',
+ ann_file='path/to/your/train/json',
+ data_prefix=dict(img='path/to/your/train/img'),
+ metainfo=dict(from_file='configs/_base_/datasets/custom.py'),
+ ...),
+ )
+
+val_dataloader = dict(
+ batch_size=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root='root/of/your/val/data',
+ ann_file='path/to/your/val/json',
+ data_prefix=dict(img='path/to/your/val/img'),
+ metainfo=dict(from_file='configs/_base_/datasets/custom.py'),
+ ...),
+ )
+
+test_dataloader = dict(
+ batch_size=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root='root/of/your/test/data',
+ ann_file='path/to/your/test/json',
+ data_prefix=dict(img='path/to/your/test/img'),
+ metainfo=dict(from_file='configs/_base_/datasets/custom.py'),
+ ...),
+ )
+...
+```
+
+请确保所有的路径都是正确的。
+
+## 数据集封装
+
+目前 [MMEngine](https://github.com/open-mmlab/mmengine) 支持以下数据集封装：
+
+- [ConcatDataset](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/basedataset.html#concatdataset)
+- [RepeatDataset](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/basedataset.html#repeatdataset)
+
+### CombinedDataset
+
+MMPose 提供了一个 `CombinedDataset` 类，它可以将多个数据集封装成一个数据集。它的使用方法如下：
+
+```python
+dataset_1 = dict(
+ type='dataset_type_1',
+ data_root='root/of/your/dataset1',
+ data_prefix=dict(img_path='path/to/your/img'),
+ ann_file='annotations/train.json',
+ pipeline=[
+ # 使用转换器将标注信息统一为需要的格式
+ converter_transform_1
+ ])
+
+dataset_2 = dict(
+ type='dataset_type_2',
+ data_root='root/of/your/dataset2',
+ data_prefix=dict(img_path='path/to/your/img'),
+ ann_file='annotations/train.json',
+ pipeline=[
+ converter_transform_2
+ ])
+
+shared_pipeline = [
+ LoadImage(),
+ ParseImage(),
+]
+
+combined_dataset = dict(
+ type='CombinedDataset',
+ metainfo=dict(from_file='path/to/your/metainfo'),
+ datasets=[dataset_1, dataset_2],
+ pipeline=shared_pipeline,
+)
+```
+
+- **合并数据集的元信息** 决定了标注格式，可以是子数据集的元信息，也可以是自定义的元信息。如果要自定义元信息，可以参考 [创建自定义数据集的元信息文件](#创建自定义数据集的元信息文件)。
+- **KeypointConverter** 用于将不同的标注格式转换成统一的格式。比如将关键点个数不同、关键点排列顺序不同的数据集进行合并。
+- 更详细的说明请前往[混合数据集训练](../user_guides/mixed_datasets.md)。
diff --git a/internlm_langchain/knowledge_base/MMPose/content/customize_logging.md b/internlm_langchain/knowledge_base/MMPose/content/customize_logging.md
new file mode 100644
index 00000000..093a530d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/customize_logging.md
@@ -0,0 +1,3 @@
+# Customize Logging
+
+Coming soon.
diff --git a/internlm_langchain/knowledge_base/MMPose/content/customize_optimizer.md b/internlm_langchain/knowledge_base/MMPose/content/customize_optimizer.md
new file mode 100644
index 00000000..fd6a2829
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/customize_optimizer.md
@@ -0,0 +1,3 @@
+# Customize Optimizer and Scheduler
+
+Coming soon.
diff --git a/internlm_langchain/knowledge_base/MMPose/content/customize_transforms.md b/internlm_langchain/knowledge_base/MMPose/content/customize_transforms.md
new file mode 100644
index 00000000..15441399
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/customize_transforms.md
@@ -0,0 +1,3 @@
+# Customize Data Transformation and Augmentation
+
+Coming soon.
diff --git a/internlm_langchain/knowledge_base/MMPose/content/dataflow.md b/internlm_langchain/knowledge_base/MMPose/content/dataflow.md
new file mode 100644
index 00000000..9f098b02
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/dataflow.md
@@ -0,0 +1,3 @@
+# Dataflow in MMPose
+
+Coming soon.
diff --git a/internlm_langchain/knowledge_base/MMPose/content/dataset_tools.md b/internlm_langchain/knowledge_base/MMPose/content/dataset_tools.md
new file mode 100644
index 00000000..a2e6d01d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/dataset_tools.md
@@ -0,0 +1,413 @@
+# 数据集格式转换脚本
+
+MMPose 提供了一些工具来帮助用户处理数据集。
+
+## Animal Pose 数据集
+
+
+ + - 拼接操作 + + ```python + neck=dict(type='FeatureMapProcessor', concat=True) + ``` + +
+ + 拼接之前，其它特征图会被缩放到和序号为 0 的特征图相同的尺寸。 + + - 缩放操作 + + ```python + neck=dict(type='FeatureMapProcessor', scale_factor=2.0) + ``` + +
+ +### 预测头（Head） + +通常来说，预测头是模型算法实现的核心，用于控制模型的输出，并进行损失函数计算。 + +MMPose 中 Head 相关的模块定义在 `$MMPOSE/mmpose/models/heads` 目录下，开发者在自定义预测头时需要继承我们提供的基类 `BaseHead`，并重载以下三个方法对应模型推理的三种模式： + +- forward() + +- predict() + +- loss() + +具体而言，`predict()` 返回的应是输入图片尺度下的结果，因此需要调用 `self.decode()` 对网络输出进行解码，这一过程实现在 `BaseHead` 中已经实现，它会调用编解码器提供的 `decode()` 方法来完成解码。 + +另一方面，我们会在 `predict()` 中进行测试时增强。在进行预测时，一个常见的测试时增强技巧是进行翻转集成。即，将一张图片先进行一次推理，再将图片水平翻转进行一次推理，推理的结果再次水平翻转回去，对两次推理的结果进行平均。这个技巧能有效提升模型的预测稳定性。 + +下面是在 `RegressionHead` 中定义 `predict()` 的例子： + +```Python +def predict(self, + feats: Tuple[Tensor], + batch_data_samples: OptSampleList, + test_cfg: ConfigType = {}) -> Predictions: + """Predict results from outputs.""" + + if test_cfg.get('flip_test', False): + # TTA: flip test -> feats = [orig, flipped] + assert isinstance(feats, list) and len(feats) == 2 + flip_indices = batch_data_samples[0].metainfo['flip_indices'] + input_size = batch_data_samples[0].metainfo['input_size'] + _feats, _feats_flip = feats + _batch_coords = self.forward(_feats) + _batch_coords_flip = flip_coordinates( + self.forward(_feats_flip), + flip_indices=flip_indices, + shift_coords=test_cfg.get('shift_coords', True), + input_size=input_size) + batch_coords = (_batch_coords + _batch_coords_flip) * 0.5 + else: + batch_coords = self.forward(feats) # (B, K, D) + + batch_coords.unsqueeze_(dim=1) # (B, N, K, D) + preds = self.decode(batch_coords) +``` + +`loss()`除了进行损失函数的计算，还会进行 accuracy 等训练时指标的计算，并通过一个字典 `losses` 来传递: + +```Python + # calculate accuracy +_, avg_acc, _ = keypoint_pck_accuracy( + pred=to_numpy(pred_coords), + gt=to_numpy(keypoint_labels), + mask=to_numpy(keypoint_weights) > 0, + thr=0.05, + norm_factor=np.ones((pred_coords.size(0), 2), dtype=np.float32)) + +acc_pose = torch.tensor(avg_acc, device=keypoint_labels.device) +losses.update(acc_pose=acc_pose) +``` + +每个 batch 的数据都打包成了 `batch_data_samples`。以 Regression-based 方法为例，训练所需的归一化的坐标值和关键点权重可以用如下方式获取： + +```Python +keypoint_labels = torch.cat( + [d.gt_instance_labels.keypoint_labels for d in batch_data_samples]) +keypoint_weights = torch.cat([ + d.gt_instance_labels.keypoint_weights for d in batch_data_samples +]) +``` + +以下为 `RegressionHead` 中完整的 `loss()` 实现： + +```Python +def loss(self, + inputs: Tuple[Tensor], + batch_data_samples: OptSampleList, + train_cfg: ConfigType = {}) -> dict: + """Calculate losses from a batch of inputs and data samples.""" + + pred_outputs = self.forward(inputs) + + keypoint_labels = torch.cat( + [d.gt_instance_labels.keypoint_labels for d in batch_data_samples]) + keypoint_weights = torch.cat([ + d.gt_instance_labels.keypoint_weights for d in batch_data_samples + ]) + + # calculate losses + losses = dict() + loss = self.loss_module(pred_outputs, keypoint_labels, + keypoint_weights.unsqueeze(-1)) + + if isinstance(loss, dict): + losses.update(loss) + else: + losses.update(loss_kpt=loss) + + # calculate accuracy + _, avg_acc, _ = keypoint_pck_accuracy( + pred=to_numpy(pred_outputs), + gt=to_numpy(keypoint_labels), + mask=to_numpy(keypoint_weights) > 0, + thr=0.05, + norm_factor=np.ones((pred_outputs.size(0), 2), dtype=np.float32)) + acc_pose = torch.tensor(avg_acc, device=keypoint_labels.device) + losses.update(acc_pose=acc_pose) + + return losses +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/how_to_deploy.md b/internlm_langchain/knowledge_base/MMPose/content/how_to_deploy.md new file mode 100644 index 00000000..b4fead87 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/how_to_deploy.md @@ -0,0 +1,3 @@ +# How to Deploy MMPose Models + +Coming soon. diff --git a/internlm_langchain/knowledge_base/MMPose/content/implement_new_models.md b/internlm_langchain/knowledge_base/MMPose/content/implement_new_models.md new file mode 100644 index 00000000..4a10b0c3 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/implement_new_models.md @@ -0,0 +1,3 @@ +# Implement New Models + +Coming soon. diff --git a/internlm_langchain/knowledge_base/MMPose/content/inference.md b/internlm_langchain/knowledge_base/MMPose/content/inference.md new file mode 100644 index 00000000..0844bc61 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/inference.md @@ -0,0 +1,267 @@ +# 使用现有模型进行推理 + +MMPose为姿态估计提供了大量可以从[模型库](https://mmpose.readthedocs.io/en/latest/model_zoo.html)中找到的预测训练模型。本指南将演示**如何执行推理**，或使用训练过的模型对提供的图像或视频运行姿态估计。 + +有关在标准数据集上测试现有模型的说明，请参阅本指南。 + +在MMPose，模型由配置文件定义，而其已计算好的参数存储在权重文件（checkpoint file）中。您可以在[模型库](https://mmpose.readthedocs.io/en/latest/model_zoo.html)中找到模型配置文件和相应的权重文件的URL。我们建议从使用HRNet模型的[配置文件](https://github.com/open-mmlab/mmpose/blob/main/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py)和[权重文件](https://download.openmmlab.com/mmpose/v1/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192-81c58e40_20220909.pth)开始。 + +## 推理器：统一的推理接口 + +MMPose提供了一个被称为`MMPoseInferencer`的、全面的推理API。这个API使得用户得以使用所有MMPose支持的模型来对图像和视频进行模型推理。此外，该API可以完成推理结果自动化，并方便用户保存预测结果。 + +### 基本用法 + +`MMPoseInferencer`可以在任何Python程序中被用来执行姿态估计任务。以下是在一个在Python Shell中使用预训练的人体姿态模型对给定图像进行推理的示例。 + +```python +from mmpose.apis import MMPoseInferencer + +img_path = 'tests/data/coco/000000000785.jpg' # 将img_path替换给你自己的路径 + +# 使用模型别名创建推断器 +inferencer = MMPoseInferencer('human') + +# MMPoseInferencer采用了惰性推断方法，在给定输入时创建一个预测生成器 +result_generator = inferencer(img_path, show=True) +result = next(result_generator) +``` + +如果一切正常，你将在一个新窗口中看到下图： + + + +`result` 变量是一个包含两个键值 `'visualization'` 和 `'predictions'` 的字典。 + +- `'visualization'` 键对应的值是一个列表，该列表： + - 包含可视化结果，例如输入图像、估计姿态的标记，以及可选的预测热图。 + - 如果没有指定 `return_vis` 参数，该列表将保持为空。 +- `'predictions'` 键对应的值是： + - 一个包含每个检测实例的预估关键点的列表。 + +`result` 字典的结构如下所示： + +```python +result = { + 'visualization': [ + # 元素数量：batch_size（默认为1） + vis_image_1, + ... + ], + 'predictions': [ + # 每张图像的姿态估计结果 + # 元素数量：batch_size（默认为1） + [ + # 每个检测到的实例的姿态信息 + # 元素数量：检测到的实例数 + {'keypoints': ..., # 实例 1 + 'keypoint_scores': ..., + ... + }, + {'keypoints': ..., # 实例 2 + 'keypoint_scores': ..., + ... + }, + ] + ... + ] +} +``` + +还可以使用用于用于推断的**命令行界面工具**（CLI, command-line interface）: `demo/inferencer_demo.py`。这个工具允许用户使用以下命令使用相同的模型和输入执行推理： + +```python +python demo/inferencer_demo.py 'tests/data/coco/000000000785.jpg' \ + --pose2d 'human' --show --pred-out-dir 'predictions' +``` + +预测结果将被保存在路径`predictions/000000000785.json`。作为一个API，`inferencer_demo.py`的输入参数与`MMPoseInferencer`的相同。前者能够处理一系列输入类型，包括以下内容： + +- 图像路径 + +- 视频路径 + +- 文件夹路径（这会导致该文件夹中的所有图像都被推断出来） + +- 表示图像的 numpy array (在命令行界面工具中未支持) + +- 表示图像的 numpy array 列表 (在命令行界面工具中未支持) + +- 摄像头（在这种情况下，输入参数应该设置为`webcam`或`webcam:{CAMERA_ID}`） + +当输入对应于多个图像时，例如输入为**视频**或**文件夹**路径时，推理生成器必须被遍历，以便推理器对视频/文件夹中的所有帧/图像进行推理。以下是一个示例： + +```python +folder_path = 'tests/data/coco' + +result_generator = inferencer(folder_path, show=True) +results = [result for result in result_generator] +``` + +在这个示例中，`inferencer` 接受 `folder_path` 作为输入，并返回一个生成器对象（`result_generator`），用于生成推理结果。通过遍历 `result_generator` 并将每个结果存储在 `results` 列表中，您可以获得视频/文件夹中所有帧/图像的推理结果。 + +### 自定义姿态估计模型 + +`MMPoseInferencer`提供了几种可用于自定义所使用的模型的方法： + +```python +# 使用模型别名构建推断器 +inferencer = MMPoseInferencer('human') + +# 使用模型配置名构建推断器 +inferencer = MMPoseInferencer('td-hm_hrnet-w32_8xb64-210e_coco-256x192') + +# 使用模型配置文件和权重文件的路径或 URL 构建推断器 +inferencer = MMPoseInferencer( + pose2d='configs/body_2d_keypoint/topdown_heatmap/coco/' \ + 'td-hm_hrnet-w32_8xb64-210e_coco-256x192.py', + pose2d_weights='https://download.openmmlab.com/mmpose/top_down/' \ + 'hrnet/hrnet_w32_coco_256x192-c78dce93_20200708.pth' +) +``` + +模型别名的完整列表可以在模型别名部分中找到。 + +此外，自顶向下的姿态估计器还需要一个对象检测模型。`MMPoseInferencer`能够推断用MMPose支持的数据集训练的模型的实例类型，然后构建必要的对象检测模型。用户也可以通过以下方式手动指定检测模型: + +```python +# 通过别名指定检测模型 +# 可用的别名包括“human”、“hand”、“face”、“animal”、 +# 以及mmdet中定义的任何其他别名 +inferencer = MMPoseInferencer( + # 假设姿态估计器是在自定义数据集上训练的 + pose2d='custom_human_pose_estimator.py', + pose2d_weights='custom_human_pose_estimator.pth', + det_model='human' +) + +# 使用模型配置名称指定检测模型 +inferencer = MMPoseInferencer( + pose2d='human', + det_model='yolox_l_8x8_300e_coco', + det_cat_ids=[0], # 指定'human'类的类别id +) + +# 使用模型配置文件和权重文件的路径或URL构建推断器 +inferencer = MMPoseInferencer( + pose2d='human', + det_model=f'{PATH_TO_MMDET}/configs/yolox/yolox_l_8x8_300e_coco.py', + det_weights='https://download.openmmlab.com/mmdetection/v2.0/' \ + 'yolox/yolox_l_8x8_300e_coco/' \ + 'yolox_l_8x8_300e_coco_20211126_140236-d3bd2b23.pth', + det_cat_ids=[0], # 指定'human'类的类别id +) +``` + +### 转储结果 + +在执行姿态估计推理任务之后，您可能希望保存结果以供进一步分析或处理。本节将指导您将预测的关键点和可视化结果保存到本地。 + +要将预测保存在JSON文件中，在运行`MMPoseInferencer`的实例`inferencer`时使用`pred_out_dir`参数: + +```python +result_generator = inferencer(img_path, pred_out_dir='predictions') +result = next(result_generator) +``` + +预测结果将以JSON格式保存在`predictions/`文件夹中，每个文件以相应的输入图像或视频的名称命名。 + +对于更高级的场景，还可以直接从`inferencer`返回的`result`字典中访问预测结果。其中，`predictions`包含输入图像或视频中每个单独实例的预测关键点列表。然后，您可以使用您喜欢的方法操作或存储这些结果。 + +请记住，如果你想将可视化图像和预测文件保存在一个文件夹中，你可以使用`out_dir`参数： + +```python +result_generator = inferencer(img_path, out_dir='output') +result = next(result_generator) +``` + +在这种情况下，可视化图像将保存在`output/visualization/`文件夹中，而预测将存储在`output/forecasts/`文件夹中。 + +### 可视化 + +推理器`inferencer`可以自动对输入的图像或视频进行预测。可视化结果可以显示在一个新的窗口中，并保存在本地。 + +要在新窗口中查看可视化结果，请使用以下代码： + +请注意： + +- 如果输入视频来自网络摄像头，默认情况下将在新窗口中显示可视化结果，以此让用户看到输入 + +- 如果平台上没有GUI，这个步骤可能会卡住 + +要将可视化结果保存在本地，可以像这样指定`vis_out_dir`参数: + +```python +result_generator = inferencer(img_path, vis_out_dir='vis_results') +result = next(result_generator) +``` + +输入图片或视频的可视化预测结果将保存在`vis_results/`文件夹中 + +在开头展示的滑雪图中，姿态的可视化估计结果由关键点（用实心圆描绘）和骨架（用线条表示）组成。这些视觉元素的默认大小可能不会产生令人满意的结果。用户可以使用`radius`和`thickness`参数来调整圆的大小和线的粗细，如下所示： + +```python +result_generator = inferencer(img_path, show=True, radius=4, thickness=2) +result = next(result_generator) +``` + +### 推理器参数 + +`MMPoseInferencer`提供了各种自定义姿态估计、可视化和保存预测结果的参数。下面是初始化推断器时可用的参数列表及对这些参数的描述： + +| Argument | Description | +| ---------------- | ------------------------------------------------------------ | +| `pose2d` | 指定 2D 姿态估计模型的模型别名、配置文件名称或配置文件路径。 | +| `pose2d_weights` | 指定 2D 姿态估计模型权重文件的URL或本地路径。 | +| `pose3d` | 指定 3D 姿态估计模型的模型别名、配置文件名称或配置文件路径。 | +| `pose3d_weights` | 指定 3D 姿态估计模型权重文件的URL或本地路径。 | +| `det_model` | 指定对象检测模型的模型别名、配置文件名或配置文件路径。 | +| `det_weights` | 指定对象检测模型权重文件的 URL 或本地路径。 | +| `det_cat_ids` | 指定与要检测的对象类对应的类别 id 列表。 | +| `device` | 执行推理的设备。如果为 `None`，推理器将选择最合适的一个。 | +| `scope` | 定义模型模块的名称空间 | + +推理器被设计用于可视化和保存预测。以下表格列出了在使用 `MMPoseInferencer` 进行推断时可用的参数列表，以及它们与 2D 和 3D 推理器的兼容性： + +| 参数 | 描述 | 2D | 3D | +| ------------------------ | -------------------------------------------------------------------------------------------------------------------------- | --- | --- | +| `show` | 控制是否在弹出窗口中显示图像或视频。 | ✔️ | ✔️ | +| `radius` | 设置可视化关键点的半径。 | ✔️ | ✔️ | +| `thickness` | 确定可视化链接的厚度。 | ✔️ | ✔️ | +| `kpt_thr` | 设置关键点分数阈值。分数超过此阈值的关键点将被显示。 | ✔️ | ✔️ | +| `draw_bbox` | 决定是否显示实例的边界框。 | ✔️ | ✔️ | +| `draw_heatmap` | 决定是否绘制预测的热图。 | ✔️ | ❌ | +| `black_background` | 决定是否在黑色背景上显示预估的姿势。 | ✔️ | ❌ | +| `skeleton_style` | 设置骨架样式。可选项包括 'mmpose'（默认）和 'openpose'。 | ✔️ | ❌ | +| `use_oks_tracking` | 决定是否在追踪中使用OKS作为相似度测量。 | ❌ | ✔️ | +| `tracking_thr` | 设置追踪的相似度阈值。 | ❌ | ✔️ | +| `norm_pose_2d` | 决定是否将边界框缩放至数据集的平均边界框尺寸，并将边界框移至数据集的平均边界框中心。 | ❌ | ✔️ | +| `rebase_keypoint_height` | 决定是否将最低关键点的高度置为 0。 | ❌ | ✔️ | +| `return_vis` | 决定是否在结果中包含可视化图像。 | ✔️ | ✔️ | +| `vis_out_dir` | 定义保存可视化图像的文件夹路径。如果未设置，将不保存可视化图像。 | ✔️ | ✔️ | +| `return_datasample` | 决定是否以 `PoseDataSample` 格式返回预测。 | ✔️ | ✔️ | +| `pred_out_dir` | 指定保存预测的文件夹路径。如果未设置，将不保存预测。 | ✔️ | ✔️ | +| `out_dir` | 如果 `vis_out_dir` 或 `pred_out_dir` 未设置，它们将分别设置为 `f'{out_dir}/visualization'` 或 `f'{out_dir}/predictions'`。 | ✔️ | ✔️ | + +### 模型别名 + +MMPose为常用模型提供了一组预定义的别名。在初始化 `MMPoseInferencer` 时，这些别名可以用作简略的表达方式，而不是指定完整的模型配置名称。下面是可用的模型别名及其对应的配置名称的列表： + +| 别名 | 配置文件名称 | 对应任务 | 姿态估计模型 | 检测模型 | +| --------- | -------------------------------------------------- | ------------------------------- | ------------- | ------------------- | +| animal | rtmpose-m_8xb64-210e_ap10k-256x256 | Animal pose estimation | RTMPose-m | RTMDet-m | +| human | rtmpose-m_8xb256-420e_aic-coco-256x192 | Human pose estimation | RTMPose-m | RTMDet-m | +| face | rtmpose-m_8xb64-60e_wflw-256x256 | Face keypoint detection | RTMPose-m | yolox-s | +| hand | rtmpose-m_8xb32-210e_coco-wholebody-hand-256x256 | Hand keypoint detection | RTMPose-m | ssdlite_mobilenetv2 | +| wholebody | rtmpose-m_8xb64-270e_coco-wholebody-256x192 | Human wholebody pose estimation | RTMPose-m | RTMDet-m | +| vitpose | td-hm_ViTPose-base-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-base | RTMDet-m | +| vitpose-s | td-hm_ViTPose-small-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-small | RTMDet-m | +| vitpose-b | td-hm_ViTPose-base-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-base | RTMDet-m | +| vitpose-l | td-hm_ViTPose-large-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-large | RTMDet-m | +| vitpose-h | td-hm_ViTPose-huge-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-huge | RTMDet-m | + +此外，用户可以使用命令行界面工具显示所有可用的别名，使用以下命令: + +```shell +python demo/inferencer_demo.py --show-alias +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/installation.md b/internlm_langchain/knowledge_base/MMPose/content/installation.md new file mode 100644 index 00000000..ef515c80 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/installation.md @@ -0,0 +1,248 @@ +# 安装 + +我们推荐用户按照我们的最佳实践来安装 MMPose。但除此之外，如果您想根据 +您的习惯完成安装流程，也可以参见 [自定义安装](#自定义安装) 一节来获取更多信息。 + +- [安装](#安装) + - [依赖环境](#依赖环境) + - [最佳实践](#最佳实践) + - [从源码安装 MMPose](#从源码安装-mmpose) + - [作为 Python 包安装](#作为-python-包安装) + - [验证安装](#验证安装) + - [自定义安装](#自定义安装) + - [CUDA 版本](#cuda-版本) + - [不使用 MIM 安装 MMEngine](#不使用-mim-安装-mmengine) + - [在 CPU 环境中安装](#在-cpu-环境中安装) + - [在 Google Colab 中安装](#在-google-colab-中安装) + - [通过 Docker 使用 MMPose](#通过-docker-使用-mmpose) + - [故障解决](#故障解决) + +## 依赖环境 + +在本节中，我们将演示如何准备 PyTorch 相关的依赖环境。 + +MMPose 适用于 Linux、Windows 和 macOS。它需要 Python 3.7+、CUDA 9.2+ 和 PyTorch 1.8+。 + +如果您对配置 PyTorch 环境已经很熟悉，并且已经完成了配置，可以直接进入下一节：[安装](#安装-mmpose)。否则，请依照以下步骤完成配置。 + +**第 1 步** 从[官网](https://docs.conda.io/en/latest/miniconda.html) 下载并安装 Miniconda。 + +**第 2 步** 创建一个 conda 虚拟环境并激活它。 + +```shell +conda create --name openmmlab python=3.8 -y +conda activate openmmlab +``` + +**第 3 步** 按照[官方指南](https://pytorch.org/get-started/locally/) 安装 PyTorch。例如： + +在 GPU 平台： + +```shell +conda install pytorch torchvision -c pytorch +``` + +```{warning} +以上命令会自动安装最新版的 PyTorch 与对应的 cudatoolkit，请检查它们是否与您的环境匹配。 +``` + +在 CPU 平台： + +```shell +conda install pytorch torchvision cpuonly -c pytorch +``` + +**第 4 步** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine) 和 [MMCV](https://github.com/open-mmlab/mmcv/tree/2.x) + +```shell +pip install -U openmim +mim install mmengine +mim install "mmcv>=2.0.1" +``` + +请注意，MMPose 中的一些推理示例脚本需要使用 [MMDetection](https://github.com/open-mmlab/mmdetection) (mmdet) 检测人体。如果您想运行这些示例脚本，可以通过运行以下命令安装 mmdet: + +```shell +mim install "mmdet>=3.1.0" +``` + +## 最佳实践 + +根据具体需求，我们支持两种安装模式: 从源码安装（推荐）和作为 Python 包安装 + +### 从源码安装（推荐） + +如果基于 MMPose 框架开发自己的任务，需要添加新的功能，比如新的模型或是数据集，或者使用我们提供的各种工具。从源码按如下方式安装 mmpose： + +```shell +git clone https://github.com/open-mmlab/mmpose.git +cd mmpose +pip install -r requirements.txt +pip install -v -e . +# "-v" 表示输出更多安装相关的信息 +# "-e" 表示以可编辑形式安装，这样可以在不重新安装的情况下，让本地修改直接生效 +``` + +### 作为 Python 包安装 + +如果只是希望调用 MMPose 的接口，或者在自己的项目中导入 MMPose 中的模块。直接使用 mim 安装即可。 + +```shell +mim install "mmpose>=1.1.0" +``` + +## 验证安装 + +为了验证 MMPose 是否安装正确，您可以通过以下步骤运行模型推理。 + +**第 1 步** 我们需要下载配置文件和模型权重文件 + +```shell +mim download mmpose --config td-hm_hrnet-w48_8xb32-210e_coco-256x192 --dest . +``` + +下载过程往往需要几秒或更多的时间，这取决于您的网络环境。完成之后，您会在当前目录下找到这两个文件：`td-hm_hrnet-w48_8xb32-210e_coco-256x192.py` 和 `hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth`, 分别是配置文件和对应的模型权重文件。 + +**第 2 步** 验证推理示例 + +如果您是**从源码安装**的 mmpose，可以直接运行以下命令进行验证： + +```shell +python demo/image_demo.py \ + tests/data/coco/000000000785.jpg \ + td-hm_hrnet-w48_8xb32-210e_coco-256x192.py \ + hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth \ + --out-file vis_results.jpg \ + --draw-heatmap +``` + +如果一切顺利，您将会得到这样的可视化结果： + + + +代码会将预测的关键点和热图绘制在图像中的人体上，并保存到当前文件夹下的 `vis_results.jpg`。 + +如果您是**作为 Python 包安装**，可以打开您的 Python 解释器，复制并粘贴如下代码： + +```python +from mmpose.apis import inference_topdown, init_model +from mmpose.utils import register_all_modules + +register_all_modules() + +config_file = 'td-hm_hrnet-w48_8xb32-210e_coco-256x192.py' +checkpoint_file = 'hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth' +model = init_model(config_file, checkpoint_file, device='cpu') # or device='cuda:0' + +# 请准备好一张带有人体的图片 +results = inference_topdown(model, 'demo.jpg') +``` + +示例图片 `demo.jpg` 可以从 [Github](https://raw.githubusercontent.com/open-mmlab/mmpose/main/tests/data/coco/000000000785.jpg) 下载。 +推理结果是一个 `PoseDataSample` 列表，预测结果将会保存在 `pred_instances` 中，包括检测到的关键点位置和置信度。 + +## 自定义安装 + +### CUDA 版本 + +安装 PyTorch 时，需要指定 CUDA 版本。如果您不清楚选择哪个，请遵循我们的建议： + +- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 系列 以及 NVIDIA A100，CUDA 11 是必需的。 +- 对于更早的 NVIDIA GPU，CUDA 11 是向后兼容 (backward compatible) 的，但 CUDA 10.2 能够提供更好的兼容性，也更加轻量。 + +请确保您的 GPU 驱动版本满足最低的版本需求，参阅[这张表](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。 + +```{note} +如果按照我们的最佳实践进行安装，CUDA 运行时库就足够了，因为我们提供相关 CUDA 代码的预编译，您不需要进行本地编译。 +但如果您希望从源码进行 MMCV 的编译，或是进行其他 CUDA 算子的开发，那么就必须安装完整的 CUDA 工具链，参见 +[NVIDIA 官网](https://developer.nvidia.com/cuda-downloads)，另外还需要确保该 CUDA 工具链的版本与 PyTorch 安装时 +的配置相匹配（如用 `conda install` 安装 PyTorch 时指定的 cudatoolkit 版本）。 +``` + +### 不使用 MIM 安装 MMEngine + +若不使用 mim 安装 MMEngine，请遵循 [ MMEngine 安装指南](https://mmengine.readthedocs.io/zh_CN/latest/get_started/installation.html). + +例如，您可以通过以下命令安装 MMEngine: + +```shell +pip install mmengine +``` + +### 不使用 MIM 安装 MMCV + +MMCV 包含 C++ 和 CUDA 扩展，因此其对 PyTorch 的依赖比较复杂。MIM 会自动解析这些 +依赖，选择合适的 MMCV 预编译包，使安装更简单，但它并不是必需的。 + +若不使用 mim 来安装 MMCV，请遵照 [MMCV 安装指南](https://mmcv.readthedocs.io/zh_CN/2.x/get_started/installation.html)。 +它需要您用指定 url 的形式手动指定对应的 PyTorch 和 CUDA 版本。 + +举个例子，如下命令将会安装基于 PyTorch 1.10.x 和 CUDA 11.3 编译的 mmcv。 + +```shell +pip install 'mmcv>=2.0.1' -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html +``` + +### 在 CPU 环境中安装 + +MMPose 可以仅在 CPU 环境中安装，在 CPU 模式下，您可以完成训练、测试和模型推理等所有操作。 + +在 CPU 模式下，MMCV 的部分功能将不可用，通常是一些 GPU 编译的算子，如 `Deformable Convolution`。MMPose 中大部分的模型都不会依赖这些算子，但是如果您尝试使用包含这些算子的模型来运行训练、测试或推理，将会报错。 + +### 在 Google Colab 中安装 + +[Google Colab](https://colab.research.google.com/) 通常已经包含了 PyTorch 环境，因此我们只需要安装 MMEngine, MMCV 和 MMPose 即可，命令如下： + +**第 1 步** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine) 和 [MMCV](https://github.com/open-mmlab/mmcv/tree/2.x) + +```shell +!pip3 install openmim +!mim install mmengine +!mim install "mmcv>=2.0.1" +``` + +**第 2 步** 从源码安装 mmpose + +```shell +!git clone https://github.com/open-mmlab/mmpose.git +%cd mmpose +!pip install -e . +``` + +**第 3 步** 验证 + +```python +import mmpose +print(mmpose.__version__) +# 预期输出： 1.1.0 +``` + +```{note} +在 Jupyter 中，感叹号 `!` 用于执行外部命令，而 `%cd` 是一个[魔术命令](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd)，用于切换 Python 的工作路径。 +``` + +### 通过 Docker 使用 MMPose + +MMPose 提供 [Dockerfile](https://github.com/open-mmlab/mmpose/blob/master/docker/Dockerfile) +用于构建镜像。请确保您的 [Docker 版本](https://docs.docker.com/engine/install/) >=19.03。 + +```shell +# 构建默认的 PyTorch 1.8.0，CUDA 10.1 版本镜像 +# 如果您希望使用其他版本，请修改 Dockerfile +docker build -t mmpose docker/ +``` + +**注意**：请确保您已经安装了 [nvidia-container-toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker)。 + +用以下命令运行 Docker 镜像： + +```shell +docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmpose/data mmpose +``` + +`{DATA_DIR}` 是您本地存放用于 MMPose 训练、测试、推理等流程的数据目录。 + +## 故障解决 + +如果您在安装过程中遇到了什么问题，请先查阅[常见问题](faq.md)。如果没有找到解决方法，可以在 GitHub +上[提出 issue](https://github.com/open-mmlab/mmpose/issues/new/choose)。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/label_studio.md b/internlm_langchain/knowledge_base/MMPose/content/label_studio.md new file mode 100644 index 00000000..94cbd641 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/label_studio.md @@ -0,0 +1,76 @@ +# Label Studio 标注工具转COCO脚本 + +[Label Studio](https://labelstud.io/) 是一款广受欢迎的深度学习标注工具，可以对多种任务进行标注，然而对于关键点标注，Label Studio 无法直接导出成 MMPose 所需要的 COCO 格式。本文将介绍如何使用Label Studio 标注关键点数据，并利用 [labelstudio2coco.py](../../../tools/dataset_converters/labelstudio2coco.py) 工具将其转换为训练所需的格式。 + +## Label Studio 标注要求 + +根据 COCO 格式的要求，每个标注的实例中都需要包含关键点、分割和 bbox 的信息，然而 Label Studio 在标注时会将这些信息分散在不同的实例中，因此需要按一定规则进行标注，才能正常使用后续的脚本。 + +1. 标签接口设置 + +对于一个新建的 Label Studio 项目，首先要设置它的标签接口。这里需要有三种类型的标注：`KeyPointLabels`、`PolygonLabels`、`RectangleLabels`，分别对应 COCO 格式中的`keypoints`、`segmentation`、`bbox`。以下是一个标签接口的示例，可以在项目的`Settings`中找到`Labeling Interface`，点击`Code`，粘贴使用该示例。 + +```xml +
+
+
+
+
+
+
+
+
+
+
+```
+
+2. 标注顺序
+
+由于需要将多个标注实例中的不同类型标注组合到一个实例中，因此采取了按特定顺序标注的方式，以此来判断各标注是否位于同一个实例。标注时须按照 **KeyPointLabels -> PolygonLabels/RectangleLabels** 的顺序标注，其中 KeyPointLabels 的顺序和数量要与 MMPose 配置文件中的`dataset_info`的关键点顺序和数量一致， PolygonLabels 和 RectangleLabels 的标注顺序可以互换，且可以只标注其中一个，只要保证一个实例的标注中，以关键点开始，以非关键点结束即可。下图为标注的示例：
+
+*注：bbox 和 area 会根据靠后的 PolygonLabels/RectangleLabels 来计算，如若先标 PolygonLabels，那么bbox会是靠后的 RectangleLabels 的范围，面积为矩形的面积，反之则是多边形外接矩形和多边形的面积*
+
+
+
+3. 导出标注
+
+上述标注完成后，需要将标注进行导出。选择项目界面的`Export`按钮，选择`JSON`格式，再点击`Export`即可下载包含标签的 JSON 格式文件。
+
+*注：上述文件中仅仅包含标签，不包含原始图片，因此需要额外提供标注对应的图片。由于 Label Studio 会对过长的文件名进行截断，因此不建议直接使用上传的文件，而是使用`Export`功能中的导出 COCO 格式工具，使用压缩包内的图片文件夹。*
+
+
+
+## 转换工具脚本的使用
+
+转换工具脚本位于`tools/dataset_converters/labelstudio2coco.py`，使用方式如下：
+
+```bash
+python tools/dataset_converters/labelstudio2coco.py config.xml project-1-at-2023-05-13-09-22-91b53efa.json output/result.json
+```
+
+其中`config.xml`的内容为标签接口设置中提到的`Labeling Interface`中的`Code`，`project-1-at-2023-05-13-09-22-91b53efa.json`即为导出标注时导出的 Label Studio 格式的 JSON 文件，`output/result.json`为转换后得到的 COCO 格式的 JSON 文件路径，若路径不存在，该脚本会自动创建路径。
+
+随后，将图片的文件夹放置在输出目录下，即可完成 COCO 数据集的转换。目录结构示例如下：
+
+```bash
+.
+├── images
+│ ├── 38b480f2.jpg
+│ └── aeb26f04.jpg
+└── result.json
+
+```
+
+若想在 MMPose 中使用该数据集，可以进行类似如下的修改：
+
+```python
+dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_mode=data_mode,
+ ann_file='result.json',
+ data_prefix=dict(img='images/'),
+ pipeline=train_pipeline,
+)
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/migration.md b/internlm_langchain/knowledge_base/MMPose/content/migration.md
new file mode 100644
index 00000000..9a591dfc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/migration.md
@@ -0,0 +1,201 @@
+# MMPose 0.X 兼容性说明
+
+MMPose 1.0 经过了大规模重构并解决了许多遗留问题，对于 0.x 版本的大部分代码 MMPose 1.0 将不兼容。
+
+## 数据变换
+
+### 平移、旋转和缩放
+
+旧版的数据变换方法 `TopDownRandomShiftBboxCenter` 和 `TopDownGetRandomScaleRotation`，将被合并为 `RandomBBoxTransform`：
+
+```Python
+@TRANSFORMS.register_module()
+class RandomBBoxTransform(BaseTransform):
+ r"""Rnadomly shift, resize and rotate the bounding boxes.
+
+ Required Keys:
+
+ - bbox_center
+ - bbox_scale
+
+ Modified Keys:
+
+ - bbox_center
+ - bbox_scale
+
+ Added Keys:
+ - bbox_rotation
+
+ Args:
+ shift_factor (float): Randomly shift the bbox in range
+ :math:`[-dx, dx]` and :math:`[-dy, dy]` in X and Y directions,
+ where :math:`dx(y) = x(y)_scale \cdot shift_factor` in pixels.
+ Defaults to 0.16
+ shift_prob (float): Probability of applying random shift. Defaults to
+ 0.3
+ scale_factor (Tuple[float, float]): Randomly resize the bbox in range
+ :math:`[scale_factor[0], scale_factor[1]]`. Defaults to (0.5, 1.5)
+ scale_prob (float): Probability of applying random resizing. Defaults
+ to 1.0
+ rotate_factor (float): Randomly rotate the bbox in
+ :math:`[-rotate_factor, rotate_factor]` in degrees. Defaults
+ to 80.0
+ rotate_prob (float): Probability of applying random rotation. Defaults
+ to 0.6
+ """
+
+ def __init__(self,
+ shift_factor: float = 0.16,
+ shift_prob: float = 0.3,
+ scale_factor: Tuple[float, float] = (0.5, 1.5),
+ scale_prob: float = 1.0,
+ rotate_factor: float = 80.0,
+ rotate_prob: float = 0.6) -> None:
+```
+
+### 标签生成
+
+旧版用于训练标签生成的方法 `TopDownGenerateTarget` 、`TopDownGenerateTargetRegression`、`BottomUpGenerateHeatmapTarget`、`BottomUpGenerateTarget` 等将被合并为 `GenerateTarget`，而实际的生成方法由[编解码器](./user_guides/codecs.md) 提供：
+
+```Python
+@TRANSFORMS.register_module()
+class GenerateTarget(BaseTransform):
+ """Encode keypoints into Target.
+
+ The generated target is usually the supervision signal of the model
+ learning, e.g. heatmaps or regression labels.
+
+ Required Keys:
+
+ - keypoints
+ - keypoints_visible
+ - dataset_keypoint_weights
+
+ Added Keys:
+
+ - The keys of the encoded items from the codec will be updated into
+ the results, e.g. ``'heatmaps'`` or ``'keypoint_weights'``. See
+ the specific codec for more details.
+
+ Args:
+ encoder (dict | list[dict]): The codec config for keypoint encoding.
+ Both single encoder and multiple encoders (given as a list) are
+ supported
+ multilevel (bool): Determine the method to handle multiple encoders.
+ If ``multilevel==True``, generate multilevel targets from a group
+ of encoders of the same type (e.g. multiple :class:`MSRAHeatmap`
+ encoders with different sigma values); If ``multilevel==False``,
+ generate combined targets from a group of different encoders. This
+ argument will have no effect in case of single encoder. Defaults
+ to ``False``
+ use_dataset_keypoint_weights (bool): Whether use the keypoint weights
+ from the dataset meta information. Defaults to ``False``
+ """
+
+ def __init__(self,
+ encoder: MultiConfig,
+ multilevel: bool = False,
+ use_dataset_keypoint_weights: bool = False) -> None:
+```
+
+### 数据归一化
+
+旧版的数据归一化操作 `NormalizeTensor` 和 `ToTensor` 方法将由 **DataPreprocessor** 模块替代，不再作为流水线的一部分，而是作为模块加入到模型前向传播中。
+
+## 模型兼容
+
+我们对 model zoo 提供的模型权重进行了兼容性处理，确保相同的模型权重测试精度能够与 0.x 版本保持同等水平，但由于在这两个版本中存在大量处理细节的差异，推理结果可能会产生轻微的不同（精度误差小于 0.05%）。
+
+对于使用 0.x 版本训练保存的模型权重，我们在预测头中提供了 `_load_state_dict_pre_hook()` 方法来将旧版的权重字典替换为新版，如果你希望将在旧版上开发的模型兼容到新版，可以参考我们的实现。
+
+```Python
+@MODELS.register_module()
+class YourHead(BaseHead):
+def __init__(self):
+
+ ## omitted
+
+ # Register the hook to automatically convert old version state dicts
+ self._register_load_state_dict_pre_hook(self._load_state_dict_pre_hook)
+```
+
+### Heatmap-based 方法
+
+对于基于SimpleBaseline方法的模型，主要需要注意最后一层卷积层的兼容：
+
+```Python
+def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *args,
+ **kwargs):
+ version = local_meta.get('version', None)
+
+ if version and version >= self._version:
+ return
+
+ # convert old-version state dict
+ keys = list(state_dict.keys())
+ for _k in keys:
+ if not _k.startswith(prefix):
+ continue
+ v = state_dict.pop(_k)
+ k = _k[len(prefix):]
+ # In old version, "final_layer" includes both intermediate
+ # conv layers (new "conv_layers") and final conv layers (new
+ # "final_layer").
+ #
+ # If there is no intermediate conv layer, old "final_layer" will
+ # have keys like "final_layer.xxx", which should be still
+ # named "final_layer.xxx";
+ #
+ # If there are intermediate conv layers, old "final_layer" will
+ # have keys like "final_layer.n.xxx", where the weights of the last
+ # one should be renamed "final_layer.xxx", and others should be
+ # renamed "conv_layers.n.xxx"
+ k_parts = k.split('.')
+ if k_parts[0] == 'final_layer':
+ if len(k_parts) == 3:
+ assert isinstance(self.conv_layers, nn.Sequential)
+ idx = int(k_parts[1])
+ if idx < len(self.conv_layers):
+ # final_layer.n.xxx -> conv_layers.n.xxx
+ k_new = 'conv_layers.' + '.'.join(k_parts[1:])
+ else:
+ # final_layer.n.xxx -> final_layer.xxx
+ k_new = 'final_layer.' + k_parts[2]
+ else:
+ # final_layer.xxx remains final_layer.xxx
+ k_new = k
+ else:
+ k_new = k
+
+ state_dict[prefix + k_new] = v
+```
+
+### RLE-based 方法
+
+对于基于 RLE 的模型，由于新版的 `loss` 模块更名为 `loss_module`，且 flow 模型归属在 `loss` 模块下，因此需要对权重字典中 `loss` 字段进行更改：
+
+```Python
+def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *args,
+ **kwargs):
+
+ version = local_meta.get('version', None)
+
+ if version and version >= self._version:
+ return
+
+ # convert old-version state dict
+ keys = list(state_dict.keys())
+ for _k in keys:
+ v = state_dict.pop(_k)
+ k = _k.lstrip(prefix)
+ # In old version, "loss" includes the instances of loss,
+ # now it should be renamed "loss_module"
+ k_parts = k.split('.')
+ if k_parts[0] == 'loss':
+ # loss.xxx -> loss_module.xxx
+ k_new = prefix + 'loss_module.' + '.'.join(k_parts[1:])
+ else:
+ k_new = _k
+
+ state_dict[k_new] = v
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/mixed_datasets.md b/internlm_langchain/knowledge_base/MMPose/content/mixed_datasets.md
new file mode 100644
index 00000000..fac38e33
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/mixed_datasets.md
@@ -0,0 +1,159 @@
+# 混合数据集训练
+
+MMPose 提供了一个灵活、便捷的工具 `CombinedDataset` 来进行混合数据集训练。它作为一个封装器，可以包含多个子数据集，并将来自不同子数据集的数据转换成一个统一的格式，以用于模型训练。使用 `CombinedDataset` 的数据处理流程如下图所示。
+
+
+
+本篇教程的后续部分将通过一个结合 COCO 和 AI Challenger (AIC) 数据集的例子详细介绍如何配置 `CombinedDataset`。
+
+## COCO & AIC 数据集混合案例
+
+COCO 和 AIC 都是 2D 人体姿态数据集。但是，这两个数据集在关键点的数量和排列顺序上有所不同。下面是分别来自这两个数据集的图片及关键点：
+
+
+ +有些关键点（例如“左手”）在两个数据集中都有定义，但它们具有不同的序号。具体来说，“左手”关键点在 COCO 数据集中的序号为 9，在AIC数据集中的序号为 5。此外，每个数据集都包含独特的关键点，另一个数据集中不存在。例如，面部关键点（序号为0〜4）仅在 COCO 数据集中定义，而“头顶”（序号为 12）和“颈部”（序号为 13）关键点仅在 AIC 数据集中存在。以下的维恩图显示了两个数据集中关键点之间的关系。 + +
+ +接下来，我们会介绍两种混合数据集的方式： + +- [将 AIC 合入 COCO 数据集](#将-aic-合入-coco-数据集) +- [合并 AIC 和 COCO 数据集](#合并-aic-和-coco-数据集) + +### 将 AIC 合入 COCO 数据集 + +如果用户想提高其模型在 COCO 或类似数据集上的性能，可以将 AIC 数据集作为辅助数据。此时应该仅选择 AIC 数据集中与 COCO 数据集共享的关键点，忽略其余关键点。此外，还需要将这些被选择的关键点在 AIC 数据集中的序号进行转换，以匹配在 COCO 数据集中对应关键点的序号。 + +
+ +在这种情况下，来自 COCO 的数据不需要进行转换。此时 COCO 数据集可通过如下方式配置： + +```python +dataset_coco = dict( + type='CocoDataset', + data_root='data/coco/', + ann_file='annotations/person_keypoints_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=[], # `pipeline` 应为空列表，因为 COCO 数据不需要转换 +) +``` + +对于 AIC 数据集，需要转换关键点的顺序。MMPose 提供了一个 `KeypointConverter` 转换器来实现这一点。以下是配置 AIC 子数据集的示例： + +```python +dataset_aic = dict( + type='AicDataset', + data_root='data/aic/', + ann_file='annotations/aic_train.json', + data_prefix=dict(img='ai_challenger_keypoint_train_20170902/' + 'keypoint_train_images_20170902/'), + pipeline=[ + dict( + type='KeypointConverter', + num_keypoints=17, # 与 COCO 数据集关键点数一致 + mapping=[ # 需要列出所有带转换关键点的序号 + (0, 6), # 0 (AIC 中的序号) -> 6 (COCO 中的序号) + (1, 8), + (2, 10), + (3, 5), + (4, 7), + (5, 9), + (6, 12), + (7, 14), + (8, 16), + (9, 11), + (10, 13), + (11, 15), + ]) + ], +) +``` + +`KeypointConverter` 会将原序号在 0 到 11 之间的关键点的序号转换为在 5 到 16 之间的对应序号。同时，在 AIC 中序号为为 12 和 13 的关键点将被删除。另外，目标序号在 0 到 4 之间的关键点在 `mapping` 参数中没有定义，这些点将被设为不可见，并且不会在训练中使用。 + +子数据集都完成配置后, 混合数据集 `CombinedDataset` 可以通过如下方式配置: + +```python +dataset = dict( + type='CombinedDataset', + # 混合数据集关键点顺序和 COCO 数据集相同， + # 所以使用 COCO 数据集的描述信息 + metainfo=dict(from_file='configs/_base_/datasets/coco.py'), + datasets=[dataset_coco, dataset_aic], + # `train_pipeline` 包含了常用的数据预处理， + # 比如图片读取、数据增广等 + pipeline=train_pipeline, +) +``` + +MMPose 提供了一份完整的 [配置文件](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-aic-256x192-merge.py) 来将 AIC 合入 COCO 数据集并用于训练网络。用户可以查阅这个文件以获取更多细节，或者参考这个文件来构建新的混合数据集。 + +### 合并 AIC 和 COCO 数据集 + +将 AIC 合入 COCO 数据集的过程中丢弃了部分 AIC 数据集中的标注信息。如果用户想要使用两个数据集中的所有信息，可以将两个数据集合并，即在两个数据集中取关键点的并集。 + +
+ +在这种情况下，COCO 和 AIC 数据集都需要使用 `KeypointConverter` 来调整它们关键点的顺序： + +```python +dataset_coco = dict( + type='CocoDataset', + data_root='data/coco/', + ann_file='annotations/person_keypoints_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=[ + dict( + type='KeypointConverter', + num_keypoints=19, # 并集中有 19 个关键点 + mapping=[ + (0, 0), + (1, 1), + # 省略 + (16, 16), + ]) + ]) + +dataset_aic = dict( + type='AicDataset', + data_root='data/aic/', + ann_file='annotations/aic_train.json', + data_prefix=dict(img='ai_challenger_keypoint_train_20170902/' + 'keypoint_train_images_20170902/'), + pipeline=[ + dict( + type='KeypointConverter', + num_keypoints=19, # 并集中有 19 个关键点 + mapping=[ + (0, 6), + # 省略 + (12, 17), + (13, 18), + ]) + ], +) +``` + +合并后的数据集有 19 个关键点，这与 COCO 或 AIC 数据集都不同，因此需要一个新的数据集描述信息文件。[coco_aic.py](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/_base_/datasets/coco_aic.py) 是一个描述信息文件的示例，它基于 [coco.py](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/_base_/datasets/coco.py) 并进行了以下几点修改: + +- 添加了 AIC 数据集的文章信息； +- 在 `keypoint_info` 中添加了“头顶”和“颈部”这两个只在 AIC 中定义的关键点； +- 在 `skeleton_info` 中添加了“头顶”和“颈部”间的连线； +- 拓展 `joint_weights` 和 `sigmas` 以添加新增关键点的信息。 + +完成以上步骤后，合并数据集 `CombinedDataset` 可以通过以下方式配置： + +```python +dataset = dict( + type='CombinedDataset', + # 使用新的描述信息文件 + metainfo=dict(from_file='configs/_base_/datasets/coco_aic.py'), + datasets=[dataset_coco, dataset_aic], + # `train_pipeline` 包含了常用的数据预处理， + # 比如图片读取、数据增广等 + pipeline=train_pipeline, +) +``` + +此外，在使用混合数据集时，由于关键点数量的变化，模型的输出通道数也要做相应调整。如果用户用混合数据集训练了模型，但是要在 COCO 数据集上评估模型，就需要从模型输出的关键点中取出一个子集来匹配 COCO 中的关键点格式。可以通过 `test_cfg` 中的 `output_keypoint_indices` 参数自定义此子集。这个 [配置文件](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-aic-256x192-combine.py) 展示了如何用 AIC 和 COCO 合并后的数据集训练模型并在 COCO 数据集上进行测试。用户可以查阅这个文件以获取更多细节，或者参考这个文件来构建新的混合数据集。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/model_analysis.md b/internlm_langchain/knowledge_base/MMPose/content/model_analysis.md new file mode 100644 index 00000000..234dc5be --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/model_analysis.md @@ -0,0 +1,100 @@ +# Model Analysis + +## 统计模型参数量与计算量 + +MMPose 提供了 `tools/analysis_tools/get_flops.py` 来统计模型的参数量与计算量。 + +```shell +python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}] [--cfg-options ${CFG_OPTIONS}] +``` + +参数说明： + +`CONFIG_FILE` : 模型配置文件的路径。 + +`--shape`: 模型的输入张量形状。 + +`--input-constructor`: 如果指定为 `batch`，将会生成一个 `batch tensor` 来计算 FLOPs。 + +`--batch-size`：如果 `--input-constructor` 指定为 `batch`，将会生成一个随机 `tensor`，形状为 `(batch_size, 3, **input_shape)` 来计算 FLOPs。 + +`--cfg-options`: 如果指定，可选的 `cfg` 的键值对将会被合并到配置文件中。 + +示例： + +```shell +python tools/analysis_tools/get_flops.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py +``` + +结果如下： + +```text +============================== +Input shape: (1, 3, 256, 192) +Flops: 7.7 GFLOPs +Params: 28.54 M +============================== +``` + +```{note} +目前该工具仍处于实验阶段，我们不能保证统计结果绝对正确，一些算子（比如 GN 或自定义算子）没有被统计到 FLOPs 中。 +``` + +## 分析训练日志 + +MMPose 提供了 `tools/analysis_tools/analyze_logs.py` 来对训练日志进行简单的分析，包括： + +- 将日志绘制成损失和精度曲线图 +- 统计训练速度 + +### 绘制损失和精度曲线图 + +该功能依赖于 `seaborn`，请先运行 `pip install seaborn` 安装依赖包。 + + + +```shell +python tools/analysis_tools/analyze_logs.py plot_curve ${JSON_LOGS} [--keys ${KEYS}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}] +``` + +示例： + +- 绘制损失曲线 + + ```shell + python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_kpt --legend loss_kpt + ``` + +- 绘制精度曲线并导出为 PDF 文件 + + ```shell + python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys acc_pose --out results.pdf + ``` + +- 将多个日志文件绘制在同一张图上 + + ```shell + python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys loss_kpt --legend run1 run2 --title loss_kpt --out loss_kpt.png + ``` + +### 统计训练速度 + +```shell +python tools/analysis_tools/analyze_logs.py cal_train_time ${JSON_LOGS} [--include-outliers] +``` + +示例： + +```shell +python tools/analysis_tools/analyze_logs.py cal_train_time log.json +``` + +结果如下： + +```text +-----Analyze train time of hrnet_w32_256x192.json----- +slowest epoch 56, average time is 0.6924 +fastest epoch 1, average time is 0.6502 +time std over epochs is 0.0085 +average iter time: 0.6688 s/iter +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/overview.md b/internlm_langchain/knowledge_base/MMPose/content/overview.md new file mode 100644 index 00000000..a790cd3b --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/overview.md @@ -0,0 +1,76 @@ +# 概述 + +本章将向你介绍 MMPose 的整体框架，并提供详细的教程链接。 + +## 什么是 MMPose + + + +MMPose 是一款基于 Pytorch 的姿态估计开源工具箱，是 OpenMMLab 项目的成员之一，包含了丰富的 2D 多人姿态估计、2D 手部姿态估计、2D 人脸关键点检测、133关键点全身人体姿态估计、动物关键点检测、服饰关键点检测等算法以及相关的组件和模块，下面是它的整体框架： + +MMPose 由 **8** 个主要部分组成，apis、structures、datasets、codecs、models、engine、evaluation 和 visualization。 + +- **apis** 提供用于模型推理的高级 API + +- **structures** 提供 bbox、keypoint 和 PoseDataSample 等数据结构 + +- **datasets** 支持用于姿态估计的各种数据集 + + - **transforms** 包含各种数据增强变换 + +- **codecs** 提供姿态编解码器：编码器用于将姿态信息（通常为关键点坐标）编码为模型学习目标（如热力图），解码器则用于将模型输出解码为姿态估计结果 + +- **models** 以模块化结构提供了姿态估计模型的各类组件 + + - **pose_estimators** 定义了所有姿态估计模型类 + - **data_preprocessors** 用于预处理模型的输入数据 + - **backbones** 包含各种骨干网络 + - **necks** 包含各种模型颈部组件 + - **heads** 包含各种模型头部 + - **losses** 包含各种损失函数 + +- **engine** 包含与姿态估计任务相关的运行时组件 + + - **hooks** 提供运行时的各种钩子 + +- **evaluation** 提供各种评估模型性能的指标 + +- **visualization** 用于可视化关键点骨架和热力图等信息 + +## 如何使用本指南 + +针对不同类型的用户，我们准备了详细的指南： + +1. 安装说明： + + - [安装](./installation.md) + +2. MMPose 的基本使用方法： + + - [20 分钟上手教程](./guide_to_framework.md) + - [Demos](./demos.md) + - [模型推理](./user_guides/inference.md) + - [配置文件](./user_guides/configs.md) + - [准备数据集](./user_guides/prepare_datasets.md) + - [训练与测试](./user_guides/train_and_test.md) + +3. 对于希望基于 MMPose 进行开发的研究者和开发者： + + - [编解码器](./advanced_guides/codecs.md) + - [数据流](./advanced_guides/dataflow.md) + - [实现新模型](./advanced_guides/implement_new_models.md) + - [自定义数据集](./advanced_guides/customize_datasets.md) + - [自定义数据变换](./advanced_guides/customize_transforms.md) + - [自定义优化器](./advanced_guides/customize_optimizer.md) + - [自定义日志](./advanced_guides/customize_logging.md) + - [模型部署](./advanced_guides/how_to_deploy.md) + - [模型分析工具](./advanced_guides/model_analysis.md) + - [迁移指南](./migration.md) + +4. 对于希望加入开源社区，向 MMPose 贡献代码的研究者和开发者： + + - [参与贡献代码](./contribution_guide.md) + +5. 对于使用过程中的常见问题： + + - [FAQ](./faq.md) diff --git a/internlm_langchain/knowledge_base/MMPose/content/prepare_datasets.md b/internlm_langchain/knowledge_base/MMPose/content/prepare_datasets.md new file mode 100644 index 00000000..8b7d651e --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/prepare_datasets.md @@ -0,0 +1,221 @@ +# 准备数据集 + +在这份文档将指导如何为 MMPose 准备数据集，包括使用内置数据集、创建自定义数据集、结合数据集进行训练、浏览和下载数据集。 + +## 使用内置数据集 + +**步骤一**: 准备数据 + +MMPose 支持多种任务和相应的数据集。你可以在 [数据集仓库](https://mmpose.readthedocs.io/en/latest/dataset_zoo.html) 中找到它们。为了正确准备你的数据，请按照你选择的数据集的指南进行操作。 + +**步骤二**: 在配置文件中进行数据集设置 + +在开始训练或评估模型之前，你必须配置数据集设置。以 [`td-hm_hrnet-w32_8xb64-210e_coco-256x192.py`](/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py) 为例，它可以用于在 COCO 数据集上训练或评估 HRNet 姿态估计器。下面我们浏览一下数据集配置： + +- 基础数据集参数 + + ```python + # base dataset settings + dataset_type = 'CocoDataset' + data_mode = 'topdown' + data_root = 'data/coco/' + ``` + + - `dataset_type` 指定数据集的类名。用户可以参考 [数据集 API](https://mmpose.readthedocs.io/en/latest/api.html#datasets) 来找到他们想要的数据集的类名。 + - `data_mode` 决定了数据集的输出格式，有两个选项可用：`'topdown'` 和 `'bottomup'`。如果 `data_mode='topdown'`，数据元素表示一个实例及其姿态；否则，一个数据元素代表一张图像，包含多个实例和姿态。 + - `data_root` 指定数据集的根目录。 + +- 数据处理流程 + + ```python + # pipelines + train_pipeline = [ + dict(type='LoadImage'), + dict(type='GetBBoxCenterScale'), + dict(type='RandomFlip', direction='horizontal'), + dict(type='RandomHalfBody'), + dict(type='RandomBBoxTransform'), + dict(type='TopdownAffine', input_size=codec['input_size']), + dict(type='GenerateTarget', encoder=codec), + dict(type='PackPoseInputs') + ] + val_pipeline = [ + dict(type='LoadImage'), + dict(type='GetBBoxCenterScale'), + dict(type='TopdownAffine', input_size=codec['input_size']), + dict(type='PackPoseInputs') + ] + ``` + + `train_pipeline` 和 `val_pipeline` 分别定义了训练和评估阶段处理数据元素的步骤。除了加载图像和打包输入之外，`train_pipeline` 主要包含数据增强技术和目标生成器，而 `val_pipeline` 则专注于将数据元素转换为统一的格式。 + +- 数据加载器 + + ```python + # data loaders + train_dataloader = dict( + batch_size=64, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_mode=data_mode, + ann_file='annotations/person_keypoints_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=train_pipeline, + )) + val_dataloader = dict( + batch_size=32, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_mode=data_mode, + ann_file='annotations/person_keypoints_val2017.json', + bbox_file='data/coco/person_detection_results/' + 'COCO_val2017_detections_AP_H_56_person.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=val_pipeline, + )) + test_dataloader = val_dataloader + ``` + + 这个部分是配置数据集的关键。除了前面讨论过的基础数据集参数和数据处理流程之外，这里还定义了其他重要的参数。`batch_size` 决定了每个 GPU 的 batch size；`ann_file` 指定了数据集的注释文件；`data_prefix` 指定了图像文件夹。`bbox_file` 仅在 top-down 数据集的 val/test 数据加载器中使用，用于提供检测到的边界框信息。 + +我们推荐从使用相同数据集的配置文件中复制数据集配置，而不是从头开始编写，以最小化潜在的错误。通过这样做，用户可以根据需要进行必要的修改，从而确保更可靠和高效的设置过程。 + +## 使用自定义数据集 + +[自定义数据集](../advanced_guides/customize_datasets.md) 指南提供了如何构建自定义数据集的详细信息。在本节中，我们将强调一些使用和配置自定义数据集的关键技巧。 + +- 确定数据集类名。如果你将数据集重组为 COCO 格式，你可以简单地使用 `CocoDataset` 作为 `dataset_type` 的值。否则，你将需要使用你添加的自定义数据集类的名称。 + +- 指定元信息配置文件。MMPose 1.x 采用了与 MMPose 0.x 不同的策略来指定元信息。在 MMPose 1.x 中，用户可以按照以下方式指定元信息配置文件： + + ```python + train_dataloader = dict( + ... + dataset=dict( + type=dataset_type, + data_root='root/of/your/train/data', + ann_file='path/to/your/train/json', + data_prefix=dict(img='path/to/your/train/img'), + # specify dataset meta information + metainfo=dict(from_file='configs/_base_/datasets/custom.py'), + ...), + ) + ``` + + 注意，`metainfo` 参数必须在 val/test 数据加载器中指定。 + +## 使用混合数据集进行训练 + +MMPose 提供了一个方便且多功能的解决方案，用于训练混合数据集。请参考[混合数据集训练](./mixed_datasets.md)。 + +## 浏览数据集 + +`tools/analysis_tools/browse_dataset.py` 帮助用户可视化地浏览姿态数据集，或将图像保存到指定的目录。 + +```shell +python tools/misc/browse_dataset.py ${CONFIG} [-h] [--output-dir ${OUTPUT_DIR}] [--not-show] [--phase ${PHASE}] [--mode ${MODE}] [--show-interval ${SHOW_INTERVAL}] +``` + +| ARGS | Description | +| -------------------------------- | ---------------------------------------------------------------------------------------------------------- | +| `CONFIG` | 配置文件的路径 | +| `--output-dir OUTPUT_DIR` | 保存可视化结果的目标文件夹。如果不指定，可视化的结果将不会被保存 | +| `--not-show` | 不适用外部窗口显示可视化的结果 | +| `--phase {train, val, test}` | 数据集选项 | +| `--mode {original, transformed}` | 指定可视化图片类型。 `original` 为不使用数据增强的原始图片及标注可视化; `transformed` 为经过增强后的可视化 | +| `--show-interval SHOW_INTERVAL` | 显示图片的时间间隔 | + +例如，用户想要可视化 COCO 数据集中的图像和标注，可以使用： + +```shell +python tools/misc/browse_dataset.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-e210_coco-256x192.py --mode original +``` + +检测框和关键点将被绘制在原始图像上。下面是一个例子： + + +原始图像在被输入模型之前需要被处理。为了可视化预处理后的图像和标注，用户需要将参数 `mode` 修改为 `transformed`。例如： + +```shell +python tools/misc/browse_dataset.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-e210_coco-256x192.py --mode transformed +``` + +这是一个处理后的样本： + + + +热图目标将与之一起可视化，如果它是在 pipeline 中生成的。 + +## 用 MIM 下载数据集 + +通过使用 [OpenDataLab](https://opendatalab.com/)，您可以直接下载开源数据集。通过平台的搜索功能，您可以快速轻松地找到他们正在寻找的数据集。使用平台上的格式化数据集，您可以高效地跨数据集执行任务。 + +如果您使用 MIM 下载，请确保版本大于 v0.3.8。您可以使用以下命令进行更新、安装、登录和数据集下载： + +```shell +# upgrade your MIM +pip install -U openmim + +# install OpenDataLab CLI tools +pip install -U opendatalab +# log in OpenDataLab, registry +odl login + +# download coco2017 and preprocess by MIM +mim download mmpose --dataset coco2017 +``` + +### 已支持的数据集 + +下面是支持的数据集列表，更多数据集将在之后持续更新： + +#### 人体数据集 + +| Dataset name | Download command | +| ------------- | ----------------------------------------- | +| COCO 2017 | `mim download mmpose --dataset coco2017` | +| MPII | `mim download mmpose --dataset mpii` | +| AI Challenger | `mim download mmpose --dataset aic` | +| CrowdPose | `mim download mmpose --dataset crowdpose` | + +#### 人脸数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------ | +| LaPa | `mim download mmpose --dataset lapa` | +| 300W | `mim download mmpose --dataset 300w` | +| WFLW | `mim download mmpose --dataset wflw` | + +#### 手部数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------------ | +| OneHand10K | `mim download mmpose --dataset onehand10k` | +| FreiHand | `mim download mmpose --dataset freihand` | +| HaGRID | `mim download mmpose --dataset hagrid` | + +#### 全身数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------- | +| Halpe | `mim download mmpose --dataset halpe` | + +#### 动物数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------- | +| AP-10K | `mim download mmpose --dataset ap10k` | + +#### 服装数据集 + +Coming Soon diff --git a/internlm_langchain/knowledge_base/MMPose/content/projects.md b/internlm_langchain/knowledge_base/MMPose/content/projects.md new file mode 100644 index 00000000..460d8583 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/projects.md @@ -0,0 +1,20 @@ +# Projects based on MMPose + +There are many projects built upon MMPose. We list some of them as examples of how to extend MMPose for your own projects. As the page might not be completed, please feel free to create a PR to update this page. + +## Projects as an extension + +Some projects extend the boundary of MMPose for deployment or other research fields. They reveal the potential of what MMPose can do. We list several of them as below. + +- [Anime Face Detector](https://github.com/hysts/anime-face-detector): An anime face landmark detection toolbox. +- [PosePipeline](https://github.com/peabody124/PosePipeline): Open-Source Human Pose Estimation Pipeline for Clinical Research + +## Projects of papers + +There are also projects released with papers. Some of the papers are published in top-tier conferences (CVPR, ICCV, and ECCV), the others are also highly influential. We list some of these works as a reference for the community to develop and compare new pose estimation algorithms. Methods already supported and maintained by MMPose are not listed. + +- Pose for Everything: Towards Category-Agnostic Pose Estimation, ECCV 2022. [\[paper\]](https://arxiv.org/abs/2207.10387)[\[github\]](https://github.com/luminxu/Pose-for-Everything) +- UniFormer: Unified Transformer for Efficient Spatiotemporal Representation Learning, ICLR 2022. [\[paper\]](https://arxiv.org/abs/2201.04676)[\[github\]](https://github.com/Sense-X/UniFormer) +- Poseur:Direct Human Pose Regression with Transformers, ECCV 2022. [\[paper\]](https://arxiv.org/abs/2201.07412)[\[github\]](https://github.com/aim-uofa/Poseur) +- ViTAEv2: Vision Transformer Advanced by Exploring Inductive Bias for Image Recognition and Beyond, NeurIPS 2022. [\[paper\]](https://arxiv.org/abs/2106.03348)[\[github\]](https://github.com/ViTAE-Transformer/ViTAE-Transformer) +- Dite-HRNet:Dynamic Lightweight High-Resolution Network for Human Pose Estimation, IJCAI-ECAI 2021. [\[paper\]](https://arxiv.org/abs/2204.10762)[\[github\]](https://github.com/ZiyiZhang27/Dite-HRNet) diff --git a/internlm_langchain/knowledge_base/MMPose/content/pytorch_2.md b/internlm_langchain/knowledge_base/MMPose/content/pytorch_2.md new file mode 100644 index 00000000..4892e554 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/pytorch_2.md @@ -0,0 +1,14 @@ +# PyTorch 2.0 Compatibility and Benchmarks + +MMPose 1.0.0 is now compatible with PyTorch 2.0, ensuring that users can leverage the latest features and performance improvements offered by the PyTorch 2.0 framework when using MMPose. With the integration of inductor, users can expect faster model speeds. The table below shows several example models: + +| Model | Training Speed | Memory | +| :-------- | :---------------------: | :-----------: | +| ViTPose-B | 29.6% ↑ (0.931 → 0.655) | 10586 → 10663 | +| ViTPose-S | 33.7% ↑ (0.563 → 0.373) | 6091 → 6170 | +| HRNet-w32 | 12.8% ↑ (0.553 → 0.482) | 9849 → 10145 | +| HRNet-w48 | 37.1% ↑ (0.437 → 0.275) | 7319 → 7394 | +| RTMPose-t | 6.3% ↑ (1.533 → 1.437) | 6292 → 6489 | +| RTMPose-s | 13.1% ↑ (1.645 → 1.430) | 9013 → 9208 | + +- Pytorch 2.0 test, add projects doc and refactor by @LareinaM in [PR#2136](https://github.com/open-mmlab/mmpose/pull/2136) diff --git a/internlm_langchain/knowledge_base/MMPose/content/quick_run.md b/internlm_langchain/knowledge_base/MMPose/content/quick_run.md new file mode 100644 index 00000000..55c2d63b --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/quick_run.md @@ -0,0 +1,188 @@ +# 快速上手 + +在这一章里，我们将带领你走过MMPose工作流程中关键的七个步骤，帮助你快速上手： + +1. 使用预训练模型进行推理 +2. 准备数据集 +3. 准备配置文件 +4. 可视化训练图片 +5. 训练 +6. 测试 +7. 可视化 + +## 安装 + +请查看[安装指南](./installation.md)，以了解完整步骤。 + +## 快速开始 + +### 使用预训练模型进行推理 + +你可以通过以下命令来使用预训练模型对单张图片进行识别： + +```Bash +python demo/image_demo.py \ + tests/data/coco/000000000785.jpg \ + configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py\ + https://download.openmmlab.com/mmpose/top_down/deeppose/deeppose_res50_coco_256x192_rle-2ea9bb4a_20220616.pth +``` + +该命令中用到了测试图片、完整的配置文件、预训练模型，如果MMPose安装无误，将会弹出一个新窗口，对检测结果进行可视化显示： + + + +更多演示脚本的详细参数说明可以在 [模型推理](./user_guides/inference.md) 中找到。 + +### 准备数据集 + +MMPose支持各种不同的任务，我们提供了对应的数据集准备教程。 + +- [2D人体关键点](./dataset_zoo/2d_body_keypoint.md) + +- [3D人体关键点](./dataset_zoo/3d_body_keypoint.md) + +- [2D人手关键点](./dataset_zoo/2d_hand_keypoint.md) + +- [3D人手关键点](./dataset_zoo/3d_hand_keypoint.md) + +- [2D人脸关键点](./dataset_zoo/2d_face_keypoint.md) + +- [2D全身人体关键点](./dataset_zoo/2d_wholebody_keypoint.md) + +- [2D服饰关键点](./dataset_zoo/2d_fashion_landmark.md) + +- [2D动物关键点](./dataset_zoo/2d_animal_keypoint.md) + +你可以在【2D人体关键点数据集】>【COCO】下找到COCO数据集的准备教程，并按照教程完成数据集的下载和整理。 + +```{note} +在MMPose中，我们建议将COCO数据集存放到新建的 `$MMPOSE/data` 目录下。 +``` + +### 准备配置文件 + +MMPose拥有一套强大的配置系统，用于管理训练所需的一系列必要参数： + +- **通用**：环境、Hook、Checkpoint、Logger、Timer等 + +- **数据**：Dataset、Dataloader、数据增强等 + +- **训练**：优化器、学习率调整等 + +- **模型**：Backbone、Neck、Head、损失函数等 + +- **评测**：Metrics + +在`$MMPOSE/configs`目录下，我们提供了大量前沿论文方法的配置文件，可供直接使用和参考。 + +要在COCO数据集上训练基于ResNet50的RLE模型时，所需的配置文件为： + +```Bash +$MMPOSE/configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py +``` + +我们需要将配置文件中的 data_root 变量修改为COCO数据集存放路径： + +```Python +data_root = 'data/coco' +``` + +```{note} +感兴趣的读者也可以查阅 [配置文件](./user_guides/configs.md) 来进一步学习MMPose所使用的配置系统。 +``` + +### 可视化训练图片 + +在开始训练之前，我们还可以对训练图片进行可视化，检查训练图片是否正确进行了数据增强。 + +我们提供了相应的可视化脚本： + +```Bash +python tools/misc/browse_dastaset.py \ + configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py \ + --mode transformed +``` + + + +### 训练 + +确定数据无误后，运行以下命令启动训练： + +```Bash +python tools/train.py configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py +``` + +```{note} +MMPose中集成了大量实用训练trick和功能： + +- 学习率warmup和scheduling + +- ImageNet预训练权重 + +- 自动学习率缩放、自动batch size缩放 + +- CPU训练、多机多卡训练、集群训练 + +- HardDisk、LMDB、Petrel、HTTP等不同数据后端 + +- 混合精度浮点训练 + +- TensorBoard +``` + +### 测试 + +在不指定额外参数时，训练的权重和日志信息会默认存储到`$MMPOSE/work_dirs`目录下，最优的模型权重存放在`$MMPOSE/work_dir/best_coco`目录下。 + +我们可以通过如下指令测试模型在COCO验证集上的精度： + +```Bash +python tools/test.py \ + configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py \ + work_dir/best_coco/AP_epoch_20.pth +``` + +在COCO验证集上评测结果样例如下： + +```Bash + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets= 20 ] = 0.704 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets= 20 ] = 0.883 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets= 20 ] = 0.777 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets= 20 ] = 0.667 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets= 20 ] = 0.769 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 20 ] = 0.751 + Average Recall (AR) @[ IoU=0.50 | area= all | maxDets= 20 ] = 0.920 + Average Recall (AR) @[ IoU=0.75 | area= all | maxDets= 20 ] = 0.815 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets= 20 ] = 0.709 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets= 20 ] = 0.811 +08/23 12:04:42 - mmengine - INFO - Epoch(test) [3254/3254] coco/AP: 0.704168 coco/AP .5: 0.883134 coco/AP .75: 0.777015 coco/AP (M): 0.667207 coco/AP (L): 0.768644 coco/AR: 0.750913 coco/AR .5: 0.919710 coco/AR .75: 0.815334 coco/AR (M): 0.709232 coco/AR (L): 0.811334 +``` + +```{note} +如果需要测试模型在其他数据集上的表现，可以前往 [训练与测试](./user_guides/train_and_test.md) 查看。 +``` + +### 可视化 + +除了对关键点骨架的可视化以外，我们还支持对热度图进行可视化，你只需要在配置文件中设置`output_heatmap=True`： + +```Python +model = dict( + ## 内容省略 + test_cfg = dict( + ## 内容省略 + output_heatmaps=True + ) +) +``` + +或在命令行中添加`--cfg-options='model.test_cfg.output_heatmaps=True'`。 + +可视化效果如下： + + + +```{note} +如果你希望深入地学习MMPose，将其应用到自己的项目当中，我们准备了一份详细的 [迁移指南](./migration.md) 。 +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/train_and_test.md b/internlm_langchain/knowledge_base/MMPose/content/train_and_test.md new file mode 100644 index 00000000..452eddc9 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/train_and_test.md @@ -0,0 +1,5 @@ +# 训练与测试 + +中文内容建设中，暂时请查阅[英文版文档](../../en/user_guides/train_and_test.md) + +如果您愿意参与中文文档的翻译与维护，我们团队将十分感谢您的贡献！欢迎加入我们的社区群与我们取得联系，或直接按照 [如何给 MMPose 贡献代码](../contribution_guide.md) 在 GitHub 上提交 Pull Request。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/useful_tools.md b/internlm_langchain/knowledge_base/MMPose/content/useful_tools.md new file mode 100644 index 00000000..f2ceb771 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/useful_tools.md @@ -0,0 +1,5 @@ +# 常用工具 + +中文内容建设中，暂时请查阅[英文版文档](../../en/user_guides/useful_tools.md) + +如果您愿意参与中文文档的翻译与维护，我们团队将十分感谢您的贡献！欢迎加入我们的社区群与我们取得联系，或直接按照 [如何给 MMPose 贡献代码](../contribution_guide.md) 在 GitHub 上提交 Pull Request。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/visualization.md b/internlm_langchain/knowledge_base/MMPose/content/visualization.md new file mode 100644 index 00000000..a584eb45 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/visualization.md @@ -0,0 +1,5 @@ +# 可视化 + +中文内容建设中，暂时请查阅[英文版文档](../../en/user_guides/visualization.md) + +如果您愿意参与中文文档的翻译与维护，我们团队将十分感谢您的贡献！欢迎加入我们的社区群与我们取得联系，或直接按照 [如何给 MMPose 贡献代码](../contribution_guide.md) 在 GitHub 上提交 Pull Request。 diff --git a/internlm_langchain/knowledge_base/MMPose/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMPose/vector_store/index.faiss new file mode 100644 index 00000000..844a8a0b Binary files /dev/null and b/internlm_langchain/knowledge_base/MMPose/vector_store/index.faiss differ diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/cam_visualization.md b/internlm_langchain/knowledge_base/MMPreTrain/content/cam_visualization.md new file mode 100644 index 00000000..94d5ed17 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPreTrain/content/cam_visualization.md @@ -0,0 +1,164 @@ +# 类别激活图（CAM）可视化 + +## 类别激活图可视化工具介绍 + +MMPretrain 提供 `tools/visualization/vis_cam.py` 工具来可视化类别激活图。请使用 `pip install "grad-cam>=1.3.6"` 安装依赖的 [pytorch-grad-cam](https://github.com/jacobgil/pytorch-grad-cam)。 + +目前支持的方法有： + +| Method | What it does | +| :----------: | :-----------------------------------------------------------------------------------------------: | +| GradCAM | 使用平均梯度对 2D 激活进行加权 | +| GradCAM++ | 类似 GradCAM，但使用了二阶梯度 | +| XGradCAM | 类似 GradCAM，但通过归一化的激活对梯度进行了加权 | +| EigenCAM | 使用 2D 激活的第一主成分（无法区分类别，但效果似乎不错） | +| EigenGradCAM | 类似 EigenCAM，但支持类别区分，使用了激活 * 梯度的第一主成分，看起来和 GradCAM 差不多，但是更干净 | +| LayerCAM | 使用正梯度对激活进行空间加权，对于浅层有更好的效果 | + +也可以使用新版本 `pytorch-grad-cam` 支持的更多 CAM 方法，但我们尚未验证可用性。 + +**命令行**： + +```bash +python tools/visualization/vis_cam.py \ + ${IMG} \ + ${CONFIG_FILE} \ + ${CHECKPOINT} \ + [--target-layers ${TARGET-LAYERS}] \ + [--preview-model] \ + [--method ${METHOD}] \ + [--target-category ${TARGET-CATEGORY}] \ + [--save-path ${SAVE_PATH}] \ + [--vit-like] \ + [--num-extra-tokens ${NUM-EXTRA-TOKENS}] + [--aug_smooth] \ + [--eigen_smooth] \ + [--device ${DEVICE}] \ + [--cfg-options ${CFG-OPTIONS}] +``` + +**所有参数的说明**： + +- `img`：目标图片路径。 +- `config`：模型配置文件的路径。 +- `checkpoint`：权重路径。 +- `--target-layers`：所查看的网络层名称，可输入一个或者多个网络层，如果不设置，将使用最后一个`block`中的`norm`层。 +- `--preview-model`：是否查看模型所有网络层。 +- `--method`：类别激活图图可视化的方法，目前支持 `GradCAM`, `GradCAM++`, `XGradCAM`, `EigenCAM`, `EigenGradCAM`, `LayerCAM`，不区分大小写。如果不设置，默认为 `GradCAM`。 +- `--target-category`：查看的目标类别，如果不设置，使用模型检测出来的类别做为目标类别。 +- `--save-path`：保存的可视化图片的路径，默认不保存。 +- `--eigen-smooth`：是否使用主成分降低噪音，默认不开启。 +- `--vit-like`: 是否为 `ViT` 类似的 Transformer-based 网络 +- `--num-extra-tokens`: `ViT` 类网络的额外的 tokens 通道数，默认使用主干网络的 `num_extra_tokens`。 +- `--aug-smooth`：是否使用测试时增强 +- `--device`：使用的计算设备，如果不设置，默认为'cpu'。 +- `--cfg-options`：对配置文件的修改，参考[学习配置文件](../user_guides/config.md)。 + +```{note} +在指定 `--target-layers` 时，如果不知道模型有哪些网络层，可使用命令行添加 `--preview-model` 查看所有网络层名称； +``` + +## 如何可视化 CNN 网络的类别激活图（如 ResNet-50） + +`--target-layers` 在 `Resnet-50` 中的一些示例如下： + +- `'backbone.layer4'`，表示第四个 `ResLayer` 层的输出。 +- `'backbone.layer4.2'` 表示第四个 `ResLayer` 层中第三个 `BottleNeck` 块的输出。 +- `'backbone.layer4.2.conv1'` 表示上述 `BottleNeck` 块中 `conv1` 层的输出。 + +1. 使用不同方法可视化 `ResNet50`，默认 `target-category` 为模型检测的结果，使用默认推导的 `target-layers`。 + + ```shell + python tools/visualization/vis_cam.py \ + demo/bird.JPEG \ + configs/resnet/resnet50_8xb32_in1k.py \ + https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_batch256_imagenet_20200708-cfb998bf.pth \ + --method GradCAM + # GradCAM++, XGradCAM, EigenCAM, EigenGradCAM, LayerCAM + ``` + + | Image | GradCAM | GradCAM++ | EigenGradCAM | LayerCAM | + | ------------------------------------ | --------------------------------------- | ----------------------------------------- | -------------------------------------------- | ---------------------------------------- | + |
| 
| 
| 
| 
|
+
+2. 同一张图不同类别的激活图效果图，在 `ImageNet` 数据集中，类别 238 为 'Greater Swiss Mountain dog'，类别 281 为 'tabby, tabby cat'。
+
+ ```shell
+ python tools/visualization/vis_cam.py \
+ demo/cat-dog.png configs/resnet/resnet50_8xb32_in1k.py \
+ https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_batch256_imagenet_20200708-cfb998bf.pth \
+ --target-layers 'backbone.layer4.2' \
+ --method GradCAM \
+ --target-category 238
+ # --target-category 281
+ ```
+
+ | Category | Image | GradCAM | XGradCAM | LayerCAM |
+ | -------- | ---------------------------------------------- | ------------------------------------------------ | ------------------------------------------------- | ------------------------------------------------- |
+ | Dog | 
| 
| 
| 
|
+ | Cat | | 
| 
| 
|
+
+3. 使用 `--eigen-smooth` 以及 `--aug-smooth` 获取更好的可视化效果。
+
+ ```shell
+ python tools/visualization/vis_cam.py \
+ demo/dog.jpg \
+ configs/mobilenet_v3/mobilenet-v3-large_8xb128_in1k.py \
+ https://download.openmmlab.com/mmclassification/v0/mobilenet_v3/convert/mobilenet_v3_large-3ea3c186.pth \
+ --target-layers 'backbone.layer16' \
+ --method LayerCAM \
+ --eigen-smooth --aug-smooth
+ ```
+
+ | Image | LayerCAM | eigen-smooth | aug-smooth | eigen&aug |
+ | ------------------------------------ | --------------------------------------- | ------------------------------------------- | ----------------------------------------- | ----------------------------------------- |
+ | 
| 
| 
| 
| 
|
+
+## 如何可视化 Transformer 类型网络的类别激活图
+
+`--target-layers` 在 Transformer-based 网络中的一些示例如下：
+
+- Swin-Transformer 中：`'backbone.norm3'`
+- ViT 中：`'backbone.layers.11.ln1'`
+
+对于 Transformer-based 的网络，比如 ViT、T2T-ViT 和 Swin-Transformer，特征是被展平的。为了绘制 CAM 图，我们需要指定 `--vit-like` 选项，从而让被展平的特征恢复方形的特征图。
+
+除了特征被展平之外，一些类 ViT 的网络还会添加额外的 tokens。比如 ViT 和 T2T-ViT 中添加了分类 token，DeiT 中还添加了蒸馏 token。在这些网络中，分类计算在最后一个注意力模块之后就已经完成了，分类得分也只和这些额外的 tokens 有关，与特征图无关，也就是说，分类得分对这些特征图的导数为 0。因此，我们不能使用最后一个注意力模块的输出作为 CAM 绘制的目标层。
+
+另外，为了去除这些额外的 toekns 以获得特征图，我们需要知道这些额外 tokens 的数量。MMPretrain 中几乎所有 Transformer-based 的网络都拥有 `num_extra_tokens` 属性。而如果你希望将此工具应用于新的，或者第三方的网络，而且该网络没有指定 `num_extra_tokens` 属性，那么可以使用 `--num-extra-tokens` 参数手动指定其数量。
+
+1. 对 `Swin Transformer` 使用默认 `target-layers` 进行 CAM 可视化：
+
+ ```shell
+ python tools/visualization/vis_cam.py \
+ demo/bird.JPEG \
+ configs/swin_transformer/swin-tiny_16xb64_in1k.py \
+ https://download.openmmlab.com/mmclassification/v0/swin-transformer/swin_tiny_224_b16x64_300e_imagenet_20210616_090925-66df6be6.pth \
+ --vit-like
+ ```
+
+2. 对 `Vision Transformer(ViT)` 进行 CAM 可视化：
+
+ ```shell
+ python tools/visualization/vis_cam.py \
+ demo/bird.JPEG \
+ configs/vision_transformer/vit-base-p16_64xb64_in1k-384px.py \
+ https://download.openmmlab.com/mmclassification/v0/vit/finetune/vit-base-p16_in21k-pre-3rdparty_ft-64xb64_in1k-384_20210928-98e8652b.pth \
+ --vit-like \
+ --target-layers 'backbone.layers.11.ln1'
+ ```
+
+3. 对 `T2T-ViT` 进行 CAM 可视化：
+
+ ```shell
+ python tools/visualization/vis_cam.py \
+ demo/bird.JPEG \
+ configs/t2t_vit/t2t-vit-t-14_8xb64_in1k.py \
+ https://download.openmmlab.com/mmclassification/v0/t2t-vit/t2t-vit-t-14_3rdparty_8xb64_in1k_20210928-b7c09b62.pth \
+ --vit-like \
+ --target-layers 'backbone.encoder.12.ln1'
+ ```
+
+| Image | ResNet50 | ViT | Swin | T2T-ViT |
+| --------------------------------------- | ------------------------------------------ | -------------------------------------- | --------------------------------------- | ------------------------------------------ |
+| | 
| 
| 
| 
|
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/changelog.md b/internlm_langchain/knowledge_base/MMPreTrain/content/changelog.md
new file mode 100644
index 00000000..a0dabe10
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMPreTrain/content/changelog.md differ
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/complexity_analysis.md b/internlm_langchain/knowledge_base/MMPreTrain/content/complexity_analysis.md
new file mode 100644
index 00000000..83e76325
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/complexity_analysis.md
@@ -0,0 +1,80 @@
+# 模型复杂度分析
+
+## 计算 FLOPs 和参数数量（实验性的）
+
+我们根据 [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/analysis/complexity_analysis.py) 提供了一个脚本用于计算给定模型的 FLOPs 和参数量。
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+所有参数说明：
+
+- `config` : 配置文件的路径。
+- `--shape`: 输入尺寸，支持单值或者双值， 如： `--shape 256`、`--shape 224 256`。默认为`224 224`。
+
+示例：
+
+```shell
+python tools/analysis_tools/get_flops.py configs/resnet/resnet50_8xb32_in1k.py
+```
+
+你将获得如下结果：
+
+```text
+==============================
+Input shape: (3, 224, 224)
+Flops: 4.109G
+Params: 25.557M
+Activation: 11.114M
+==============================
+```
+
+同时，你会得到每层的详细复杂度信息，如下所示：
+
+```text
++--------------------------+----------------------+-----------+--------------+
+| module | #parameters or shape | #flops | #activations |
++--------------------------+----------------------+-----------+--------------+
+| model | 25.557M | 4.109G | 11.114M |
+| backbone | 23.508M | 4.109G | 11.114M |
+| backbone.conv1 | 9.408K | 0.118G | 0.803M |
+| backbone.conv1.weight | (64, 3, 7, 7) | | |
+| backbone.bn1 | 0.128K | 1.606M | 0 |
+| backbone.bn1.weight | (64,) | | |
+| backbone.bn1.bias | (64,) | | |
+| backbone.layer1 | 0.216M | 0.677G | 4.415M |
+| backbone.layer1.0 | 75.008K | 0.235G | 2.007M |
+| backbone.layer1.1 | 70.4K | 0.221G | 1.204M |
+| backbone.layer1.2 | 70.4K | 0.221G | 1.204M |
+| backbone.layer2 | 1.22M | 1.034G | 3.111M |
+| backbone.layer2.0 | 0.379M | 0.375G | 1.305M |
+| backbone.layer2.1 | 0.28M | 0.22G | 0.602M |
+| backbone.layer2.2 | 0.28M | 0.22G | 0.602M |
+| backbone.layer2.3 | 0.28M | 0.22G | 0.602M |
+| backbone.layer3 | 7.098M | 1.469G | 2.158M |
+| backbone.layer3.0 | 1.512M | 0.374G | 0.652M |
+| backbone.layer3.1 | 1.117M | 0.219G | 0.301M |
+| backbone.layer3.2 | 1.117M | 0.219G | 0.301M |
+| backbone.layer3.3 | 1.117M | 0.219G | 0.301M |
+| backbone.layer3.4 | 1.117M | 0.219G | 0.301M |
+| backbone.layer3.5 | 1.117M | 0.219G | 0.301M |
+| backbone.layer4 | 14.965M | 0.81G | 0.627M |
+| backbone.layer4.0 | 6.04M | 0.373G | 0.326M |
+| backbone.layer4.1 | 4.463M | 0.219G | 0.151M |
+| backbone.layer4.2 | 4.463M | 0.219G | 0.151M |
+| head.fc | 2.049M | | |
+| head.fc.weight | (1000, 2048) | | |
+| head.fc.bias | (1000,) | | |
+| neck.gap | | 0.1M | 0 |
++--------------------------+----------------------+-----------+--------------+
+```
+
+```{warning}
+警告
+
+此工具仍处于试验阶段，我们不保证该数字正确无误。您最好将结果用于简单比较，但在技术报告或论文中采用该结果之前，请仔细检查。
+
+- FLOPs 与输入的尺寸有关，而参数量与输入尺寸无关。默认输入尺寸为 (1, 3, 224, 224)
+- 一些运算不会被计入 FLOPs 的统计中，例如某些自定义运算。详细信息请参考 [`mmengine.analysis.complexity_analysis._DEFAULT_SUPPORTED_FLOP_OPS`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/analysis/complexity_analysis.py)。
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/config.md b/internlm_langchain/knowledge_base/MMPreTrain/content/config.md
new file mode 100644
index 00000000..c6013f28
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/config.md
@@ -0,0 +1,412 @@
+# 学习配置文件
+
+为了管理深度学习实验的各种设置，我们使用配置文件来记录所有这些配置。这种配置文件系统具有模块化和继承特性，更多细节可以在{external+mmengine:doc}`MMEngine 中的教程 `。
+
+MMPretrain 主要使用 python 文件作为配置文件，所有配置文件都放置在 [`configs`](https://github.com/open-mmlab/mmpretrain/tree/main/configs) 文件夹下，目录结构如下所示：
+
+```text
+MMPretrain/
+ ├── configs/
+ │ ├── _base_/ # primitive configuration folder
+ │ │ ├── datasets/ # primitive datasets
+ │ │ ├── models/ # primitive models
+ │ │ ├── schedules/ # primitive schedules
+ │ │ └── default_runtime.py # primitive runtime setting
+ │ ├── beit/ # BEiT Algorithms Folder
+ │ ├── mae/ # MAE Algorithms Folder
+ │ ├── mocov2/ # MoCoV2 Algorithms Folder
+ │ ├── resnet/ # ResNet Algorithms Folder
+ │ ├── swin_transformer/ # Swin Algorithms Folder
+ │ ├── vision_transformer/ # ViT Algorithms Folder
+ │ ├── ...
+ └── ...
+```
+
+可以使用 `python tools/misc/print_config.py /PATH/TO/CONFIG` 命令来查看完整的配置信息，从而方便检查所对应的配置文件。
+
+本文主要讲解 MMPretrain 配置文件的命名和结构，以及如何基于已有的配置文件修改，并以 [ResNet50 配置文件](https://github.com/open-mmlab/mmpretrain/blob/main/configs/resnet/resnet50_8xb32_in1k.py) 逐行解释。
+
+## 配置文件结构
+
+在 `configs/_base_` 文件夹下有 4 个基本组件类型，分别是：
+
+- [模型(model)](https://github.com/open-mmlab/mmpretrain/tree/main/configs/_base_/models)
+- [数据(data)](https://github.com/open-mmlab/mmpretrain/tree/main/configs/_base_/datasets)
+- [训练策略(schedule)](https://github.com/open-mmlab/mmpretrain/tree/main/configs/_base_/schedules)
+- [运行设置(runtime)](https://github.com/open-mmlab/mmpretrain/blob/main/configs/_base_/default_runtime.py)
+
+你可以通过继承一些基本配置文件轻松构建自己的训练配置文件。我们称这些被继承的配置文件为 _原始配置文件_，如 `_base_` 文件夹中的文件一般仅作为原始配置文件。
+
+下面使用 [ResNet50 配置文件](https://github.com/open-mmlab/mmpretrain/blob/main/configs/resnet/resnet50_8xb32_in1k.py) 作为案例进行说明并注释每一行含义。
+
+```python
+_base_ = [ # 此配置文件将继承所有 `_base_` 中的配置
+ '../_base_/models/resnet50.py', # 模型配置
+ '../_base_/datasets/imagenet_bs32.py', # 数据配置
+ '../_base_/schedules/imagenet_bs256.py', # 训练策略配置
+ '../_base_/default_runtime.py' # 默认运行设置
+]
+```
+
+我们将在下面分别解释这四个原始配置文件。
+
+### 模型配置
+
+模型原始配置文件包含一个 `model` 字典数据结构，主要包括网络结构、损失函数等信息：
+
+- `type`：算法类型，我们支持了多种任务
+ - 对于图像分类任务，通常为 `ImageClassifier`，更多细节请参考 [API 文档](mmpretrain.models.classifiers)。
+ - 对于自监督任务，有多种类型的算法，例如 `MoCoV2`, `BEiT`, `MAE` 等。更多细节请参考 [API 文档](mmpretrain.models.selfsup)。
+ - 对于图像检索任务，通常为 `ImageToImageRetriever`，更多细节请参考 [API 文档](mmpretrain.models.retrievers).
+
+通常，我们使用 **`type`字段** 来指定组件的类，并使用其他字段来传递类的初始化参数。{external+mmengine:doc}`注册器教程 ` 对其进行了详细描述。
+
+这里我们以 [`ImageClassifier`](mmpretrain.models.classifiers.ImageClassifier) 的配置字段为例，对初始化参数进行说明：
+
+- `backbone`： 主干网络设置，主干网络为主要的特征提取网络，比如 `ResNet`, `Swin Transformer`, `Vision Transformer` 等等。更多可用选项请参考 [API 文档](mmpretrain.models.backbones)。
+ - 对于自监督学习，有些主干网络需要重新实现，您可以在 [API 文档](mmpretrain.models.selfsup) 中获取更多细节。
+- `neck`： 颈网络设置，颈网络主要是连接主干网和头网络的中间部分，比如 `GlobalAveragePooling` 等，更多可用选项请参考 [API 文档](mmpretrain.models.necks)。
+- `head`： 头网络设置，头网络主要是与具体任务关联的部件，如图像分类、自监督训练等，更多可用选项请参考 [API 文档](mmpretrain.models.heads)。
+ - `loss`： 损失函数设置， 支持 `CrossEntropyLoss`, `LabelSmoothLoss`, `PixelReconstructionLoss` 等，更多可用选项参考 [API 文档](mmpretrain.models.losses)。
+- `data_preprocessor`: 图像输入的预处理模块，输入在进入模型前的预处理操作，例如 `ClsDataPreprocessor`, 有关详细信息，请参阅 [API 文档](mmpretrain.models.utils.data_preprocessor)。
+- `train_cfg`: `ImageClassifier` 的额外训练配置。在 `ImageClassifier` 中，我们使用这一参数指定批数据增强设置，比如 `Mixup` 和 `CutMix`。详见[文档](mmpretrain.models.utils.batch_augments)。
+
+以下是 ResNet50 的模型配置['configs/_base_/models/resnet50.py'](https://github.com/open-mmlab/mmpretrain/blob/main/configs/_base_/models/resnet50.py)：
+
+```python
+model = dict(
+ type='ImageClassifier', # 主模型类型（对于图像分类任务，使用 `ImageClassifier`）
+ backbone=dict(
+ type='ResNet', # 主干网络类型
+ # 除了 `type` 之外的所有字段都来自 `ResNet` 类的 __init__ 方法
+ # 可查阅 https://mmpretrain.readthedocs.io/zh_CN/latest/api/generated/mmpretrain.models.backbones.ResNet.html
+ depth=50,
+ num_stages=4, # 主干网络状态(stages)的数目，这些状态产生的特征图作为后续的 head 的输入。
+ out_indices=(3, ), # 输出的特征图输出索引。
+ frozen_stages=-1, # 冻结主干网的层数
+ style='pytorch'),
+ neck=dict(type='GlobalAveragePooling'), # 颈网络类型
+ head=dict(
+ type='LinearClsHead', # 分类颈网络类型
+ # 除了 `type` 之外的所有字段都来自 `LinearClsHead` 类的 __init__ 方法
+ # 可查阅 https://mmpretrain.readthedocs.io/zh_CN/latest/api/generated/mmpretrain.models.heads.LinearClsHead.html
+ num_classes=1000,
+ in_channels=2048,
+ loss=dict(type='CrossEntropyLoss', loss_weight=1.0), # 损失函数配置信息
+ topk=(1, 5), # 评估指标，Top-k 准确率， 这里为 top1 与 top5 准确率
+ ))
+```
+
+### 数据
+
+数据原始配置文件主要包括预处理设置、dataloader 以及 评估器等设置：
+
+- `data_preprocessor`: 模型输入预处理配置，与 `model.data_preprocessor` 相同，但优先级更低。
+- `train_evaluator | val_evaluator | test_evaluator`: 构建评估器，参考 [API 文档](mmpretrain.evaluation)。
+- `train_dataloader | val_dataloader | test_dataloader`: 构建 dataloader
+ - `batch_size`: 每个 GPU 的 batch size
+ - `num_workers`: 每个 GPU 的线程数
+ - `sampler`: 采样器配置
+ - `dataset`: 数据集配置
+ - `type`: 数据集类型， MMPretrain 支持 `ImageNet`、 `Cifar` 等数据集 ，参考 [API 文档](mmpretrain.datasets)
+ - `pipeline`: 数据处理流水线，参考相关教程文档 [如何设计数据处理流水线](../advanced_guides/pipeline.md)
+
+以下是 ResNet50 的数据配置 ['configs/_base_/datasets/imagenet_bs32.py'](https://github.com/open-mmlab/mmpretrain/blob/main/configs/_base_/datasets/imagenet_bs32.py)：
+
+```python
+dataset_type = 'ImageNet'
+# 预处理配置
+data_preprocessor = dict(
+ # 输入的图片数据通道以 'RGB' 顺序
+ mean=[123.675, 116.28, 103.53], # 输入图像归一化的 RGB 通道均值
+ std=[58.395, 57.12, 57.375], # 输入图像归一化的 RGB 通道标准差
+ to_rgb=True, # 是否将通道翻转，从 BGR 转为 RGB 或者 RGB 转为 BGR
+)
+
+train_pipeline = [
+ dict(type='LoadImageFromFile'), # 读取图像
+ dict(type='RandomResizedCrop', scale=224), # 随机放缩裁剪
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'), # 随机水平翻转
+ dict(type='PackInputs'), # 准备图像以及标签
+]
+
+test_pipeline = [
+ dict(type='LoadImageFromFile'), # 读取图像
+ dict(type='ResizeEdge', scale=256, edge='short'), # 缩放短边尺寸至 256px
+ dict(type='CenterCrop', crop_size=224), # 中心裁剪
+ dict(type='PackInputs'), # 准备图像以及标签
+]
+
+# 构造训练集 dataloader
+train_dataloader = dict(
+ batch_size=32, # 每张 GPU 的 batchsize
+ num_workers=5, # 每个 GPU 的线程数
+ dataset=dict( # 训练数据集
+ type=dataset_type,
+ data_root='data/imagenet',
+ ann_file='meta/train.txt',
+ data_prefix='train',
+ pipeline=train_pipeline),
+ sampler=dict(type='DefaultSampler', shuffle=True), # 默认采样器
+ persistent_workers=True, # 是否保持进程，可以缩短每个 epoch 的准备时间
+)
+
+# 构造验证集 dataloader
+val_dataloader = dict(
+ batch_size=32,
+ num_workers=5,
+ dataset=dict(
+ type=dataset_type,
+ data_root='data/imagenet',
+ ann_file='meta/val.txt',
+ data_prefix='val',
+ pipeline=test_pipeline),
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ persistent_workers=True,
+)
+# 验证集评估设置，使用准确率为指标， 这里使用 topk1 以及 top5 准确率
+val_evaluator = dict(type='Accuracy', topk=(1, 5))
+
+test_dataloader = val_dataloader # test dataloader 配置，这里直接与 val_dataloader 相同
+test_evaluator = val_evaluator # 测试集的评估配置，这里直接与 val_evaluator 相同
+```
+
+```{note}
+预处理配置（`data_preprocessor`）既可以作为 `model` 的一个子字段，也可以定义在外部的 `data_preprocessor` 字段，
+同时配置时，优先使用 `model.data_preprocessor` 的配置。
+```
+
+### 训练策略
+
+训练策略原始配置文件主要包括预优化器设置和训练、验证及测试的循环控制器(LOOP)：
+
+- `optim_wrapper`: 优化器装饰器配置信息，我们使用优化器装饰配置优化进程。
+ - `optimizer`: 支持 `pytorch` 所有的优化器，参考相关 {external+mmengine:doc}`MMEngine ` 文档。
+ - `paramwise_cfg`: 根据参数的类型或名称设置不同的优化参数，参考相关 [学习策略文档](../advanced_guides/schedule.md) 文档。
+ - `accumulative_counts`: 积累几个反向传播后再优化参数，你可以用它通过小批量来模拟大批量。
+- `param_scheduler` : 学习率策略，你可以指定训练期间的学习率和动量曲线。有关详细信息，请参阅 MMEngine 中的 {external+mmengine:doc}`文档 `。
+- `train_cfg | val_cfg | test_cfg`: 训练、验证以及测试的循环执行器配置，请参考相关的{external+mmengine:doc}`MMEngine 文档 `。
+
+以下是 ResNet50 的训练策略配置['configs/_base_/schedules/imagenet_bs256.py'](https://github.com/open-mmlab/mmpretrain/blob/main/configs/_base_/schedules/imagenet_bs256.py)：
+
+```python
+optim_wrapper = dict(
+ # 使用 SGD 优化器来优化参数
+ optimizer=dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.0001))
+
+# 学习率参数的调整策略
+# 'MultiStepLR' 表示使用多步策略来调度学习率（LR）。
+param_scheduler = dict(
+ type='MultiStepLR', by_epoch=True, milestones=[30, 60, 90], gamma=0.1)
+
+# 训练的配置，迭代 100 个 epoch，每一个训练 epoch 后都做验证集评估
+# 'by_epoch=True' 默认使用 `EpochBaseLoop`, 'by_epoch=False' 默认使用 `IterBaseLoop`
+train_cfg = dict(by_epoch=True, max_epochs=100, val_interval=1)
+# 使用默认的验证循环控制器
+val_cfg = dict()
+# 使用默认的测试循环控制器
+test_cfg = dict()
+
+# 通过默认策略自动缩放学习率，此策略适用于总批次大小 256
+# 如果你使用不同的总批量大小，比如 512 并启用自动学习率缩放
+# 我们将学习率扩大到 2 倍
+auto_scale_lr = dict(base_batch_size=256)
+```
+
+### 运行设置
+
+本部分主要包括保存权重策略、日志配置、训练参数、断点权重路径和工作目录等等。
+
+以下是几乎所有算法都使用的运行配置['configs/_base_/default_runtime.py'](https://github.com/open-mmlab/mmpretrain/blob/main//configs/_base_/default_runtime.py)：
+
+```python
+# 默认所有注册器使用的域
+default_scope = 'mmpretrain'
+
+# 配置默认的 hook
+default_hooks = dict(
+ # 记录每次迭代的时间。
+ timer=dict(type='IterTimerHook'),
+
+ # 每 100 次迭代打印一次日志。
+ logger=dict(type='LoggerHook', interval=100),
+
+ # 启用默认参数调度 hook。
+ param_scheduler=dict(type='ParamSchedulerHook'),
+
+ # 每个 epoch 保存检查点。
+ checkpoint=dict(type='CheckpointHook', interval=1),
+
+ # 在分布式环境中设置采样器种子。
+ sampler_seed=dict(type='DistSamplerSeedHook'),
+
+ # 验证结果可视化，默认不启用，设置 True 时启用。
+ visualization=dict(type='VisualizationHook', enable=False),
+)
+
+# 配置环境
+env_cfg = dict(
+ # 是否开启 cudnn benchmark
+ cudnn_benchmark=False,
+
+ # 设置多进程参数
+ mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+
+ # 设置分布式参数
+ dist_cfg=dict(backend='nccl'),
+)
+
+# 设置可视化工具
+vis_backends = [dict(type='LocalVisBackend')] # 使用磁盘(HDD)后端
+visualizer = dict(
+ type='UniversalVisualizer', vis_backends=vis_backends, name='visualizer')
+
+# 设置日志级别
+log_level = 'INFO'
+
+# 从哪个检查点加载
+load_from = None
+
+# 是否从加载的检查点恢复训练
+resume = False
+```
+
+## 继承并修改配置文件
+
+为了精简代码、更快的修改配置文件以及便于理解，我们建议继承现有方法。
+
+对于在同一算法文件夹下的所有配置文件，MMPretrain 推荐只存在 **一个** 对应的 _原始配置_ 文件。
+所有其他的配置文件都应该继承 _原始配置_ 文件，这样就能保证配置文件的最大继承深度为 3。
+
+例如，如果在 ResNet 的基础上做了一些修改，用户首先可以通过指定 `_base_ = './resnet50_8xb32_in1k.py'`（相对于你的配置文件的路径），来继承基础的 ResNet 结构、数据集以及其他训练配置信息，然后修改配置文件中的必要参数以完成继承。如想在基础 resnet50 的基础上使用 `CutMix` 训练增强，将训练轮数由 100 改为 300 和修改学习率衰减轮数，同时修改数据集路径，可以建立新的配置文件 `configs/resnet/resnet50_8xb32-300e_in1k.py`， 文件中写入以下内容：
+
+```python
+# 在 'configs/resnet/' 创建此文件
+_base_ = './resnet50_8xb32_in1k.py'
+
+# 模型在之前的基础上使用 CutMix 训练增强
+model = dict(
+ train_cfg=dict(
+ augments=dict(type='CutMix', alpha=1.0)
+ )
+)
+
+# 优化策略在之前基础上训练更多个 epoch
+train_cfg = dict(max_epochs=300, val_interval=10) # 训练 300 个 epoch，每 10 个 epoch 评估一次
+param_scheduler = dict(step=[150, 200, 250]) # 学习率调整也有所变动
+
+# 使用自己的数据集目录
+train_dataloader = dict(
+ dataset=dict(data_root='mydata/imagenet/train'),
+)
+val_dataloader = dict(
+ batch_size=64, # 验证时没有反向传播，可以使用更大的 batchsize
+ dataset=dict(data_root='mydata/imagenet/val'),
+)
+test_dataloader = dict(
+ batch_size=64, # 测试时没有反向传播，可以使用更大的 batchsize
+ dataset=dict(data_root='mydata/imagenet/val'),
+)
+```
+
+### 使用配置文件里的中间变量
+
+用一些中间变量，中间变量让配置文件更加清晰，也更容易修改。
+
+例如数据集里的 `train_pipeline` / `test_pipeline` 是作为数据流水线的中间变量。我们首先要定义它们，然后将它们传递到 `train_dataloader` / `test_dataloader` 中。如果想修改训练或测试时输入图片的大小，就需要修改 `train_pipeline` / `test_pipeline` 这些中间变量。
+
+```python
+bgr_mean = [103.53, 116.28, 123.675]
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='RandomResizedCrop', scale=224, backend='pillow', interpolation='bicubic'),
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'),
+ dict(
+ type='RandAugment',
+ policies='timm_increasing',
+ num_policies=2,
+ total_level=10,
+ magnitude_level=6,
+ magnitude_std=0.5,
+ hparams=dict(pad_val=[round(x) for x in bgr_mean], interpolation='bicubic')),
+ dict(type='PackInputs'),
+]
+
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='ResizeEdge', scale=236, edge='short', backend='pillow', interpolation='bicubic'),
+ dict(type='CenterCrop', crop_size=224),
+ dict(type='PackInputs')
+]
+
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=val_pipeline))
+test_dataloader = dict(dataset=dict(pipeline=val_pipeline))
+```
+
+### 忽略基础配置文件里的部分内容
+
+有时，您需要设置 `_delete_=True` 去忽略基础配置文件里的一些域内容。可以查看 {external+mmengine:doc}`MMEngine 文档 ` 进一步了解该设计。
+
+以下是一个简单应用案例。 如果在上述 ResNet50 案例中 使用余弦调度 ,使用继承并直接修改会报 `get unexcepected keyword 'step'` 错，因为基础配置文件 `param_scheduler` 域信息的 `'step'` 字段被保留下来了，需要加入 `_delete_=True` 去忽略基础配置文件里的 `param_scheduler` 相关域内容：
+
+```python
+_base_ = '../../configs/resnet/resnet50_8xb32_in1k.py'
+
+# 学习率调整策略
+param_scheduler = dict(type='CosineAnnealingLR', by_epoch=True, _delete_=True)
+```
+
+### 引用基础配置文件里的变量
+
+有时，您可以引用 `_base_` 配置信息的一些域内容，这样可以避免重复定义。可以查看 {external+mmengine:doc}`MMEngine 文档 ` 进一步了解该设计。
+
+以下是一个简单应用案例，在训练数据预处理流水线中使用 `auto augment` 数据增强，参考配置文件 [`configs/resnest/resnest50_32xb64_in1k.py`](https://github.com/open-mmlab/mmpretrain/blob/main/configs/resnest/resnest50_32xb64_in1k.py)。 在定义 `train_pipeline` 时，可以直接在 `_base_` 中加入定义 auto augment 数据增强的文件命名，再通过 `{{_base_.auto_increasing_policies}}` 引用变量：
+
+```python
+_base_ = [
+ '../_base_/models/resnest50.py', '../_base_/datasets/imagenet_bs64.py',
+ '../_base_/default_runtime.py', './_randaug_policies.py',
+]
+
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(
+ type='RandAugment',
+ policies={{_base_.policies}}, # 这里使用了 _base_ 里的 `policies` 参数。
+ num_policies=2,
+ magnitude_level=12),
+ dict(type='EfficientNetRandomCrop', scale=224, backend='pillow'),
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'),
+ dict(type='ColorJitter', brightness=0.4, contrast=0.4, saturation=0.4),
+ dict(
+ type='Lighting',
+ eigval=EIGVAL,
+ eigvec=EIGVEC,
+ alphastd=0.1,
+ to_rgb=False),
+ dict(type='PackInputs'),
+]
+
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+```
+
+## 通过命令行参数修改配置信息
+
+当用户使用脚本 "tools/train.py" 或者 "tools/test.py" 提交任务，以及使用一些工具脚本时，可以通过指定 `--cfg-options` 参数来直接修改所使用的配置文件内容。
+
+- 更新配置文件内的字典
+
+ 可以按照原始配置文件中字典的键的顺序指定配置选项。
+ 例如，`--cfg-options model.backbone.norm_eval=False` 将主干网络中的所有 BN 模块更改为 `train` 模式。
+
+- 更新配置文件内列表的键
+
+ 一些配置字典在配置文件中会形成一个列表。例如，训练流水线 `data.train.pipeline` 通常是一个列表。
+ 例如，`[dict(type='LoadImageFromFile'), dict(type='TopDownRandomFlip', flip_prob=0.5), ...]` 。如果要将流水线中的 `'flip_prob=0.5'` 更改为 `'flip_prob=0.0'`，您可以这样指定 `--cfg-options data.train.pipeline.1.flip_prob=0.0` 。
+
+- 更新列表/元组的值。
+
+ 当配置文件中需要更新的是一个列表或者元组，例如，配置文件通常会设置 `val_evaluator = dict(type='Accuracy', topk=(1, 5))`，用户如果想更改 `topk`，
+ 需要指定 `--cfg-options val_evaluator.topk="(1,3)"`。注意这里的引号 " 对于列表以及元组数据类型的修改是必要的，
+ 并且 **不允许** 引号内所指定的值的书写存在空格。
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/confusion_matrix.md b/internlm_langchain/knowledge_base/MMPreTrain/content/confusion_matrix.md
new file mode 100644
index 00000000..98c039c6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/confusion_matrix.md
@@ -0,0 +1,83 @@
+# 混淆矩阵
+
+MMPretrain 提供 `tools/analysis_tools/confusion_matrix.py` 工具来分析预测结果的混淆矩阵。关于混淆矩阵的介绍，可参考[链接](https://zh.wikipedia.org/zh-cn/%E6%B7%B7%E6%B7%86%E7%9F%A9%E9%98%B5)。
+
+## 命令行使用
+
+**命令行**：
+
+```shell
+python tools/analysis_tools/confusion_matrix.py \
+ ${CONFIG_FILE} \
+ ${CHECKPOINT} \
+ [--show] \
+ [--show-path] \
+ [--include-values] \
+ [--cmap ${CMAP}] \
+ [--cfg-options ${CFG-OPTIONS}]
+```
+
+**所有参数的说明**：
+
+- `config`：模型配置文件的路径。
+- `checkpoint`：权重路径。
+- `--show`：是否展示混淆矩阵的 matplotlib 可视化结果，默认不展示。
+- `--show-path`：如果 `show` 为 True，可视化结果的保存路径。
+- `--include-values`：是否在可视化结果上添加数值。
+- `--cmap`：可视化结果使用的颜色映射图，即 `cmap`，默认为 `viridis`。
+- `--cfg-options`：对配置文件的修改，参考[学习配置文件](../user_guides/config.md)。
+
+**使用示例**：
+
+```shell
+python tools/analysis_tools/confusion_matrix.py \
+ configs/resnet/resnet50_8xb16_cifar10.py \
+ https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_b16x8_cifar10_20210528-f54bfad9.pth \
+ --show
+```
+
+**输出图片**：
+
+
+
+## 基础用法
+
+```python
+>>> import torch
+>>> from mmpretrain.evaluation import ConfusionMatrix
+>>> y_pred = [0, 1, 1, 3]
+>>> y_true = [0, 2, 1, 3]
+>>> ConfusionMatrix.calculate(y_pred, y_true, num_classes=4)
+tensor([[1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 0, 1]])
+>>> # plot the confusion matrix
+>>> import matplotlib.pyplot as plt
+>>> y_score = torch.rand((1000, 10))
+>>> y_true = torch.randint(10, (1000, ))
+>>> matrix = ConfusionMatrix.calculate(y_score, y_true)
+>>> ConfusionMatrix().plot(matrix)
+>>> plt.show()
+```
+
+## 结合评估器使用
+
+```python
+>>> import torch
+>>> from mmpretrain.evaluation import ConfusionMatrix
+>>> from mmpretrain.structures import DataSample
+>>> from mmengine.evaluator import Evaluator
+>>> data_samples = [
+... DataSample().set_gt_label(i%5).set_pred_score(torch.rand(5))
+... for i in range(1000)
+... ]
+>>> evaluator = Evaluator(metrics=ConfusionMatrix())
+>>> evaluator.process(data_samples)
+>>> evaluator.evaluate(1000)
+{'confusion_matrix/result': tensor([[37, 37, 48, 43, 35],
+ [35, 51, 32, 46, 36],
+ [45, 28, 39, 42, 46],
+ [42, 40, 40, 35, 43],
+ [40, 39, 41, 37, 43]])}
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/contribution_guide.md b/internlm_langchain/knowledge_base/MMPreTrain/content/contribution_guide.md
new file mode 100644
index 00000000..2549cc28
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/contribution_guide.md
@@ -0,0 +1,62 @@
+# 参与贡献 OpenMMLab
+
+欢迎任何类型的贡献，包括但不限于
+
+- 修改拼写错误或代码错误
+- 添加文档或将文档翻译成其他语言
+- 添加新功能和新组件
+
+## 工作流程
+
+1. fork 并 pull 最新的 OpenMMLab 仓库 (MMPreTrain)
+2. 签出到一个新分支（不要使用 master 分支提交 PR）
+3. 进行修改并提交至 fork 出的自己的远程仓库
+4. 在我们的仓库中创建一个 PR
+
+```{note}
+如果你计划添加一些新的功能，并引入大量改动，请尽量首先创建一个 issue 来进行讨论。
+```
+
+## 代码风格
+
+### Python
+
+我们采用 [PEP8](https://www.python.org/dev/peps/pep-0008/) 作为统一的代码风格。
+
+我们使用下列工具来进行代码风格检查与格式化：
+
+- [flake8](https://github.com/PyCQA/flake8): Python 官方发布的代码规范检查工具，是多个检查工具的封装
+- [isort](https://github.com/timothycrosley/isort): 自动调整模块导入顺序的工具
+- [yapf](https://github.com/google/yapf): 一个 Python 文件的格式化工具。
+- [codespell](https://github.com/codespell-project/codespell): 检查单词拼写是否有误
+- [mdformat](https://github.com/executablebooks/mdformat): 检查 markdown 文件的工具
+- [docformatter](https://github.com/myint/docformatter): 一个 docstring 格式化工具。
+
+yapf 和 isort 的格式设置位于 [setup.cfg](https://github.com/open-mmlab/mmpretrain/blob/main/setup.cfg)
+
+我们使用 [pre-commit hook](https://pre-commit.com/) 来保证每次提交时自动进行代
+码检查和格式化，启用的功能包括 `flake8`, `yapf`, `isort`, `trailing whitespaces`, `markdown files`, 修复 `end-of-files`, `double-quoted-strings`,
+`python-encoding-pragma`, `mixed-line-ending`, 对 `requirments.txt`的排序等。
+pre-commit hook 的配置文件位于 [.pre-commit-config](https://github.com/open-mmlab/mmpretrain/blob/main/.pre-commit-config.yaml)
+
+在你克隆仓库后，你需要按照如下步骤安装并初始化 pre-commit hook。
+
+```shell
+pip install -U pre-commit
+```
+
+在仓库文件夹中执行
+
+```shell
+pre-commit install
+```
+
+在此之后，每次提交，代码规范检查和格式化工具都将被强制执行。
+
+```{important}
+在创建 PR 之前，请确保你的代码完成了代码规范检查，并经过了 yapf 的格式化。
+```
+
+### C++ 和 CUDA
+
+C++ 和 CUDA 的代码规范遵从 [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html)
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/convention.md b/internlm_langchain/knowledge_base/MMPreTrain/content/convention.md
new file mode 100644
index 00000000..941236b6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/convention.md
@@ -0,0 +1,114 @@
+# MMPretrain 中的约定
+
+## 模型命名规则
+
+MMPretrain 按照以下风格进行模型命名，代码库的贡献者需要遵循相同的命名规则。模型名总体分为五个部分：算法信息，模块信息，预训练信息，训练信息和数据信息。逻辑上属于不同部分的单词之间用下划线 `'_'` 连接，同一部分有多个单词用短横线 `'-'` 连接。
+
+```text
+{algorithm info}_{module info}_{pretrain info}_{training info}_{data info}
+```
+
+- `algorithm info`（可选）：算法信息，表示用以训练该模型的主要算法，如 MAE、BEiT 等
+- `module info`：模块信息，主要包含模型的主干网络名称，如 resnet、vit 等
+- `pretrain info`（可选）：预训练信息，比如预训练模型是在 ImageNet-21k 数据集上训练的等
+- `training info`：训练信息，训练策略设置，包括 batch size，schedule 以及数据增强等；
+- `data info`：数据信息，数据集名称、模态、输入尺寸等，如 imagenet, cifar 等；
+
+### 算法信息
+
+指用以训练该模型的算法名称，例如：
+
+- `simclr`
+- `mocov2`
+- `eva-mae-style`
+
+使用监督图像分类任务训练的模型可以省略这个字段。
+
+### 模块信息
+
+指模型的结构信息，一般主要包含模型的主干网络结构，`neck` 和 `head` 信息一般被省略。例如：
+
+- `resnet50`
+- `vit-base-p16`
+- `swin-base`
+
+### 预训练信息
+
+如果该模型是在预训练模型基础上，通过微调获得的，我们需要记录预训练模型的一些信息。例如：
+
+- 预训练模型的来源：`fb`、`openai`等。
+- 训练预训练模型的方法：`clip`、`mae`、`distill` 等。
+- 用于预训练的数据集：`in21k`、`laion2b`等（`in1k`可以省略）
+- 训练时长：`300e`、`1600e` 等。
+
+并非所有信息都是必要的，只需要选择用以区分不同的预训练模型的信息即可。
+
+在此字段的末尾，使用 `-pre` 作为标识符，例如 `mae-in21k-pre`。
+
+### 训练信息
+
+训练策略的一些设置，包括训练类型、 `batch size`、 `lr schedule`、 数据增强以及特殊的损失函数等等,比如:
+Batch size 信息：
+
+- 格式为`{gpu x batch_per_gpu}`, 如 `8xb32`
+
+训练类型(主要见于 transformer 网络，如 `ViT` 算法，这类算法通常分为预训练和微调两种模式):
+
+- `ft` : Finetune config，用于微调的配置文件
+- `pt` : Pretrain config，用于预训练的配置文件
+
+训练策略信息，训练策略以复现配置文件为基础，此基础不必标注训练策略。但如果在此基础上进行改进，则需注明训练策略，按照应用点位顺序排列，如：`{pipeline aug}-{train aug}-{loss trick}-{scheduler}-{epochs}`
+
+- `coslr-200e` : 使用 cosine scheduler, 训练 200 个 epoch
+- `autoaug-mixup-lbs-coslr-50e` : 使用了 `autoaug`、`mixup`、`label smooth`、`cosine scheduler`, 训练了 50 个轮次
+
+如果模型是从官方仓库等第三方仓库转换过来的，训练信息可以省略，使用 `3rdparty` 作为标识符。
+
+### 数据信息
+
+- `in1k` : `ImageNet1k` 数据集，默认使用 `224x224` 大小的图片
+- `in21k` : `ImageNet21k` 数据集，有些地方也称为 `ImageNet22k` 数据集，默认使用 `224x224` 大小的图片
+- `in1k-384px` : 表示训练的输出图片大小为 `384x384`
+- `cifar100`
+
+### 模型命名案例
+
+```text
+vit-base-p32_clip-openai-pre_3rdparty_in1k
+```
+
+- `vit-base-p32`: 模块信息
+- `clip-openai-pre`：预训练信息
+ - `clip`：预训练方法是 clip
+ - `openai`：预训练模型来自 OpenAI
+ - `pre`：预训练标识符
+- `3rdparty`：模型是从第三方仓库转换而来的
+- `in1k`：数据集信息。该模型是从 ImageNet-1k 数据集训练而来的，输入大小为 `224x224`
+
+```text
+beit_beit-base-p16_8xb256-amp-coslr-300e_in1k
+```
+
+- `beit`: 算法信息
+- `beit-base`：模块信息，由于主干网络来自 BEiT 中提出的修改版 ViT，主干网络名称也是 `beit`
+- `8xb256-amp-coslr-300e`：训练信息
+ - `8xb256`：使用 8 个 GPU，每个 GPU 的批量大小为 256
+ - `amp`：使用自动混合精度训练
+ - `coslr`：使用余弦退火学习率调度器
+ - `300e`：训练 300 个 epoch
+- `in1k`：数据集信息。该模型是从 ImageNet-1k 数据集训练而来的，输入大小为 `224x224`
+
+## 配置文件命名规则
+
+配置文件的命名与模型名称几乎相同，有几点不同：
+
+- 训练信息是必要的，不能是 `3rdparty`
+- 如果配置文件只包含主干网络设置，既没有头部设置也没有数据集设置，我们将其命名为`{module info}_headless.py`。这种配置文件通常用于大型数据集上的第三方预训练模型。
+
+### 权重命名规则
+
+权重的命名主要包括模型名称，日期和哈希值。
+
+```text
+{model_name}_{date}-{hash}.pth
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/dataset_prepare.md b/internlm_langchain/knowledge_base/MMPreTrain/content/dataset_prepare.md
new file mode 100644
index 00000000..59a0d0af
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/dataset_prepare.md
@@ -0,0 +1,351 @@
+# 准备数据集
+
+## CustomDataset
+
+[`CustomDataset`](mmpretrain.datasets.CustomDataset) 是一个通用的数据集类，供您使用自己的数据集。目前 `CustomDataset` 支持以下两种方式组织你的数据集文件：
+
+### 子文件夹方式
+
+在这种格式下，您只需要重新组织您的数据集文件夹并将所有样本放在一个文件夹中，而无需创建任何标注文件。
+
+对于监督任务（使用 `with_label=true`），我们使用子文件夹的名称作为类别名称，如下例所示，`class_x` 和 `class_y` 将被识别为类别名称。
+
+```text
+data_prefix/
+├── class_x
+│ ├── xxx.png
+│ ├── xxy.png
+│ └── ...
+│ └── xxz.png
+└── class_y
+ ├── 123.png
+ ├── nsdf3.png
+ ├── ...
+ └── asd932_.png
+```
+
+对于无监督任务（使用 `with_label=false`），我们直接加载指定文件夹下的所有样本文件：
+
+```
+data_prefix/
+├── folder_1
+│ ├── xxx.png
+│ ├── xxy.png
+│ └── ...
+├── 123.png
+├── nsdf3.png
+└── ...
+```
+
+假如你希望将之用于训练，那么配置文件中需要添加以下配置：
+
+```python
+train_dataloader = dict(
+ ...
+ # 训练数据集配置
+ dataset=dict(
+ type='CustomDataset',
+ data_prefix='path/to/data_prefix',
+ with_label=True, # 对于无监督任务，使用 False
+ pipeline=...
+ )
+)
+```
+
+```{note}
+如果要使用此格式，请不要指定 `ann_file`，或指定 `ann_file=''`。
+
+请注意，子文件夹格式需要对文件夹进行扫描，这可能会导致初始化速度变慢，尤其是对于大型数据集或慢速文件 IO。
+```
+
+### 标注文件方式
+
+标注文件格式主要使用文本文件来保存类别信息，`data_prefix` 存放图片，`ann_file` 存放标注类别信息。
+
+如下案例，dataset 目录如下：
+
+在这种格式中，我们使用文本标注文件来存储图像文件路径和对应的类别索引。
+
+对于监督任务（`with_label=true`），注释文件应在一行中包含一个样本的文件路径和类别索引，并用空格分隔，如下所示：
+
+所有这些文件路径都可以是绝对路径，也可以是相对于 `data_prefix` 的相对路径。
+
+```text
+folder_1/xxx.png 0
+folder_1/xxy.png 1
+123.png 4
+nsdf3.png 3
+...
+```
+
+```{note}
+类别的索引号从 0 开始。真实标签的值应在`[0, num_classes - 1]`范围内。
+
+此外，请使用数据集设置中的 `classes` 字段来指定每个类别的名称
+```
+
+对于无监督任务（`with_label=false`），标注文件只需要在一行中包含一个样本的文件路径，如下：
+
+```text
+folder_1/xxx.png
+folder_1/xxy.png
+123.png
+nsdf3.png
+...
+```
+
+假设整个数据集文件夹如下：
+
+```text
+data_root
+├── meta
+│ ├── test.txt # 测试数据集的标注文件
+│ ├── train.txt # 训练数据集的标注文件
+│ └── val.txt # 验证数据集的标注文件
+
+├── train
+│ ├── 123.png
+│ ├── folder_1
+│ │ ├── xxx.png
+│ │ └── xxy.png
+│ └── nsdf3.png
+├── test
+└── val
+```
+
+这是配置文件中的数据集设置的示例：
+
+```python
+# 训练数据设置
+train_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root='path/to/data_root', # `ann_flie` 和 `data_prefix` 共同的文件路径前缀
+ ann_file='meta/train.txt', # 相对于 `data_root` 的标注文件路径
+ data_prefix='train', # `ann_file` 中文件路径的前缀，相对于 `data_root`
+ classes=['A', 'B', 'C', 'D', ...], # 每个类别的名称
+ pipeline=..., # 处理数据集样本的一系列变换操作
+ )
+ ...
+)
+```
+
+```{note}
+有关如何使用 `CustomDataset` 的完整示例，请参阅[如何使用自定义数据集进行预训练](../notes/pretrain_custom_dataset.md)
+```
+
+## ImageNet
+
+ImageNet 有多个版本，但最常用的一个是 [ILSVRC 2012](http://www.image-net.org/challenges/LSVRC/2012/)。 可以通过以下步骤使用它。
+
+`````{tabs}
+
+````{group-tab} MIM 下载
+
+MIM支持使用一条命令行从 [OpenDataLab](https://opendatalab.com/) 下载并预处理 ImageNet 数据集。
+
+_需要在 [OpenDataLab 官网](https://opendatalab.com/) 注册账号并命令行登录_。
+
+```Bash
+# 安装opendatalab库
+pip install -U opendatalab
+# 登录到 OpenDataLab, 如果还没有注册，请到官网注册一个
+odl login
+# 使用 MIM 下载数据集, 最好在 $MMPreTrain 目录执行
+mim download mmpretrain --dataset imagenet1k
+```
+
+````
+
+````{group-tab} 从官网下载
+
+
+1. 注册一个帐户并登录到[下载页面](http://www.image-net.org/download-images)。
+2. 找到 ILSVRC2012 的下载链接，下载以下两个文件：
+ - ILSVRC2012_img_train.tar (~138GB)
+ - ILSVRC2012_img_val.tar (~6.3GB)
+3. 解压已下载的图片。
+
+````
+`````
+
+### ImageNet数据集目录结构
+
+我们支持两种方式组织ImageNet数据集，子目录格式和文本注释文件格式。
+
+#### 子文件夹格式
+
+我们提供了一个样例，您可以从这个[链接](https://download.openmmlab.com/mmpretrain/datasets/imagenet_1k.zip)下载和解压。数据集的目录结构应如下所示：
+
+```text
+data/imagenet/
+├── train/
+│ ├── n01440764
+│ │ ├── n01440764_10026.JPEG
+│ │ ├── n01440764_10027.JPEG
+│ │ ├── n01440764_10029.JPEG
+│ │ ├── n01440764_10040.JPEG
+│ │ ├── n01440764_10042.JPEG
+│ │ ├── n01440764_10043.JPEG
+│ │ └── n01440764_10048.JPEG
+│ ├── ...
+├── val/
+│ ├── n01440764
+│ │ ├── ILSVRC2012_val_00000293.JPEG
+│ │ ├── ILSVRC2012_val_00002138.JPEG
+│ │ ├── ILSVRC2012_val_00003014.JPEG
+│ │ └── ...
+│ ├── ...
+```
+
+#### 文本标注文件格式
+
+您可以从[此链接](https://download.openmmlab.com/mmclassification/datasets/imagenet/meta/caffe_ilsvrc12.tar.gz)下载并解压元数据，然后组织文件夹如下：
+
+```text
+data/imagenet/
+├── meta/
+│ ├── train.txt
+│ ├── test.txt
+│ └── val.txt
+├── train/
+│ ├── n01440764
+│ │ ├── n01440764_10026.JPEG
+│ │ ├── n01440764_10027.JPEG
+│ │ ├── n01440764_10029.JPEG
+│ │ ├── n01440764_10040.JPEG
+│ │ ├── n01440764_10042.JPEG
+│ │ ├── n01440764_10043.JPEG
+│ │ └── n01440764_10048.JPEG
+│ ├── ...
+├── val/
+│ ├── ILSVRC2012_val_00000001.JPEG
+│ ├── ILSVRC2012_val_00000002.JPEG
+│ ├── ILSVRC2012_val_00000003.JPEG
+│ ├── ILSVRC2012_val_00000004.JPEG
+│ ├── ...
+```
+
+### 配置
+
+当您的数据集以上述方式组织时，您可以使用具有以下配置的 [`ImageNet`](mmpretrain.datasets.ImageNet) 数据集：
+
+```python
+train_dataloader = dict(
+ ...
+ # 训练数据集配置
+ dataset=dict(
+ type='ImageNet',
+ data_root='data/imagenet/',
+ split='train',
+ pipeline=...,
+ )
+)
+
+val_dataloader = dict(
+ ...
+ # 验证数据集配置
+ dataset=dict(
+ type='ImageNet',
+ data_root='data/imagenet/',
+ split='val',
+ pipeline=...,
+ )
+)
+
+test_dataloader = val_dataloader
+```
+
+## 支持的图像分类数据集
+
+| 数据集 | split | 主页 |
+| ----------------------------------------------------------------------------------- | ----------------------------------- | ---------------------------------------------------------------------------------- |
+| [`Calthch101`](mmpretrain.datasets.Caltech101)(data_root[, split, pipeline, ...]) | ["train", "test"] | [Caltech 101](https://data.caltech.edu/records/mzrjq-6wc02) 数据集 |
+| [`CIFAR10`](mmpretrain.datasets.CIFAR10)(data_root[, split, pipeline, ...]) | ["train", "test"] | [CIFAR10](https://www.cs.toronto.edu/~kriz/cifar.html) 数据集 |
+| [`CIFAR100`](mmpretrain.datasets.CIFAR100)(data_root[, split, pipeline, ...]) | ["train", "test"] | [CIFAR100](https://www.cs.toronto.edu/~kriz/cifar.html) 数据集 |
+| [`CUB`](mmpretrain.datasets.CUB)(data_root[, split, pipeline, ...]) | ["train", "test"] | [CUB-200-2011](http://www.vision.caltech.edu/datasets/cub_200_2011/) 数据集 |
+| [`DTD`](mmpretrain.datasets.DTD)(data_root[, split, pipeline, ...]) | ["train", "val", "tranval", "test"] | [Describable Texture Dataset (DTD)](https://www.robots.ox.ac.uk/~vgg/data/dtd/) 数据集 |
+| [`FashionMNIST`](mmpretrain.datasets.FashionMNIST) (data_root[, split, pipeline, ...]) | ["train", "test"] | [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) 数据集 |
+| [`FGVCAircraft`](mmpretrain.datasets.FGVCAircraft)(data_root[, split, pipeline, ...]) | ["train", "val", "tranval", "test"] | [FGVC Aircraft](https://www.robots.ox.ac.uk/~vgg/data/fgvc-aircraft/) 数据集 |
+| [`Flowers102`](mmpretrain.datasets.Flowers102)(data_root[, split, pipeline, ...]) | ["train", "val", "tranval", "test"] | [Oxford 102 Flower](https://www.robots.ox.ac.uk/~vgg/data/flowers/102/) 数据集 |
+| [`Food101`](mmpretrain.datasets.Food101)(data_root[, split, pipeline, ...]) | ["train", "test"] | [Food101](https://data.vision.ee.ethz.ch/cvl/datasets_extra/food-101/) 数据集 |
+| [`MNIST`](mmpretrain.datasets.MNIST) (data_root[, split, pipeline, ...]) | ["train", "test"] | [MNIST](http://yann.lecun.com/exdb/mnist/) 数据集 |
+| [`OxfordIIITPet`](mmpretrain.datasets.OxfordIIITPet)(data_root[, split, pipeline, ...]) | ["tranval", test"] | [Oxford-IIIT Pets](https://www.robots.ox.ac.uk/~vgg/data/pets/) 数据集 |
+| [`Places205`](mmpretrain.datasets.Places205)(data_root[, pipeline, ...]) | - | [Places205](http://places.csail.mit.edu/downloadData.html) 数据集 |
+| [`StanfordCars`](mmpretrain.datasets.StanfordCars)(data_root[, split, pipeline, ...]) | ["train", "test"] | [StanfordCars](https://ai.stanford.edu/~jkrause/cars/car_dataset.html) 数据集 |
+| [`SUN397`](mmpretrain.datasets.SUN397)(data_root[, split, pipeline, ...]) | ["train", "test"] | [SUN397](https://vision.princeton.edu/projects/2010/SUN/) 数据集 |
+| [`VOC`](mmpretrain.datasets.VOC)(data_root[, image_set_path, pipeline, ...]) | ["train", "val", "tranval", "test"] | [Pascal VOC](http://host.robots.ox.ac.uk/pascal/VOC/) 数据集 |
+
+有些数据集主页链接可能已经失效，您可以通过[OpenDataLab](https://opendatalab.com/)下载数据集，例如 [Stanford Cars](https://opendatalab.com/Stanford_Cars/download)数据集。
+
+## OpenMMLab 2.0 标准数据集
+
+为了统一不同任务的数据集接口，便于多任务的算法模型训练，OpenMMLab 制定了 **OpenMMLab 2.0 数据集格式规范**， 数据集标注文件需符合该规范，数据集基类基于该规范去读取与解析数据标注文件。如果用户提供的数据标注文件不符合规定格式，用户可以选择将其转化为规定格式，并使用 OpenMMLab 的算法库基于该数据标注文件进行算法训练和测试。
+
+OpenMMLab 2.0 数据集格式规范规定，标注文件必须为 `json` 或 `yaml`，`yml` 或 `pickle`，`pkl` 格式；标注文件中存储的字典必须包含 `metainfo` 和 `data_list` 两个字段。其中 `metainfo` 是一个字典，里面包含数据集的元信息；`data_list` 是一个列表，列表中每个元素是一个字典，该字典定义了一个原始数据（raw data），每个原始数据包含一个或若干个训练/测试样本。
+
+假设您要使用训练数据集，那么配置文件如下所示：
+
+```
+
+{
+ 'metainfo':
+ {
+ 'classes': ('cat', 'dog'), # 'cat' 的类别序号为 0，'dog' 为 1。
+ ...
+ },
+ 'data_list':
+ [
+ {
+ 'img_path': "xxx/xxx_0.jpg",
+ 'gt_label': 0,
+ ...
+ },
+ {
+ 'img_path': "xxx/xxx_1.jpg",
+ 'gt_label': 1,
+ ...
+ },
+ ...
+ ]
+}
+```
+
+同时假设数据集存放路径如下：
+
+```text
+data
+├── annotations
+│ ├── train.json
+│ └── ...
+├── train
+│ ├── xxx/xxx_0.jpg
+│ ├── xxx/xxx_1.jpg
+│ ├── ...
+```
+
+通过以下字典构建：
+
+```python
+dataset_cfg=dict(
+ type='CustomDataset',
+ ann_file='path/to/ann_file_path',
+ data_prefix='path/to/images_folder',
+ pipeline=transfrom_list)
+```
+
+## 其他数据集
+
+MMPretrain 还支持更多其他的数据集，可以通过查阅[数据集文档](mmpretrain.datasets)获取它们的配置信息。
+
+如果需要使用一些特殊格式的数据集，您需要实现您自己的数据集类，请参阅[添加新数据集](../advanced_guides/datasets.md)。
+
+## 数据集包装
+
+MMEngine 中支持以下数据包装器，您可以参考 {external+mmengine:doc}`MMEngine 教程 ` 了解如何使用它。
+
+- {external:py:class}`~mmengine.dataset.ConcatDataset`
+- {external:py:class}`~mmengine.dataset.RepeatDataset`
+- {external:py:class}`~mmengine.dataset.ClassBalancedDataset`
+
+除上述之外，MMPretrain 还支持了[KFoldDataset](mmpretrain.datasets.KFoldDataset)，需用通过使用 `tools/kfold-cross-valid.py` 来使用它。
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/dataset_visualization.md b/internlm_langchain/knowledge_base/MMPreTrain/content/dataset_visualization.md
new file mode 100644
index 00000000..aa20251d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/dataset_visualization.md
@@ -0,0 +1,90 @@
+# 数据集可视化
+
+## 数据集可视化工具简介
+
+```bash
+python tools/visualization/browse_dataset.py \
+ ${CONFIG_FILE} \
+ [-o, --output-dir ${OUTPUT_DIR}] \
+ [-p, --phase ${DATASET_PHASE}] \
+ [-n, --show-number ${NUMBER_IMAGES_DISPLAY}] \
+ [-i, --show-interval ${SHOW_INTERRVAL}] \
+ [-m, --mode ${DISPLAY_MODE}] \
+ [-r, --rescale-factor ${RESCALE_FACTOR}] \
+ [-c, --channel-order ${CHANNEL_ORDER}] \
+ [--cfg-options ${CFG_OPTIONS}]
+```
+
+**所有参数的说明**：
+
+- `config` : 模型配置文件的路径。
+- `-o, --output-dir`: 保存图片文件夹，如果没有指定，默认为 `''`,表示不保存。
+- **`-p, --phase`**: 可视化数据集的阶段，只能为 `['train', 'val', 'test']` 之一，默认为 `'train'`。
+- **`-n, --show-number`**: 可视化样本数量。如果没有指定，默认展示数据集的所有图片。
+- `-i, --show-interval`: 浏览时，每张图片的停留间隔，单位为秒。
+- **`-m, --mode`**: 可视化的模式，只能为 `['original', 'transformed', 'concat', 'pipeline']` 之一。 默认为`'transformed'`.
+- `-r, --rescale-factor`: 在 `mode='original'` 下，可视化图片的放缩倍数，在图片过大或过小时设置。
+- `-c, --channel-order`: 图片的通道顺序，为 `['BGR', 'RGB']` 之一，默认为 `'BGR'`。
+- `--cfg-options` : 对配置文件的修改，参考[学习配置文件](../user_guides/config.md)。
+
+```{note}
+
+1. `-m, --mode` 用于设置可视化的模式，默认设置为 'transformed'。
+- 如果 `--mode` 设置为 'original'，则获取原始图片；
+- 如果 `--mode` 设置为 'transformed'，则获取预处理后的图片；
+- 如果 `--mode` 设置为 'concat'，获取原始图片和预处理后图片拼接的图片；
+- 如果 `--mode` 设置为 'pipeline'，则获得数据流水线所有中间过程图片。
+
+2. `-r, --rescale-factor` 在数据集中图片的分辨率过大或者过小时设置。比如在可视化 CIFAR 数据集时，由于图片的分辨率非常小，可将 `-r, --rescale-factor` 设置为 10。
+```
+
+## 如何可视化原始图像
+
+使用 **'original'** 模式 ：
+
+```shell
+python ./tools/visualization/browse_dataset.py ./configs/resnet/resnet101_8xb16_cifar10.py --phase val --output-dir tmp --mode original --show-number 100 --rescale-factor 10 --channel-order RGB
+```
+
+- `--phase val`: 可视化验证集，可简化为 `-p val`;
+- `--output-dir tmp`: 可视化结果保存在 "tmp" 文件夹，可简化为 `-o tmp`;
+- `--mode original`: 可视化原图，可简化为 `-m original`;
+- `--show-number 100`: 可视化 100 张图，可简化为 `-n 100`;
+- `--rescale-factor`: 图像放大 10 倍，可简化为 `-r 10`;
+- `--channel-order RGB`: 可视化图像的通道顺序为 "RGB", 可简化为 `-c RGB`。
+
+
+
+## 如何可视化处理后图像
+
+使用 **'transformed'** 模式：
+
+```shell
+python ./tools/visualization/browse_dataset.py ./configs/resnet/resnet50_8xb32_in1k.py -n 100
+```
+
+
+
+## 如何同时可视化原始图像与处理后图像
+
+使用 **'concat'** 模式：
+
+```shell
+python ./tools/visualization/browse_dataset.py configs/swin_transformer/swin-small_16xb64_in1k.py -n 10 -m concat
+```
+
+
+
+使用 **'pipeline'** 模式：
+
+```shell
+python ./tools/visualization/browse_dataset.py configs/swin_transformer/swin-small_16xb64_in1k.py -m pipeline
+```
+
+
+
+```shell
+python ./tools/visualization/browse_dataset.py configs/beit/beit_beit-base-p16_8xb256-amp-coslr-300e_in1k.py -m pipeline
+```
+
+
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/datasets.md b/internlm_langchain/knowledge_base/MMPreTrain/content/datasets.md
new file mode 100644
index 00000000..83b7959b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/datasets.md
@@ -0,0 +1,73 @@
+# 添加新数据集
+
+用户可以编写一个继承自 [BasesDataset](https://mmpretrain.readthedocs.io/zh_CN/latest/_modules/mmpretrain/datasets/base_dataset.html#BaseDataset) 的新数据集类，并重载 `load_data_list(self)` 方法，类似 [CIFAR10](https://github.com/open-mmlab/mmpretrain/blob/main/mmpretrain/datasets/cifar.py) 和 [ImageNet](https://github.com/open-mmlab/mmpretrain/blob/main/mmpretrain/datasets/imagenet.py)。
+
+通常，此方法返回一个包含所有样本的列表，其中的每个样本都是一个字典。字典中包含了必要的数据信息，例如 `img` 和 `gt_label`。
+
+假设我们将要实现一个 `Filelist` 数据集，该数据集将使用文件列表进行训练和测试。注释列表的格式如下：
+
+```text
+000001.jpg 0
+000002.jpg 1
+...
+```
+
+## 1. 创建数据集类
+
+我们可以在 `mmpretrain/datasets/filelist.py` 中创建一个新的数据集类以加载数据。
+
+```python
+from mmpretrain.registry import DATASETS
+from .base_dataset import BaseDataset
+
+
+@DATASETS.register_module()
+class Filelist(BaseDataset):
+
+ def load_data_list(self):
+ assert isinstance(self.ann_file, str)
+
+ data_list = []
+ with open(self.ann_file) as f:
+ samples = [x.strip().split(' ') for x in f.readlines()]
+ for filename, gt_label in samples:
+ img_path = add_prefix(filename, self.img_prefix)
+ info = {'img_path': img_path, 'gt_label': int(gt_label)}
+ data_list.append(info)
+ return data_list
+```
+
+## 2. 添加到库
+
+将新的数据集类加入到 `mmpretrain/datasets/__init__.py` 中：
+
+```python
+from .base_dataset import BaseDataset
+...
+from .filelist import Filelist
+
+__all__ = [
+ 'BaseDataset', ... ,'Filelist'
+]
+```
+
+### 3. 修改相关配置文件
+
+然后在配置文件中，为了使用 `Filelist`，用户可以按以下方式修改配置
+
+```python
+train_dataloader = dict(
+ ...
+ dataset=dict(
+ type='Filelist',
+ ann_file='image_list.txt',
+ pipeline=train_pipeline,
+ )
+)
+```
+
+所有继承 [`BaseDataset`](https://github.com/open-mmlab/mmpretrain/blob/main/mmpretrain/datasets/base_dataset.py) 的数据集类都具有**懒加载**以及**节省内存**的特性，可以参考相关文档 {external+mmengine:doc}`BaseDataset `。
+
+```{note}
+如果数据样本时获取的字典中，只包含了 'img_path' 不包含 'img'， 则在 pipeline 中必须包含 'LoadImgFromFile'。
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/downstream.md b/internlm_langchain/knowledge_base/MMPreTrain/content/downstream.md
new file mode 100644
index 00000000..0744f1e3
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/downstream.md
@@ -0,0 +1,125 @@
+# 下游任务
+
+## 检测
+
+我们使用 MMDetection 进行图像检测。首先确保您已经安装了 [MIM](https://github.com/open-mmlab/mim)，这也是 OpenMMLab 的一个项目。
+
+```shell
+pip install openmim
+mim install 'mmdet>=3.0.0rc0'
+```
+
+此外，请参考 MMDetection 的[安装](https://mmdetection.readthedocs.io/en/dev-3.x/get_started.html)和[数据准备](https://mmdetection.readthedocs.io/en/dev-3.x/user_guides/dataset_prepare.html)
+
+### 训练
+
+安装完后，您可以使用如下的简单命令运行 MMDetection。
+
+```shell
+# distributed version
+bash tools/benchmarks/mmdetection/mim_dist_train_c4.sh ${CONFIG} ${PRETRAIN} ${GPUS}
+bash tools/benchmarks/mmdetection/mim_dist_train_fpn.sh ${CONFIG} ${PRETRAIN} ${GPUS}
+
+# slurm version
+bash tools/benchmarks/mmdetection/mim_slurm_train_c4.sh ${PARTITION} ${CONFIG} ${PRETRAIN}
+bash tools/benchmarks/mmdetection/mim_slurm_train_fpn.sh ${PARTITION} ${CONFIG} ${PRETRAIN}
+```
+
+- `${CONFIG}`：直接用 MMDetection 中的配置文件路径即可。对于一些算法，我们有一些修改过的配置文件，
+ 可以在相应算法文件夹下的 `benchmarks` 文件夹中找到。另外，您也可以从头开始编写配置文件。
+- `${PRETRAIN}`：预训练模型文件
+- `${GPUS}`：使用多少 GPU 进行训练，对于检测任务，我们默认使用 8 个 GPU。
+
+例子：
+
+```shell
+bash ./tools/benchmarks/mmdetection/mim_dist_train_c4.sh \
+ configs/byol/benchmarks/mask-rcnn_r50-c4_ms-1x_coco.py \
+ https://download.openmmlab.com/mmselfsup/1.x/byol/byol_resnet50_16xb256-coslr-200e_in1k/byol_resnet50_16xb256-coslr-200e_in1k_20220825-de817331.pth 8
+```
+
+### 测试
+
+在训练之后，您可以运行如下命令测试您的模型。
+
+```shell
+# distributed version
+bash tools/benchmarks/mmdetection/mim_dist_test.sh ${CONFIG} ${CHECKPOINT} ${GPUS}
+
+# slurm version
+bash tools/benchmarks/mmdetection/mim_slurm_test.sh ${PARTITION} ${CONFIG} ${CHECKPOINT}
+```
+
+备注：
+
+- `${CHECKPOINT}`：您想测试的训练好的检测模型。
+
+例子：
+
+```shell
+bash ./tools/benchmarks/mmdetection/mim_dist_test.sh \
+configs/benchmarks/mmdetection/coco/mask-rcnn_r50_fpn_ms-1x_coco.py \
+https://download.openmmlab.com/mmselfsup/1.x/byol/byol_resnet50_16xb256-coslr-200e_in1k/byol_resnet50_16xb256-coslr-200e_in1k_20220825-de817331.pth 8
+```
+
+## 分割
+
+我们使用 MMSegmentation 进行图像分割。首先确保您已经安装了 [MIM](https://github.com/open-mmlab/mim)，这也是 OpenMMLab 的一个项目。
+
+```shell
+pip install openmim
+mim install 'mmsegmentation>=1.0.0rc0'
+```
+
+此外，请参考 MMSegmentation 的[安装](https://mmsegmentation.readthedocs.io/en/dev-1.x/get_started.html)和[数据准备](https://mmsegmentation.readthedocs.io/en/dev-1.x/user_guides/2_dataset_prepare.html)。
+
+### 训练
+
+在安装完后，可以使用如下简单命令运行 MMSegmentation。
+
+```shell
+# distributed version
+bash tools/benchmarks/mmsegmentation/mim_dist_train.sh ${CONFIG} ${PRETRAIN} ${GPUS}
+
+# slurm version
+bash tools/benchmarks/mmsegmentation/mim_slurm_train.sh ${PARTITION} ${CONFIG} ${PRETRAIN}
+```
+
+备注：
+
+- `${CONFIG}`：直接用 MMSegmentation 中的配置文件路径即可。对于一些算法，我们有一些修改过的配置文件，
+ 可以在相应算法文件夹下的 `benchmarks` 文件夹中找到。另外，您也可以从头开始编写配置文件。
+- `${PRETRAIN}`：预训练模型文件
+- `${GPUS}`：使用多少 GPU 进行训练，对于检测任务，我们默认使用 8 个 GPU。
+
+例子：
+
+```shell
+bash ./tools/benchmarks/mmsegmentation/mim_dist_train.sh \
+configs/benchmarks/mmsegmentation/voc12aug/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py \
+https://download.openmmlab.com/mmselfsup/1.x/byol/byol_resnet50_16xb256-coslr-200e_in1k/byol_resnet50_16xb256-coslr-200e_in1k_20220825-de817331.pth 4
+```
+
+### 测试
+
+在训练之后，您可以运行如下命令测试您的模型。
+
+```shell
+# distributed version
+bash tools/benchmarks/mmsegmentation/mim_dist_test.sh ${CONFIG} ${CHECKPOINT} ${GPUS}
+
+# slurm version
+bash tools/benchmarks/mmsegmentation/mim_slurm_test.sh ${PARTITION} ${CONFIG} ${CHECKPOINT}
+```
+
+备注：
+
+- `${CHECKPOINT}`：您想测试的训练好的分割模型。
+
+例子：
+
+```shell
+bash ./tools/benchmarks/mmsegmentation/mim_dist_test.sh \
+configs/benchmarks/mmsegmentation/voc12aug/fcn_r50-d8_4xb4-20k_voc12aug-512x512.py \
+https://download.openmmlab.com/mmselfsup/1.x/byol/byol_resnet50_16xb256-coslr-200e_in1k/byol_resnet50_16xb256-coslr-200e_in1k_20220825-de817331.pth 4
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/evaluation.md b/internlm_langchain/knowledge_base/MMPreTrain/content/evaluation.md
new file mode 100644
index 00000000..32db1975
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/evaluation.md
@@ -0,0 +1,97 @@
+# 自定义评估指标
+
+## 使用 MMPretrain 中的指标
+
+在 MMPretrain 中，我们为单标签分类和多标签分类提供了多种指标：
+
+**单标签分类**:
+
+- [`Accuracy`](mmpretrain.evaluation.Accuracy)
+- [`SingleLabelMetric`](mmpretrain.evaluation.SingleLabelMetric)，包括精度、召回率、f1-score 和支持度。
+
+**多标签分类**:
+
+- [`AveragePrecision`](mmpretrain.evaluation.AveragePrecision)， 或 AP (mAP)。
+- [`MultiLabelMetric`](mmpretrain.evaluation.MultiLabelMetric)，包括精度、召回率、f1-score 和支持度。
+
+要在验证和测试期间使用这些指标，我们需要修改配置文件中的 `val_evaluator` 和 `test_evaluator` 字段。
+
+以下为几个例子：
+
+1. 在验证和测试期间计算 top-1 和 top-5 准确率。
+
+ ```python
+ val_evaluator = dict(type='Accuracy', topk=(1, 5))
+ test_evaluator = val_evaluator
+ ```
+
+2. 在验证和测试期间计算 top-1 准确率、top-5 准确度、精确度和召回率。
+
+ ```python
+ val_evaluator = [
+ dict(type='Accuracy', topk=(1, 5)),
+ dict(type='SingleLabelMetric', items=['precision', 'recall']),
+ ]
+ test_evaluator = val_evaluator
+ ```
+
+3. 计算 mAP（平均平均精度）、CP（类别平均精度）、CR（类别平均召回率）、CF（类别平均 F1 分数）、OP（总体平均精度）、OR（总体平均召回率）和 OF1（总体平均 F1 分数）。
+
+ ```python
+ val_evaluator = [
+ dict(type='AveragePrecision'),
+ dict(type='MultiLabelMetric', average='macro'), # class-wise mean
+ dict(type='MultiLabelMetric', average='micro'), # overall mean
+ ]
+ test_evaluator = val_evaluator
+ ```
+
+## 添加新的指标
+
+MMPretrain 支持为追求更高定制化的用户实现定制化的评估指标。
+
+您需要在 `mmpretrain/evaluation/metrics` 下创建一个新文件，并在该文件中实现新的指标，例如，在 `mmpretrain/evaluation/metrics/my_metric.py` 中。并创建一个自定义的评估指标类 `MyMetric` 继承 [MMEngine 中的 BaseMetric](mmengine.evaluator.BaseMetric)。
+
+需要分别覆盖数据格式处理方法`process`和度量计算方法`compute_metrics`。 将其添加到“METRICS”注册表以实施任何自定义评估指标。
+
+```python
+from mmengine.evaluator import BaseMetric
+from mmpretrain.registry import METRICS
+
+@METRICS.register_module()
+class MyMetric(BaseMetric):
+
+ def process(self, data_batch: Sequence[Dict], data_samples: Sequence[Dict]):
+ """ The processed results should be stored in ``self.results``, which will
+ be used to computed the metrics when all batches have been processed.
+ `data_batch` stores the batch data from dataloader,
+ and `data_samples` stores the batch outputs from model.
+ """
+ ...
+
+ def compute_metrics(self, results: List):
+ """ Compute the metrics from processed results and returns the evaluation results.
+ """
+ ...
+```
+
+然后，将其导入 `mmpretrain/evaluation/metrics/__init__.py` 以将其添加到 `mmpretrain.evaluation` 包中。
+
+```python
+# In mmpretrain/evaluation/metrics/__init__.py
+...
+from .my_metric import MyMetric
+
+__all__ = [..., 'MyMetric']
+```
+
+最后，在配置文件的 `val_evaluator` 和 `test_evaluator` 字段中使用 `MyMetric`。
+
+```python
+val_evaluator = dict(type='MyMetric', ...)
+test_evaluator = val_evaluator
+```
+
+```{note}
+更多的细节可以参考 {external+mmengine:doc}`MMEngine 文档: Evaluation `.
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/faq.md b/internlm_langchain/knowledge_base/MMPreTrain/content/faq.md
new file mode 100644
index 00000000..efd2ff5e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/faq.md
@@ -0,0 +1,100 @@
+# 常见问题
+
+我们在这里列出了一些常见问题及其相应的解决方案。如果您发现任何常见问题并有方法
+帮助解决，欢迎随时丰富列表。如果这里的内容没有涵盖您的问题，请按照
+[提问模板](https://github.com/open-mmlab/mmpretrain/issues/new/choose)
+在 GitHub 上提出问题，并补充模板中需要的信息。
+
+## 安装
+
+- MMEngine, MMCV 与 MMPretrain 的兼容问题
+
+ 这里我们列举了各版本 MMPretrain 对 MMEngine 和 MMCV 版本的依赖，请选择合适的 MMEngine 和 MMCV 版本来避免安装和使用中的问题。
+
+ | MMPretrain 版本 | MMEngine 版本 | MMCV 版本 |
+ | :-------------: | :---------------: | :--------------: |
+ | 1.0.2 (main) | mmengine >= 0.8.3 | mmcv >= 2.0.0 |
+ | 1.0.0 | mmengine >= 0.8.0 | mmcv >= 2.0.0 |
+ | 1.0.0rc8 | mmengine >= 0.7.1 | mmcv >= 2.0.0rc4 |
+ | 1.0.0rc7 | mmengine >= 0.5.0 | mmcv >= 2.0.0rc4 |
+
+ ```{note}
+ 由于 `dev` 分支处于频繁开发中，MMEngine 和 MMCV 版本依赖可能不准确。如果您在使用
+ `dev` 分支时遇到问题，请尝试更新 MMEngine 和 MMCV 到最新版。
+ ```
+
+- 使用 Albumentations
+
+ 如果你希望使用 `albumentations` 相关的功能，我们建议使用 `pip install -r requirements/optional.txt` 或者
+ `pip install -U albumentations>=0.3.2 --no-binary qudida,albumentations` 命令进行安装。
+
+ 如果你直接使用 `pip install albumentations>=0.3.2` 来安装，它会同时安装 `opencv-python-headless`
+ （即使你已经安装了 `opencv-python`）。具体细节可参阅
+ [官方文档](https://albumentations.ai/docs/getting_started/installation/#note-on-opencv-dependencies)。
+
+## 通用问题
+
+### 如果我对源码进行了改动，需要重新安装以使改动生效吗？
+
+如果你遵照[最佳实践](../get_started.md#最佳实践)的指引，从源码安装 mmpretrain，那么任何本地修改都不需要重新安装即可生效。
+
+### 如何在多个 MMPretrain 版本下进行开发？
+
+通常来说，我们推荐通过不同虚拟环境来管理多个开发目录下的 MMPretrain。
+但如果你希望在不同目录（如 mmpretrain-0.21, mmpretrain-0.23 等）使用同一个环境进行开发，
+我们提供的训练和测试 shell 脚本会自动使用当前目录的 mmpretrain，其他 Python 脚本
+则可以在命令前添加 `` PYTHONPATH=`pwd` `` 来使用当前目录的代码。
+
+反过来，如果你希望 shell 脚本使用环境中安装的 MMPretrain，而不是当前目录的，
+则可以去掉 shell 脚本中如下一行代码：
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```
+
+### `load_from` 和 `init_cfg` 之间的关系是什么？
+
+- `load_from`: 如果`resume=False`，只导入模型权重，主要用于加载训练过的模型；
+ 如果 `resume=True` ，加载所有的模型权重、优化器状态和其他训练信息，主要用于恢复中断的训练。
+
+- `init_cfg`: 你也可以指定`init=dict(type="Pretrained", checkpoint=xxx)`来加载权重，
+ 表示在模型权重初始化时加载权重，通常在训练的开始阶段执行。
+ 主要用于微调预训练模型，你可以在骨干网络的配置中配置它，还可以使用 `prefix` 字段来只加载对应的权重，例如：
+
+ ```python
+ model = dict(
+ backbone=dict(
+ type='ResNet',
+ depth=50,
+ init_cfg=dict(type='Pretrained', checkpoints=xxx, prefix='backbone'),
+ )
+ ...
+ )
+ ```
+
+参见 [微调模型](./finetune_custom_dataset.md) 以了解更多关于模型微调的细节。
+
+### `default_hooks` 和 `custom_hooks` 之间有什么区别？
+
+几乎没有区别。通常，`default_hooks` 字段用于指定几乎所有实验都会使用的钩子，
+而 `custom_hooks` 字段指部分实验特有的钩子。
+
+另一个区别是 `default_hooks` 是一个字典，而 `custom_hooks` 是一个列表，请不要混淆。
+
+### 在训练期间，我没有收到训练日志，这是什么原因？
+
+如果你的训练数据集很小，而批处理量却很大，我们默认的日志间隔可能太大，无法记录你的训练日志。
+
+你可以缩减日志间隔，再试一次，比如:
+
+```python
+default_hooks = dict(
+ ...
+ logger=dict(type='LoggerHook', interval=10),
+ ...
+)
+```
+
+### 如何基于其它数据集训练，例如我自己的数据集或者是 COCO 数据集？
+
+我们提供了 [具体示例](./pretrain_custom_dataset.md) 来展示如何在其它数据集上进行训练。
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/finetune_custom_dataset.md b/internlm_langchain/knowledge_base/MMPreTrain/content/finetune_custom_dataset.md
new file mode 100644
index 00000000..2b8cbd68
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/finetune_custom_dataset.md
@@ -0,0 +1,328 @@
+# 如何在自定义数据集上微调模型
+
+在很多场景下，我们需要快速地将模型应用到新的数据集上，但从头训练模型通常很难快速收敛，这种不确定性会浪费额外的时间。
+通常，已有的、在大数据集上训练好的模型会比随机初始化提供更为有效的先验信息，粗略来讲，在此基础上的学习我们称之为模型微调。
+
+已经证明，在 ImageNet 数据集上预训练的模型对于其他数据集和其他下游任务有很好的效果。
+因此，该教程提供了如何将 [Model Zoo](../modelzoo_statistics.md) 中提供的预训练模型用于其他数据集，已获得更好的效果。
+
+在本教程中，我们提供了一个实践示例和一些关于如何在自己的数据集上微调模型的技巧。
+
+## 第一步：准备你的数据集
+
+按照 [准备数据集](../user_guides/dataset_prepare.md) 准备你的数据集。
+假设我们的数据集根文件夹路径为 `data/custom_dataset/`
+
+假设我们想进行有监督图像分类训练，并使用子文件夹格式的 `CustomDataset` 来组织数据集：
+
+```text
+data/custom_dataset/
+├── train
+│ ├── class_x
+│ │ ├── x_1.png
+│ │ ├── x_2.png
+│ │ ├── x_3.png
+│ │ └── ...
+│ ├── class_y
+│ └── ...
+└── test
+ ├── class_x
+ │ ├── test_x_1.png
+ │ ├── test_x_2.png
+ │ ├── test_x_3.png
+ │ └── ...
+ ├── class_y
+ └── ...
+```
+
+## 第二步：选择一个配置文件作为模板
+
+在这里，我们使用 `configs/resnet/resnet50_8xb32_in1k.py` 作为示例。
+首先在同一文件夹下复制一份配置文件，并将其重命名为 `resnet50_8xb32-ft_custom.py`。
+
+```{tip}
+按照惯例，配置名称的最后一个字段是数据集，例如，`in1k` 表示 ImageNet-1k，`coco` 表示 coco 数据集
+```
+
+这个配置的内容是：
+
+```python
+_base_ = [
+ '../_base_/models/resnet50.py', # 模型设置
+ '../_base_/datasets/imagenet_bs32.py', # 数据设置
+ '../_base_/schedules/imagenet_bs256.py', # 训练策略设置
+ '../_base_/default_runtime.py', # 运行设置
+]
+```
+
+## 第三步：修改模型设置
+
+在进行模型微调时，我们通常希望在主干网络（backbone）加载预训练模型，再用我们的数据集训练一个新的分类头（head）。
+
+为了在主干网络加载预训练模型，我们需要修改主干网络的初始化设置，使用
+`Pretrained` 类型的初始化函数。另外，在初始化设置中，我们使用 `prefix='backbone'`
+来告诉初始化函数需要加载的子模块的前缀，`backbone`即指加载模型中的主干网络。
+方便起见，我们这里使用一个在线的权重文件链接，它
+会在训练前自动下载对应的文件，你也可以提前下载这个模型，然后使用本地路径。
+
+接下来，新的配置文件需要按照新数据集的类别数目来修改分类头的配置。只需要修改分
+类头中的 `num_classes` 设置即可。
+
+另外，当新的小数据集和原本预训练的大数据集中的数据分布较为类似的话，我们在进行微调时会希望
+冻结主干网络前面几层的参数，只训练后面层以及分类头的参数，这么做有助于在后续训练中，
+保持网络从预训练权重中获得的提取低阶特征的能力。在 MMPretrain 中，
+这一功能可以通过简单的一个 `frozen_stages` 参数来实现。比如我们需要冻结前两层网
+络的参数，只需要在上面的配置中添加一行：
+
+```{note}
+注意，目前并非所有的主干网络都支持 `frozen_stages` 参数。请检查[文档](https://mmpretrain.readthedocs.io/en/latest/api.html#module-mmpretrain.models.backbones)
+确认使用的主干网络是否支持这一参数。
+```
+
+```python
+_base_ = [
+ '../_base_/models/resnet50.py', # 模型设置
+ '../_base_/datasets/imagenet_bs32.py', # 数据设置
+ '../_base_/schedules/imagenet_bs256.py', # 训练策略设置
+ '../_base_/default_runtime.py', # 运行设置
+]
+
+# >>>>>>>>>>>>>>> 在这里重载模型相关配置 >>>>>>>>>>>>>>>>>>>
+model = dict(
+ backbone=dict(
+ frozen_stages=2,
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint='https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb32_in1k_20210831-ea4938fc.pth',
+ prefix='backbone',
+ )),
+ head=dict(num_classes=10),
+)
+# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+```
+
+```{tip}
+这里我们只需要设定我们想要修改的部分配置，其他配置将会自动从我们的基配置文件中获取。
+```
+
+## 第四步：修改数据集设置
+
+为了在新数据集上进行微调，我们需要覆盖一些数据集设置，例如数据集类型、数据流水线等。
+
+```python
+_base_ = [
+ '../_base_/models/resnet50.py', # 模型设置
+ '../_base_/datasets/imagenet_bs32.py', # 数据设置
+ '../_base_/schedules/imagenet_bs256.py', # 训练策略设置
+ '../_base_/default_runtime.py', # 运行设置
+]
+
+# 模型设置
+model = dict(
+ backbone=dict(
+ frozen_stages=2,
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint='https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb32_in1k_20210831-ea4938fc.pth',
+ prefix='backbone',
+ )),
+ head=dict(num_classes=10),
+)
+
+# >>>>>>>>>>>>>>> 在这里重载数据配置 >>>>>>>>>>>>>>>>>>>
+data_root = 'data/custom_dataset'
+train_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='', # 我们假定使用子文件夹格式，因此需要将标注文件置空
+ data_prefix='train',
+ ))
+val_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='', # 我们假定使用子文件夹格式，因此需要将标注文件置空
+ data_prefix='test',
+ ))
+test_dataloader = val_dataloader
+# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+```
+
+## 第五步：修改训练策略设置（可选）
+
+微调所使用的训练超参数一般与默认的超参数不同，它通常需要更小的学习率和更快的学习率衰减。
+
+```python
+_base_ = [
+ '../_base_/models/resnet50.py', # 模型设置
+ '../_base_/datasets/imagenet_bs32.py', # 数据设置
+ '../_base_/schedules/imagenet_bs256.py', # 训练策略设置
+ '../_base_/default_runtime.py', # 运行设置
+]
+
+# 模型设置
+model = dict(
+ backbone=dict(
+ frozen_stages=2,
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint='https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb32_in1k_20210831-ea4938fc.pth',
+ prefix='backbone',
+ )),
+ head=dict(num_classes=10),
+)
+
+# 数据设置
+data_root = 'data/custom_dataset'
+train_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='',
+ data_prefix='train',
+ ))
+val_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='',
+ data_prefix='test',
+ ))
+test_dataloader = val_dataloader
+
+# >>>>>>>>>>>>>>> 在这里重载训练策略设置 >>>>>>>>>>>>>>>>>>>
+# 优化器超参数
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001))
+# 学习率策略
+param_scheduler = dict(
+ type='MultiStepLR', by_epoch=True, milestones=[15], gamma=0.1)
+# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+```
+
+```{tip}
+更多关于配置文件的信息，请参阅[学习配置文件](../user_guides/config.md)
+```
+
+## 开始训练
+
+现在，我们完成了用于微调的配置文件，完整的文件如下：
+
+```python
+_base_ = [
+ '../_base_/models/resnet50.py', # 模型设置
+ '../_base_/datasets/imagenet_bs32.py', # 数据设置
+ '../_base_/schedules/imagenet_bs256.py', # 训练策略设置
+ '../_base_/default_runtime.py', # 运行设置
+]
+
+# 模型设置
+model = dict(
+ backbone=dict(
+ frozen_stages=2,
+ init_cfg=dict(
+ type='Pretrained',
+ checkpoint='https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb32_in1k_20210831-ea4938fc.pth',
+ prefix='backbone',
+ )),
+ head=dict(num_classes=10),
+)
+
+# 数据设置
+data_root = 'data/custom_dataset'
+train_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='',
+ data_prefix='train',
+ ))
+val_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='',
+ data_prefix='test',
+ ))
+test_dataloader = val_dataloader
+
+# 训练策略设置
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001))
+param_scheduler = dict(
+ type='MultiStepLR', by_epoch=True, milestones=[15], gamma=0.1)
+```
+
+接下来，我们使用一台 8 张 GPU 的电脑来训练我们的模型，指令如下：
+
+```shell
+bash tools/dist_train.sh configs/resnet/resnet50_8xb32-ft_custom.py 8
+```
+
+当然，我们也可以使用单张 GPU 来进行训练，使用如下命令：
+
+```shell
+python tools/train.py configs/resnet/resnet50_8xb32-ft_custom.py
+```
+
+但是如果我们使用单张 GPU 进行训练的话，需要在数据集设置部分作如下修改：
+
+```python
+data_root = 'data/custom_dataset'
+train_dataloader = dict(
+ batch_size=256,
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='',
+ data_prefix='train',
+ ))
+val_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root=data_root,
+ ann_file='',
+ data_prefix='test',
+ ))
+test_dataloader = val_dataloader
+```
+
+这是因为我们的训练策略是针对批次大小（batch size）为 256 设置的。在父配置文件中，
+设置了单张 `batch_size=32`，如果使用 8 张 GPU，总的批次大小就是 256。而如果使
+用单张 GPU，就必须手动修改 `batch_size=256` 来匹配训练策略。
+
+然而，更大的批次大小需要更大的 GPU 显存，这里有几个简单的技巧来节省显存：
+
+1. 启用自动混合精度训练
+
+ ```shell
+ python tools/train.py configs/resnet/resnet50_8xb32-ft_custom.py --amp
+ ```
+
+2. 使用较小的批次大小，例如仍然使用 `batch_size=32`，而不是 256，并启用学习率自动缩放
+
+ ```shell
+ python tools/train.py configs/resnet/resnet50_8xb32-ft_custom.py --auto-scale-lr
+ ```
+
+ 学习率自动缩放功能会根据实际的 batch size 和配置文件中的 `auto_scale_lr.base_batch_size`
+ 字段对学习率进行线性调整（你可以在基配置文件 `configs/_base_/schedules/imagenet_bs256.py`
+ 中找到这一字段）
+
+```{note}
+以上技巧都有可能对训练效果造成轻微影响。
+```
+
+### 在命令行指定预训练模型
+
+如果您不想修改配置文件，您可以使用 `--cfg-options` 将您的预训练模型文件添加到 `init_cfg`.
+
+例如，以下命令也会加载预训练模型：
+
+```shell
+bash tools/dist_train.sh configs/tutorial/resnet50_finetune_cifar.py 8 \
+ --cfg-options model.backbone.init_cfg.type='Pretrained' \
+ model.backbone.init_cfg.checkpoint='https://download.openmmlab.com/mmselfsup/1.x/mocov3/mocov3_resnet50_8xb512-amp-coslr-100e_in1k/mocov3_resnet50_8xb512-amp-coslr-100e_in1k_20220927-f1144efa.pth' \
+ model.backbone.init_cfg.prefix='backbone' \
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/get_started.md b/internlm_langchain/knowledge_base/MMPreTrain/content/get_started.md
new file mode 100644
index 00000000..0cf252f1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/get_started.md
@@ -0,0 +1,163 @@
+# 依赖环境
+
+在本节中，我们将演示如何准备 PyTorch 相关的依赖环境。
+
+MMPretrain 适用于 Linux、Windows 和 macOS。它需要 Python 3.7+、CUDA 10.2+ 和 PyTorch 1.8+。
+
+```{note}
+如果你对配置 PyTorch 环境已经很熟悉，并且已经完成了配置，可以直接进入[下一节](#安装)。
+否则的话，请依照以下步骤完成配置。
+```
+
+**第 1 步** 从[官网](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda。
+
+**第 2 步** 创建一个 conda 虚拟环境并激活它。
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**第 3 步** 按照[官方指南](https://pytorch.org/get-started/locally/)安装 PyTorch。例如：
+
+在 GPU 平台：
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+```{warning}
+以上命令会自动安装最新版的 PyTorch 与对应的 cudatoolkit，请检查它们是否与你的环境匹配。
+```
+
+在 CPU 平台：
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+# 安装
+
+我们推荐用户按照我们的最佳实践来安装 MMPretrain。但除此之外，如果你想根据
+你的习惯完成安装流程，也可以参见[自定义安装](#自定义安装)一节来获取更多信息。
+
+## 最佳实践
+
+根据具体需求，我们支持两种安装模式：
+
+- [从源码安装（推荐）](#从源码安装)：希望基于 MMPretrain 框架开发自己的预训练任务，需要添加新的功能，比如新的模型或是数据集，或者使用我们提供的各种工具。
+- [作为 Python 包安装](#作为-python-包安装)：只是希望调用 MMPretrain 的 API 接口，或者在自己的项目中导入 MMPretrain 中的模块。
+
+### 从源码安装
+
+这种情况下，从源码按如下方式安装 mmpretrain：
+
+```shell
+git clone https://github.com/open-mmlab/mmpretrain.git
+cd mmpretrain
+pip install -U openmim && mim install -e .
+```
+
+```{note}
+`"-e"` 表示以可编辑形式安装，这样可以在不重新安装的情况下，让本地修改直接生效
+```
+
+### 作为 Python 包安装
+
+直接使用 mim 安装即可。
+
+```shell
+pip install -U openmim && mim install "mmpretrain>=1.0.0rc8"
+```
+
+```{note}
+`mim` 是一个轻量级的命令行工具，可以根据 PyTorch 和 CUDA 版本为 OpenMMLab 算法库配置合适的环境。同时它也提供了一些对于深度学习实验很有帮助的功能。
+```
+
+## 安装多模态支持 (可选)
+
+MMPretrain 中的多模态模型需要额外的依赖项，要安装这些依赖项，请在安装过程中添加 `[multimodal]` 参数，如下所示：
+
+```shell
+# 从源码安装
+mim install -e ".[multimodal]"
+
+# 作为 Python 包安装
+mim install "mmpretrain[multimodal]>=1.0.0rc8"
+```
+
+## 验证安装
+
+为了验证 MMPretrain 的安装是否正确，我们提供了一些示例代码来执行模型推理。
+
+如果你是**从源码安装**的 mmpretrain，那么直接运行以下命令进行验证：
+
+```shell
+python demo/image_demo.py demo/demo.JPEG resnet18_8xb32_in1k --device cpu
+```
+
+你可以看到命令行中输出了结果字典，包括 `pred_label`，`pred_score` 和 `pred_class` 三个字段。
+
+如果你是**作为 Python 包安装**，那么可以打开你的 Python 解释器，并粘贴如下代码：
+
+```python
+from mmpretrain import get_model, inference_model
+
+model = get_model('resnet18_8xb32_in1k', device='cpu') # 或者 device='cuda:0'
+inference_model(model, 'demo/demo.JPEG')
+```
+
+你会看到输出一个字典，包含预测的标签、得分及类别名。
+
+```{note}
+以上示例中，`resnet18_8xb32_in1k` 是模型名称。你可以使用 [`mmpretrain.list_models`](mmpretrain.apis.list_models) 接口来
+浏览所有的模型，或者在[模型汇总](./modelzoo_statistics.md)页面进行查找。
+```
+
+## 自定义安装
+
+### CUDA 版本
+
+安装 PyTorch 时，需要指定 CUDA 版本。如果您不清楚选择哪个，请遵循我们的建议：
+
+- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 series 以及 NVIDIA A100，CUDA 11 是必需的。
+- 对于更早的 NVIDIA GPU，CUDA 11 是向前兼容的，但 CUDA 10.2 能够提供更好的兼容性，也更加轻量。
+
+请确保你的 GPU 驱动版本满足最低的版本需求，参阅[这张表](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。
+
+```{note}
+如果按照我们的最佳实践进行安装，CUDA 运行时库就足够了，因为我们提供相关 CUDA 代码的预编译，你不需要进行本地编译。
+但如果你希望从源码进行 MMCV 的编译，或是进行其他 CUDA 算子的开发，那么就必须安装完整的 CUDA 工具链，参见
+[NVIDIA 官网](https://developer.nvidia.com/cuda-downloads)，另外还需要确保该 CUDA 工具链的版本与 PyTorch 安装时
+的配置相匹配（如用 `conda install` 安装 PyTorch 时指定的 cudatoolkit 版本）。
+```
+
+### 在 CPU 环境中安装
+
+MMPretrain 可以仅在 CPU 环境中安装，在 CPU 模式下，你可以完成训练、测试和模型推理等所有操作。
+
+### 在 Google Colab 中安装
+
+参考 [Colab 教程](https://colab.research.google.com/github/mzr1996/mmclassification-tutorial/blob/master/1.x/MMClassification_tools.ipynb) 安装即可。
+
+### 通过 Docker 使用 MMPretrain
+
+MMPretrain 提供 [Dockerfile](https://github.com/open-mmlab/mmpretrain/blob/main/docker/Dockerfile)
+用于构建镜像。请确保你的 [Docker 版本](https://docs.docker.com/engine/install/) >=19.03。
+
+```shell
+# 构建默认的 PyTorch 1.12.1，CUDA 11.3 版本镜像
+# 如果你希望使用其他版本，请修改 Dockerfile
+docker build -t mmpretrain docker/
+```
+
+用以下命令运行 Docker 镜像：
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmpretrain/data mmpretrain
+```
+
+## 故障解决
+
+如果你在安装过程中遇到了什么问题，请先查阅[常见问题](./notes/faq.md)。如果没有找到解决方法，可以在 GitHub
+上[提出 issue](https://github.com/open-mmlab/mmpretrain/issues/new/choose)。
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/inference.md b/internlm_langchain/knowledge_base/MMPreTrain/content/inference.md
new file mode 100644
index 00000000..068e42e1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/inference.md
@@ -0,0 +1,176 @@
+# 使用现有模型进行推理
+
+本文将展示如何使用以下API：
+
+- [**`list_models`**](mmpretrain.apis.list_models): 列举 MMPretrain 中所有可用模型名称
+- [**`get_model`**](mmpretrain.apis.get_model): 通过模型名称或模型配置文件获取模型
+- [**`inference_model`**](mmpretrain.apis.inference_model): 使用与模型相对应任务的推理器进行推理。主要用作快速
+ 展示。如需配置进阶用法，还需要直接使用下列推理器。
+- 推理器:
+ 1. [**`ImageClassificationInferencer`**](mmpretrain.apis.ImageClassificationInferencer):
+ 对给定图像执行图像分类。
+ 2. [**`ImageRetrievalInferencer`**](mmpretrain.apis.ImageRetrievalInferencer):
+ 从给定的一系列图像中，检索与给定图像最相似的图像。
+ 3. [**`ImageCaptionInferencer`**](mmpretrain.apis.ImageCaptionInferencer):
+ 生成给定图像的一段描述。
+ 4. [**`VisualQuestionAnsweringInferencer`**](mmpretrain.apis.VisualQuestionAnsweringInferencer):
+ 根据给定的图像回答问题。
+ 5. [**`VisualGroundingInferencer`**](mmpretrain.apis.VisualGroundingInferencer):
+ 根据一段描述，从给定图像中找到一个与描述对应的对象。
+ 6. [**`TextToImageRetrievalInferencer`**](mmpretrain.apis.TextToImageRetrievalInferencer):
+ 从给定的一系列图像中，检索与给定文本最相似的图像。
+ 7. [**`ImageToTextRetrievalInferencer`**](mmpretrain.apis.ImageToTextRetrievalInferencer):
+ 从给定的一系列文本中，检索与给定图像最相似的文本。
+ 8. [**`NLVRInferencer`**](mmpretrain.apis.NLVRInferencer):
+ 对给定的一对图像和一段文本进行自然语言视觉推理（NLVR 任务）。
+ 9. [**`FeatureExtractor`**](mmpretrain.apis.FeatureExtractor):
+ 通过视觉主干网络从图像文件提取特征。
+
+## 列举可用模型
+
+列出 MMPreTrain 中的所有已支持的模型。
+
+```python
+>>> from mmpretrain import list_models
+>>> list_models()
+['barlowtwins_resnet50_8xb256-coslr-300e_in1k',
+ 'beit-base-p16_beit-in21k-pre_3rdparty_in1k',
+ ...]
+```
+
+`list_models` 支持 Unix 文件名风格的模式匹配，你可以使用 \*\* * \*\* 匹配任意字符。
+
+```python
+>>> from mmpretrain import list_models
+>>> list_models("*convnext-b*21k")
+['convnext-base_3rdparty_in21k',
+ 'convnext-base_in21k-pre-3rdparty_in1k-384px',
+ 'convnext-base_in21k-pre_3rdparty_in1k']
+```
+
+你还可以使用推理器的 `list_models` 方法获取对应任务可用的所有模型。
+
+```python
+>>> from mmpretrain import ImageCaptionInferencer
+>>> ImageCaptionInferencer.list_models()
+['blip-base_3rdparty_caption',
+ 'blip2-opt2.7b_3rdparty-zeroshot_caption',
+ 'flamingo_3rdparty-zeroshot_caption',
+ 'ofa-base_3rdparty-finetuned_caption']
+```
+
+## 获取模型
+
+选定需要的模型后，你可以使用 `get_model` 获取特定模型。
+
+```python
+>>> from mmpretrain import get_model
+
+# 不加载预训练权重的模型
+>>> model = get_model("convnext-base_in21k-pre_3rdparty_in1k")
+
+# 加载默认的权重文件
+>>> model = get_model("convnext-base_in21k-pre_3rdparty_in1k", pretrained=True)
+
+# 加载制定的权重文件
+>>> model = get_model("convnext-base_in21k-pre_3rdparty_in1k", pretrained="your_local_checkpoint_path")
+
+# 指定额外的模型初始化参数，例如修改 head 中的 num_classes。
+>>> model = get_model("convnext-base_in21k-pre_3rdparty_in1k", head=dict(num_classes=10))
+
+# 另外一个例子：移除模型的 neck，head 模块，直接从 backbone 中的 stage 1, 2, 3 输出
+>>> model_headless = get_model("resnet18_8xb32_in1k", head=None, neck=None, backbone=dict(out_indices=(1, 2, 3)))
+```
+
+获得的模型是一个通常的 PyTorch Module
+
+```python
+>>> import torch
+>>> from mmpretrain import get_model
+>>> model = get_model('convnext-base_in21k-pre_3rdparty_in1k', pretrained=True)
+>>> x = torch.rand((1, 3, 224, 224))
+>>> y = model(x)
+>>> print(type(y), y.shape)
+ torch.Size([1, 1000])
+```
+
+## 在给定图像上进行推理
+
+这里是一个例子，我们将使用 ResNet-50 预训练模型对给定的 [图像](https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG) 进行分类。
+
+```python
+>>> from mmpretrain import inference_model
+>>> image = 'https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG'
+>>> # 如果你没有图形界面，请设置 `show=False`
+>>> result = inference_model('resnet50_8xb32_in1k', image, show=True)
+>>> print(result['pred_class'])
+sea snake
+```
+
+上述 `inference_model` 接口可以快速进行模型推理，但它每次调用都需要重新初始化模型，也无法进行多个样本的推理。
+因此我们需要使用推理器来进行多次调用。
+
+```python
+>>> from mmpretrain import ImageClassificationInferencer
+>>> image = 'https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG'
+>>> inferencer = ImageClassificationInferencer('resnet50_8xb32_in1k')
+>>> # 注意推理器的输出始终为一个结果列表，即使输入只有一个样本
+>>> result = inferencer('https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG')[0]
+>>> print(result['pred_class'])
+sea snake
+>>>
+>>> # 你可以对多张图像进行批量推理
+>>> image_list = ['demo/demo.JPEG', 'demo/bird.JPEG'] * 16
+>>> results = inferencer(image_list, batch_size=8)
+>>> print(len(results))
+32
+>>> print(results[1]['pred_class'])
+house finch, linnet, Carpodacus mexicanus
+```
+
+通常，每个样本的结果都是一个字典。比如图像分类的结果是一个包含了 `pred_label`、`pred_score`、`pred_scores`、`pred_class` 等字段的字典：
+
+```python
+{
+ "pred_label": 65,
+ "pred_score": 0.6649366617202759,
+ "pred_class":"sea snake",
+ "pred_scores": array([..., 0.6649366617202759, ...], dtype=float32)
+}
+```
+
+你可以为推理器配置额外的参数，比如使用你自己的配置文件和权重文件，在 CUDA 上进行推理：
+
+```python
+>>> from mmpretrain import ImageClassificationInferencer
+>>> image = 'https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG'
+>>> config = 'configs/resnet/resnet50_8xb32_in1k.py'
+>>> checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb32_in1k_20210831-ea4938fc.pth'
+>>> inferencer = ImageClassificationInferencer(model=config, pretrained=checkpoint, device='cuda')
+>>> result = inferencer(image)[0]
+>>> print(result['pred_class'])
+sea snake
+```
+
+## 使用 Gradio 推理示例
+
+我们还提供了一个基于 gradio 的推理示例，提供了 MMPretrain 所支持的所有任务的推理展示功能，你可以在 [projects/gradio_demo/launch.py](https://github.com/open-mmlab/mmpretrain/blob/main/projects/gradio_demo/launch.py) 找到这一例程。
+
+请首先使用 `pip install -U gradio` 安装 `gradio` 库。
+
+这里是界面效果预览：
+
+
+
+## 从图像中提取特征
+
+与 `model.extract_feat` 相比，`FeatureExtractor` 用于直接从图像文件中提取特征，而不是从一批张量中提取特征。简单说，`model.extract_feat` 的输入是 `torch.Tensor`，`FeatureExtractor` 的输入是图像。
+
+```
+>>> from mmpretrain import FeatureExtractor, get_model
+>>> model = get_model('resnet50_8xb32_in1k', backbone=dict(out_indices=(0, 1, 2, 3)))
+>>> extractor = FeatureExtractor(model)
+>>> features = extractor('https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG')[0]
+>>> features[0].shape, features[1].shape, features[2].shape, features[3].shape
+(torch.Size([256]), torch.Size([512]), torch.Size([1024]), torch.Size([2048]))
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/log_result_analysis.md b/internlm_langchain/knowledge_base/MMPreTrain/content/log_result_analysis.md
new file mode 100644
index 00000000..748a9076
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/log_result_analysis.md
@@ -0,0 +1,223 @@
+# 日志分析工具
+
+## 日志分析
+
+### 日志分析工具介绍
+
+`tools/analysis_tools/analyze_logs.py` 脚本绘制指定键值的变化曲线。
+
+
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve \
+ ${JSON_LOGS} \
+ [--keys ${KEYS}] \
+ [--title ${TITLE}] \
+ [--legend ${LEGEND}] \
+ [--backend ${BACKEND}] \
+ [--style ${STYLE}] \
+ [--out ${OUT_FILE}] \
+ [--window-size ${WINDOW_SIZE}]
+```
+
+**所有参数的说明：**
+
+- `json_logs` : 模型配置文件的路径（可同时传入多个，使用空格分开）。
+- `--keys` : 分析日志的关键字段，数量为 `len(${JSON_LOGS}) * len(${KEYS})` 默认为 ‘loss’。
+- `--title` : 分析日志的图片名称，默认使用配置文件名， 默认为空。
+- `--legend` : 图例的名称，其数目必须与相等`len(${JSON_LOGS}) * len(${KEYS})`。 默认使用 `"${JSON_LOG}-${KEYS}"`.
+- `--backend` : matplotlib 的绘图后端，默认由 matplotlib 自动选择。
+- `--style` : 绘图配色风格，默认为 `whitegrid`。
+- `--out` : 保存分析图片的路径，如不指定则不保存。
+- `--window-size`: 可视化窗口大小，如果没有指定，默认为 `'12*7'`。如果需要指定，需按照格式 `'W*H'`。
+
+```{note}
+The `--style` option depends on `seaborn` package, please install it before setting it.
+```
+
+### 如何或绘制损失/精度曲线
+
+我们将给出一些示例，来展示如何使用 `tools/analysis_tools/analyze_logs.py`脚本绘制精度曲线的损失曲线
+
+#### 绘制某日志文件对应的损失曲线图
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve your_log_json --keys loss --legend loss
+```
+
+#### 绘制某日志文件对应的 top-1 和 top-5 准确率曲线图，并将曲线图导出为 results.jpg 文件。
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve your_log_json --keys accuracy/top1 accuracy/top5 --legend top1 top5 --out results.jpg
+```
+
+#### 在同一图像内绘制两份日志文件对应的 top-1 准确率曲线图。
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys accuracy/top1 --legend exp1 exp2
+```
+
+### 如何统计训练时间
+
+`tools/analysis_tools/analyze_logs.py` 也可以根据日志文件统计训练耗时。
+
+```shell
+python tools/analysis_tools/analyze_logs.py cal_train_time \
+ ${JSON_LOGS}
+ [--include-outliers]
+```
+
+**所有参数的说明：**
+
+- `json_logs`：模型配置文件的路径（可同时传入多个，使用空格分开）。
+- `--include-outliers`：如果指定，将不会排除每个轮次中第一个时间记录（有时第一轮迭代会耗时较长）。
+
+**示例：**
+
+```shell
+python tools/analysis_tools/analyze_logs.py cal_train_time work_dirs/your_exp/20230206_181002/vis_data/scalars.json
+```
+
+预计输出结果如下所示：
+
+```text
+-----Analyze train time of work_dirs/your_exp/20230206_181002/vis_data/scalars.json-----
+slowest epoch 68, average time is 0.3818
+fastest epoch 1, average time is 0.3694
+time std over epochs is 0.0020
+average iter time: 0.3777 s/iter
+```
+
+## 结果分析
+
+利用 `tools/test.py` 的`--out`，我们可以将所有的样本的推理结果保存到输出文件中。利用这一文件，我们可以进行进一步的分析。
+
+### 如何进行离线度量评估
+
+我们提供了 `tools/analysis_tools/eval_metric.py` 脚本，使用户能够根据预测文件评估模型。
+
+```shell
+python tools/analysis_tools/eval_metric.py \
+ ${RESULT} \
+ [--metric ${METRIC_OPTIONS} ...]
+```
+
+**所有参数说明**：
+
+- `result`：`tools/test.py` 输出的结果文件。
+- `--metric`：用于评估结果的指标，请至少指定一个指标，并且你可以通过指定多个 `--metric` 来同时计算多个指标。
+
+请参考[评估文档](mmpretrain.evaluation)选择可用的评估指标和对应的选项。
+
+```{note}
+在 `tools/test.py` 中，我们支持使用 `--out-item` 选项来选择保存何种结果至输出文件。
+请确保没有额外指定 `--out-item`，或指定了 `--out-item=pred`。
+```
+
+**示例**:
+
+```shell
+# 获取结果文件
+python tools/test.py configs/resnet/resnet18_8xb16_cifar10.py \
+ https://download.openmmlab.com/mmclassification/v0/resnet/resnet18_b16x8_cifar10_20210528-bd6371c8.pth \
+ --out results.pkl
+
+# 计算 top-1 和 top-5 准确率
+python tools/analysis_tools/eval_metric.py results.pkl --metric type=Accuracy topk=1,5
+
+# 计算总体准确率，各个类别上的精确度、召回率、F1-score
+python tools/analysis_tools/eval_metric.py results.pkl --metric type=Accuracy \
+ --metric type=SingleLabelMetric items=precision,recall,f1-score average=None
+```
+
+### 如何绘制测试结果的混淆矩阵
+
+我们提供 `tools/analysis_tools/confusion_matrix.py`，帮助用户能够从测试输出文件中绘制混淆矩阵。
+
+```shell
+python tools/analysis_tools/confusion_matrix.py \
+ ${CONFIG} \
+ ${RESULT} \
+ [--out ${OUT}] \
+ [--show] \
+ [--show-path ${SHOW_PATH}] \
+ [--include-values] \
+ [--cmap] \
+ [--cfg-options ${CFG_OPTIONS} ...] \
+```
+
+**所有参数说明**：
+
+- `config`：配置文件的路径。
+- `result`：`tools/test.py`的输出结果文件，或是模型权重文件。
+- `--out`：将混淆矩阵保存到指定路径下的 pickle 文件中。
+- `--show`：是否可视化混淆矩阵图。
+- `--show-path`：将可视化混淆矩阵图保存到指定路径下。
+- `--include-values`：是否在可视化混淆矩阵图中显示具体值。
+- `--cmap`：用以可视化混淆矩阵的颜色配置。
+- `--cfg-options`：额外的配置选项，会被合入配置文件，参考[学习配置文件](../user_guides/config.md)。
+
+```{note}
+在 `tools/test.py` 中，我们支持使用 `--out-item` 选项来选择保存何种结果至输出文件。
+请确保没有额外指定 `--out-item`，或指定了 `--out-item=pred`。
+```
+
+**Examples**:
+
+```shell
+# 获取结果文件
+python tools/test.py configs/resnet/resnet18_8xb16_cifar10.py \
+ https://download.openmmlab.com/mmclassification/v0/resnet/resnet18_b16x8_cifar10_20210528-bd6371c8.pth \
+ --out results.pkl
+
+# 将混淆矩阵计算结果保存至 cm.pkl 中
+python tools/analysis_tools/confusion_matrix.py configs/resnet/resnet18_8xb16_cifar10.py results.pkl --out cm.pkl
+
+# 可视化混淆矩阵图，并在图形窗口显示
+python tools/analysis_tools/confusion_matrix.py configs/resnet/resnet18_8xb16_cifar10.py results.pkl --show
+```
+
+### 如何将预测结果可视化
+
+我们可以使用脚本 `tools/analysis_tools/analyze_results.py` 来保存预测成功或失败时得分最高的图像。
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+ ${CONFIG} \
+ ${RESULT} \
+ [--out-dir ${OUT_DIR}] \
+ [--topk ${TOPK}] \
+ [--rescale-factor ${RESCALE_FACTOR}] \
+ [--cfg-options ${CFG_OPTIONS}]
+```
+
+**所有参数说明：**:
+
+- `config`：配置文件的路径。
+- `result`：`tools/test.py`的输出结果文件。
+- `--out_dir`：保存结果分析的文件夹路径。
+- `--topk`：分别保存多少张预测成功/失败的图像。如果不指定，默认为 `20`。
+- `--rescale-factor`：图像的缩放系数，如果样本图像过大或过小时可以使用（过小的图像可能导致结果标签非常模糊）。
+- `--cfg-options`：额外的配置选项，会被合入配置文件，参考[学习配置文件](../user_guides/config.md)。
+
+```{note}
+在 `tools/test.py` 中，我们支持使用 `--out-item` 选项来选择保存何种结果至输出文件。
+请确保没有额外指定 `--out-item`，或指定了 `--out-item=pred`。
+```
+
+**示例**:
+
+```shell
+# 获取预测结果文件
+python tools/test.py configs/resnet/resnet18_8xb16_cifar10.py \
+ https://download.openmmlab.com/mmclassification/v0/resnet/resnet18_b16x8_cifar10_20210528-bd6371c8.pth \
+ --out results.pkl
+
+# 保存预测成功/失败的图像中，得分最高的前 10 张，并在可视化时将输出图像放大 10 倍。
+python tools/analysis_tools/analyze_results.py \
+ configs/resnet/resnet18_8xb16_cifar10.py \
+ results.pkl \
+ --out-dir output \
+ --topk 10 \
+ --rescale-factor 10
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/model_serving.md b/internlm_langchain/knowledge_base/MMPreTrain/content/model_serving.md
new file mode 100644
index 00000000..12f67797
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/model_serving.md
@@ -0,0 +1,88 @@
+# TorchServe 部署
+
+为了使用 [`TorchServe`](https://pytorch.org/serve/) 部署一个 `MMPretrain` 模型，需要进行以下几步：
+
+## 1. 转换 MMPretrain 模型至 TorchServe
+
+```shell
+python tools/torchserve/mmpretrain2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+```{note}
+${MODEL_STORE} 需要是一个文件夹的绝对路径。
+```
+
+示例：
+
+```shell
+python tools/torchserve/mmpretrain2torchserve.py \
+ configs/resnet/resnet18_8xb32_in1k.py \
+ checkpoints/resnet18_8xb32_in1k_20210831-fbbb1da6.pth \
+ --output-folder ./checkpoints \
+ --model-name resnet18_in1k
+```
+
+## 2. 构建 `mmpretrain-serve` docker 镜像
+
+```shell
+docker build -t mmpretrain-serve:latest docker/serve/
+```
+
+## 3. 运行 `mmpretrain-serve` 镜像
+
+请参考官方文档 [基于 docker 运行 TorchServe](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment).
+
+为了使镜像能够使用 GPU 资源，需要安装 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)。之后可以传递 `--gpus` 参数以在 GPU 上运。
+
+示例：
+
+```shell
+docker run --rm \
+--name mar \
+--cpus 8 \
+--gpus device=0 \
+-p8080:8080 -p8081:8081 -p8082:8082 \
+--mount type=bind,source=`realpath ./checkpoints`,target=/home/model-server/model-store \
+mmpretrain-serve:latest
+```
+
+```{note}
+`realpath ./checkpoints` 是 "./checkpoints" 的绝对路径，你可以将其替换为你保存 TorchServe 模型的目录的绝对路径。
+```
+
+参考 [该文档](https://github.com/pytorch/serve/blob/master/docs/rest_api.md) 了解关于推理 (8080)，管理 (8081) 和指标 (8082) 等 API 的信息。
+
+## 4. 测试部署
+
+```shell
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T demo/demo.JPEG
+```
+
+您应该获得类似于以下内容的响应：
+
+```json
+{
+ "pred_label": 58,
+ "pred_score": 0.38102269172668457,
+ "pred_class": "water snake"
+}
+```
+
+另外，你也可以使用 `test_torchserver.py` 来比较 TorchServe 和 PyTorch 的结果，并进行可视化。
+
+```shell
+python tools/torchserve/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}]
+```
+
+示例：
+
+```shell
+python tools/torchserve/test_torchserver.py \
+ demo/demo.JPEG \
+ configs/resnet/resnet18_8xb32_in1k.py \
+ checkpoints/resnet18_8xb32_in1k_20210831-fbbb1da6.pth \
+ resnet18_in1k
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/modules.md b/internlm_langchain/knowledge_base/MMPreTrain/content/modules.md
new file mode 100644
index 00000000..cb0fac6a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/modules.md
@@ -0,0 +1,512 @@
+# 自定义模型
+
+在我们的设计中，我们定义一个完整的模型为顶层模块，根据功能的不同，基本几种不同类型的模型组件组成。
+
+- 模型：顶层模块定义了具体的任务类型，例如 `ImageClassifier` 用在图像分类任务中， `MAE` 用在自监督学习中， `ImageToImageRetriever` 用在图像检索中。
+- 主干网络：通常是一个特征提取网络，涵盖了模型之间绝大多数的差异，例如 `ResNet`、`MobileNet`。
+- 颈部：用于连接主干网络和头部的组件，例如 `GlobalAveragePooling`。
+- 头部：用于执行特定任务的组件，例如 `ClsHead`、 `ContrastiveHead`。
+- 损失函数：在头部用于计算损失函数的组件，例如 `CrossEntropyLoss`、`LabelSmoothLoss`。
+- 目标生成器: 用于自监督学习任务的组件，例如 `VQKD`、 `HOGGenerator`。
+
+## 添加新的顶层模型
+
+通常来说，对于图像分类和图像检索任务来说，模型顶层模型流程基本一致。但是不同的自监督学习算法却用不同的计算流程，像 `MAE` 和 `BEiT` 就大不相同。 所以在这个部分，我们将简单介绍如何添加一个新的自监督学习算法。
+
+### 添加新的自监督学习算法
+
+1. 创建新文件 `mmpretrain/models/selfsup/new_algorithm.py` 以及实现 `NewAlgorithm`
+
+ ```python
+ from mmpretrain.registry import MODELS
+ from .base import BaseSelfSupvisor
+
+
+ @MODELS.register_module()
+ class NewAlgorithm(BaseSelfSupvisor):
+
+ def __init__(self, backbone, neck=None, head=None, init_cfg=None):
+ super().__init__(init_cfg)
+ pass
+
+ # ``extract_feat`` function is defined in BaseSelfSupvisor, you could
+ # overwrite it if needed
+ def extract_feat(self, inputs, **kwargs):
+ pass
+
+ # the core function to compute the loss
+ def loss(self, inputs, data_samples, **kwargs):
+ pass
+
+ ```
+
+2. 在 `mmpretrain/models/selfsup/__init__.py` 中导入对应的新算法
+
+ ```python
+ ...
+ from .new_algorithm import NewAlgorithm
+
+ __all__ = [
+ ...,
+ 'NewAlgorithm',
+ ...
+ ]
+ ```
+
+3. 在配置文件中使用新算法
+
+ ```python
+ model = dict(
+ type='NewAlgorithm',
+ backbone=...,
+ neck=...,
+ head=...,
+ ...
+ )
+ ```
+
+## 添加新的主干网络
+
+这里，我们以 `ResNet_CIFAR` 为例，展示了如何开发一个新的主干网络组件。
+
+`ResNet_CIFAR` 针对 CIFAR 32x32 的图像输入，远小于大多数模型使用的ImageNet默认的224x224输入配置，所以我们将骨干网络中 `kernel_size=7,stride=2`
+的设置替换为 `kernel_size=3, stride=1`，并移除了 stem 层之后的
+`MaxPooling`，以避免传递过小的特征图到残差块中。
+
+最简单的方式就是继承自 `ResNet` 并只修改 stem 层。
+
+1. 创建一个新文件 `mmpretrain/models/backbones/resnet_cifar.py`。
+
+ ```python
+ import torch.nn as nn
+
+ from mmpretrain.registry import MODELS
+ from .resnet import ResNet
+
+
+ @MODELS.register_module()
+ class ResNet_CIFAR(ResNet):
+
+ """ResNet backbone for CIFAR.
+
+ （对这个主干网络的简短描述）
+
+ Args:
+ depth(int): Network depth, from {18, 34, 50, 101, 152}.
+ ...
+ （参数文档）
+ """
+
+ def __init__(self, depth, deep_stem=False, **kwargs):
+ # 调用基类 ResNet 的初始化函数
+ super(ResNet_CIFAR, self).__init__(depth, deep_stem=deep_stem **kwargs)
+ # 其他特殊的初始化流程
+ assert not self.deep_stem, 'ResNet_CIFAR do not support deep_stem'
+
+ def _make_stem_layer(self, in_channels, base_channels):
+ # 重载基类的方法，以实现对网络结构的修改
+ self.conv1 = build_conv_layer(
+ self.conv_cfg,
+ in_channels,
+ base_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ bias=False)
+ self.norm1_name, norm1 = build_norm_layer(
+ self.norm_cfg, base_channels, postfix=1)
+ self.add_module(self.norm1_name, norm1)
+ self.relu = nn.ReLU(inplace=True)
+
+ def forward(self, x):
+ # 如果需要的话，可以自定义forward方法
+ x = self.conv1(x)
+ x = self.norm1(x)
+ x = self.relu(x)
+ outs = []
+ for i, layer_name in enumerate(self.res_layers):
+ res_layer = getattr(self, layer_name)
+ x = res_layer(x)
+ if i in self.out_indices:
+ outs.append(x)
+ # 输出值需要是一个包含不同层多尺度输出的元组
+ # 如果不需要多尺度特征，可以直接在最终输出上包一层元组
+ return tuple(outs)
+
+ def init_weights(self):
+ # 如果需要的话，可以自定义权重初始化的方法
+ super().init_weights()
+
+ # 如果有预训练模型，则不需要进行权重初始化
+ if self.init_cfg is not None and self.init_cfg['type'] == 'Pretrained':
+ return
+
+ # 通常来说，我们建议用`init_cfg`去列举不同层权重初始化方法
+ # 包括卷积层，线性层，归一化层等等
+ # 如果有特殊需要，可以在这里进行额外的初始化操作
+ ...
+ ```
+
+```{note}
+在 OpenMMLab 2.0 的设计中，将原有的`BACKBONES`、`NECKS`、`HEADS`、`LOSSES`等注册名统一为`MODELS`.
+```
+
+2. 在 `mmpretrain/models/backbones/__init__.py` 中导入新模块
+
+ ```python
+ ...
+ from .resnet_cifar import ResNet_CIFAR
+
+ __all__ = [
+ ..., 'ResNet_CIFAR'
+ ]
+ ```
+
+3. 在配置文件中使用新的主干网络
+
+ ```python
+ model = dict(
+ ...
+ backbone=dict(
+ type='ResNet_CIFAR',
+ depth=18,
+ other_arg=xxx),
+ ...
+ ```
+
+### 为自监督学习添加新的主干网络
+
+对于一部分自监督学习算法，主干网络做了一定修改，例如 `MAE`、`BEiT` 等。 这些主干网络需要处理 `mask` 相关的逻辑，以此从可见的图像块中提取对应的特征信息。
+
+以 [MAEViT](mmpretrain.models.selfsup.MAEViT) 作为例子，我们需要重写 `forward` 函数，进行基于 `mask` 的计算。我们实现了 `init_weights` 进行特定权重的初始化和 `random_masking` 函数来生成 `MAE` 预训练所需要的 `mask`。
+
+```python
+class MAEViT(VisionTransformer):
+ """Vision Transformer for MAE pre-training"""
+
+ def __init__(mask_ratio, **kwargs) -> None:
+ super().__init__(**kwargs)
+ # position embedding is not learnable during pretraining
+ self.pos_embed.requires_grad = False
+ self.mask_ratio = mask_ratio
+ self.num_patches = self.patch_resolution[0] * self.patch_resolution[1]
+
+ def init_weights(self) -> None:
+ """Initialize position embedding, patch embedding and cls token."""
+ super().init_weights()
+ # define what if needed
+ pass
+
+ def random_masking(
+ self,
+ x: torch.Tensor,
+ mask_ratio: float = 0.75
+ ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """Generate the mask for MAE Pre-training."""
+ pass
+
+ def forward(
+ self,
+ x: torch.Tensor,
+ mask: Optional[bool] = True
+ ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """Generate features for masked images.
+
+ The function supports two kind of forward behaviors. If the ``mask`` is
+ ``True``, the function will generate mask to masking some patches
+ randomly and get the hidden features for visible patches, which means
+ the function will be executed as masked imagemodeling pre-training;
+ if the ``mask`` is ``None`` or ``False``, the forward function will
+ call ``super().forward()``, which extract features from images without
+ mask.
+ """
+ if mask is None or False:
+ return super().forward(x)
+
+ else:
+ B = x.shape[0]
+ x = self.patch_embed(x)[0]
+ # add pos embed w/o cls token
+ x = x + self.pos_embed[:, 1:, :]
+
+ # masking: length -> length * mask_ratio
+ x, mask, ids_restore = self.random_masking(x, self.mask_ratio)
+
+ # append cls token
+ cls_token = self.cls_token + self.pos_embed[:, :1, :]
+ cls_tokens = cls_token.expand(B, -1, -1)
+ x = torch.cat((cls_tokens, x), dim=1)
+
+ for _, layer in enumerate(self.layers):
+ x = layer(x)
+ # Use final norm
+ x = self.norm1(x)
+
+ return (x, mask, ids_restore)
+
+```
+
+## 添加新的颈部组件
+
+这里我们以 `GlobalAveragePooling` 为例。这是一个非常简单的颈部组件，没有任何参数。
+
+要添加新的颈部组件，我们主要需要实现 `forward` 函数，该函数对主干网络的输出进行
+一些操作并将结果传递到头部。
+
+1. 创建一个新文件 `mmpretrain/models/necks/gap.py`
+
+ ```python
+ import torch.nn as nn
+
+ from mmpretrain.registry import MODELS
+
+ @MODELS.register_module()
+ class GlobalAveragePooling(nn.Module):
+
+ def __init__(self):
+ self.gap = nn.AdaptiveAvgPool2d((1, 1))
+
+ def forward(self, inputs):
+ # 简单起见，我们默认输入是一个张量
+ outs = self.gap(inputs)
+ outs = outs.view(inputs.size(0), -1)
+ return outs
+ ```
+
+2. 在 `mmpretrain/models/necks/__init__.py` 中导入新模块
+
+ ```python
+ ...
+ from .gap import GlobalAveragePooling
+
+ __all__ = [
+ ..., 'GlobalAveragePooling'
+ ]
+ ```
+
+3. 修改配置文件以使用新的颈部组件
+
+ ```python
+ model = dict(
+ neck=dict(type='GlobalAveragePooling'),
+ )
+ ```
+
+## 添加新的头部组件
+
+### 基于分类头
+
+在此，我们以一个简化的 `VisionTransformerClsHead` 为例，说明如何开发新的头部组件。
+
+要添加一个新的头部组件，基本上我们需要实现 `pre_logits` 函数用于进入最后的分类头之前需要的处理，
+以及 `forward` 函数。
+
+1. 创建一个文件 `mmpretrain/models/heads/vit_head.py`.
+
+ ```python
+ import torch.nn as nn
+
+ from mmpretrain.registry import MODELS
+ from .cls_head import ClsHead
+
+
+ @MODELS.register_module()
+ class LinearClsHead(ClsHead):
+
+ def __init__(self, num_classes, in_channels, hidden_dim, **kwargs):
+ super().__init__(**kwargs)
+ self.in_channels = in_channels
+ self.num_classes = num_classes
+ self.hidden_dim = hidden_dim
+
+ self.fc1 = nn.Linear(in_channels, hidden_dim)
+ self.act = nn.Tanh()
+ self.fc2 = nn.Linear(hidden_dim, num_classes)
+
+ def pre_logits(self, feats):
+ # 骨干网络的输出通常包含多尺度信息的元组
+ # 对于分类任务来说，我们只需要关注最后的输出
+ feat = feats[-1]
+
+ # VisionTransformer的最终输出是一个包含patch tokens和cls tokens的元组
+ # 这里我们只需要cls tokens
+ _, cls_token = feat
+
+ # 完成除了最后的线性分类头以外的操作
+ return self.act(self.fc1(cls_token))
+
+ def forward(self, feats):
+ pre_logits = self.pre_logits(feats)
+
+ # 完成最后的分类头
+ cls_score = self.fc(pre_logits)
+ return cls_score
+ ```
+
+2. 在 `mmpretrain/models/heads/__init__.py` 中导入这个模块
+
+ ```python
+ ...
+ from .vit_head import VisionTransformerClsHead
+
+ __all__ = [
+ ..., 'VisionTransformerClsHead'
+ ]
+ ```
+
+3. 修改配置文件以使用新的头部组件。
+
+ ```python
+ model = dict(
+ head=dict(
+ type='VisionTransformerClsHead',
+ ...,
+ ))
+ ```
+
+### 基于 BaseModule 类
+
+这是一个基于 MMEngine 中的 `BaseModule` 进行开发例子，`MAEPretrainHead`，主要是为了 `MAE` 掩码学习。我们需要实现 `loss` 函数来计算损失吗，不过其它的函数均为可选项。
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine.model import BaseModule
+
+from mmpretrain.registry import MODELS
+
+
+@MODELS.register_module()
+class MAEPretrainHead(BaseModule):
+ """Head for MAE Pre-training."""
+
+ def __init__(self,
+ loss: dict,
+ norm_pix: bool = False,
+ patch_size: int = 16) -> None:
+ super().__init__()
+ self.norm_pix = norm_pix
+ self.patch_size = patch_size
+ self.loss_module = MODELS.build(loss)
+
+ def patchify(self, imgs: torch.Tensor) -> torch.Tensor:
+ """Split images into non-overlapped patches."""
+ p = self.patch_size
+ assert imgs.shape[2] == imgs.shape[3] and imgs.shape[2] % p == 0
+
+ h = w = imgs.shape[2] // p
+ x = imgs.reshape(shape=(imgs.shape[0], 3, h, p, w, p))
+ x = torch.einsum('nchpwq->nhwpqc', x)
+ x = x.reshape(shape=(imgs.shape[0], h * w, p**2 * 3))
+ return x
+
+ def construct_target(self, target: torch.Tensor) -> torch.Tensor:
+ """Construct the reconstruction target."""
+ target = self.patchify(target)
+ if self.norm_pix:
+ # normalize the target image
+ mean = target.mean(dim=-1, keepdim=True)
+ var = target.var(dim=-1, keepdim=True)
+ target = (target - mean) / (var + 1.e-6)**.5
+
+ return target
+
+ def loss(self, pred: torch.Tensor, target: torch.Tensor,
+ mask: torch.Tensor) -> torch.Tensor:
+ """Generate loss."""
+ target = self.construct_target(target)
+ loss = self.loss_module(pred, target, mask)
+
+ return loss
+```
+
+完成实现后，之后的步骤和 [基于分类头](#基于分类头) 中的步骤 2 和步骤 3 一致。
+
+## 添加新的损失函数
+
+要添加新的损失函数，我们主要需要在损失函数模块中 `forward` 函数。这里需要注意的是，损失模块也应该注册到`MODELS`中。另外，利用装饰器 `weighted_loss` 可以方便的实现对每个元素的损失进行加权平均。
+
+假设我们要模拟从另一个分类模型生成的概率分布，需要添加 `L1loss` 来实现该目的。
+
+1. 创建一个新文件 `mmpretrain/models/losses/l1_loss.py`
+
+ ```python
+ import torch
+ import torch.nn as nn
+
+ from mmpretrain.registry import MODELS
+ from .utils import weighted_loss
+
+ @weighted_loss
+ def l1_loss(pred, target):
+ assert pred.size() == target.size() and target.numel() > 0
+ loss = torch.abs(pred - target)
+ return loss
+
+ @MODELS.register_module()
+ class L1Loss(nn.Module):
+
+ def __init__(self, reduction='mean', loss_weight=1.0):
+ super(L1Loss, self).__init__()
+ self.reduction = reduction
+ self.loss_weight = loss_weight
+
+ def forward(self,
+ pred,
+ target,
+ weight=None,
+ avg_factor=None,
+ reduction_override=None):
+ assert reduction_override in (None, 'none', 'mean', 'sum')
+ reduction = (
+ reduction_override if reduction_override else self.reduction)
+ loss = self.loss_weight * l1_loss(
+ pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+ return loss
+ ```
+
+2. 在文件 `mmpretrain/models/losses/__init__.py` 中导入这个模块
+
+ ```python
+ ...
+ from .l1_loss import L1Loss
+
+ __all__ = [
+ ..., 'L1Loss'
+ ]
+ ```
+
+3. 修改配置文件中的 `loss` 字段以使用新的损失函数
+
+ ```python
+ model = dict(
+ head=dict(
+ loss=dict(type='L1Loss', loss_weight=1.0),
+ ))
+ ```
+
+最后我们可以在配置文件中结合所有新增的模型组件来使用新的模型。由于`ResNet_CIFAR` 不是一个基于ViT的骨干网络，这里我们不用`VisionTransformerClsHead`的配置。
+
+```python
+model = dict(
+ type='ImageClassifier',
+ backbone=dict(
+ type='ResNet_CIFAR',
+ depth=18,
+ num_stages=4,
+ out_indices=(3, ),
+ style='pytorch'),
+ neck=dict(type='GlobalAveragePooling'),
+ head=dict(
+ type='LinearClsHead',
+ num_classes=10,
+ in_channels=512,
+ loss=dict(type='L1Loss', loss_weight=1.0),
+ topk=(1, 5),
+ ))
+
+```
+
+```{tip}
+为了方便，相同的模型组件可以直接从已有的config文件里继承，更多细节可以参考[学习配置文件](../user_guides/config.md)。
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/npu.md b/internlm_langchain/knowledge_base/MMPreTrain/content/npu.md
new file mode 100644
index 00000000..b81c1751
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/npu.md
@@ -0,0 +1,41 @@
+# NPU (华为昇腾)
+
+## 使用方法
+
+首先，请参考[链接](https://mmcv.readthedocs.io/zh_CN/latest/get_started/build.html#npu-mmcv-full)安装带有 NPU 支持的 MMCV 和[链接](https://mmengine.readthedocs.io/en/latest/get_started/installation.html#build-from-source)安装 MMEngine。
+
+使用如下命令，可以利用 8 个 NPU 在机器上训练模型（以 ResNet 为例）：
+
+```shell
+bash tools/dist_train.sh configs/cspnet/resnet50_8xb32_in1k.py 8
+```
+
+或者，使用如下命令，在一个 NPU 上训练模型（以 ResNet 为例）：
+
+```shell
+python tools/train.py configs/cspnet/resnet50_8xb32_in1k.py
+```
+
+## 经过验证的模型
+
+| Model | Top-1 (%) | Top-5 (%) | Config | Download |
+| :---------------------------------------------------------: | :-------: | :-------: | :----------------------------------------------------------: | :-------------------------------------------------------------: |
+| [ResNet-50](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/resnet/README.md) | 76.40 | 93.21 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/resnet/resnet50_8xb32_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/resnet50_8xb32_in1k.log) |
+| [ResNetXt-32x4d-50](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/resnext/README.md) | 77.48 | 93.75 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/resnext/resnext50-32x4d_8xb32_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/resnext50-32x4d_8xb32_in1k.log) |
+| [HRNet-W18](https://github.com/open-mmlab/mmclassification/blob/master/configs/hrnet/README.md) | 77.06 | 93.57 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/hrnet/hrnet-w18_4xb32_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/hrnet-w18_4xb32_in1k.log) |
+| [ResNetV1D-152](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/resnet/README.md) | 79.41 | 94.48 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/resnet/resnetv1d152_8xb32_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/resnetv1d152_8xb32_in1k.log) |
+| [SE-ResNet-50](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/seresnet/README.md) | 77.65 | 93.74 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/seresnet/seresnet50_8xb32_in1k.py) | [model](<>) \|[log](https://download.openmmlab.com/mmclassification/v1/device/npu/seresnet50_8xb32_in1k.log) |
+| [ShuffleNetV2 1.0x](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/shufflenet_v2/README.md) | 69.52 | 88.79 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/shufflenet_v2/shufflenet-v2-1x_16xb64_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/shufflenet-v2-1x_16xb64_in1k.log) |
+| [MobileNetV2](https://github.com/open-mmlab/mmclassification/tree/1.x/configs/mobilenet_v2) | 71.74 | 90.28 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/mobilenet_v2/mobilenet-v2_8xb32_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/mobilenet-v2_8xb32_in1k.log) |
+| [MobileNetV3-Small](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/mobilenet_v3/README.md) | 67.09 | 87.17 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/mobilenet_v3/mobilenet-v3-small_8xb128_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/mobilenet-v3-small.log) |
+| [\*CSPResNeXt50](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/cspnet/README.md) | 77.25 | 93.46 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/cspnet/cspresnext50_8xb32_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/cspresnext50_8xb32_in1k.log) |
+| [\*EfficientNet-B4](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/efficientnet/README.md) | 75.73 | 92.9100 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/efficientnet/efficientnet-b4_8xb32_in1k.py) | [model](<>) \|[log](https://download.openmmlab.com/mmclassification/v1/device/npu/efficientnet-b4_8xb32_in1k.log) |
+| [\*\*DenseNet121](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/densenet/README.md) | 72.53 | 90.85 | [config](https://github.com/open-mmlab/mmclassification/blob/1.x/configs/densenet/densenet121_4xb256_in1k.py) | [model](<>) \| [log](https://download.openmmlab.com/mmclassification/v1/device/npu/densenet121_4xb256_in1k.log) |
+
+**注意:**
+
+- 如果没有特别标记，NPU 上的结果与使用 FP32 的 GPU 上的结果结果相同。
+- (\*) 这些模型的训练结果低于相应模型中自述文件上的结果，主要是因为自述文件上的结果直接是 timm 训练得出的权重，而这边的结果是根据 mmcls 的配置重新训练得到的结果。GPU 上的配置训练结果与 NPU 的结果相同。
+- (\*\*)这个模型的精度略低，因为 config 是 4 张卡的配置，我们使用 8 张卡来运行，用户可以调整超参数以获得最佳精度结果。
+
+**以上所有模型权重及训练日志均由华为昇腾团队提供**
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/pipeline.md b/internlm_langchain/knowledge_base/MMPreTrain/content/pipeline.md
new file mode 100644
index 00000000..99506b08
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/pipeline.md
@@ -0,0 +1,148 @@
+# 自定义数据处理流程
+
+## 数据流的设计
+
+在[新数据集教程](./datasets.md)中，我们知道数据集类使用 `load_data_list` 方法来初始化整个数据集，我们将每个样本的信息保存到一个 dict 中。
+
+通常，为了节省内存，我们只加载 `load_data_list` 中的图片路径和标签，使用时加载完整的图片内容。此外，我们可能希望在训练时选择样本时进行一些随机数据扩充。几乎所有的数据加载、预处理和格式化操作都可以通过**数据管道**在 MMPretrain 中进行配置。
+
+数据管道意味着在从数据集中索引样本时如何处理样本字典，它由一系列数据变换组成。每个数据变换都将一个字典作为输入，对其进行处理，并为下一个数据变换输出一个字典。
+
+这是 ImageNet 上 ResNet-50 训练的数据管道示例。
+
+```python
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='RandomResizedCrop', scale=224),
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'),
+ dict(type='PackInputs'),
+]
+```
+
+MMPretrain 中所有可用的数据变换都可以在 [数据变换文档](mmpretrain.datasets.transforms) 中找到。
+
+## 修改训练/测试管道
+
+MMPretrain 中的数据管道非常灵活。您几乎可以从配置文件中控制数据预处理的每一步，但另一方面，面对如此多的选项，您可能会感到困惑。
+
+这是图像分类任务的常见做法和指南。
+
+### 读取
+
+在数据管道的开始，我们通常需要从文件路径加载图像数据。
+[`LoadImageFromFile`](mmcv.transforms.LoadImageFromFile) 通常用于执行此任务。
+
+```python
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ ...
+]
+```
+
+如果您想从具有特殊格式或特殊位置的文件中加载数据，您可以 [实施新的加载变换](#添加新的数据变换) 并将其添加到数据管道的开头。
+
+### 增强和其它处理
+
+在训练过程中，我们通常需要做数据增强来避免过拟合。在测试过程中，我们还需要做一些数据处理，比如调整大小和裁剪。这些数据变换将放置在加载过程之后。
+
+这是一个简单的数据扩充方案示例。它会将输入图像随机调整大小并裁剪到指定比例，并随机水平翻转图像。
+
+```python
+train_pipeline = [
+ ...
+ dict(type='RandomResizedCrop', scale=224),
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'),
+ ...
+]
+```
+
+这是 [Swin-Transformer](../papers/swin_transformer.md) 训练中使用的大量数据增强配方示例。 为了与官方实施保持一致，它指定 `pillow` 作为调整大小后端，`bicubic` 作为调整大小算法。 此外，它添加了 [`RandAugment`](mmpretrain.datasets.transforms.RandAugment) 和 [`RandomErasing`](mmpretrain.datasets.transforms.RandomErasing) 作为额外的数据增强方法。
+
+此配置指定了数据扩充的每个细节，您只需将其复制到您自己的配置文件中即可应用 Swin-Transformer 的数据扩充。
+
+```python
+bgr_mean = [103.53, 116.28, 123.675]
+bgr_std = [57.375, 57.12, 58.395]
+
+train_pipeline = [
+ ...
+ dict(type='RandomResizedCrop', scale=224, backend='pillow', interpolation='bicubic'),
+ dict(type='RandomFlip', prob=0.5, direction='horizontal'),
+ dict(
+ type='RandAugment',
+ policies='timm_increasing',
+ num_policies=2,
+ total_level=10,
+ magnitude_level=9,
+ magnitude_std=0.5,
+ hparams=dict(
+ pad_val=[round(x) for x in bgr_mean], interpolation='bicubic')),
+ dict(
+ type='RandomErasing',
+ erase_prob=0.25,
+ mode='rand',
+ min_area_ratio=0.02,
+ max_area_ratio=1 / 3,
+ fill_color=bgr_mean,
+ fill_std=bgr_std),
+ ...
+]
+```
+
+```{note}
+通常，数据管道中的数据增强部分仅处理图像方面的变换，而不处理图像归一化或混合/剪切混合等变换。 因为我们可以对 batch data 做 image normalization 和 mixup/cutmix 来加速。要配置图像归一化和 mixup/cutmix，请使用 [数据预处理器](mmpretrain.models.utils.data_preprocessor)。
+```
+
+### 格式化
+
+格式化是从数据信息字典中收集训练数据，并将这些数据转换为模型友好的格式。
+
+在大多数情况下，您可以简单地使用 [`PackInputs`](mmpretrain.datasets.transforms.PackInputs)，它将 NumPy 数组格式的图像转换为 PyTorch 张量，并将 ground truth 类别信息和其他元信息打包为 [`DataSample`](mmpretrain.structures.DataSample)。
+
+```python
+train_pipeline = [
+ ...
+ dict(type='PackInputs'),
+]
+```
+
+## 添加新的数据变换
+
+1. 在任何文件中写入一个新的数据转换，例如 `my_transform.py`，并将其放在文件夹 `mmpretrain/datasets/transforms/` 中。 数据变换类需要继承 [`mmcv.transforms.BaseTransform`](mmcv.transforms.BaseTransform) 类并覆盖以字典作为输入并返回字典的 `transform` 方法。
+
+ ```python
+ from mmcv.transforms import BaseTransform
+ from mmpretrain.registry import TRANSFORMS
+
+ @TRANSFORMS.register_module()
+ class MyTransform(BaseTransform):
+
+ def transform(self, results):
+ # Modify the data information dict `results`.
+ return results
+ ```
+
+2. 在 `mmpretrain/datasets/transforms/__init__.py` 中导入新的变换
+
+ ```python
+ ...
+ from .my_transform import MyTransform
+
+ __all__ = [
+ ..., 'MyTransform'
+ ]
+ ```
+
+3. 在配置文件中使用
+
+ ```python
+ train_pipeline = [
+ ...
+ dict(type='MyTransform'),
+ ...
+ ]
+ ```
+
+## 数据管道可视化
+
+数据流水线设计完成后，可以使用 [可视化工具](../useful_tools/dataset_visualization.md) 查看效果。
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/pretrain_custom_dataset.md b/internlm_langchain/knowledge_base/MMPreTrain/content/pretrain_custom_dataset.md
new file mode 100644
index 00000000..786ecba8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/pretrain_custom_dataset.md
@@ -0,0 +1,247 @@
+# 如何在自定义数据集上进行模型预训练
+
+在本教程中，我们提供了一个实践示例和一些有关如何在您自己的数据集上进行训练的技巧。
+
+在 MMPretrain 中，我们支持用户直接调用 MMPretrain 的 `CustomDataset` （类似于 `torchvision` 的 `ImageFolder`）, 该数据集能自动的读取给的路径下的图片。你只需要准备你的数据集路径，并修改配置文件，即可轻松使用 MMPretrain 进行预训练。
+
+## 第一步：准备你的数据集
+
+按照 [准备数据集](../user_guides/dataset_prepare.md) 准备你的数据集。
+假设我们的数据集根文件夹路径为 `data/custom_dataset/`
+
+假设我们想使用 MAE 算法进行图像自监督训练，并使用子文件夹格式的 `CustomDataset` 来组织数据集：
+
+```text
+data/custom_dataset/
+├── sample1.png
+├── sample2.png
+├── sample3.png
+├── sample4.png
+└── ...
+```
+
+## 第二步：选择一个配置文件作为模板
+
+在本教程中，我们使用 `configs/mae/mae_vit-base-p16_8xb512-amp-coslr-300e_in1k.py` 作为一个示例进行介绍。
+首先在同一文件夹下复制一份配置文件，并将其重命名为 `mae_vit-base-p16_8xb512-amp-coslr-300e_custom.py`。
+
+```{tip}
+按照惯例，配置名称的最后一个字段是数据集，例如，`in1k` 表示 ImageNet-1k，`coco` 表示 coco 数据集
+```
+
+这个配置文件的内容如下：
+
+```python
+_base_ = [
+ '../_base_/models/mae_vit-base-p16.py',
+ '../_base_/datasets/imagenet_bs512_mae.py',
+ '../_base_/default_runtime.py',
+]
+
+# optimizer wrapper
+optim_wrapper = dict(
+ type='AmpOptimWrapper',
+ loss_scale='dynamic',
+ optimizer=dict(
+ type='AdamW',
+ lr=1.5e-4 * 4096 / 256,
+ betas=(0.9, 0.95),
+ weight_decay=0.05),
+ paramwise_cfg=dict(
+ custom_keys={
+ 'ln': dict(decay_mult=0.0),
+ 'bias': dict(decay_mult=0.0),
+ 'pos_embed': dict(decay_mult=0.),
+ 'mask_token': dict(decay_mult=0.),
+ 'cls_token': dict(decay_mult=0.)
+ }))
+
+# learning rate scheduler
+param_scheduler = [
+ dict(
+ type='LinearLR',
+ start_factor=0.0001,
+ by_epoch=True,
+ begin=0,
+ end=40,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingLR',
+ T_max=260,
+ by_epoch=True,
+ begin=40,
+ end=300,
+ convert_to_iter_based=True)
+]
+
+# runtime settings
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=300)
+default_hooks = dict(
+ # only keeps the latest 3 checkpoints
+ checkpoint=dict(type='CheckpointHook', interval=1, max_keep_ckpts=3))
+
+randomness = dict(seed=0, diff_rank_seed=True)
+
+# auto resume
+resume = True
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=4096)
+```
+
+## 第三步：修改数据集设置
+
+- 重载数据集设置中的 `type` 为 `'CustomDataset'`
+- 重载数据集设置中的 `data_root` 为 `data/custom_dataset`
+- 重载数据集设置中的 `ann_file` 为空字符串，这是因为我们使用子文件格式的 `CustomDataset`，需要将配置文件置空
+- 重载数据集设置中的 `data_prefix` 为空字符串，这是因为我们希望使用数据集根目录下的所有数据进行训练，并不需要将其拆分为不同子集。
+
+修改后的文件应如下：
+
+```python
+_base_ = [
+ '../_base_/models/mae_vit-base-p16.py',
+ '../_base_/datasets/imagenet_bs512_mae.py',
+ '../_base_/default_runtime.py',
+]
+
+# >>>>>>>>>>>>>>> 在此重载数据设置 >>>>>>>>>>>>>>>>>>>
+train_dataloader = dict(
+ dataset=dict(
+ type='CustomDataset',
+ data_root='data/custom_dataset/',
+ ann_file='', # 我们假定使用子文件夹格式，因此需要将标注文件置空
+ data_prefix='', # 使用 `data_root` 路径下所有数据
+ with_label=False,
+ )
+)
+# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+# optimizer wrapper
+optim_wrapper = dict(
+ type='AmpOptimWrapper',
+ loss_scale='dynamic',
+ optimizer=dict(
+ type='AdamW',
+ lr=1.5e-4 * 4096 / 256,
+ betas=(0.9, 0.95),
+ weight_decay=0.05),
+ paramwise_cfg=dict(
+ custom_keys={
+ 'ln': dict(decay_mult=0.0),
+ 'bias': dict(decay_mult=0.0),
+ 'pos_embed': dict(decay_mult=0.),
+ 'mask_token': dict(decay_mult=0.),
+ 'cls_token': dict(decay_mult=0.)
+ }))
+
+# learning rate scheduler
+param_scheduler = [
+ dict(
+ type='LinearLR',
+ start_factor=0.0001,
+ by_epoch=True,
+ begin=0,
+ end=40,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingLR',
+ T_max=260,
+ by_epoch=True,
+ begin=40,
+ end=300,
+ convert_to_iter_based=True)
+]
+
+# runtime settings
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=300)
+default_hooks = dict(
+ # only keeps the latest 3 checkpoints
+ checkpoint=dict(type='CheckpointHook', interval=1, max_keep_ckpts=3))
+
+randomness = dict(seed=0, diff_rank_seed=True)
+
+# auto resume
+resume = True
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=4096)
+```
+
+使用上述配置文件，你就能够轻松的在自定义数据集上使用 `MAE` 算法来进行预训练了。
+
+## 另一个例子：在 COCO 数据集上训练 MAE
+
+```{note}
+你可能需要参考[文档](https://github.com/open-mmlab/mmdetection/blob/3.x/docs/en/get_started.md)安装 MMDetection 来使用 `mmdet.CocoDataset`。
+```
+
+与在自定义数据集上进行预训练类似，我们在本教程中也提供了一个使用 COCO 数据集进行预训练的示例。修改后的文件如下：
+
+```python
+# >>>>>>>>>>>>>>>>>>>>> Start of Changed >>>>>>>>>>>>>>>>>>>>>>>>>
+_base_ = [
+ '../_base_/models/mae_vit-base-p16.py',
+ '../_base_/datasets/imagenet_mae.py',
+ '../_base_/default_runtime.py',
+]
+
+# >>>>>>>>>>>>>>> 在这里重载数据配置 >>>>>>>>>>>>>>>>>>>
+train_dataloader = dict(
+ dataset=dict(
+ type='mmdet.CocoDataset',
+ data_root='data/coco/',
+ ann_file='annotations/instances_train2017.json', # 仅用于加载图片，不会使用标签
+ data_prefix=dict(img='train2017/'),
+ )
+)
+# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+# optimizer wrapper
+optim_wrapper = dict(
+ type='AmpOptimWrapper',
+ loss_scale='dynamic',
+ optimizer=dict(
+ type='AdamW',
+ lr=1.5e-4 * 4096 / 256,
+ betas=(0.9, 0.95),
+ weight_decay=0.05),
+ paramwise_cfg=dict(
+ custom_keys={
+ 'ln': dict(decay_mult=0.0),
+ 'bias': dict(decay_mult=0.0),
+ 'pos_embed': dict(decay_mult=0.),
+ 'mask_token': dict(decay_mult=0.),
+ 'cls_token': dict(decay_mult=0.)
+ }))
+# learning rate scheduler
+param_scheduler = [
+ dict(
+ type='LinearLR',
+ start_factor=0.0001,
+ by_epoch=True,
+ begin=0,
+ end=40,
+ convert_to_iter_based=True),
+ dict(
+ type='CosineAnnealingLR',
+ T_max=260,
+ by_epoch=True,
+ begin=40,
+ end=300,
+ convert_to_iter_based=True)
+]
+# runtime settings
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=300)
+default_hooks = dict(
+ # only keeps the latest 3 checkpoints
+ checkpoint=dict(type='CheckpointHook', interval=1, max_keep_ckpts=3))
+randomness = dict(seed=0, diff_rank_seed=True)
+# auto resume
+resume = True
+# NOTE: `auto_scale_lr` is for automatically scaling LR
+# based on the actual training batch size.
+auto_scale_lr = dict(base_batch_size=4096)
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/print_config.md b/internlm_langchain/knowledge_base/MMPreTrain/content/print_config.md
new file mode 100644
index 00000000..3ec0d303
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/print_config.md
@@ -0,0 +1,28 @@
+# 打印完整配置文件
+
+`print_config.py`脚本脚本会解析所有输入变量，并打印完整配置信息。
+
+## 说明：
+
+`tools/misc/print_config.py` 脚本会逐字打印整个配置文件，并展示所有导入的文件。
+
+```shell
+python tools/misc/print_config.py ${CONFIG} [--cfg-options ${CFG_OPTIONS}]
+```
+
+所有参数的说明：
+
+- `config`：模型配置文件的路径。
+- `--cfg-options`：额外的配置选项，会被合入配置文件，参考[学习配置文件](../user_guides/config.md)。
+
+## 示例：
+
+打印`configs/t2t_vit/t2t-vit-t-14_8xb64_in1k.py`文件的完整配置
+
+```shell
+# 打印完成的配置文件
+python tools/misc/print_config.py configs/t2t_vit/t2t-vit-t-14_8xb64_in1k.py
+
+# 将完整的配置文件保存为一个独立的配置文件
+python tools/misc/print_config.py configs/t2t_vit/t2t-vit-t-14_8xb64_in1k.py > final_config.py
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/projects.md b/internlm_langchain/knowledge_base/MMPreTrain/content/projects.md
new file mode 100644
index 00000000..0843dc4d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/projects.md
@@ -0,0 +1 @@
+# 基于 MMPretrain 的项目列表（待更新）
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/runtime.md b/internlm_langchain/knowledge_base/MMPreTrain/content/runtime.md
new file mode 100644
index 00000000..e5fa3864
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/runtime.md
@@ -0,0 +1,213 @@
+# 自定义运行参数
+
+运行参数配置包括许多有用的功能，如权重文件保存、日志配置等等，在本教程中，我们将介绍如何配置这些功能。
+
+## 保存权重文件
+
+权重文件保存功能是一个在训练阶段默认注册的钩子， 你可以通过配置文件中的 `default_hooks.checkpoint` 字段配置它。
+
+```{note}
+钩子机制在 OpenMMLab 开源算法库中应用非常广泛。通过钩子，你可以在不修改运行器的主要执行逻辑的情况下插入许多功能。
+
+可以通过{external+mmengine:doc}`相关文章 `进一步理解钩子。
+```
+
+**默认配置:**
+
+```python
+default_hooks = dict(
+ ...
+ checkpoint = dict(type='CheckpointHook', interval=1)
+ ...
+)
+```
+
+下面是一些[权重文件钩子(CheckpointHook)](mmengine.hooks.CheckpointHook)的常用可配置参数。
+
+- **`interval`** (int): 文件保存周期。如果使用-1，它将永远不会保存权重。
+- **`by_epoch`** (bool): 选择 **`interval`** 是基于epoch还是基于iteration， 默认为 `True`.
+- **`out_dir`** (str): 保存权重文件的根目录。如果不指定，检查点将被保存在工作目录中。如果指定，检查点将被保存在 **`out_dir`** 的子文件夹中。
+- **`max_keep_ckpts`** (int): 要保留的权重文件数量。在某些情况下，为了节省磁盘空间，我们希望只保留最近的几个权重文件。默认为 -1，也就是无限制。
+- **`save_best`** (str, List[str]): 如果指定，它将保存具有最佳评估结果的权重。
+ 通常情况下，你可以直接使用`save_best="auto"`来自动选择评估指标。
+
+而如果你想要更高级的配置，请参考[权重文件钩子(CheckpointHook)](tutorials/hook.md#checkpointhook)。
+
+## 权重加载 / 断点训练
+
+在配置文件中，你可以加载指定模型权重或者断点继续训练，如下所示:
+
+```python
+# 从指定权重文件加载
+load_from = "Your checkpoint path"
+
+# 是否从加载的断点继续训练
+resume = False
+```
+
+`load_from` 字段可以是本地路径，也可以是HTTP路径。你可以从检查点恢复训练，方法是指定 `resume=True`。
+
+```{tip}
+你也可以通过指定 `load_from=None` 和 `resume=True` 启用从最新的断点自动恢复。
+Runner执行器将自动从工作目录中找到最新的权重文件。
+```
+
+如果你用我们的 `tools/train.py` 脚本来训练模型，你只需使用 `--resume` 参数来恢复训练，就不用手动修改配置文件了。如下所示:
+
+```bash
+# 自动从最新的断点恢复
+python tools/train.py configs/resnet/resnet50_8xb32_in1k.py --resume
+
+# 从指定的断点恢复
+python tools/train.py configs/resnet/resnet50_8xb32_in1k.py --resume checkpoints/resnet.pth
+```
+
+## 随机性(Randomness)配置
+
+为了让实验尽可能是可复现的， 我们在 `randomness` 字段中提供了一些控制随机性的选项。
+
+默认情况下，我们不会在配置文件中指定随机数种子，在每次实验中，程序会生成一个不同的随机数种子。
+
+**默认配置:**
+
+```python
+randomness = dict(seed=None, deterministic=False)
+```
+
+为了使实验更具可复现性，你可以指定一个种子并设置 `deterministic=True`。
+`deterministic` 选项的使用效果可以在[这里](https://pytorch.org/docs/stable/notes/randomness.html#cuda-convolution-benchmarking)找到。
+
+## 日志配置
+
+日志的配置与多个字段有关。
+
+在`log_level`字段中，你可以指定全局日志级别。参见 {external+python:ref}`Logging Levels` 以获得日志级别列表。
+
+```python
+log_level = 'INFO'
+```
+
+在 `default_hooks.logger` 字段中，你可以指定训练和测试期间的日志间隔。
+而所有可用的参数可以在[日志钩子文档](tutorials/hook.md#loggerhook)中找到。
+
+```python
+default_hooks = dict(
+ ...
+ # 每100次迭代就打印一次日志
+ logger=dict(type='LoggerHook', interval=100),
+ ...
+)
+```
+
+在 `log_processor` 字段中，你可以指定日志信息的平滑方法。
+通常，我们使用一个长度为10的窗口来平滑日志中的值，并输出所有信息的平均值。
+如果你想特别指定某些信息的平滑方法，请参阅{external+mmengine:doc}`日志处理器文档 `。
+
+```python
+# 默认设置，它将通过一个10长度的窗口平滑训练日志中的值
+log_processor = dict(window_size=10)
+```
+
+在 `visualizer` 字段中，你可以指定多个后端来保存日志信息，如TensorBoard和WandB。
+更多的细节可以在[可视化工具](#visualizer)找到。
+
+## 自定义钩子
+
+上述许多功能是由钩子实现的，你也可以通过修改 `custom_hooks` 字段来插入其他的自定义钩子。
+下面是 MMEngine 和 MMPretrain 中的一些钩子，你可以直接使用，例如：
+
+- [EMAHook](mmpretrain.engine.hooks.EMAHook)
+- [SyncBuffersHook](mmengine.hooks.SyncBuffersHook)
+- [EmptyCacheHook](mmengine.hooks.EmptyCacheHook)
+- [ClassNumCheckHook](mmpretrain.engine.hooks.ClassNumCheckHook)
+- ......
+
+例如，EMA（Exponential Moving Average）在模型训练中被广泛使用，你可以以下方式启用它：
+
+```python
+custom_hooks = [
+ dict(type='EMAHook', momentum=4e-5, priority='ABOVE_NORMAL'),
+]
+```
+
+## 验证可视化
+
+验证可视化钩子是一个验证过程中默认注册的钩子。
+你可以在 `default_hooks.visualization` 字段中来配置它。
+
+默认情况下，我们禁用这个钩子，你可以通过指定 `enable=True` 来启用它。而更多的参数可以在
+[可视化钩子文档](mmpretrain.engine.hooks.VisualizationHook)中找到。
+
+```python
+default_hooks = dict(
+ ...
+ visualization=dict(type='VisualizationHook', enable=False),
+ ...
+)
+```
+
+这个钩子将在验证数据集中选择一部分图像，在每次验证过程中记录并可视化它们的预测结果。
+你可以用它来观察训练期间模型在实际图像上的性能变化。
+
+此外，如果你的验证数据集中的图像很小（\<100， 如Cifra数据集），
+你可以指定 `rescale_factor` 来缩放它们，如 `rescale_factor=2.`, 将可视化的图像放大两倍。
+
+## Visualizer
+
+`Visualizer` 用于记录训练和测试过程中的各种信息，包括日志、图像和标量。
+默认情况下，记录的信息将被保存在工作目录下的 `vis_data` 文件夹中。
+
+**默认配置:**
+
+```python
+visualizer = dict(
+ type='UniversalVisualizer',
+ vis_backends=[
+ dict(type='LocalVisBackend'),
+ ]
+)
+```
+
+通常，最有用的功能是将日志和标量如 `loss` 保存到不同的后端。
+例如，要把它们保存到 TensorBoard，只需像下面这样设置：
+
+```python
+visualizer = dict(
+ type='UniversalVisualizer',
+ vis_backends=[
+ dict(type='LocalVisBackend'),
+ dict(type='TensorboardVisBackend'),
+ ]
+)
+```
+
+或者像下面这样把它们保存到 WandB：
+
+```python
+visualizer = dict(
+ type='UniversalVisualizer',
+ vis_backends=[
+ dict(type='LocalVisBackend'),
+ dict(type='WandbVisBackend'),
+ ]
+)
+```
+
+## 环境配置
+
+在 `env_cfg` 字段中，你可以配置一些底层的参数，如 cuDNN、多进程和分布式通信。
+
+**在修改这些参数之前，请确保你理解这些参数的含义。**
+
+```python
+env_cfg = dict(
+ # 是否启用cudnn基准测试
+ cudnn_benchmark=False,
+
+ # 设置多进程参数
+ mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+
+ # 设置分布式参数
+ dist_cfg=dict(backend='nccl'),
+)
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/schedule.md b/internlm_langchain/knowledge_base/MMPreTrain/content/schedule.md
new file mode 100644
index 00000000..d1c347d1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/schedule.md
@@ -0,0 +1,359 @@
+# 自定义训练优化策略
+
+在我们的算法库中，已经提供了通用数据集（如ImageNet，CIFAR）的[默认训练策略配置](https://github.com/open-mmlab/mmpretrain/blob/main/configs/_base_/schedules)。如果想要在这些数据集上继续提升模型性能，或者在不同数据集和方法上进行新的尝试，我们通常需要修改这些默认的策略。
+
+在本教程中，我们将介绍如何在运行自定义训练时，通过修改配置文件进行构造优化器、参数化精细配置、梯度裁剪、梯度累计以及定制动量调整策略等。同时也会通过模板简单介绍如何自定义开发优化器和构造器。
+
+## 配置训练优化策略
+
+我们通过 `optim_wrapper` 来配置主要的优化策略，包括优化器的选择，混合精度训练的选择，参数化精细配置，梯度裁剪以及梯度累计。接下来将分别介绍这些内容。
+
+### 构造 PyTorch 内置优化器
+
+MMPretrain 支持 PyTorch 实现的所有优化器，仅需在配置文件中，指定优化器封装需要的 `optimizer` 字段。
+
+如果要使用 [`SGD`](torch.optim.SGD)，则修改如下。这里要注意所有优化相关的配置都需要封装在 `optim_wrapper` 配置里。
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='SGD', lr=0.0003, weight_decay=0.0001)
+)
+```
+
+```{note}
+配置文件中的 'type' 不是构造时的参数，而是 PyTorch 内置优化器的类名。
+更多优化器选择可以参考{external+torch:ref}`PyTorch 支持的优化器列表`。
+```
+
+要修改模型的学习率，只需要在优化器的配置中修改 `lr` 即可。
+要配置其他参数，可直接根据 [PyTorch API 文档](torch.optim) 进行。
+
+例如，如果想使用 [`Adam`](torch.optim.Adam) 并设置参数为 `torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)`。
+则需要进行如下修改：
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer = dict(
+ type='Adam',
+ lr=0.001,
+ betas=(0.9, 0.999),
+ eps=1e-08,
+ weight_decay=0,
+ amsgrad=False),
+)
+```
+
+````{note}
+考虑到对于单精度训练来说，优化器封装的默认类型就是 `OptimWrapper`，我们在这里可以直接省略，因此配置文件可以进一步简化为：
+
+```python
+optim_wrapper = dict(
+ optimizer=dict(
+ type='Adam',
+ lr=0.001,
+ betas=(0.9, 0.999),
+ eps=1e-08,
+ weight_decay=0,
+ amsgrad=False))
+```
+````
+
+### 混合精度训练
+
+如果我们想要使用混合精度训练（Automactic Mixed Precision），我们只需简单地将 `optim_wrapper` 的类型改为 `AmpOptimWrapper`。
+
+```python
+optim_wrapper = dict(type='AmpOptimWrapper', optimizer=...)
+```
+
+另外，为了方便，我们同时在启动训练脚本 `tools/train.py` 中提供了 `--amp` 参数作为开启混合精度训练的开关，更多细节可以参考[训练教程](../user_guides/train.md)。
+
+### 参数化精细配置
+
+在一些模型中，不同的优化策略需要适应特定的参数，例如不在 BatchNorm 层使用权重衰减，或者在不同层使用不同的学习率等等。
+我们需要用到 `optim_wrapper` 中的 `paramwise_cfg` 参数来进行精细化配置。
+
+- **为不同类型的参数设置超参乘子**
+
+ 例如，我们可以在 `paramwise_cfg` 配置中设置 `norm_decay_mult=0.` 来改变归一化层权重和偏移的衰减为0。
+
+ ```python
+ optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.8, weight_decay=1e-4),
+ paramwise_cfg=dict(norm_decay_mult=0.))
+ ```
+
+ 支持更多类型的参数配置，参考以下列表：
+
+ - `bias_lr_mult`：偏置的学习率系数（不包括正则化层的偏置以及可变形卷积的 offset），默认值为 1
+ - `bias_decay_mult`：偏置的权值衰减系数（不包括正则化层的偏置以及可变形卷积的 offset），默认值为 1
+ - `norm_decay_mult`：正则化层权重和偏置的权值衰减系数，默认值为 1
+ - `flat_decay_mult`: 一维参数的权值衰减系数，默认值为 1
+ - `dwconv_decay_mult`：Depth-wise 卷积的权值衰减系数，默认值为 1
+ - `bypass_duplicate`：是否跳过重复的参数，默认为 `False`
+ - `dcn_offset_lr_mult`：可变形卷积（Deformable Convolution）的学习率系数，默认值为 1
+
+- **为特定参数设置超参乘子**
+
+ MMPretrain 通过 `paramwise_cfg` 的 `custom_keys` 参数来配置特定参数的超参乘子。
+
+ 例如，我们可以通过以下配置来设置所有 `backbone.layer0` 层的学习率和权重衰减为0， `backbone` 的其余层和优化器保持一致，另外 `head` 层的学习率为0.001.
+
+ ```python
+ optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001),
+ paramwise_cfg=dict(
+ custom_keys={
+ 'backbone.layer0': dict(lr_mult=0, decay_mult=0),
+ 'backbone': dict(lr_mult=1),
+ 'head': dict(lr_mult=0.1)
+ }))
+ ```
+
+### 梯度裁剪
+
+在训练过程中，损失函数可能接近于一些异常陡峭的区域，从而导致梯度爆炸。而梯度裁剪可以帮助稳定训练过程，更多介绍可以参见[该页面](https://paperswithcode.com/method/gradient-clipping)。
+
+目前我们支持在 `optim_wrapper` 字段中添加 `clip_grad` 参数来进行梯度裁剪，更详细的参数可参考 [PyTorch 文档](torch.nn.utils.clip_grad_norm_)。
+
+用例如下：
+
+```python
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001),
+ # norm_type: 使用的范数类型，此处使用范数2。
+ clip_grad=dict(max_norm=35, norm_type=2))
+```
+
+### 梯度累计
+
+计算资源缺乏缺乏时，每个训练批次的大小（batch size）只能设置为较小的值，这可能会影响模型的性能。
+
+可以使用梯度累计来规避这一问题。我们支持在 `optim_wrapper` 字段中添加 `accumulative_counts` 参数来进行梯度累计。
+
+用例如下：
+
+```python
+train_dataloader = dict(batch_size=64)
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001),
+ accumulative_counts=4)
+```
+
+表示训练时，每 4 个 iter 执行一次反向传播。由于此时单张 GPU 上的批次大小为 64，也就等价于单张 GPU 上一次迭代的批次大小为 256，也即：
+
+```python
+train_dataloader = dict(batch_size=256)
+optim_wrapper = dict(
+ optimizer=dict(type='SGD', lr=0.01, weight_decay=0.0001))
+```
+
+## 配置参数优化策略
+
+在训练过程中，优化参数例如学习率、动量，通常不会是固定不变，而是随着训练进程的变化而调整。PyTorch 支持一些学习率调整的调度器，但是不足以完成复杂的策略。在 MMPretrain 中，我们提供 `param_scheduler` 来更好地控制不同优化参数的策略。
+
+### 配置学习率调整策略
+
+深度学习研究中，广泛应用学习率衰减来提高网络的性能。我们支持大多数 PyTorch 学习率调度器， 其中包括 `ExponentialLR`, `LinearLR`, `StepLR`, `MultiStepLR` 等等。
+
+- **单个学习率策略**
+
+ 多数情况下，我们使用单一学习率策略，这里 `param_scheduler` 会是一个字典。比如在默认的 ResNet 网络训练中，我们使用阶梯式的学习率衰减策略 [`MultiStepLR`](mmengine.optim.MultiStepLR)，配置文件为：
+
+ ```python
+ param_scheduler = dict(
+ type='MultiStepLR',
+ by_epoch=True,
+ milestones=[100, 150],
+ gamma=0.1)
+ ```
+
+ 或者我们想使用 [`CosineAnnealingLR`](mmengine.optim.CosineAnnealingLR) 来进行学习率衰减：
+
+ ```python
+ param_scheduler = dict(
+ type='CosineAnnealingLR',
+ by_epoch=True,
+ T_max=num_epochs)
+ ```
+
+- **多个学习率策略**
+
+ 然而在一些其他情况下，为了提高模型的精度，通常会使用多种学习率策略。例如，在训练的早期阶段，网络容易不稳定，而学习率的预热就是为了减少这种不稳定性。
+
+ 整个学习过程中，学习率将会通过预热从一个很小的值逐步提高到预定值，再会通过其他的策略进一步调整。
+
+ 在 MMPretrain 中，我们同样使用 `param_scheduler` ，将多种学习策略写成列表就可以完成上述预热策略的组合。
+
+ 例如：
+
+ 1. 在前50次迭代中逐**迭代次数**地**线性**预热
+
+ ```python
+ param_scheduler = [
+ # 逐迭代次数，线性预热
+ dict(type='LinearLR',
+ start_factor=0.001,
+ by_epoch=False, # 逐迭代次数
+ end=50), # 只预热50次迭代次数
+ # 主要的学习率策略
+ dict(type='MultiStepLR',
+ by_epoch=True,
+ milestones=[8, 11],
+ gamma=0.1)
+ ]
+ ```
+
+ 2. 在前10轮迭代中逐**迭代次数**地**线性**预热
+
+ ```python
+ param_scheduler = [
+ # 在前10轮迭代中，逐迭代次数，线性预热
+ dict(type='LinearLR',
+ start_factor=0.001,
+ by_epoch=True,
+ end=10,
+ convert_to_iter_based=True, # 逐迭代次数更新学习率.
+ ),
+ # 在 10 轮次后，通过余弦退火衰减
+ dict(type='CosineAnnealingLR', by_epoch=True, begin=10)
+ ]
+ ```
+
+ 注意这里增加了 `begin` 和 `end` 参数，这两个参数指定了调度器的**生效区间**。生效区间通常只在多个调度器组合时才需要去设置，使用单个调度器时可以忽略。当指定了 `begin` 和 `end` 参数时，表示该调度器只在 [begin, end) 区间内生效，其单位是由 `by_epoch` 参数决定。在组合不同调度器时，各调度器的 `by_epoch` 参数不必相同。如果没有指定的情况下，`begin` 为 0， `end` 为最大迭代轮次或者最大迭代次数。
+
+ 如果相邻两个调度器的生效区间没有紧邻，而是有一段区间没有被覆盖，那么这段区间的学习率维持不变。而如果两个调度器的生效区间发生了重叠，则对多组调度器叠加使用，学习率的调整会按照调度器配置文件中的顺序触发（行为与 PyTorch 中 [`ChainedScheduler`](torch.optim.lr_scheduler.ChainedScheduler) 一致）。
+
+ ```{tip}
+ 为了避免学习率曲线与预期不符， 配置完成后，可以使用 MMPretrain 提供的 [学习率可视化工具](../useful_tools/scheduler_visualization.md) 画出对应学习率调整曲线。
+ ```
+
+### 配置动量调整策略
+
+MMPretrain 支持动量调度器根据学习率修改优化器的动量，从而使损失函数收敛更快。用法和学习率调度器一致。
+
+我们支持的动量策略和详细的使用细节可以参考[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/momentum_scheduler.py)。我们只将调度器中的 `LR` 替换为了 `Momentum`，动量策略可以直接追加 `param_scheduler` 列表中。
+
+这里是一个用例：
+
+```python
+param_scheduler = [
+ # 学习率策略
+ dict(type='LinearLR', ...),
+ # 动量策略
+ dict(type='LinearMomentum',
+ start_factor=0.001,
+ by_epoch=False,
+ begin=0,
+ end=1000)
+]
+```
+
+## 新增优化器或者优化器构造器
+
+```{note}
+本部分将修改 MMPretrain 源码或者向 MMPretrain 框架添加代码，初学者可跳过。
+```
+
+### 新增优化器
+
+在学术研究和工业实践中，可能需要使用 MMPretrain 未实现的优化方法，可以通过以下方法添加。
+
+1. 定义一个新的优化器
+
+ 一个自定义的优化器可根据如下规则进行定制：
+
+ 假设我们想添加一个名为 `MyOptimzer` 的优化器，其拥有参数 `a`, `b` 和 `c`。
+ 可以创建一个名为 `mmpretrain/engine/optimizer` 的文件夹，并在目录下的一个文件，如 `mmpretrain/engine/optimizer/my_optimizer.py` 中实现该自定义优化器：
+
+ ```python
+ from mmpretrain.registry import OPTIMIZERS
+ from torch.optim import Optimizer
+
+
+ @OPTIMIZERS.register_module()
+ class MyOptimizer(Optimizer):
+
+ def __init__(self, a, b, c):
+ ...
+
+ def step(self, closure=None):
+ ...
+ ```
+
+2. 注册优化器
+
+ 要注册上面定义的上述模块，首先需要将此模块导入到主命名空间中。有两种方法可以实现它。
+
+ 修改 `mmpretrain/engine/optimizers/__init__.py`，将其导入至 `mmpretrain.engine` 包。
+
+ ```python
+ # 在 mmpretrain/engine/optimizers/__init__.py 中
+ ...
+ from .my_optimizer import MyOptimizer # MyOptimizer 是我们自定义的优化器的名字
+
+ __all__ = [..., 'MyOptimizer']
+ ```
+
+ 在运行过程中，我们会自动导入 `mmpretrain.engine` 包并同时注册 `MyOptimizer`。
+
+3. 在配置文件中指定优化器
+
+ 之后，用户便可在配置文件的 `optim_wrapper.optimizer` 域中使用 `MyOptimizer`：
+
+ ```python
+ optim_wrapper = dict(
+ optimizer=dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value))
+ ```
+
+### 新增优化器构造器
+
+某些模型可能具有一些特定于参数的设置以进行优化，例如为所有 BatchNorm 层设置不同的权重衰减。
+
+尽管我们已经可以使用 [`optim_wrapper.paramwise_cfg` 字段](#参数化精细配置)来配置特定参数的优化设置，但可能仍然无法覆盖你的需求。
+
+当然你可以在此基础上进行修改。我们默认使用 [`DefaultOptimWrapperConstructor`](mmengine.optim.DefaultOptimWrapperConstructor) 来构造优化器。在构造过程中，通过 `paramwise_cfg` 来精细化配置不同设置。这个默认构造器可以作为新优化器构造器实现的模板。
+
+我们可以新增一个优化器构造器来覆盖这些行为。
+
+```python
+# 在 mmpretrain/engine/optimizers/my_optim_constructor.py 中
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmpretrain.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class MyOptimWrapperConstructor:
+
+ def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
+ ...
+
+ def __call__(self, model):
+ ...
+```
+
+这是一个已实现的 [OptimWrapperConstructor](mmpretrain.engine.optimizers.LearningRateDecayOptimWrapperConstructor) 具体例子。
+
+接下来类似 [新增优化器教程](#新增优化器) 来导入并使用新的优化器构造器。
+
+1. 修改 `mmpretrain/engine/optimizers/__init__.py`，将其导入至 `mmpretrain.engine` 包。
+
+ ```python
+ # 在 mmpretrain/engine/optimizers/__init__.py 中
+ ...
+ from .my_optim_constructor import MyOptimWrapperConstructor
+
+ __all__ = [..., 'MyOptimWrapperConstructor']
+ ```
+
+2. 在配置文件的 `optim_wrapper.constructor` 字段中使用 `MyOptimWrapperConstructor` 。
+
+ ```python
+ optim_wrapper = dict(
+ constructor=dict(type='MyOptimWrapperConstructor'),
+ optimizer=...,
+ paramwise_cfg=...,
+ )
+ ```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/scheduler_visualization.md b/internlm_langchain/knowledge_base/MMPreTrain/content/scheduler_visualization.md
new file mode 100644
index 00000000..8ac903ac
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/scheduler_visualization.md
@@ -0,0 +1,44 @@
+# 优化器参数策略可视化
+
+该工具旨在帮助用户检查优化器的超参数调度器（无需训练），支持学习率（learning rate）和动量（momentum）。
+
+## 工具简介
+
+```bash
+python tools/visualization/vis_scheduler.py \
+ ${CONFIG_FILE} \
+ [-p, --parameter ${PARAMETER_NAME}] \
+ [-d, --dataset-size ${DATASET_SIZE}] \
+ [-n, --ngpus ${NUM_GPUs}] \
+ [-s, --save-path ${SAVE_PATH}] \
+ [--title ${TITLE}] \
+ [--style ${STYLE}] \
+ [--window-size ${WINDOW_SIZE}] \
+ [--cfg-options]
+```
+
+**所有参数的说明**：
+
+- `config` : 模型配置文件的路径。
+- **`-p, parameter`**: 可视化参数名，只能为 `["lr", "momentum"]` 之一， 默认为 `"lr"`.
+- **`-d, --dataset-size`**: 数据集的大小。如果指定，`build_dataset` 将被跳过并使用这个大小作为数据集大小，默认使用 `build_dataset` 所得数据集的大小。
+- **`-n, --ngpus`**: 使用 GPU 的数量，默认为 1。
+- **`-s, --save-path`**: 保存的可视化图片的路径，默认不保存。
+- `--title`: 可视化图片的标题，默认为配置文件名。
+- `--style`: 可视化图片的风格，默认为 `whitegrid`。
+- `--window-size`: 可视化窗口大小，如果没有指定，默认为 `12*7`。如果需要指定，按照格式 `'W*H'`。
+- `--cfg-options`: 对配置文件的修改，参考[学习配置文件](../user_guides/config.md)。
+
+```{note}
+部分数据集在解析标注阶段比较耗时，可直接将 `-d, dataset-size` 指定数据集的大小，以节约时间。
+```
+
+## 如何在开始训练前可视化学习率曲线
+
+你可以使用如下命令来绘制配置文件 `configs/swin_transformer/swin-base_16xb64_in1k.py` 将会使用的变化率曲线：
+
+```bash
+python tools/visualization/vis_scheduler.py configs/swin_transformer/swin-base_16xb64_in1k.py --dataset-size 1281167 --ngpus 16
+```
+
+
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/shape_bias.md b/internlm_langchain/knowledge_base/MMPreTrain/content/shape_bias.md
new file mode 100644
index 00000000..f557197d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/shape_bias.md
@@ -0,0 +1,96 @@
+## 形状偏差(Shape Bias)工具用法
+
+形状偏差(shape bias)衡量模型与纹理相比，如何依赖形状来感知图像中的语义。关于更多细节，我们向感兴趣的读者推荐这篇[论文](https://arxiv.org/abs/2106.07411) 。MMPretrain提供现成的工具箱来获得分类模型的形状偏差。您可以按照以下步骤操作：
+
+### 准备数据集
+
+首先你应该下载[cue-conflict](https://github.com/bethgelab/model-vs-human/releases/download/v0.1/cue-conflict.tar.gz) 到`data`文件夹，然后解压缩这个数据集。之后，你的`data`文件夹应具有一下结构：
+
+```text
+data
+├──cue-conflict
+| |──airplane
+| |──bear
+| ...
+| |── truck
+```
+
+### 修改分类配置
+
+我们在使用MAE预训练的ViT-base模型上运行形状偏移工具。它的配置文件为`configs/mae/benchmarks/vit-base-p16_8xb128-coslr-100e_in1k.py`，它的检查点可从[此链接](https://download.openmmlab.com/mmselfsup/1.x/mae/mae_vit-base-p16_8xb512-fp16-coslr-1600e_in1k/vit-base-p16_ft-8xb128-coslr-100e_in1k/vit-base-p16_ft-8xb128-coslr-100e_in1k_20220825-cf70aa21.pth) 下载。将原始配置中的test_pipeline, test_dataloader和test_evaluation替换为以下配置：
+
+```python
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(
+ type='ResizeEdge',
+ scale=256,
+ edge='short',
+ backend='pillow'),
+ dict(type='CenterCrop', crop_size=224),
+ dict(type='PackInputs')
+]
+test_dataloader = dict(
+ pin_memory=True,
+ collate_fn=dict(type='default_collate'),
+ batch_size=32,
+ num_workers=4,
+ dataset=dict(
+ type='CustomDataset',
+ data_root='data/cue-conflict',
+ pipeline=test_pipeline,
+ _delete_=True),
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ persistent_workers=True,
+ drop_last=False)
+test_evaluator = dict(
+ type='mmpretrain.ShapeBiasMetric',
+ _delete_=True,
+ csv_dir='work_dirs/shape_bias',
+ model_name='mae')
+```
+
+请注意，你应该对上面的`csv_dir`和`model_name`进行自定义修改。我把修改后的示例配置文件重命名为`configs/mae/benchmarks/`文件夹中的`vit-base-p16_8xb128-coslr-100e_in1k_shape-bias.py`文件。
+
+### 用上面修改后的配置文件在你的模型上做推断
+
+然后，你应该使用修改后的配置文件在`cue-conflict`数据集上推断你的模型。
+
+```shell
+# For PyTorch
+bash tools/dist_test.sh $CONFIG $CHECKPOINT
+```
+
+**所有参数的说明**：
+
+- `$CONFIG`: 修改后的配置文件的路径。
+- `$CHECKPOINT`: 检查点文件的路径或链接。
+
+```shell
+# Example
+bash tools/dist_test.sh configs/mae/benchmarks/vit-base-p16_8xb128-coslr-100e_in1k_shape-bias.py https://download.openmmlab.com/mmselfsup/1.x/mae/mae_vit-base-p16_8xb512-fp16-coslr-1600e_in1k/vit-base-p16_ft-8xb128-coslr-100e_in1k/vit-base-p16_ft-8xb128-coslr-100e_in1k_20220825-cf70aa21.pth 1
+```
+
+之后，你应该在`csv_dir`文件夹中获得一个名为`cue-conflict_model-name_session-1.csv`的csv文件。除了这个文件以外，你还应该下载这些[csv文件](https://github.com/bethgelab/model-vs-human/tree/master/raw-data/cue-conflict) 到`csv_dir`。
+
+### 绘制形状偏差图
+
+然后我们可以开始绘制形状偏差图：
+
+```shell
+python tools/analysis_tools/shape_bias.py --csv-dir $CSV_DIR --result-dir $RESULT_DIR --colors $RGB --markers o --plotting-names $YOUR_MODEL_NAME --model-names $YOUR_MODEL_NAME
+```
+
+**所有参数的说明**:
+
+- `--csv-dir $CSV_DIR`, 与保存这些csv文件的目录相同。
+- `--result-dir $RESULT_DIR`, 输出名为`cue-conflict_shape-bias_matrixplot.pdf`的结果的目录。
+- `--colors $RGB`, 应该是RGB值，格式为R G B，例如100 100 100，如果你想绘制几个模型的形状偏差，可以是多个RGB值。
+- `--plotting-names $YOUR_MODEL_NAME`, 形状偏移图中图例的名称，您可以将其设置为模型名称。如果要绘制多个模型，plotting_names可以是多个值。
+- `model-names $YOUR_MODEL_NAME`, 应与配置中指定的名称相同，如果要绘制多个模型的形状偏差，则可以是多个名称。
+
+请注意，`--colors`的每三个值对应于`--model-names`的一个值。完成以上所有步骤后，你将获得下图。
+
+
| 
|
+
+## 如何可视化自监督模型的t-SNE（如 MAE）
+
+以下是在ImageNet数据集上训练的 MAE-ViT-base 模型上运行 t-SNE 可视化的一个样例。输入数据来自 ImageNet 验证集。MAE和一些自监督预训练算法配置中没有 test_dataloader 信息。在分析这些自监督算法时，你需要在配置中添加 test_dataloader 信息，或者使用 `--test-cfg` 字段来指定一个配置文件。
+
+```shell
+python tools/visualization/vis_tsne.py \
+ configs/mae/mae_vit-base-p16_8xb512-amp-coslr-800e_in1k.py \
+ --checkpoint https://download.openmmlab.com/mmselfsup/1.x/mae/mae_vit-base-p16_8xb512-fp16-coslr-800e_in1k/mae_vit-base-p16_8xb512-coslr-800e-fp16_in1k_20220825-5d81fbc4.pth \
+ --test-cfg configs/_base_/datasets/imagenet_bs32.py
+```
+
+| MAE-ViT-base |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 
|
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/test.md b/internlm_langchain/knowledge_base/MMPreTrain/content/test.md
new file mode 100644
index 00000000..054e1e41
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/test.md
@@ -0,0 +1,117 @@
+# 测试
+
+## 单机单卡测试
+
+你可以使用 `tools/test.py` 在电脑上用 CPU 或是 GPU 进行模型的测试。
+
+以下是测试脚本的完整用法：
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [ARGS]
+```
+
+````{note}
+默认情况下，MMPretrain 会自动调用你的 GPU 进行测试。如果你有 GPU 但仍想使用 CPU 进行测试，请设置环境变量 `CUDA_VISIBLE_DEVICES` 为空或者 -1 来对禁用 GPU。
+
+```bash
+CUDA_VISIBLE_DEVICES=-1 python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [ARGS]
+```
+````
+
+| 参数 | 描述 |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CONFIG_FILE` | 配置文件的路径。 |
+| `CHECKPOINT_FILE` | 权重文件路径（支持 http 链接，你可以在[这里](https://mmpretrain.readthedocs.io/en/latest/modelzoo_statistics.html)寻找需要的权重文件）。 |
+| `--work-dir WORK_DIR` | 用来保存测试指标结果的文件夹。 |
+| `--out OUT` | 用来保存测试输出的文件。 |
+| `--out-item OUT_ITEM` | 指定测试输出文件的内容，可以为 "pred" 或 "metrics"，其中 "pred" 表示保存所有模型输出，这些数据可以用于离线测评；"metrics" 表示输出测试指标。默认为 "pred"。 |
+| `--cfg-options CFG_OPTIONS` | 重载配置文件中的一些设置。使用类似 `xxx=yyy` 的键值对形式指定，这些设置会被融合入从配置文件读取的配置。你可以使用 `key="[a,b]"` 或者 `key=a,b` 的格式来指定列表格式的值，且支持嵌套，例如 \`key="[(a,b),(c,d)]"，这里的引号是不可省略的。另外每个重载项内部不可出现空格。 |
+| `--show-dir SHOW_DIR` | 用于保存可视化预测结果图像的文件夹。 |
+| `--show` | 在窗口中显示预测结果图像。 |
+| `--interval INTERVAL` | 每隔多少样本进行一次预测结果可视化。 |
+| `--wait-time WAIT_TIME` | 每个窗口的显示时间（单位为秒）。 |
+| `--no-pin-memory` | 是否在 dataloaders 中关闭 `pin_memory` 选项 |
+| `--tta` | 是否开启 Test-Time-Aug (TTA). 如果配置文件有 `tta_pipeline` 和 `tta_model`，将使用这些配置指定 TTA transforms，并且决定如何融合 TTA 的结果。 否则，通过平均分类分数使用 flip TTA。 |
+| `--launcher {none,pytorch,slurm,mpi}` | 启动器，默认为 "none"。 |
+
+## 单机多卡测试
+
+我们提供了一个 shell 脚本，可以使用 `torch.distributed.launch` 启动多 GPU 任务。
+
+```shell
+bash ./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [PY_ARGS]
+```
+
+| 参数 | 描述 |
+| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `CONFIG_FILE` | 配置文件的路径。 |
+| `CHECKPOINT_FILE` | 权重文件路径（支持 http 链接，你可以在[这里](https://mmpretrain.readthedocs.io/en/latest/modelzoo_statistics.html)寻找需要的权重文件）。 |
+| `GPU_NUM` | 使用的 GPU 数量。 |
+| `[PY_ARGS]` | `tools/test.py` 支持的其他可选参数，参见[上文](#单机单卡测试)。 |
+
+你还可以使用环境变量来指定启动器的额外参数，比如用如下命令将启动器的通讯端口变更为 29666：
+
+```shell
+PORT=29666 bash ./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [PY_ARGS]
+```
+
+如果你希望使用不同的 GPU 进行多项测试任务，可以在启动时指定不同的通讯端口和不同的可用设备。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 bash ./tools/dist_test.sh ${CONFIG_FILE1} ${CHECKPOINT_FILE} 4 [PY_ARGS]
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 bash ./tools/dist_test.sh ${CONFIG_FILE2} ${CHECKPOINT_FILE} 4 [PY_ARGS]
+```
+
+## 多机测试
+
+### 同一网络下的多机
+
+如果你希望使用同一局域网下连接的多台电脑进行一个测试任务，可以使用如下命令：
+
+在第一台机器上：
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_test.sh $CONFIG $CHECKPOINT_FILE $GPUS
+```
+
+在第二台机器上：
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_test.sh $CONFIG $CHECKPOINT_FILE $GPUS
+```
+
+和单机多卡相比，你需要指定一些额外的环境变量：
+
+| 环境变量 | 描述 |
+| ------------- | ---------------------------------------------- |
+| `NNODES` | 机器总数。 |
+| `NODE_RANK` | 本机的序号 |
+| `PORT` | 通讯端口，它在所有机器上都应当是一致的。 |
+| `MASTER_ADDR` | 主机的 IP 地址，它在所有机器上都应当是一致的。 |
+
+### Slurm 管理下的多机集群
+
+如果你在 [slurm](https://slurm.schedmd.com/) 集群上，可以使用 `tools/slurm_test.sh` 脚本启动任务。
+
+```shell
+[ENV_VARS] ./tools/slurm_test.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${CHECKPOINT_FILE} [PY_ARGS]
+```
+
+这里是该脚本的一些参数：
+
+| 参数 | 描述 |
+| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `PARTITION` | 使用的集群分区。 |
+| `JOB_NAME` | 任务的名称，你可以随意起一个名字。 |
+| `CONFIG_FILE` | 配置文件路径。 |
+| `CHECKPOINT_FILE` | 权重文件路径（支持 http 链接，你可以在[这里](https://mmpretrain.readthedocs.io/en/latest/modelzoo_statistics.html)寻找需要的权重文件）。 |
+| `[PY_ARGS]` | `tools/test.py` 支持的其他可选参数，参见[上文](#单机单卡测试)。 |
+
+这里是一些你可以用来配置 slurm 任务的环境变量：
+
+| 环境变量 | 描述 |
+| --------------- | ------------------------------------------------------------------------------------------ |
+| `GPUS` | 使用的 GPU 总数，默认为 8。 |
+| `GPUS_PER_NODE` | 每个节点分配的 GPU 数，你可以根据节点情况指定。默认为 8。 |
+| `CPUS_PER_TASK` | 每个任务分配的 CPU 数（通常一个 GPU 对应一个任务）。默认为 5。 |
+| `SRUN_ARGS` | `srun` 命令支持的其他参数。可用的选项参见[官方文档](https://slurm.schedmd.com/srun.html)。 |
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/train.md b/internlm_langchain/knowledge_base/MMPreTrain/content/train.md
new file mode 100644
index 00000000..841edabb
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/train.md
@@ -0,0 +1,118 @@
+# 训练
+
+在本教程中，我们将介绍如何使用 MMPretrain 中提供的脚本启动训练任务。
+如果你需要了解一些具体的训练例子，可以查阅 [如何在自定义数据集上进行模型预训练](../notes/pretrain_custom_dataset.md) 和 [如何在自定义数据集上微调模型](../notes/finetune_custom_dataset.md).
+
+## 单机单卡训练
+
+你可以使用 `tools/train.py` 在电脑上用 CPU 或是 GPU 进行模型的训练。
+
+以下是训练脚本的完整用法：
+
+```shell
+python tools/train.py ${CONFIG_FILE} [ARGS]
+```
+
+````{note}
+默认情况下，MMPretrain 会自动调用你的 GPU 进行训练。如果你有 GPU 但仍想使用 CPU 进行训练，请设置环境变量 `CUDA_VISIBLE_DEVICES` 为空或者 -1 来对禁用 GPU。
+
+```bash
+CUDA_VISIBLE_DEVICES=-1 python tools/train.py ${CONFIG_FILE} [ARGS]
+```
+````
+
+| 参数 | 描述 |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CONFIG_FILE` | 配置文件的路径。 |
+| `--work-dir WORK_DIR` | 用来保存训练日志和权重文件的文件夹，默认是 `./work_dirs` 目录下，与配置文件同名的文件夹。 |
+| `--resume [RESUME]` | 恢复训练。如果指定了权重文件路径，则从指定的权重文件恢复；如果没有指定，则尝试从最新的权重文件进行恢复。 |
+| `--amp` | 启用混合精度训练。 |
+| `--no-validate` | **不建议** 在训练过程中不进行验证集上的精度验证。 |
+| `--auto-scale-lr` | 自动根据实际的批次大小（batch size）和预设的批次大小对学习率进行缩放。 |
+| `--no-pin-memory` | 是否在 dataloaders 中关闭 `pin_memory` 选项 |
+| `--no-persistent-workers` | 是否在 dataloaders 中关闭 `persistent_workers` 选项 |
+| `--cfg-options CFG_OPTIONS` | 重载配置文件中的一些设置。使用类似 `xxx=yyy` 的键值对形式指定，这些设置会被融合入从配置文件读取的配置。你可以使用 `key="[a,b]"` 或者 `key=a,b` 的格式来指定列表格式的值，且支持嵌套，例如 \`key="[(a,b),(c,d)]"，这里的引号是不可省略的。另外每个重载项内部不可出现空格。 |
+| `--launcher {none,pytorch,slurm,mpi}` | 启动器，默认为 "none"。 |
+
+## 单机多卡训练
+
+我们提供了一个 shell 脚本，可以使用 `torch.distributed.launch` 启动多 GPU 任务。
+
+```shell
+bash ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [PY_ARGS]
+```
+
+| 参数 | 描述 |
+| ------------- | ---------------------------------------------------------------- |
+| `CONFIG_FILE` | 配置文件的路径。 |
+| `GPU_NUM` | 使用的 GPU 数量。 |
+| `[PY_ARGS]` | `tools/train.py` 支持的其他可选参数，参见[上文](#单机单卡训练)。 |
+
+你还可以使用环境变量来指定启动器的额外参数，比如用如下命令将启动器的通讯端口变更为 29666：
+
+```shell
+PORT=29666 bash ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [PY_ARGS]
+```
+
+如果你希望使用不同的 GPU 进行多项训练任务，可以在启动时指定不同的通讯端口和不同的可用设备。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 bash ./tools/dist_train.sh ${CONFIG_FILE1} 4 [PY_ARGS]
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 bash ./tools/dist_train.sh ${CONFIG_FILE2} 4 [PY_ARGS]
+```
+
+## 多机训练
+
+### 同一网络下的多机
+
+如果你希望使用同一局域网下连接的多台电脑进行一个训练任务，可以使用如下命令：
+
+在第一台机器上：
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_train.sh $CONFIG $GPUS
+```
+
+在第二台机器上：
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_train.sh $CONFIG $GPUS
+```
+
+和单机多卡相比，你需要指定一些额外的环境变量：
+
+| 环境变量 | 描述 |
+| ------------- | ---------------------------------------------- |
+| `NNODES` | 机器总数。 |
+| `NODE_RANK` | 本机的序号 |
+| `PORT` | 通讯端口，它在所有机器上都应当是一致的。 |
+| `MASTER_ADDR` | 主机的 IP 地址，它在所有机器上都应当是一致的。 |
+
+通常来说，如果这几台机器之间不是高速网络连接，训练速度会非常慢。
+
+### Slurm 管理下的多机集群
+
+如果你在 [slurm](https://slurm.schedmd.com/) 集群上，可以使用 `tools/slurm_train.sh` 脚本启动任务。
+
+```shell
+[ENV_VARS] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR} [PY_ARGS]
+```
+
+这里是该脚本的一些参数：
+
+| 参数 | 描述 |
+| ------------- | ---------------------------------------------------------------- |
+| `PARTITION` | 使用的集群分区。 |
+| `JOB_NAME` | 任务的名称，你可以随意起一个名字。 |
+| `CONFIG_FILE` | 配置文件路径。 |
+| `WORK_DIR` | 用以保存日志和权重文件的文件夹。 |
+| `[PY_ARGS]` | `tools/train.py` 支持的其他可选参数，参见[上文](#单机单卡训练)。 |
+
+这里是一些你可以用来配置 slurm 任务的环境变量：
+
+| 环境变量 | 描述 |
+| --------------- | ------------------------------------------------------------------------------------------ |
+| `GPUS` | 使用的 GPU 总数，默认为 8。 |
+| `GPUS_PER_NODE` | 每个节点分配的 GPU 数，你可以根据节点情况指定。默认为 8。 |
+| `CPUS_PER_TASK` | 每个任务分配的 CPU 数（通常一个 GPU 对应一个任务）。默认为 5。 |
+| `SRUN_ARGS` | `srun` 命令支持的其他参数。可用的选项参见[官方文档](https://slurm.schedmd.com/srun.html)。 |
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/verify_dataset.md b/internlm_langchain/knowledge_base/MMPreTrain/content/verify_dataset.md
new file mode 100644
index 00000000..655ce977
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/verify_dataset.md
@@ -0,0 +1,28 @@
+# 数据集验证
+
+在 MMPretrain 中，`tools/misc/verify_dataset.py` 脚本会检查数据集的所有图片，查看是否有**已经损坏**的图片。
+
+## 工具介绍
+
+```shell
+python tools/print_config.py \
+ ${CONFIG} \
+ [--out-path ${OUT-PATH}] \
+ [--phase ${PHASE}] \
+ [--num-process ${NUM-PROCESS}]
+ [--cfg-options ${CFG_OPTIONS}]
+```
+
+**所有参数说明**:
+
+- `config` : 配置文件的路径。
+- `--out-path` : 输出结果路径，默认为 ‘brokenfiles.log’。
+- `--phase` : 检查哪个阶段的数据集，可用值为 “train” 、”test” 或者 “val”， 默认为 “train”。
+- `--num-process` : 指定的进程数，默认为 1。
+- `--cfg-options`: 额外的配置选项，会被合入配置文件，参考[教程 1：如何编写配置文件](https://mmpretrain.readthedocs.io/zh_CN/latest/tutorials/config.html)。
+
+## 示例：
+
+```shell
+python tools/misc/verify_dataset.py configs/t2t_vit/t2t-vit-t-14_8xb64_in1k.py --out-path broken_imgs.log --phase val --num-process 8
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMPreTrain/vector_store/index.faiss
new file mode 100644
index 00000000..3c0ec00c
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMPreTrain/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/1_learn_about_config.md b/internlm_langchain/knowledge_base/MMRazor/content/1_learn_about_config.md
new file mode 100644
index 00000000..05cfd254
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/1_learn_about_config.md
@@ -0,0 +1,17 @@
+# Learn about Configs
+
+## Directory structure of configs in mmrazor
+
+
+
+`mmxxx`: means some task repositories of OpenMMLab, such mmcls, mmdet, mmseg and so on.
+
+`_base_`: includes configures of datasets, experiment settings and model architectures.
+
+`distill`/`nas`/`pruning`: model compression algorithms.
+
+`vanilla`: task models owned by mmrazor.
+
+## More about config
+
+Please refer to [config](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/config.md) in mmengine.
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/2_train_different_types_algorithms.md b/internlm_langchain/knowledge_base/MMRazor/content/2_train_different_types_algorithms.md
new file mode 100644
index 00000000..06c68970
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/2_train_different_types_algorithms.md
@@ -0,0 +1,107 @@
+# Train different types algorithms
+
+**Before running our algorithms, you may need to prepare the datasets according to the instructions in the corresponding document.**
+
+**Note**:
+
+- With the help of mmengine, mmrazor unified entered interfaces for various tasks, thus our algorithms will adapt all OpenMMLab upstream repos in theory.
+
+- We dynamically pass arguments `cfg-options` (e.g., `mutable_cfg` in nas algorithm or `channel_cfg` in pruning algorithm) to **avoid the need for a config for each subnet or checkpoint**. If you want to specify different subnets for retraining or testing, you just need to change this argument.
+
+### NAS
+
+Here we take SPOS(Single Path One Shot) as an example. There are three steps to start neural network search(NAS), including **supernet pre-training**, **search for subnet on the trained supernet** and **subnet retraining**.
+
+#### Supernet Pre-training
+
+```Python
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+The usage of optional arguments are the same as corresponding tasks like mmclassification, mmdetection and mmsegmentation.
+
+For example,
+
+```Python
+python ./tools/train.py \
+ configs/nas/mmcls/spos/spos_shufflenet_supernet_8xb128_in1k.py
+ --work-dir $WORK_DIR
+```
+
+#### Search for Subnet on The Trained Supernet
+
+```Python
+python tools/train.py ${CONFIG_FILE} --cfg-options load_from=${CHECKPOINT_PATH} [optional arguments]
+```
+
+For example,
+
+```Python
+python ./tools/train.py \
+ configs/nas/mmcls/spos/spos_shufflenet_search_8xb128_in1k.py \
+ --cfg-options load_from=$STEP1_CKPT \
+ --work-dir $WORK_DIR
+```
+
+#### Subnet Retraining
+
+```Python
+python tools/train.py ${CONFIG_FILE} \
+ --cfg-options algorithm.fix_subnet=${MUTABLE_CFG_PATH} [optional arguments]
+```
+
+- `MUTABLE_CFG_PATH`: Path of `fix_subnet`. `fix_subnet` represents **config for mutable of the subnet searched out**, used to specify different subnets for retraining. An example for `fix_subnet` can be found [here](https://github.com/open-mmlab/mmrazor/blob/master/configs/nas/spos/SPOS_SHUFFLENETV2_330M_IN1k_PAPER.yaml), and the usage can be found [here](https://github.com/open-mmlab/mmrazor/blob/master/configs/nas/spos/README.md#subnet-retraining-on-imagenet).
+
+For example,
+
+```Python
+python ./tools/train.py \
+ configs/nas/mmcls/spos/spos_shufflenet_subnet_8xb128_in1k.py \
+ --work-dir $WORK_DIR \
+ --cfg-options algorithm.fix_subnet=$YAML_FILE_BY_STEP2
+```
+
+We note that instead of using `--cfg-options`, you can also directly modify ``` configs/nas/mmcls/spos/``spos_shufflenet_subnet_8xb128_in1k``.py ``` like this:
+
+```Python
+fix_subnet = 'configs/nas/mmcls/spos/SPOS_SHUFFLENETV2_330M_IN1k_PAPER.yaml'
+model = dict(fix_subnet=fix_subnet)
+```
+
+### Pruning
+
+Pruning has three steps, including **supernet pre-training**, **search for subnet on the trained supernet** and **subnet retraining**. The commands of the first two steps are similar to NAS, except that we need to use `CONFIG_FILE` of Pruning here. The commands of the **subnet retraining** are as follows.
+
+#### Subnet Retraining
+
+```Python
+python tools/train.py ${CONFIG_FILE} --cfg-options model._channel_cfg_paths=${CHANNEL_CFG_PATH} [optional arguments]
+```
+
+Different from NAS, the argument that needs to be specified here is `channel_cfg_paths` .
+
+- `CHANNEL_CFG_PATH`: Path of `_channel_cfg_path`. `channel_cfg` represents **config for channel of the subnet searched out**, used to specify different subnets for testing.
+
+For example, the default `_channel_cfg_paths` is set in the config below.
+
+```Python
+python ./tools/train.py \
+ configs/pruning/mmcls/autoslim/autoslim_mbv2_1.5x_subnet_8xb256_in1k_flops-530M.py \
+ --work-dir your_work_dir
+```
+
+### Distillation
+
+There is only one step to start knowledge distillation.
+
+```Python
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+For example,
+
+```Python
+python ./tools/train.py \
+ configs/distill/mmcls/kd/kd_logits_r34_r18_8xb32_in1k.py \
+ --work-dir your_work_dir
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/3_train_with_different_devices.md b/internlm_langchain/knowledge_base/MMRazor/content/3_train_with_different_devices.md
new file mode 100644
index 00000000..aa24654e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/3_train_with_different_devices.md
@@ -0,0 +1,93 @@
+# Train with different devices
+
+**Note**: The default learning rate in config files is for 8 GPUs. If using different number GPUs, the total batch size will change in proportion, you have to scale the learning rate following `new_lr = old_lr * new_ngpus / old_ngpus`. We recommend to use `tools/dist_train.sh` even with 1 gpu, since some methods do not support non-distributed training.
+
+### Training with CPU
+
+```Python
+export CUDA_VISIBLE_DEVICES=-1
+python tools/train.py ${CONFIG_FILE}
+```
+
+**Note**: We do not recommend users to use CPU for training because it is too slow and some algorithms are using `SyncBN` which is based on distributed training. We support this feature to allow users to debug on machines without GPU for convenience.
+
+### Train with single/multiple GPUs
+
+```Python
+sh tools/dist_train.sh ${CONFIG_FILE} ${GPUS} --work_dir ${YOUR_WORK_DIR} [optional arguments]
+```
+
+**Note**: During training, checkpoints and logs are saved in the same folder structure as the config file under `work_dirs/`. Custom work directory is not recommended since evaluation scripts infer work directories from the config file name. If you want to save your weights somewhere else, please use symlink, for example:
+
+```Python
+ln -s ${YOUR_WORK_DIRS} ${MMRAZOR}/work_dirs
+```
+
+Alternatively, if you run MMRazor on a cluster managed with [slurm](https://slurm.schedmd.com/):
+
+```Python
+GPUS_PER_NODE=${GPUS_PER_NODE} GPUS=${GPUS} SRUN_ARGS=${SRUN_ARGS} sh tools/xxx/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${YOUR_WORK_DIR} [optional arguments]
+```
+
+### Train with multiple machines
+
+If you launch with multiple machines simply connected with ethernet, you can simply run the following commands:
+
+On the first machine:
+
+```Python
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+On the second machine:
+
+```Python
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+Usually it is slow if you do not have high speed networking like InfiniBand.
+
+If you launch with slurm, the command is the same as that on single machine described above, but you need refer to [slurm_train.sh](https://github.com/open-mmlab/mmselfsup/blob/master/tools/slurm_train.sh) to set appropriate parameters and environment variables.
+
+### Launch multiple jobs on a single machine
+
+If you launch multiple jobs on a single machine, e.g., 2 jobs of 4-GPU training on a machine with 8 GPUs, you need to specify different ports (29500 by default) for each job to avoid communication conflict.
+
+If you use `dist_train.sh` to launch training jobs:
+
+```Python
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh tools/xxx/dist_train.sh ${CONFIG_FILE} 4 --work_dir tmp_work_dir_1
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh tools/xxx/dist_train.sh ${CONFIG_FILE} 4 --work_dir tmp_work_dir_2
+```
+
+If you use launch training jobs with slurm, you have two options to set different communication ports:
+
+Option 1:
+
+In `config1.py`:
+
+```Python
+dist_params = dict(backend='nccl', port=29500)
+```
+
+In `config2.py`:
+
+```Python
+dist_params = dict(backend='nccl', port=29501)
+```
+
+Then you can launch two jobs with config1.py and config2.py.
+
+```Python
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py tmp_work_dir_1
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py tmp_work_dir_2
+```
+
+Option 2:
+
+You can set different communication ports without the need to modify the configuration file, but have to set the `cfg-options` to overwrite the default port in configuration file.
+
+```Python
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py tmp_work_dir_1 --cfg-options dist_params.port=29500
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py tmp_work_dir_2 --cfg-options dist_params.port=29501
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/4_test_a_model.md b/internlm_langchain/knowledge_base/MMRazor/content/4_test_a_model.md
new file mode 100644
index 00000000..152b5dc4
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/4_test_a_model.md
@@ -0,0 +1,79 @@
+# Test a model
+
+### NAS
+
+To test nas method, you can use the following command.
+
+```Python
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_PATH} --cfg-options algorithm.fix_subnet=${FIX_SUBNET_PATH} [optional arguments]
+```
+
+- `FIX_SUBNET_PATH`: Path of `fix_subnet`. `fix_subnet` represents **config for mutable of the subnet searched out**, used to specify different subnets for testing. An example for `fix_subnet` can be found [here](https://github.com/open-mmlab/mmrazor/blob/master/configs/nas/spos/SPOS_SHUFFLENETV2_330M_IN1k_PAPER.yaml).
+
+The usage of optional arguments are the same as corresponding tasks like mmclassification, mmdetection and mmsegmentation.
+
+For example,
+
+```Python
+python tools/test.py \
+ configs/nas/mmcls/spos/spos_subnet_shufflenetv2_8xb128_in1k.py \
+ your_subnet_checkpoint_path \
+ --cfg-options algorithm.fix_subnet=configs/nas/mmcls/spos/SPOS_SHUFFLENETV2_330M_IN1k_PAPER.yaml
+```
+
+### Pruning
+
+#### Split Checkpoint(Optional)
+
+If you train a slimmable model during retraining, checkpoints of different subnets are actually fused in only one checkpoint. You can split this checkpoint to multiple independent checkpoints by using the following command
+
+```Python
+python tools/model_converters/split_checkpoint.py ${CONFIG_FILE} ${CHECKPOINT_PATH} --channel-cfgs ${CHANNEL_CFG_PATH} [optional arguments]
+```
+
+- `CHANNEL_CFG_PATH`: A list of paths of `channel_cfg`. For example, when you retrain a slimmable model, your command will be like `--cfg-options algorithm.channel_cfg=cfg1,cfg2,cfg3`. And your command here should be `--channel-cfgs cfg1 cfg2 cfg3`. The order of them should be the same.
+
+For example,
+
+```Python
+python tools/model_converters/split_checkpoint.py \
+ configs/pruning/autoslim/autoslim_mbv2_subnet_8xb256_in1k.py \
+ your_retraining_checkpoint_path \
+ --channel-cfgs configs/pruning/autoslim/AUTOSLIM_MBV2_530M_OFFICIAL.yaml configs/pruning/autoslim/AUTOSLIM_MBV2_320M_OFFICIAL.yaml configs/pruning/autoslim/AUTOSLIM_MBV2_220M_OFFICIAL.yaml
+```
+
+#### Test
+
+To test pruning method, you can use following command
+
+```Python
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_PATH} --cfg-options model._channel_cfg_paths=${CHANNEL_CFG_PATH} [optional arguments]
+```
+
+- `task`: one of `mmcls`、`mmdet` and `mmseg`
+
+- `CHANNEL_CFG_PATH`: Path of `channel_cfg`. `channel_cfg` represents **config for channel of the subnet searched out**, used to specify different subnets for testing. An example for `channel_cfg` can be found [here](https://github.com/open-mmlab/mmrazor/blob/master/configs/pruning/autoslim/AUTOSLIM_MBV2_220M_OFFICIAL.yaml), and the usage can be found [here](https://github.com/open-mmlab/mmrazor/blob/master/configs/pruning/autoslim/README.md#test-a-subnet).
+
+For example,
+
+```Python
+python ./tools/test.py \
+ configs/pruning/mmcls/autoslim/autoslim_mbv2__1.5x_subnet_8xb256_in1k-530M.py \
+ your_splitted_checkpoint_path --metrics accuracy
+```
+
+### Distillation
+
+To test the distillation method, you can use the following command
+
+```Python
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_PATH} [optional arguments]
+```
+
+For example,
+
+```Python
+python ./tools/test.py \
+ configs/distill/mmseg/cwd/cwd_logits_pspnet_r101_d8_pspnet_r18_d8_512x1024_cityscapes_80k.py \
+ your_splitted_checkpoint_path --show
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/algorithm.md b/internlm_langchain/knowledge_base/MMRazor/content/algorithm.md
new file mode 100644
index 00000000..ae632db6
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/algorithm.md
@@ -0,0 +1,273 @@
+# Algorithm
+
+## Introduction
+
+### What is algorithm in MMRazor
+
+MMRazor is a model compression toolkit, which includes 4 mianstream technologies:
+
+- Neural Architecture Search (NAS)
+- Pruning
+- Knowledge Distillation (KD)
+- Quantization (come soon)
+
+And in MMRazor, `algorithm` is a general item for these technologies. For example, in NAS,
+
+[SPOS](https://github.com/open-mmlab/mmrazor/blob/master/configs/nas/spos)[ ](https://arxiv.org/abs/1904.00420)is an `algorithm`, [CWD](https://github.com/open-mmlab/mmrazor/blob/master/configs/distill/cwd) is also an `algorithm` of knowledge distillation.
+
+`algorithm` is the entrance of `mmrazor/models` . Its role in MMRazor is the same as both `classifier` in [MMClassification](https://github.com/open-mmlab/mmclassification) and `detector` in [MMDetection](https://github.com/open-mmlab/mmdetection).
+
+### About base algorithm
+
+In the directory of `models/algorithms`, all model compression algorithms are divided into 4 subdirectories: nas / pruning / distill / quantization. These algorithms must inherit from `BaseAlgorithm`, whose definition is as below.
+
+```Python
+from typing import Dict, List, Optional, Tuple, Union
+from mmengine.model import BaseModel
+from mmrazor.registry import MODELS
+
+LossResults = Dict[str, torch.Tensor]
+TensorResults = Union[Tuple[torch.Tensor], torch.Tensor]
+PredictResults = List[BaseDataElement]
+ForwardResults = Union[LossResults, TensorResults, PredictResults]
+
+@MODELS.register_module()
+class BaseAlgorithm(BaseModel):
+
+ def __init__(self,
+ architecture: Union[BaseModel, Dict],
+ data_preprocessor: Optional[Union[Dict, nn.Module]] = None,
+ init_cfg: Optional[Dict] = None):
+
+ ......
+
+ super().__init__(data_preprocessor, init_cfg)
+ self.architecture = architecture
+
+ def forward(self,
+ batch_inputs: torch.Tensor,
+ data_samples: Optional[List[BaseDataElement]] = None,
+ mode: str = 'tensor') -> ForwardResults:
+
+ if mode == 'loss':
+ return self.loss(batch_inputs, data_samples)
+ elif mode == 'tensor':
+ return self._forward(batch_inputs, data_samples)
+ elif mode == 'predict':
+ return self._predict(batch_inputs, data_samples)
+ else:
+ raise RuntimeError(f'Invalid mode "{mode}". '
+ 'Only supports loss, predict and tensor mode')
+
+ def loss(
+ self,
+ batch_inputs: torch.Tensor,
+ data_samples: Optional[List[BaseDataElement]] = None,
+ ) -> LossResults:
+ """Calculate losses from a batch of inputs and data samples."""
+ return self.architecture(batch_inputs, data_samples, mode='loss')
+
+ def _forward(
+ self,
+ batch_inputs: torch.Tensor,
+ data_samples: Optional[List[BaseDataElement]] = None,
+ ) -> TensorResults:
+ """Network forward process."""
+ return self.architecture(batch_inputs, data_samples, mode='tensor')
+
+ def _predict(
+ self,
+ batch_inputs: torch.Tensor,
+ data_samples: Optional[List[BaseDataElement]] = None,
+ ) -> PredictResults:
+ """Predict results from a batch of inputs and data samples with post-
+ processing."""
+ return self.architecture(batch_inputs, data_samples, mode='predict')
+```
+
+As you can see from above, `BaseAlgorithm` is inherited from `BaseModel` of MMEngine. `BaseModel` implements the basic functions of the algorithmic model, such as weights initialize,
+
+batch inputs preprocess (see more information in `BaseDataPreprocessor` class of MMEngine), parse losses, and update model parameters. For more details of `BaseModel` , you can see docs for `BaseModel`.
+
+`BaseAlgorithm`'s forward is just a wrapper of `BaseModel`'s forward. Sub-classes inherited from BaseAlgorithm only need to override the `loss` method, which implements the logic to calculate loss, thus various algorithms can be trained in the runner.
+
+## How to use existing algorithms in MMRazor
+
+1. Configure your architecture that will be slimmed
+
+- Use the model config of other repos of OpenMMLab directly as below, which is an example of setting Faster-RCNN as our architecture.
+
+```Python
+_base_ = [
+ 'mmdet::_base_/models/faster_rcnn_r50_fpn.py',
+]
+
+architecture = _base_.model
+```
+
+- Use your customized model as below, which is an example of defining a VGG model as our architecture.
+
+```{note}
+How to customize architectures can refer to our tutorial: [Customize Architectures](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_architectures.html).
+```
+
+```Python
+default_scope='mmcls'
+architecture = dict(
+ type='ImageClassifier',
+ backbone=dict(type='VGG', depth=11, num_classes=1000),
+ neck=None,
+ head=dict(
+ type='ClsHead',
+ loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
+ topk=(1, 5),
+ ))
+```
+
+2. Apply the registered algorithm to your architecture.
+
+```{note}
+The arg name of `algorithm` in config is **model** rather than **algorithm** in order to get better supports of MMCV and MMEngine.
+```
+
+Maybe more args in model need to set according to the used algorithm.
+
+```Python
+model = dict(
+ type='BaseAlgorithm',
+ architecture=architecture)
+```
+
+```{note}
+About the usage of `Config`, refer to [config.md](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/config.md) please.
+```
+
+3. Apply some custom hooks or loops to your algorithm. (optional)
+
+- Custom hooks
+
+```Python
+custom_hooks = [
+ dict(type='NaiveVisualizationHook', priority='LOWEST'),
+]
+```
+
+- Custom loops
+
+```Python
+_base_ = ['./spos_shufflenet_supernet_8xb128_in1k.py']
+
+# To chose from ['train_cfg', 'val_cfg', 'test_cfg'] based on your loop type
+train_cfg = dict(
+ _delete_=True,
+ type='mmrazor.EvolutionSearchLoop',
+ dataloader=_base_.val_dataloader,
+ evaluator=_base_.val_evaluator)
+
+val_cfg = dict()
+test_cfg = dict()
+```
+
+## How to customize your algorithm
+
+### Common pipeline
+
+1. Register a new algorithm
+
+Create a new file `mmrazor/models/algorithms/{subdirectory}/xxx.py`
+
+```Python
+from mmrazor.models.algorithms import BaseAlgorithm
+from mmrazor.registry import MODELS
+
+@MODELS.register_module()
+class XXX(BaseAlgorithm):
+ def __init__(self, architecture):
+ super().__init__(architecture)
+ pass
+
+ def loss(self, batch_inputs):
+ pass
+```
+
+2. Rewrite its `loss` method.
+
+```Python
+from mmrazor.models.algorithms import BaseAlgorithm
+from mmrazor.registry import MODELS
+
+@MODELS.register_module()
+class XXX(BaseAlgorithm):
+ def __init__(self, architecture):
+ super().__init__(architecture)
+ ......
+
+ def loss(self, batch_inputs):
+ ......
+ return LossResults
+```
+
+3. Add the remaining functions of the algorithm
+
+```{note}
+This step is special because of the diversity of algorithms. Some functions of the algorithm may also be implemented in other files.
+```
+
+```Python
+from mmrazor.models.algorithms import BaseAlgorithm
+from mmrazor.registry import MODELS
+
+@MODELS.register_module()
+class XXX(BaseAlgorithm):
+ def __init__(self, architecture):
+ super().__init__(architecture)
+ ......
+
+ def loss(self, batch_inputs):
+ ......
+ return LossResults
+
+ def aaa(self):
+ ......
+
+ def bbb(self):
+ ......
+```
+
+4. Import the class
+
+You can add the following line to `mmrazor/models/algorithms/{subdirectory}/__init__.py`
+
+```CoffeeScript
+from .xxx import XXX
+
+__all__ = ['XXX']
+```
+
+In addition, import XXX in `mmrazor/models/algorithms/__init__.py`
+
+5. Use the algorithm in your config file.
+
+Please refer to the previous section about how to use existing algorithms in MMRazor
+
+```Python
+model = dict(
+ type='XXX',
+ architecture=architecture)
+```
+
+### Pipelines for different algorithms
+
+Please refer to our tutorials about how to customize different algorithms for more details as below.
+
+1. NAS
+
+[Customize NAS algorithms](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_nas_algorithms.html)
+
+2. Pruning
+
+[Customize Pruning algorithms](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_pruning_algorithms.html)
+
+3. Distill
+
+[Customize KD algorithms](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_kd_algorithms.html)
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/apply_existing_algorithms_to_new_tasks.md b/internlm_langchain/knowledge_base/MMRazor/content/apply_existing_algorithms_to_new_tasks.md
new file mode 100644
index 00000000..119d7a6c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/apply_existing_algorithms_to_new_tasks.md
@@ -0,0 +1,83 @@
+# Apply existing algorithms to new tasks
+
+Here we show how to apply existing algorithms to other tasks with an example of [SPOS ](https://github.com/open-mmlab/mmrazor/tree/main/configs/nas/mmcls/spos)& [DetNAS](https://github.com/open-mmlab/mmrazor/tree/main/configs/nas/mmdet/detnas).
+
+> SPOS: Single Path One-Shot NAS for classification
+>
+> DetNAS: Single Path One-Shot NAS for detection
+
+**You just need to configure the existing algorithms in your config only by replacing** **the architecture of** **mmcls** **with** **mmdet** **'s**
+
+You can implement a new algorithm by inheriting from the existing algorithm quickly if the new task's specificity leads to the failure of applying directly.
+
+SPOS config VS DetNAS config
+
+- SPOS
+
+```Python
+_base_ = [
+ 'mmrazor::_base_/settings/imagenet_bs1024_spos.py',
+ 'mmrazor::_base_/nas_backbones/spos_shufflenet_supernet.py',
+ 'mmcls::_base_/default_runtime.py',
+]
+
+# model
+supernet = dict(
+ type='ImageClassifier',
+ data_preprocessor=_base_.preprocess_cfg,
+ backbone=_base_.nas_backbone,
+ neck=dict(type='GlobalAveragePooling'),
+ head=dict(
+ type='LinearClsHead',
+ num_classes=1000,
+ in_channels=1024,
+ loss=dict(
+ type='LabelSmoothLoss',
+ num_classes=1000,
+ label_smooth_val=0.1,
+ mode='original',
+ loss_weight=1.0),
+ topk=(1, 5)))
+
+model = dict(
+ type='mmrazor.SPOS',
+ architecture=supernet,
+ mutator=dict(type='mmrazor.OneShotModuleMutator'))
+
+find_unused_parameters = True
+```
+
+- DetNAS
+
+```Python
+_base_ = [
+ 'mmdet::_base_/models/faster-rcnn_r50_fpn.py',
+ 'mmdet::_base_/datasets/coco_detection.py',
+ 'mmdet::_base_/schedules/schedule_1x.py',
+ 'mmdet::_base_/default_runtime.py',
+ 'mmrazor::_base_/nas_backbones/spos_shufflenet_supernet.py'
+]
+
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+
+supernet = _base_.model
+
+supernet.backbone = _base_.nas_backbone
+supernet.backbone.norm_cfg = norm_cfg
+supernet.backbone.out_indices = (0, 1, 2, 3)
+supernet.backbone.with_last_layer = False
+
+supernet.neck.norm_cfg = norm_cfg
+supernet.neck.in_channels = [64, 160, 320, 640]
+
+supernet.roi_head.bbox_head.norm_cfg = norm_cfg
+supernet.roi_head.bbox_head.type = 'Shared4Conv1FCBBoxHead'
+
+model = dict(
+ _delete_=True,
+ type='mmrazor.SPOS',
+ architecture=supernet,
+ mutator=dict(type='mmrazor.OneShotModuleMutator'))
+
+find_unused_parameters = True
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/changelog.md b/internlm_langchain/knowledge_base/MMRazor/content/changelog.md
new file mode 100644
index 00000000..338c9425
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/changelog.md
@@ -0,0 +1,278 @@
+# Changelog of v1.x
+
+## v1.0.0 (24/04/2023)
+
+We are excited to announce the first official release of MMRazor 1.0.
+
+### Highlights
+
+- MMRazor quantization is released, which has got through task models and model deployment. With its help, we can quantize and deploy pre-trained models in OpenMMLab to specified backend quickly.
+
+### New Features & Improvements
+
+#### NAS
+
+- Update searchable model. (https://github.com/open-mmlab/mmrazor/pull/438)
+- Update NasMutator to build search_space in NAS. (https://github.com/open-mmlab/mmrazor/pull/426)
+
+#### Pruning
+
+- Add a new pruning algorithm named GroupFisher. We support the full pipeline for GroupFisher, including pruning, finetuning and deployment.(https://github.com/open-mmlab/mmrazor/pull/459)
+
+#### KD
+
+- Support stopping distillation after a certain epoch. (https://github.com/open-mmlab/mmrazor/pull/455)
+- Support distilling rtmdet with mmrazor, refer to here. (https://github.com/open-mmlab/mmyolo/pull/544)
+- Add mask channel in MGD Loss. (https://github.com/open-mmlab/mmrazor/pull/461)
+
+#### Quantization
+
+- Support two quantization types: QAT and PTQ (https://github.com/open-mmlab/mmrazor/pull/513)
+- Support various quantization bits. (https://github.com/open-mmlab/mmrazor/pull/513)
+- Support various quantization methods, such as per_tensor / per_channel, symmetry / asymmetry and so on. (https://github.com/open-mmlab/mmrazor/pull/513)
+- Support deploy quantized models to multiple backends, such as OpenVINO, TensorRT and so on. (https://github.com/open-mmlab/mmrazor/pull/513)
+- Support applying quantization algorithms to multiple task repos directly, such as mmcls, mmdet and so on. (https://github.com/open-mmlab/mmrazor/pull/513)
+
+### Bug Fixes
+
+- Fix split in Darts config. (https://github.com/open-mmlab/mmrazor/pull/451)
+- Fix a bug in Recorders. (https://github.com/open-mmlab/mmrazor/pull/446)
+- Fix a bug when using get_channel_unit.py. (https://github.com/open-mmlab/mmrazor/pull/432)
+- Fix a bug when deploying a pruned model to cuda. (https://github.com/open-mmlab/mmrazor/pull/495)
+
+### Contributors
+
+A total of 10 developers contributed to this release.
+Thanks @415905716 @gaoyang07 @humu789 @LKJacky @HIT-cwh @aptsunny @cape-zck @vansin @twmht @wm901115nwpu
+
+## v1.0.0rc2 (06/01/2023)
+
+We are excited to announce the release of MMRazor 1.0.0rc2.
+
+### New Features
+
+#### NAS
+
+- Add Performance Predictor: Support 4 performance predictors with 4 basic machine learning algorithms, which can be used to directly predict model accuracy without evaluation.(https://github.com/open-mmlab/mmrazor/pull/306)
+
+- Support [Autoformer](https://arxiv.org/pdf/2107.00651.pdf), a one-shot architecture search algorithm dedicated to vision transformer search.(https://github.com/open-mmlab/mmrazor/pull/315 )
+
+- Support [BigNAS](https://arxiv.org/pdf/2003.11142), a NAS algorithm which searches the following items in MobileNetV3 with the one-shot paradigm: kernel_sizes, out_channels, expand_ratios, block_depth and input sizes. (https://github.com/open-mmlab/mmrazor/pull/219 )
+
+#### Pruning
+
+- Support [DCFF](https://arxiv.org/abs/2107.06916), a filter channel pruning algorithm dedicated to efficient image classification.(https://github.com/open-mmlab/mmrazor/pull/295)
+
+- We release a powerful tool to automatically analyze channel dependency, named ChannelAnalyzer. Here is an example as shown below.(https://github.com/open-mmlab/mmrazor/pull/371)
+
+Now, ChannelAnalyzer supports most of CNN models in torchvision, mmcls, mmseg and mmdet. We will continue to support more models.
+
+```python
+from mmrazor.models.task_modules import ChannelAnalyzer
+from mmengine.hub import get_model
+import json
+
+model = get_model('mmdet::retinanet/retinanet_r18_fpn_1x_coco.py')
+unit_configs: dict = ChannelAnalyzer().analyze(model)
+unit_config0 = list(unit_configs.values())[0]
+print(json.dumps(unit_config0, indent=4))
+# # short version of the config
+# {
+# "channels": {
+# "input_related": [
+# {"name": "backbone.layer2.0.bn1"},
+# {“name": "backbone.layer2.0.conv2"}
+# ],
+# "output_related": [
+# {"name": "backbone.layer2.0.conv1"},
+# {"name": "backbone.layer2.0.bn1"}
+# ]
+# },
+#}
+```
+
+#### KD
+
+- Support [MGD](https://arxiv.org/abs/2205.01529), a detection distillation algorithm.(https://github.com/open-mmlab/mmrazor/pull/381)
+
+### Bug Fixes
+
+- Fix `FpnTeacherDistll` techer forward from `backbone + neck + head` to `backbone + neck`(#387 )
+- Fix some expire configs and checkpoints(#373 #372 #422 )
+
+### Ongoing Changes
+
+We will release Quantization in next version(1.0.0rc3)!
+
+### Contributors
+
+A total of 11 developers contributed to this release: @wutongshenqiu @sunnyxiaohu @aptsunny @humu789 @TinyTigerPan @FreakieHuang @LKJacky @wilxy @gaoyang07 @spynccat @yivona08.
+
+## v1.0.0rc1 (27/10/2022)
+
+We are excited to announce the release of MMRazor 1.0.0rc1.
+
+### Highlights
+
+- **New Pruning Framework**：We have systematically refactored the Pruning module. The new Pruning module can more automatically resolve the dependencies between channels and cover more corner cases.
+
+### New Features
+
+#### Pruning
+
+- A new pruning framework is released in this release. (#311, #313)
+ It consists of five core modules, including Algorithm, `ChannelMutator`, `MutableChannelUnit`, `MutableChannel` and `DynamicOp`.
+
+- MutableChannelUnit is introduced for the first time. Each MutableChannelUnit manages all channels with channel dependency.
+
+ ```python
+ from mmrazor.registry import MODELS
+
+ ARCHITECTURE_CFG = dict(
+ _scope_='mmcls',
+ type='ImageClassifier',
+ backbone=dict(type='MobileNetV2', widen_factor=1.5),
+ neck=dict(type='GlobalAveragePooling'),
+ head=dict(type='mmcls.LinearClsHead', num_classes=1000, in_channels=1920))
+ model = MODELS.build(ARCHITECTURE_CFG)
+ from mmrazor.models.mutators import ChannelMutator
+
+ channel_mutator = ChannelMutator()
+ channel_mutator.prepare_from_supernet(model)
+ units = channel_mutator.mutable_units
+ print(units[0])
+ # SequentialMutableChannelUnit(
+ # name=backbone.conv1.conv_(0, 48)_48
+ # (output_related): ModuleList(
+ # (0): Channel(backbone.conv1.conv, index=(0, 48), is_output_channel=true, expand_ratio=1)
+ # (1): Channel(backbone.conv1.bn, index=(0, 48), is_output_channel=true, expand_ratio=1)
+ # (2): Channel(backbone.layer1.0.conv.0.conv, index=(0, 48), is_output_channel=true, expand_ratio=1)
+ # (3): Channel(backbone.layer1.0.conv.0.bn, index=(0, 48), is_output_channel=true, expand_ratio=1)
+ # )
+ # (input_related): ModuleList(
+ # (0): Channel(backbone.conv1.bn, index=(0, 48), is_output_channel=false, expand_ratio=1)
+ # (1): Channel(backbone.layer1.0.conv.0.conv, index=(0, 48), is_output_channel=false, expand_ratio=1)
+ # (2): Channel(backbone.layer1.0.conv.0.bn, index=(0, 48), is_output_channel=false, expand_ratio=1)
+ # (3): Channel(backbone.layer1.0.conv.1.conv, index=(0, 48), is_output_channel=false, expand_ratio=1)
+ # )
+ # (mutable_channel): SquentialMutableChannel(num_channels=48, activated_channels=48)
+ # )
+ ```
+
+Our new pruning algorithm can help you develop pruning algorithm more fluently. Pelease refer to our documents [PruningUserGuide](<./docs/en/user_guides/../../pruning/%5Bpruning_user_guide.md%5D(http://pruning_user_guide.md/)>) for model detail.
+
+#### Distillation
+
+- Support [CRD](https://arxiv.org/abs/1910.10699), a distillation algorithm based on contrastive representation learning. (#281)
+
+- Support [PKD](https://arxiv.org/abs/2207.02039), a distillation algorithm that can be used in `MMDetection` and `MMDetection3D`. #304
+
+- Support [DEIT](https://arxiv.org/abs/2012.12877), a classic **Transformer** distillation algorithm.(#332)
+
+- Add a more powerful baseline setting for [KD](https://arxiv.org/abs/1503.02531). (#305)
+
+- Add `MethodInputsRecorder` and `FuncInputsRecorder` to record the input of a class method or a function.(#320)
+
+#### NAS
+
+- Support [DSNAS](https://arxiv.org/pdf/2002.09128.pdf), a nas algorithm that does not require retraining. (#226 )
+
+#### Tools
+
+- Support configurable immediate feature map visualization. (#293 )
+ A useful tool is supported in this release to visualize the immediate features of a neural network. Please refer to our documents [VisualizationUserGuide](http://./docs/zh_cn/user_guides/visualization.md) for more details.
+
+### Bug Fixes
+
+- Fix the bug that `FunctionXXRecorder` and `FunctionXXDelivery` can not be pickled. (#320)
+
+### Ongoing changes
+
+- Quantization: We are developing the basic interface of PTQ and QAT. RFC(Request for Comments) will be released soon.
+- AutoSlim: AutoSlim is not yet available and is being refactored.
+- Fx Pruning Tracer: Currently, the model topology can only be resolved through the backward tracer. In the future, both backward tracer and fx tracer will be supported.
+- More Algorithms: BigNAS、AutoFormer、GreedyNAS and Resrep will be released in the next few versions.
+- Documentation: we will add more design docs, tutorials, and migration guidance so that the community can deep dive into our new design, participate the future development, and smoothly migrate downstream libraries to MMRazor 1.x.
+
+### Contributors
+
+A total of 12 developers contributed to this release.
+Thanks @FreakieHuang @gaoyang07 @HIT-cwh @humu789 @LKJacky @pppppM @pprp @spynccat @sunnyxiaohu @wilxy @kitecats @SheffieldCao
+
+## v1.0.0rc0 (31/8/2022)
+
+We are excited to announce the release of MMRazor 1.0.0rc0.
+MMRazor 1.0.0rc0 is the first version of MMRazor 1.x, a part of the OpenMMLab 2.0 projects.
+Built upon the new [training engine](https://github.com/open-mmlab/mmengine),
+MMRazor 1.x simplified the interaction with other OpenMMLab repos, and upgraded the basic APIs of KD / Pruning / NAS.
+It also provides a series of knowledge distillation algorithms.
+
+### Highlights
+
+- **New engines**. MMRazor 1.x is based on [MMEngine](https://github.com/open-mmlab/mmengine), which provides a general and powerful runner that allows more flexible customizations and significantly simplifies the entrypoints of high-level interfaces.
+
+- **Unified interfaces**. As a part of the OpenMMLab 2.0 projects, MMRazor 1.x unifies and refactors the interfaces and internal logic of train, testing, datasets, models, evaluation, and visualization. All the OpenMMLab 2.0 projects share the same design in those interfaces and logic to allow the emergence of multi-task/modality algorithms.
+
+- **More configurable KD**. MMRazor 1.x add [Recorder](../advanced_guides/recorder.md) to get the data needed for KD more automatically，[Delivery ](../advanced_guides/delivery.md) to automatically pass the teacher's intermediate results to the student， and connector to handle feature dimension mismatches between teacher and student.
+
+- **More kinds of KD algorithms**. Benefitting from the powerful APIs of KD， we have added several categories of KD algorithms, data-free distillation, self-distillation, and zero-shot distillation.
+
+- **Unify the basic interface of NAS and Pruning**. We refactored [Mutable](../advanced_guides/mutable.md), adding mutable value and mutable channel. Both NAS and Pruning can be developed based on mutables.
+
+- **More documentation and tutorials**. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmrazor.readthedocs.io/en/1.0.0rc0/).
+
+### Breaking Changes
+
+#### Training and testing
+
+- MMRazor 1.x runs on PyTorch>=1.6. We have deprecated the support of PyTorch 1.5 to embrace the mixed precision training and other new features since PyTorch 1.6. Some models can still run on PyTorch 1.5, but the full functionality of MMRazor 1.x is not guaranteed.
+- MMRazor 1.x uses Runner in [MMEngine](https://github.com/open-mmlab/mmengine) rather than that in MMCV. The new Runner implements and unifies the building logic of dataset, model, evaluation, and visualizer. Therefore, MMRazor 1.x no longer maintains the building logics of those modules in `mmdet.train.apis` and `tools/train.py`. Those code have been migrated into [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py).
+- The Runner in MMEngine also supports testing and validation. The testing scripts are also simplified, which has similar logic as that in training scripts to build the runner.
+
+#### Configs
+
+- The [Runner in MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py) uses a different config structures
+- Config and model names
+
+#### Components
+
+- Algorithms
+- Distillers
+- Mutators
+- Mutables
+- Hooks
+
+### Improvements
+
+- Support mixed precision training of all the models. However, some models may got Nan results due to some numerical issues. We will update the documentation and list their results (accuracy of failure) of mixed precision training.
+
+### Bug Fixes
+
+- AutoSlim: Models of different sizes will no longer have the same size checkpoint
+
+### New Features
+
+- Support [Activation Boundaries Loss](https://arxiv.org/pdf/1811.03233.pdf)
+- Support [Be Your Own Teacher](https://arxiv.org/abs/1905.08094)
+- Support [Data-Free Learning of Student Networks](https://doi.org/10.1109/ICCV.2019.00361)
+- Support [Data-Free Adversarial Distillation](https://arxiv.org/pdf/1912.11006.pdf)
+- Support [Decoupled Knowledge Distillation](https://arxiv.org/pdf/2203.08679.pdf)
+- Support [Factor Transfer](https://arxiv.org/abs/1802.04977)
+- Support [FitNets](https://arxiv.org/abs/1412.6550)
+- Support [Distilling the Knowledge in a Neural Network](https://arxiv.org/abs/1503.02531)
+- Support [Overhaul](https://arxiv.org/abs/1904.01866)
+- Support [Zero-shot Knowledge Transfer via Adversarial Belief Matching](https://arxiv.org/abs/1905.09768)
+
+### Ongoing changes
+
+- Quantization: We are developing the basic interface of PTQ and QAT. RFC(Request for Comments) will be released soon.
+- AutoSlim: AutoSlim is not yet available and is being refactored.
+- Fx Pruning Tracer: Currently, the model topology can only be resolved through the backward tracer. In the future, both backward tracer and fx tracer will be supported.
+- More Algorithms: BigNAS、AutoFormer、GreedyNAS and Resrep will be released in the next few versions.
+- Documentation: we will add more design docs, tutorials, and migration guidance so that the community can deep dive into our new design, participate the future development, and smoothly migrate downstream libraries to MMRazor 1.x.
+
+### Contributors
+
+A total of 13 developers contributed to this release.
+Thanks @FreakieHuang @gaoyang07 @HIT-cwh @humu789 @LKJacky @pppppM @pprp @spynccat @sunnyxiaohu @wilxy @wutongshenqiu @NickYangMin @Hiwyl
+Special thanks to @Davidgzx for his contribution to the data-free distillation algorithms
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/contribution_guide.md b/internlm_langchain/knowledge_base/MMRazor/content/contribution_guide.md
new file mode 100644
index 00000000..1ca3a9af
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/contribution_guide.md
@@ -0,0 +1,59 @@
+# Contribute Guide
+
+All kinds of contributions are welcome, including but not limited to the following.
+
+- Fix typo or bugs
+- Add documentation or translate the documentation into other languages
+- Add new features and components
+
+### Workflow
+
+1. fork and pull the latest OpenMMLab repository
+2. checkout a new branch (do not use master branch for PRs)
+3. commit your changes
+4. create a PR
+
+```{note}
+If you plan to add some new features that involve large changes, it is encouraged to open an issue for discussion first.
+```
+
+### Code style
+
+#### Python
+
+We adopt [PEP8](https://www.python.org/dev/peps/pep-0008/) as the preferred code style.
+
+We use the following tools for linting and formatting:
+
+- [flake8](https://github.com/PyCQA/flake8): A wrapper around some linter tools.
+- [isort](https://github.com/timothycrosley/isort): A Python utility to sort imports.
+- [yapf](https://github.com/google/yapf): A formatter for Python files.
+- [codespell](https://github.com/codespell-project/codespell): A Python utility to fix common misspellings in text files.
+- [mdformat](https://github.com/executablebooks/mdformat): Mdformat is an opinionated Markdown formatter that can be used to enforce a consistent style in Markdown files.
+- [docformatter](https://github.com/myint/docformatter): A formatter to format docstring.
+
+Style configurations of yapf and isort can be found in [setup.cfg](./setup.cfg).
+
+We use [pre-commit hook](https://pre-commit.com/) that checks and formats for `flake8`, `yapf`, `isort`, `trailing whitespaces`, `markdown files`,
+fixes `end-of-files`, `double-quoted-strings`, `python-encoding-pragma`, `mixed-line-ending`, sorts `requirments.txt` automatically on every commit.
+The config for a pre-commit hook is stored in [.pre-commit-config](./.pre-commit-config.yaml).
+
+After you clone the repository, you will need to install initialize pre-commit hook.
+
+```shell
+pip install -U pre-commit
+```
+
+From the repository folder
+
+```shell
+pre-commit install
+```
+
+After this on every commit check code linters and formatter will be enforced.
+
+> Before you create a PR, make sure that your code lints and is formatted by yapf.
+
+#### C++ and CUDA
+
+We follow the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html).
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/customize_architectures.md b/internlm_langchain/knowledge_base/MMRazor/content/customize_architectures.md
new file mode 100644
index 00000000..d815eb79
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/customize_architectures.md
@@ -0,0 +1,255 @@
+# Customize Architectures
+
+Different from other tasks, architectures in MMRazor may consist of some special model components, such as **searchable backbones, connectors, dynamic ops**. In MMRazor, you can not only develop some common model components like other codebases of OpenMMLab, but also develop some special model components. Here is how to develop searchable model components and common model components.
+
+## Develop searchable model components
+
+1. Define a new backbone
+
+Create a new file `mmrazor/models/architectures/backbones/searchable_shufflenet_v2.py`, class `SearchableShuffleNetV2` inherits from `BaseBackBone` of mmcls, which is the codebase that you will use to build the model.
+
+```Python
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import torch.nn as nn
+from mmcls.models.backbones.base_backbone import BaseBackbone
+from mmcv.cnn import ConvModule, constant_init, normal_init
+from mmcv.runner import ModuleList, Sequential
+from torch import Tensor
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmrazor.registry import MODELS
+
+@MODELS.register_module()
+class SearchableShuffleNetV2(BaseBackbone):
+
+ def __init__(self, ):
+ pass
+
+ def _make_layer(self, out_channels, num_blocks, stage_idx):
+ pass
+
+ def _freeze_stages(self):
+ pass
+
+ def init_weights(self):
+ pass
+
+ def forward(self, x):
+ pass
+
+ def train(self, mode=True):
+ pass
+```
+
+2. Build the architecture of the new backbone based on `arch_setting`
+
+```Python
+@MODELS.register_module()
+class SearchableShuffleNetV2(BaseBackbone):
+ def __init__(self,
+ arch_setting: List[List],
+ stem_multiplier: int = 1,
+ widen_factor: float = 1.0,
+ out_indices: Sequence[int] = (4, ),
+ frozen_stages: int = -1,
+ with_last_layer: bool = True,
+ conv_cfg: Optional[Dict] = None,
+ norm_cfg: Dict = dict(type='BN'),
+ act_cfg: Dict = dict(type='ReLU'),
+ norm_eval: bool = False,
+ with_cp: bool = False,
+ init_cfg: Optional[Union[Dict, List[Dict]]] = None) -> None:
+ layers_nums = 5 if with_last_layer else 4
+ for index in out_indices:
+ if index not in range(0, layers_nums):
+ raise ValueError('the item in out_indices must in '
+ f'range(0, 5). But received {index}')
+
+ self.frozen_stages = frozen_stages
+ if frozen_stages not in range(-1, layers_nums):
+ raise ValueError('frozen_stages must be in range(-1, 5). '
+ f'But received {frozen_stages}')
+
+ super().__init__(init_cfg)
+
+ self.arch_setting = arch_setting
+ self.widen_factor = widen_factor
+ self.out_indices = out_indices
+ self.conv_cfg = conv_cfg
+ self.norm_cfg = norm_cfg
+ self.act_cfg = act_cfg
+ self.norm_eval = norm_eval
+ self.with_cp = with_cp
+
+ last_channels = 1024
+ self.in_channels = 16 * stem_multiplier
+
+ # build the first layer
+ self.conv1 = ConvModule(
+ in_channels=3,
+ out_channels=self.in_channels,
+ kernel_size=3,
+ stride=2,
+ padding=1,
+ conv_cfg=conv_cfg,
+ norm_cfg=norm_cfg,
+ act_cfg=act_cfg)
+
+ # build the middle layers
+ self.layers = ModuleList()
+ for channel, num_blocks, mutable_cfg in arch_setting:
+ out_channels = round(channel * widen_factor)
+ layer = self._make_layer(out_channels, num_blocks,
+ copy.deepcopy(mutable_cfg))
+ self.layers.append(layer)
+
+ # build the last layer
+ if with_last_layer:
+ self.layers.append(
+ ConvModule(
+ in_channels=self.in_channels,
+ out_channels=last_channels,
+ kernel_size=1,
+ conv_cfg=conv_cfg,
+ norm_cfg=norm_cfg,
+ act_cfg=act_cfg))
+```
+
+3. Implement`_make_layer` with `mutable_cfg`
+
+```Python
+@MODELS.register_module()
+class SearchableShuffleNetV2(BaseBackbone):
+
+ ...
+
+ def _make_layer(self, out_channels: int, num_blocks: int,
+ mutable_cfg: Dict) -> Sequential:
+ """Stack mutable blocks to build a layer for ShuffleNet V2.
+ Note:
+ Here we use ``module_kwargs`` to pass dynamic parameters such as
+ ``in_channels``, ``out_channels`` and ``stride``
+ to build the mutable.
+ Args:
+ out_channels (int): out_channels of the block.
+ num_blocks (int): number of blocks.
+ mutable_cfg (dict): Config of mutable.
+ Returns:
+ mmcv.runner.Sequential: The layer made.
+ """
+ layers = []
+ for i in range(num_blocks):
+ stride = 2 if i == 0 else 1
+
+ mutable_cfg.update(
+ module_kwargs=dict(
+ in_channels=self.in_channels,
+ out_channels=out_channels,
+ stride=stride))
+ layers.append(MODELS.build(mutable_cfg))
+ self.in_channels = out_channels
+
+ return Sequential(*layers)
+
+ ...
+```
+
+4. Implement other common methods
+
+You can refer to the implementation of `ShuffleNetV2` in mmcls for finishing other common methods.
+
+5. Import the module
+
+You can either add the following line to `mmrazor/models/architectures/backbones/__init__.py`
+
+```Python
+from .searchable_shufflenet_v2 import SearchableShuffleNetV2
+
+__all__ = ['SearchableShuffleNetV2']
+```
+
+or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.architectures.backbones.searchable_shufflenet_v2'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+6. Use the backbone in your config file
+
+```Python
+architecture = dict(
+ type=xxx,
+ model=dict(
+ ...
+ backbone=dict(
+ type='mmrazor.SearchableShuffleNetV2',
+ arg1=xxx,
+ arg2=xxx),
+ ...
+```
+
+## Develop common model components
+
+Here we show how to add a new backbone with an example of `xxxNet`.
+
+1. Define a new backbone
+
+Create a new file `mmrazor/models/architectures/backbones/xxxnet.py`, then implement the class `xxxNet`.
+
+```Python
+from mmengine.model import BaseModule
+from mmrazor.registry import MODELS
+
+@MODELS.register_module()
+class xxxNet(BaseModule):
+
+ def __init__(self, arg1, arg2, init_cfg=None):
+ super().__init__(init_cfg=init_cfg)
+ pass
+
+ def forward(self, x):
+ pass
+```
+
+2. Import the module
+
+You can either add the following line to `mmrazor/models/architectures/backbones/__init__.py`
+
+```Python
+from .xxxnet import xxxNet
+
+__all__ = ['xxxNet']
+```
+
+or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.architectures.backbones.xxxnet'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+3. Use the backbone in your config file
+
+```Python
+architecture = dict(
+ type=xxx,
+ model=dict(
+ ...
+ backbone=dict(
+ type='xxxNet',
+ arg1=xxx,
+ arg2=xxx),
+ ...
+```
+
+How to add other model components is similar to backbone's. For more details, please refer to other codebases' docs.
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/customize_kd_algorithms.md b/internlm_langchain/knowledge_base/MMRazor/content/customize_kd_algorithms.md
new file mode 100644
index 00000000..dee759c5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/customize_kd_algorithms.md
@@ -0,0 +1,124 @@
+# Customize KD algorithms
+
+Here we show how to develop new KD algorithms with an example of `SingleTeacherDistill`.
+
+1. Register a new algorithm
+
+Create a new file `mmrazor/models/algorithms/distill/configurable/single_teacher_distill.py`, class `SingleTeacherDistill` inherits from class `BaseAlgorithm`
+
+```Python
+from mmrazor.registry import MODELS
+from ..base import BaseAlgorithm
+
+@ALGORITHMS.register_module()
+class SingleTeacherDistill(BaseAlgorithm):
+ def __init__(self, use_gt, **kwargs):
+ super(Distillation, self).__init__(**kwargs)
+ pass
+
+ def train_step(self, data, optimizer):
+ pass
+```
+
+2. Develop connectors (Optional) .
+
+Take ConvModuleConnector as an example.
+
+```python
+from mmrazor.registry import MODELS
+from .base_connector import BaseConnector
+
+@MODELS.register_module()
+class ConvModuleConnector(BaseConnector):
+ def __init__(self, in_channel, out_channel, kernel_size = 1, stride = 1):
+ ...
+
+ def forward_train(self, feature):
+ ...
+```
+
+3. Develop distiller.
+
+Take `ConfigurableDistiller` as an example.
+
+```python
+from .base_distiller import BaseDistiller
+from mmrazor.registry import MODELS
+
+
+@MODELS.register_module()
+class ConfigurableDistiller(BaseDistiller):
+ def __init__(self,
+ student_recorders = None,
+ teacher_recorders = None,
+ distill_deliveries = None,
+ connectors = None,
+ distill_losses = None,
+ loss_forward_mappings = None):
+ ...
+
+ def build_connectors(self, connectors):
+ ...
+
+ def build_distill_losses(self, losses):
+ ...
+
+ def compute_distill_losses(self):
+ ...
+```
+
+4. Develop custom loss (Optional).
+
+Here we take `L1Loss` as an example. Create a new file in `mmrazor/models/losses/l1_loss.py`.
+
+```python
+from mmrazor.registry import MODELS
+
+@MODELS.register_module()
+class L1Loss(nn.Module):
+ def __init__(
+ self,
+ loss_weight: float = 1.0,
+ size_average: Optional[bool] = None,
+ reduce: Optional[bool] = None,
+ reduction: str = 'mean',
+ ) -> None:
+ super().__init__()
+ ...
+
+ def forward(self, s_feature, t_feature):
+ loss = F.l1_loss(s_feature, t_feature, self.size_average, self.reduce,
+ self.reduction)
+ return self.loss_weight * loss
+```
+
+5. Import the class
+
+You can either add the following line to `mmrazor/models/algorithms/__init__.py`
+
+```Python
+from .single_teacher_distill import SingleTeacherDistill
+
+__all__ = [..., 'SingleTeacherDistill']
+```
+
+or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.algorithms.distill.configurable.single_teacher_distill'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+6. Use the algorithm in your config file
+
+```Python
+algorithm = dict(
+ type='Distill',
+ distiller=dict(type='SingleTeacherDistill', ...),
+ # you can also use your new algorithm components here
+ ...
+)
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/customize_mixed_algorithms.md b/internlm_langchain/knowledge_base/MMRazor/content/customize_mixed_algorithms.md
new file mode 100644
index 00000000..17b928d1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/customize_mixed_algorithms.md
@@ -0,0 +1,164 @@
+# Customize mixed algorithms
+
+Here we show how to customize mixed algorithms with our algorithm components. We take [AutoSlim ](https://github.com/open-mmlab/mmrazor/tree/main/configs/pruning/mmcls/autoslim)as an example.
+
+```{note}
+**Why is AutoSlim a mixed algorithm?**
+
+In [AutoSlim](https://github.com/open-mmlab/mmrazor/tree/main/configs/pruning/mmcls/autoslim), the sandwich rule and the inplace distillation will be introduced to enhance the training process, which is called as the slimmable training. The sandwich rule means that we train the model at smallest width, largest width and (n − 2) random widths, instead of n random widths. And the inplace distillation means that we use the predicted label of the model at the largest width as the training label for other widths, while for the largest width we use ground truth. So both the KD algorithm and the pruning algorithm are used in [AutoSlim](https://github.com/open-mmlab/mmrazor/tree/main/configs/pruning/mmcls/autoslim).
+```
+
+1. Register a new algorithm
+
+Create a new file `mmrazor/models/algorithms/nas/autoslim.py`, class `AutoSlim` inherits from class `BaseAlgorithm`. You need to build the KD algorithm component (distiller) and the pruning algorithm component (mutator) because AutoSlim is a mixed algorithm.
+
+```{note}
+You can also inherit from the existing algorithm instead of `BaseAlgorithm` if your algorithm is similar to the existing algorithm.
+```
+
+```{note}
+You can choose existing algorithm components in MMRazor, such as `OneShotChannelMutator` and `ConfigurableDistiller` in AutoSlim.
+
+If these in MMRazor don't meet your needs, you can customize new algorithm components for your algorithm. Reference is as follows:
+
+[Customize NAS algorithms](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_nas_algorithms.html)
+[Customize Pruning algorithms](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_pruning_algorithms.html)
+[Customize KD algorithms](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_kd_algorithms.html)
+```
+
+```Python
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Union
+import torch
+from torch import nn
+
+from mmrazor.models.distillers import ConfigurableDistiller
+from mmrazor.models.mutators import OneShotChannelMutator
+from mmrazor.registry import MODELS
+from ..base import BaseAlgorithm
+
+VALID_MUTATOR_TYPE = Union[OneShotChannelMutator, Dict]
+VALID_DISTILLER_TYPE = Union[ConfigurableDistiller, Dict]
+
+@MODELS.register_module()
+class AutoSlim(BaseAlgorithm):
+ def __init__(self,
+ mutator: VALID_MUTATOR_TYPE,
+ distiller: VALID_DISTILLER_TYPE,
+ architecture: Union[BaseModel, Dict],
+ data_preprocessor: Optional[Union[Dict, nn.Module]] = None,
+ num_random_samples: int = 2,
+ init_cfg: Optional[Dict] = None) -> None:
+ super().__init__(architecture, data_preprocessor, init_cfg)
+ self.mutator = self._build_mutator(mutator)
+ # `prepare_from_supernet` must be called before distiller initialized
+ self.mutator.prepare_from_supernet(self.architecture)
+
+ self.distiller = self._build_distiller(distiller)
+ self.distiller.prepare_from_teacher(self.architecture)
+ self.distiller.prepare_from_student(self.architecture)
+
+ ......
+
+ def _build_mutator(self,
+ mutator: VALID_MUTATOR_TYPE) -> OneShotChannelMutator:
+ """build mutator."""
+ if isinstance(mutator, dict):
+ mutator = MODELS.build(mutator)
+ if not isinstance(mutator, OneShotChannelMutator):
+ raise TypeError('mutator should be a `dict` or '
+ '`OneShotModuleMutator` instance, but got '
+ f'{type(mutator)}')
+
+ return mutator
+
+ def _build_distiller(
+ self, distiller: VALID_DISTILLER_TYPE) -> ConfigurableDistiller:
+ if isinstance(distiller, dict):
+ distiller = MODELS.build(distiller)
+ if not isinstance(distiller, ConfigurableDistiller):
+ raise TypeError('distiller should be a `dict` or '
+ '`ConfigurableDistiller` instance, but got '
+ f'{type(distiller)}')
+
+ return distiller
+```
+
+2. Implement the core logic in `train_step`
+
+In `train_step`, both the `mutator` and the `distiller` play an important role. For example, `sample_subnet`, `set_max_subnet` and `set_min_subnet` are supported by the `mutator`, and the function of`distill_step` is mainly implemented by the `distiller`.
+
+```Python
+@MODELS.register_module()
+class AutoSlim(BaseAlgorithm):
+
+ ......
+
+ def train_step(self, data: List[dict],
+ optim_wrapper: OptimWrapper) -> Dict[str, torch.Tensor]:
+
+ def distill_step(
+ batch_inputs: torch.Tensor, data_samples: List[BaseDataElement]
+ ) -> Dict[str, torch.Tensor]:
+ ......
+
+ ......
+
+ batch_inputs, data_samples = self.data_preprocessor(data, True)
+
+ total_losses = dict()
+ for kind in self.sample_kinds:
+ # update the max subnet loss.
+ if kind == 'max':
+ self.set_max_subnet()
+ ......
+ total_losses.update(add_prefix(max_subnet_losses, 'max_subnet'))
+ # update the min subnet loss.
+ elif kind == 'min':
+ self.set_min_subnet()
+ min_subnet_losses = distill_step(batch_inputs, data_samples)
+ total_losses.update(add_prefix(min_subnet_losses, 'min_subnet'))
+ # update the random subnets loss.
+ elif 'random' in kind:
+ self.set_subnet(self.sample_subnet())
+ random_subnet_losses = distill_step(batch_inputs, data_samples)
+ total_losses.update(
+ add_prefix(random_subnet_losses, f'{kind}_subnet'))
+
+ return total_losses
+```
+
+3. Import the class
+
+You can either add the following line to `mmrazor/models/algorithms/nas/__init__.py`
+
+```Python
+from .autoslim import AutoSlim
+
+__all__ = ['AutoSlim']
+```
+
+or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.algorithms.nas.autoslim'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+4. Use the algorithm in your config file
+
+```Python
+model= dict(
+ type='mmrazor.AutoSlim',
+ architecture=...,
+ mutator=dict(
+ type='OneShotChannelMutator',
+ ...),
+ distiller=dict(
+ type='ConfigurableDistiller',
+ ...),
+ ...)
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/customize_nas_algorithms.md b/internlm_langchain/knowledge_base/MMRazor/content/customize_nas_algorithms.md
new file mode 100644
index 00000000..b8f180c0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/customize_nas_algorithms.md
@@ -0,0 +1,136 @@
+# Customize NAS algorithms
+
+Here we show how to develop new NAS algorithms with an example of SPOS.
+
+1. Register a new algorithm
+
+Create a new file `mmrazor/models/algorithms/nas/spos.py`, class `SPOS` inherits from class `BaseAlgorithm`
+
+```Python
+from mmrazor.registry import MODELS
+from ..base import BaseAlgorithm
+
+@MODELS.register_module()
+class SPOS(BaseAlgorithm):
+ def __init__(self, **kwargs):
+ super(SPOS, self).__init__(**kwargs)
+ pass
+
+ def loss(self, batch_inputs, data_samples):
+ pass
+```
+
+2. Develop new algorithm components (optional)
+
+SPOS can directly use class `OneShotModuleMutator` as core functions provider. If mutators provided in MMRazor don’t meet your needs, you can develop new algorithm components for your algorithm like `OneShotModuleMutator`, we will take `OneShotModuleMutator` as an example to introduce how to develop a new algorithm component:
+
+a. Create a new file `mmrazor/models/mutators/module_mutator/one_shot_module_mutator.py`, class `OneShotModuleMutator` inherits from class `ModuleMutator`
+
+b. Finish the functions you need in `OneShotModuleMutator`, eg: `sample_choices`, `set_choices` and so on.
+
+```Python
+from mmrazor.registry import MODELS
+from .module_mutator import ModuleMutator
+
+
+@MODELS.register_module()
+class OneShotModuleMutator(ModuleMutator):
+
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+
+ def sample_choices(self) -> Dict[int, Any]:
+ pass
+
+ def set_choices(self, choices: Dict[int, Any]) -> None:
+ pass
+
+ @property
+ def mutable_class_type(self):
+ return OneShotMutableModule
+```
+
+c. Import the new mutator
+
+You can either add the following line to `mmrazor/models/mutators/__init__.py`
+
+```Python
+from .module_mutator import OneShotModuleMutator
+```
+
+or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.mutators.module_mutator.one_shot_module_mutator'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+d. Use the algorithm component in your config file
+
+```Python
+mutator=dict(type='mmrazor.OneShotModuleMutator')
+```
+
+For further information, please refer to [Mutator ](https://mmrazor.readthedocs.io/en/main/advanced_guides/mutator.html)for more details.
+
+3. Rewrite its `loss` function.
+
+Develop key logic of your algorithm in function`loss`. When having special steps to optimize, you should rewrite the function `train_step`.
+
+```Python
+@MODELS.register_module()
+class SPOS(BaseAlgorithm):
+ def __init__(self, **kwargs):
+ super(SPOS, self).__init__(**kwargs)
+ pass
+
+ def sample_subnet(self):
+ pass
+
+ def set_subnet(self, subnet):
+ pass
+
+ def loss(self, batch_inputs, data_samples):
+ if self.is_supernet:
+ random_subnet = self.sample_subnet()
+ self.set_subnet(random_subnet)
+ return self.architecture(batch_inputs, data_samples, mode='loss')
+ else:
+ return self.architecture(batch_inputs, data_samples, mode='loss')
+```
+
+4. Add your custom functions (optional)
+
+After finishing your key logic in function `loss`, if you also need other custom functions, you can add them in class `SPOS` as follows.
+
+5. Import the class
+
+You can either add the following line to `mmrazor/models/algorithms/nas/__init__.py`
+
+```Python
+from .spos import SPOS
+
+__all__ = ['SPOS']
+```
+
+or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.algorithms.nas.spos'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+6. Use the algorithm in your config file
+
+```Python
+model = dict(
+ type='mmrazor.SPOS',
+ architecture=supernet,
+ mutator=dict(type='mmrazor.OneShotModuleMutator'))
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/customize_pruning_algorithms.md b/internlm_langchain/knowledge_base/MMRazor/content/customize_pruning_algorithms.md
new file mode 100644
index 00000000..3980dfbd
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/customize_pruning_algorithms.md
@@ -0,0 +1,155 @@
+# Customize pruning algorithms
+
+Here we show how to develop new Pruning algorithms with an example of AutoSlim.
+
+1. Register a new algorithm
+
+Create a new file `mmrazor/models/algorithms/prunning/autoslim.py`, class `AutoSlim` inherits from class `BaseAlgorithm`.
+
+```Python
+from mmrazor.registry import MODELS
+from .base import BaseAlgorithm
+
+@MODELS.register_module()
+class AutoSlim(BaseAlgorithm):
+ def __init__(self,
+ mutator,
+ distiller,
+ architecture,
+ data_preprocessor,
+ num_random_samples = 2,
+ init_cfg = None) -> None:
+ super().__init__(**kwargs)
+ pass
+
+ def train_step(self, data, optimizer):
+ pass
+```
+
+2. Develop new algorithm components (optional)
+
+AutoSlim can directly use class `OneShotChannelMutator` as core functions provider. If it can not meet your needs, you can develop new algorithm components for your algorithm like `OneShotChannalMutator`. We will take `OneShotChannelMutator` as an example to introduce how to develop a new algorithm component:
+
+a. Create a new file `mmrazor/models/mutators/channel_mutator/one_shot_channel_mutator.py`, class `OneShotChannelMutator` can inherits from `ChannelMutator`.
+
+b. Finish the functions you need, eg: `build_search_groups`, `set_choices` , `sample_choices` and so on
+
+```Python
+from mmrazor.registry import MODELS
+from .channel_mutator import ChannelMutator
+
+
+@MODELS.register_module()
+class OneShotChannelMutator(ChannelMutator):
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+
+ def sample_choices(self):
+ pass
+
+ def set_choices(self, choice_dict):
+ pass
+
+ # supernet is a kind of architecture in `mmrazor/models/architectures/`
+ def build_search_groups(self, supernet):
+ pass
+```
+
+c. Import the module in `mmrazor/models/mutators/channel_mutator/__init__.py`
+
+```Python
+from .one_shot_channel_mutator import OneShotChannelMutator
+
+ __all__ = [..., 'OneShotChannelMutator']
+```
+
+3. Rewrite its train_step
+
+Develop key logic of your algorithm in function`train_step`
+
+```Python
+from mmrazor.registry import MODELS
+from ..base import BaseAlgorithm
+
+@ALGORITHMS.register_module()
+class AutoSlim(BaseAlgorithm):
+ def __init__(self,
+ mutator,
+ distiller,
+ architecture,
+ data_preprocessor,
+ num_random_samples = 2,
+ init_cfg = None) -> None:
+ super(AutoSlim, self).__init__(**kwargs)
+ pass
+
+ def train_step(self, data: List[dict],
+ optim_wrapper: OptimWrapper) -> Dict[str, torch.Tensor]:
+
+ def distill_step(
+ batch_inputs: torch.Tensor, data_samples: List[BaseDataElement]
+ ) -> Dict[str, torch.Tensor]:
+ ...
+ return subnet_losses
+
+ batch_inputs, data_samples = self.data_preprocessor(data, True)
+
+ total_losses = dict()
+ for kind in self.sample_kinds:
+ # update the max subnet loss.
+ if kind == 'max':
+ self.set_max_subnet()
+ with optim_wrapper.optim_context(
+ self), self.distiller.teacher_recorders: # type: ignore
+ max_subnet_losses = self(batch_inputs, data_samples, mode='loss')
+ parsed_max_subnet_losses, _ = self.parse_losses(max_subnet_losses)
+ optim_wrapper.update_params(parsed_max_subnet_losses)
+ total_losses.update(add_prefix(max_subnet_losses, 'max_subnet'))
+ # update the min subnet loss.
+ elif kind == 'min':
+ self.set_min_subnet()
+ min_subnet_losses = distill_step(batch_inputs, data_samples)
+ total_losses.update(add_prefix(min_subnet_losses, 'min_subnet'))
+ # update the random subnets loss.
+ elif 'random' in kind:
+ self.set_subnet(self.sample_subnet())
+ random_subnet_losses = distill_step(batch_inputs, data_samples)
+ total_losses.update(
+ add_prefix(random_subnet_losses, f'{kind}_subnet'))
+
+ return total_losses
+```
+
+4. Add your custom functions (optional)
+
+After finishing your key logic in function `train_step`, if you also need other custom functions, you can add them in class `AutoSlim`.
+
+5. Import the class
+
+You can either add the following line to `mmrazor/models/algorithms/__init__.py`
+
+```Python
+from .pruning import AutoSlim
+
+__all__ = [..., 'AutoSlim']
+```
+
+Or alternatively add
+
+```Python
+custom_imports = dict(
+ imports=['mmrazor.models.algorithms.pruning.autoslim'],
+ allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+6. Use the algorithm in your config file
+
+```Python
+model = dict(
+ type='AutoSlim',
+ architecture=...,
+ mutator=dict(type='OneShotChannelMutator', ...),
+ )
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/customize_quantization_algorithms.md b/internlm_langchain/knowledge_base/MMRazor/content/customize_quantization_algorithms.md
new file mode 100644
index 00000000..e1dd25ea
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/customize_quantization_algorithms.md
@@ -0,0 +1,283 @@
+# Customize Quantization algorithms
+
+Here we show how to develop new QAT algorithms with an example of LSQ on OpenVINO backend.
+
+This document is mainly aimed at QAT because the ptq process is relatively fixed and the components we provide can meet most of the needs. We will first give an overview of the overall required development components, and then introduce the specific implementation step by step.
+
+## Overall
+
+In the mmrazor quantization pipeline, in order to better support the openmmlab environment, we have configured most of the code modules for users. You can configure all the components directly in the config file. How to configure them can be found in our [file](https://github.com/open-mmlab/mmrazor/blob/quantize/configs/quantization/qat/minmax_openvino_resnet18_8xb32_in1k.py).
+
+```Python
+global_qconfig = dict(
+ w_observer=dict(),
+ a_observer=dict(),
+ w_fake_quant=dict(),
+ a_fake_quant=dict(),
+ w_qscheme=dict(),
+ a_qscheme=dict(),
+)
+model = dict(
+ type='mmrazor.MMArchitectureQuant',
+ architecture=resnet,
+ quantizer=dict(
+ type='mmrazor.OpenvinoQuantizer',
+ global_qconfig=global_qconfig,
+ tracer=dict()))
+train_cfg = dict(type='mmrazor.LSQEpochBasedLoop')
+```
+
+For `algorithm` and `tracer`, we recommend that you use the default configurations `MMArchitectureQuant` and `CustomTracer` provided by us. These two module operators are specially built for the openmmlab environment, while other modules can refer to the following steps and choose or develop new operators according to your needs.
+
+To adapt to different backends, you need to select a different `quantizer`.
+
+To develop new quantization algorithms, you need to define new `observer` and `fakequant`.
+
+If the existing `loop` does not meet your needs, you may need to make some changes to the existing `loop` based on your algorithm.
+
+## Detailed steps
+
+1. Select a quantization algorithm
+
+We recommend that you directly use the`MMArchitectureQuant` in `mmrazor/models/algorithms/quantization/mm_architecture.py`.The class `MMArchitectureQuant` inherits from class `BaseAlgorithm`.
+
+This structure is built for the model in openmmlab. If you have other requirements, you can also refer to this [document](https://mmrazor.readthedocs.io/en/main/advanced_guides/customize_architectures.html#develop-common-model-components) to design the overall framework.
+
+2. Select quantizer
+
+At present, the quantizers we support are `NativeQuantizer`, `OpenVINOQuantizer`, `TensorRTQuantizer` and `AcademicQuantizer` in `mmrazor/models/quantizers/`. `AcademicQuantizer` and `NativeQuantizer` inherit from class `BaseQuantizer` in `mmrazor/models/quantizers/base.py`:
+
+```Python
+class BaseQuantizer(BaseModule):
+ def __init__(self, tracer):
+ super().__init__()
+ self.tracer = TASK_UTILS.build(tracer)
+ @abstractmethod
+ def prepare(self, model, graph_module):
+ """tmp."""
+ pass
+ def swap_ff_with_fxff(self, model):
+ pass
+```
+
+`NativeQuantizer` is the operator we developed to adapt to the environment of mmrazor according to pytorch's official quantization logic. `AcademicQuantizer` is an operator designed for academic research to give users more space to operate.
+
+The class `OpenVINOQuantizer` and `TensorRTQuantizer` inherits from class `NativeQuantize`. They adapted `OpenVINO` and `TensorRT`backend respectively. You can also try to develop a quantizer based on other backends according to your own needs.
+
+3. Select tracer
+
+Tracer we use `CustomTracer` in `mmrazor/models/task_modules/tracer/fx/custom_tracer.py`. You can inherit this class and customize your own tracer.
+
+4. Develop new fakequant method(optional)
+
+You can use fakequants provided by pytorch in `mmrazor/models/fake_quants/torch_fake_quants.py` as core functions provider. If you want to use the fakequant methods from other papers, you can also define them yourself. Let's take lsq as an example as follows:
+
+a.Create a new file `mmrazor/models/fake_quants/lsq.py`, class `LearnableFakeQuantize` inherits from class `FakeQuantizeBase`.
+
+b. Finish the functions you need, eg: `observe_quant_params`, `calculate_qparams` and so on.
+
+```Python
+from mmrazor.registry import MODELS
+from torch.ao.quantization import FakeQuantizeBase
+
+@MODELS.register_module()
+class LearnableFakeQuantize(FakeQuantizeBase):
+ def __init__(self,
+ observer,
+ quant_min=0,
+ quant_max=255,
+ scale=1.,
+ zero_point=0.,
+ use_grad_scaling=True,
+ zero_point_trainable=False,
+ **observer_kwargs):
+ super(LearnableFakeQuantize, self).__init__()
+ pass
+
+ def observe_quant_params(self):
+ pass
+
+ def calculate_qparams(self):
+ pass
+
+ def forward(self, X):
+ pass
+```
+
+c.Import the module in `mmrazor/models/fake_quants/__init__.py`.
+
+```Python
+from .lsq import LearnableFakeQuantize
+
+__all__ = ['LearnableFakeQuantize']
+```
+
+5. Develop new observer(optional)
+
+You can directly use observers provided by pytorch in `mmrazor/models/observers/torch_observers.py` or use observers customized by yourself. Let's take `LSQObserver` as follows:
+
+a.Create a new observer file `mmrazor/models/observers/lsq.py`, class `LSQObserver` inherits from class `MinMaxObserver` and `LSQObserverMixIn`. These two observers can calculate `zero_point` and `scale`, respectively.
+
+b.Finish the functions you need, eg: `calculate_qparams` and so on.
+
+```Python
+from mmrazor.registry import MODELS
+from torch.ao.quantization.observer import MinMaxObserver
+
+class LSQObserverMixIn:
+ def __init__(self):
+ self.tensor_norm = None
+
+ @torch.jit.export
+ def _calculate_scale(self):
+ scale = 2 * self.tensor_norm / math.sqrt(self.quant_max)
+ sync_tensor(scale)
+ return scale
+
+@MODELS.register_module()
+class LSQObserver(MinMaxObserver, LSQObserverMixIn):
+ """LSQ observer.
+ Paper: Learned Step Size Quantization.
+ """
+ def __init__(self, *args, **kwargs):
+ MinMaxObserver.__init__(self, *args, **kwargs)
+ LSQObserverMixIn.__init__(self)
+
+ def forward(self, x_orig):
+ """Records the running minimum, maximum and tensor_norm of ``x``."""
+ if x_orig.numel() == 0:
+ return x_orig
+ x = x_orig.detach() # avoid keeping autograd tape
+ x = x.to(self.min_val.dtype)
+ self.tensor_norm = x.abs().mean()
+ min_val_cur, max_val_cur = torch.aminmax(x)
+ min_val = torch.min(min_val_cur, self.min_val)
+ max_val = torch.max(max_val_cur, self.max_val)
+ self.min_val.copy_(min_val)
+ self.max_val.copy_(max_val)
+ return x_orig
+
+ @torch.jit.export
+ def calculate_qparams(self):
+ """Calculates the quantization parameters."""
+ _, zero_point = MinMaxObserver.calculate_qparams(self)
+ scale = LSQObserverMixIn._calculate_scale(self)
+ return scale, zero_point
+```
+
+c.Import the module in `mmrazor/models/observers/__init__.py`
+
+```Python
+from .lsq import LSQObserver
+
+__all__ = ['LSQObserver']
+```
+
+6. Select loop or develop new loop
+
+At present, the QAT loops we support are `PTQLoop` and `QATEpochBasedLoop`, in `mmrazor/engine/runner/quantization_loops.py`. We can develop a new `LSQEpochBasedLoop` inherits from class `QATEpochBasedLoop` and finish the functions we need in LSQ method.
+
+```Python
+from mmengine.runner import EpochBasedTrainLoop
+
+@LOOPS.register_module()
+class LSQEpochBasedLoop(QATEpochBasedLoop):
+ def __init__(
+ self,
+ runner,
+ dataloader: Union[DataLoader, Dict],
+ max_epochs: int,
+ val_begin: int = 1,
+ val_interval: int = 1,
+ freeze_bn_begin: int = -1,
+ dynamic_intervals: Optional[List[Tuple[int, int]]] = None) -> None:
+ super().__init__(
+ runner,
+ dataloader,
+ max_epochs,
+ val_begin,
+ val_interval,
+ freeze_bn_begin=freeze_bn_begin,
+ dynamic_intervals=dynamic_intervals)
+
+ self.is_first_batch = True
+
+ def prepare_for_run_epoch(self):
+ pass
+
+ def prepare_for_val(self):
+ pass
+
+ def run_epoch(self) -> None:
+ pass
+```
+
+And then Import the module in `mmrazor/engine/runner/__init__.py`
+
+```Python
+from .quantization_loops import LSQEpochBasedLoop
+
+__all__ = ['LSQEpochBasedLoop']
+```
+
+7. Use the algorithm in your config file
+
+After completing the above steps, we have all the components of the qat algorithm, and now we can combine them in the config file.
+
+a.First, `_base_` stores the location of the model that needs to be quantized.
+
+b.Second, configure observer,fakequant and qscheme in `global_qconfig` in detail.
+You can configure the required quantization bit width and quantization methods in `qscheme`, such as symmetric quantization or asymmetric quantization.
+
+c.Third, build the whole mmrazor model in `model`.
+
+d.Finally, complete all the remaining required configuration files.
+
+```Python
+_base_ = ['mmcls::resnet/resnet18_8xb16_cifar10.py']
+
+global_qconfig = dict(
+ w_observer=dict(type='mmrazor.LSQPerChannelObserver'),
+ a_observer=dict(type='mmrazor.LSQObserver'),
+ w_fake_quant=dict(type='mmrazor.LearnableFakeQuantize'),
+ a_fake_quant=dict(type='mmrazor.LearnableFakeQuantize'),
+ w_qscheme=dict(
+ qdtype='qint8', bit=8, is_symmetry=True, is_symmetric_range=True),
+ a_qscheme=dict(qdtype='quint8', bit=8, is_symmetry=True),
+)
+
+model = dict(
+ _delete_=True,
+ _scope_='mmrazor',
+ type='MMArchitectureQuant',
+ data_preprocessor=dict(
+ type='mmcls.ClsDataPreprocessor',
+ num_classes=1000,
+ # RGB format normalization parameters
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ # convert image from BGR to RGB
+ to_rgb=True),
+ architecture=resnet,
+ float_checkpoint=float_ckpt,
+ quantizer=dict(
+ type='mmrazor.OpenVINOQuantizer',
+ is_qat=True,
+ global_qconfig=global_qconfig,
+ tracer=dict(
+ type='mmrazor.CustomTracer',
+ skipped_methods=[
+ 'mmcls.models.heads.ClsHead._get_loss',
+ 'mmcls.models.heads.ClsHead._get_predictions'
+ ])))
+
+# learning policy
+optim_wrapper = dict()
+param_scheduler = dict()
+model_wrapper_cfg = dict()
+
+# train, val, test setting
+train_cfg = dict(type='mmrazor.LSQEpochBasedLoop')
+val_cfg = dict()
+test_cfg = val_cfg
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/delivery.md b/internlm_langchain/knowledge_base/MMRazor/content/delivery.md
new file mode 100644
index 00000000..b7c842c0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/delivery.md
@@ -0,0 +1,217 @@
+# Delivery
+
+## Introduction of Delivery
+
+`Delivery` is a mechanism used in **knowledge distillation**, which is to **align the intermediate results** between the teacher model and the student model by delivering and rewriting these intermediate results between them. As shown in the figure below, deliveries can be used to:
+
+- **Deliver the output of a layer of the teacher model directly to a layer of the student model.** In some knowledge distillation algorithms, we may need to deliver the output of a layer of the teacher model to the student model directly. For example, in [LAD](https://arxiv.org/abs/2108.10520) algorithm, the student model needs to obtain the label assignment of the teacher model directly.
+- **Align the inputs of the teacher model and the student model.** For example, in the MMClassification framework, some widely used data augmentations such as [mixup](https://arxiv.org/abs/1710.09412) and [CutMix](https://arxiv.org/abs/1905.04899) are not implemented in Data Pipelines but in `forward_train`, and due to the randomness of these data augmentation methods, it may lead to a gap between the input of the teacher model and the student model.
+
+
+
+In general, the delivery mechanism allows us to deliver intermediate results between the teacher model and the student model **without adding additional code**, which reduces the hard coding in the source code.
+
+## Usage of Delivery
+
+Currently, we support two deliveries: `FunctionOutputsDelivery` and `MethodOutputsDelivery`, both of which inherit from `DistillDiliver`. And these deliveries can be managed by `DistillDeliveryManager` or just be used on their own.
+
+Their relationship is shown below.
+
+
+
+### FunctionOutputsDelivery
+
+`FunctionOutputsDelivery` is used to align the **function's** intermediate results between the teacher model and the student model.
+
+```{note}
+When initializing `FunctionOutputsDelivery`, you need to pass `func_path` argument, which requires extra attention. For example,
+`anchor_inside_flags` is a function in mmdetection to check whether the
+anchors are inside the border. This function is in
+`mmdet/core/anchor/utils.py` and used in
+`mmdet/models/dense_heads/anchor_head`. Then the `func_path` should be
+`mmdet.models.dense_heads.anchor_head.anchor_inside_flags` but not
+`mmdet.core.anchor.utils.anchor_inside_flags`.
+```
+
+#### Case 1: Delivery single function's output from the teacher to the student.
+
+```Python
+import random
+from mmrazor.core import FunctionOutputsDelivery
+
+def toy_func() -> int:
+ return random.randint(0, 1000000)
+
+delivery = FunctionOutputsDelivery(max_keep_data=1, func_path='toy_module.toy_func')
+
+# override_data is False, which means that not override the data with
+# the recorded data. So it will get the original output of toy_func
+# in teacher model, and it is also recorded to be deliveried to the student.
+delivery.override_data = False
+with delivery:
+ output_teacher = toy_module.toy_func()
+
+# override_data is True, which means that override the data with
+# the recorded data, so it will get the output of toy_func
+# in teacher model rather than the student's.
+delivery.override_data = True
+with delivery:
+ output_student = toy_module.toy_func()
+
+print(output_teacher == output_student)
+```
+
+Out:
+
+```Python
+True
+```
+
+#### Case 2: Delivery multi function's outputs from the teacher to the student.
+
+If a function is executed more than once during the forward of the teacher model, all the outputs of this function will be used to override function outputs from the student model
+
+```{note}
+Delivery order is first-in first-out.
+```
+
+```Python
+delivery = FunctionOutputsDelivery(
+ max_keep_data=2, func_path='toy_module.toy_func')
+
+delivery.override_data = False
+with delivery:
+ output1_teacher = toy_module.toy_func()
+ output2_teacher = toy_module.toy_func()
+
+delivery.override_data = True
+with delivery:
+ output1_student = toy_module.toy_func()
+ output2_student = toy_module.toy_func()
+
+print(output1_teacher == output1_student and output2_teacher == output2_student)
+```
+
+Out:
+
+```Python
+True
+```
+
+### MethodOutputsDelivery
+
+`MethodOutputsDelivery` is used to align the **method's** intermediate results between the teacher model and the student model.
+
+#### Case: Align the inputs of the teacher model and the student model
+
+Here we use mixup as an example to show how to align the inputs of the teacher model and the student model.
+
+- Without Delivery
+
+```Python
+# main.py
+from mmcls.models.utils import Augments
+from mmrazor.core import MethodOutputsDelivery
+
+augments_cfg = dict(type='BatchMixup', alpha=1., num_classes=10, prob=1.0)
+augments = Augments(augments_cfg)
+
+imgs = torch.randn(2, 3, 32, 32)
+label = torch.randint(0, 10, (2,))
+
+imgs_teacher, label_teacher = augments(imgs, label)
+imgs_student, label_student = augments(imgs, label)
+
+print(torch.equal(label_teacher, label_student))
+print(torch.equal(imgs_teacher, imgs_student))
+```
+
+Out:
+
+```Python
+False
+False
+from mmcls.models.utils import Augments
+from mmrazor.core import DistillDeliveryManager
+```
+
+The results are different due to the randomness of mixup.
+
+- With Delivery
+
+```Python
+delivery = MethodOutputsDelivery(
+ max_keep_data=1, method_path='mmcls.models.utils.Augments.__call__')
+
+delivery.override_data = False
+with delivery:
+ imgs_teacher, label_teacher = augments(imgs, label)
+
+delivery.override_data = True
+with delivery:
+ imgs_student, label_student = augments(imgs, label)
+
+print(torch.equal(label_teacher, label_student))
+print(torch.equal(imgs_teacher, imgs_student))
+```
+
+Out:
+
+```Python
+True
+True
+```
+
+The randomness is eliminated by using `MethodOutputsDelivery`.
+
+### 2.3 DistillDeliveryManager
+
+`DistillDeliveryManager` is actually a context manager, used to manage delivers. When entering the ` DistillDeliveryManager`, all delivers managed will be started.
+
+With the help of `DistillDeliveryManager`, we are able to manage several different DistillDeliveries with as little code as possible, thereby reducing the possibility of errors.
+
+#### Case: Manager deliveries with DistillDeliveryManager
+
+```Python
+from mmcls.models.utils import Augments
+from mmrazor.core import DistillDeliveryManager
+
+augments_cfg = dict(type='BatchMixup', alpha=1., num_classes=10, prob=1.0)
+augments = Augments(augments_cfg)
+
+distill_deliveries = [
+ ConfigDict(type='MethodOutputs', max_keep_data=1,
+ method_path='mmcls.models.utils.Augments.__call__')]
+
+# instantiate DistillDeliveryManager
+manager = DistillDeliveryManager(distill_deliveries)
+
+imgs = torch.randn(2, 3, 32, 32)
+label = torch.randint(0, 10, (2,))
+
+manager.override_data = False
+with manager:
+ imgs_teacher, label_teacher = augments(imgs, label)
+
+manager.override_data = True
+with manager:
+ imgs_student, label_student = augments(imgs, label)
+
+print(torch.equal(label_teacher, label_student))
+print(torch.equal(imgs_teacher, imgs_student))
+```
+
+Out:
+
+```Python
+True
+True
+```
+
+## Reference
+
+\[1\] Zhang, Hongyi, et al. "mixup: Beyond empirical risk minimization." *arXiv* abs/1710.09412 (2017).
+
+\[2\] Yun, Sangdoo, et al. "Cutmix: Regularization strategy to train strong classifiers with localizable features." *ICCV* (2019).
+
+\[3\] Nguyen, Chuong H., et al. "Improving object detection by label assignment distillation." *WACV* (2022).
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/faq.md b/internlm_langchain/knowledge_base/MMRazor/content/faq.md
new file mode 100644
index 00000000..318b08dc
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/faq.md
@@ -0,0 +1 @@
+# Frequently Asked Questions
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/how_to_prune_your_model.md b/internlm_langchain/knowledge_base/MMRazor/content/how_to_prune_your_model.md
new file mode 100644
index 00000000..7a8f6005
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/how_to_prune_your_model.md
@@ -0,0 +1,134 @@
+# How to prune your model
+
+## Overview
+
+This section will introduce you to pruning your model. Before that, we suggest you read the document [User Guides: Pruning Framework](../../user_guides/pruning_user_guide.md) to have an overview of our pruning framework.
+
+First, we suppose your model is defined and trained using one openmmlab repo.
+Our pruning algorithms work as a wrapper of a model. To prune your model, you need to replace your model config with our algorithm config, which has a parameter 'architecture' to store your original model. The pipeline is shown below.
+
+), tensor([[[[-0.0894]]]], grad_fn=)]
+```
+
+Test Correctness of recorded results
+
+```Python
+print(torch.equal(r1.data_buffer[0], model.conv1(x)))
+print(torch.equal(r1.data_buffer[1], model.conv1(x + 1)))
+```
+
+Out:
+
+```Python
+True
+True
+```
+
+### ParameterRecorder
+
+`ParameterRecorder` is used to record the intermediate parameter of `nn.Module`. Its usage is similar to `ModuleOutputsRecorder`'s and `ModuleInputsRecorder`'s, but it instantiates with parameter name instead of module name.
+
+#### Example
+
+Suppose there is a toy Module `ToyModule` in toy_module.py.
+
+```Python
+from torch import nn
+import torch
+from mmrazor.core import ModuleOutputsRecorder
+
+class ToyModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.toy_conv = nn.Conv2d(1, 1, 1)
+
+ def forward(self, x):
+ return self.toy_conv(x)
+
+model = ToyModel()
+# instantiate with specifying parameter name.
+r1 = ParameterRecorder('toy_conv.weight')
+# initialize is to make specified module can be recorded by
+# registering customized forward hook.
+r1.initialize(model)
+
+print(r1.data_buffer)
+```
+
+Out:
+
+```Python
+[Parameter containing: tensor([[[[0.2971]]]], requires_grad=True)]
+```
+
+Test Correctness of recorded results
+
+```Python
+print(torch.equal(r1.data_buffer[0], model.toy_conv.weight))
+```
+
+Out:
+
+```Python
+True
+```
+
+### RecorderManager
+
+`RecorderManager` is actually context manager, which can be used to manage various types of recorders.
+
+With the help of `RecorderManager`, we can manage several different recorders with as little code as possible, which reduces the possibility of errors.
+
+#### Example
+
+Suppose there is a toy class `Toy` owned has a toy method `toy_func` in toy_module.py.
+
+```Python
+import random
+from torch import nn
+from mmrazor.core import RecorderManager
+
+class Toy():
+ def toy_func(self):
+ return random.randint(0, 1000000)
+
+class ToyModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 1, 1)
+ self.conv2 = nn.Conv2d(1, 1, 1)
+ self.toy = Toy()
+
+ def forward(self, x):
+ return self.conv2(self.conv1(x)) + self.toy.toy_func()
+
+# configure multi-recorders
+conv1_rec = ConfigDict(type='ModuleOutputs', source='conv1')
+conv2_rec = ConfigDict(type='ModuleOutputs', source='conv2')
+func_rec = ConfigDict(type='MethodOutputs', source='toy_module.Toy.toy_func')
+# instantiate RecorderManager with a dict that contains recorders' configs,
+# you can customize their keys.
+manager = RecorderManager(
+ {'conv1_rec': conv1_rec,
+ 'conv2_rec': conv2_rec,
+ 'func_rec': func_rec})
+
+model = ToyModel()
+# initialize is to make specified module can be recorded by
+# registering customized forward hook.
+manager.initialize(model)
+
+x = torch.rand(1, 1, 1, 1)
+with manager:
+ out = model(x)
+
+conv2_out = manager.get_recorder('conv2_rec').get_record_data()
+print(conv2_out)
+```
+
+Out:
+
+```Python
+tensor([[[[0.5543]]]], grad_fn=)
+```
+
+Display output of `toy_func`
+
+```Python
+func_out = manager.get_recorder('func_rec').get_record_data()
+print(func_out)
+```
+
+Out:
+
+```Python
+313167
+```
diff --git a/internlm_langchain/knowledge_base/MMRazor/content/visualization.md b/internlm_langchain/knowledge_base/MMRazor/content/visualization.md
new file mode 100644
index 00000000..4642139d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRazor/content/visualization.md
@@ -0,0 +1,158 @@
+## 可视化
+
+## 特征图可视化
+
+
+
+# 输入一个图片 list
+results = inferencer(images)
+# 输出为列表
+print(type(results['visualization']), results['visualization'][0].shape)
+# (512, 683, 3)
+print(type(results['predictions']), results['predictions'][0].shape)
+# (512, 683)
+
+results = inferencer(images, return_datasamples=True)
+#
+print(type(results[0]))
+#
+```
+
+### 初始化
+
+`MMSegInferencer` 必须使用 `model` 初始化，该 `model` 可以是模型名称或一个 `Config`，甚至可以是配置文件的路径。
+模型名称可以在模型的元文件（configs/xxx/metafile.yaml）中找到，比如 maskformer 的一个模型名称是 `maskformer_r50-d32_8xb2-160k_ade20k-512x512`，如果输入模型名称，模型的权重将自动下载。以下是其他输入参数：
+
+- weights（str，可选）- 权重的路径。如果未指定，并且模型是元文件中的模型名称，则权重将从元文件加载。默认为 None。
+- classes（list，可选）- 输入类别用于结果渲染，由于分割模型的预测结构是标签索引的分割图，`classes` 是一个相应的标签索引的类别列表。若 classes 没有定义，可视化工具将默认使用 `cityscapes` 的类别。默认为 None。
+- palette（list，可选）- 输入调色盘用于结果渲染，它是对应分类的配色列表。若 palette 没有定义，可视化工具将默认使用 `cityscapes` 的调色盘。默认为 None。
+- dataset_name（str，可选）- [数据集名称或别名](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/utils/class_names.py#L302-L317)，可视化工具将使用数据集的元信息，如类别和配色，但 `classes` 和 `palette` 具有更高的优先级。默认为 None。
+- device（str，可选）- 运行推理的设备。如果无，则会自动使用可用的设备。默认为 None。
+- scope（str，可选）- 模型的作用域。默认为 'mmseg'。
+
+### 可视化预测结果
+
+`MMSegInferencer` 有4个用于可视化预测的参数，您可以在初始化推理器时使用它们：
+
+- show（bool）- 是否弹出窗口显示图像。默认为 False。
+- wait_time（float）- 显示的间隔。默认值为 0。
+- img_out_dir（str）- `out_dir` 的子目录，用于保存渲染有色分割掩膜，因此如果要保存预测掩膜，则必须定义 `out_dir`。默认为 `vis`。
+- opacity（int，float）- 分割掩膜的透明度。默认值为 0.8。
+
+这些参数的示例请参考[基本使用](#基本使用)
+
+### 模型列表
+
+在 MMSegmentation 中有一个非常容易列出所有模型名称的方法
+
+```
+>>> from mmseg.apis import MMSegInferencer
+# models 是一个模型名称列表，它们将自动打印
+>>> models = MMSegInferencer.list_models('mmseg')
+```
+
+## 推理 API
+
+### mmseg.apis.init_model
+
+从配置文件初始化一个分割器。
+
+参数：
+
+- config（str，`Path` 或 `mmengine.Config`）- 配置文件路径或配置对象。
+- checkpoint（str，可选）- 权重路径。如果为 None，则模型将不会加载任何权重。
+- device（str，可选）- CPU/CUDA 设备选项。默认为 'cuda:0'。
+- cfg_options（dict，可选）- 用于覆盖所用配置中的某些设置的选项。
+
+返回值：
+
+- nn.Module：构建好的分割器。
+
+示例：
+
+```python
+from mmseg.apis import init_model
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# 初始化不带权重的模型
+model = init_model(config_path)
+
+# 初始化模型并加载权重
+model = init_model(config_path, checkpoint_path)
+
+# 在 CPU 上的初始化模型并加载权重
+model = init_model(config_path, checkpoint_path, 'cpu')
+```
+
+### mmseg.apis.inference_model
+
+使用分割器推理图像。
+
+参数：
+
+- model（nn.Module）- 加载的分割器
+- imgs（str，np.ndarray 或 list\[str/np.ndarray\]）- 图像文件或加载的图像
+
+返回值：
+
+- `SegDataSample` 或 list\[`SegDataSample`\]：如果 imgs 是列表或元组，则返回相同长度的列表类型结果，否则直接返回分割结果。
+
+**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用作不同组件之间的接口。`SegDataSample` 实现抽象数据元素 `mmengine.structures.BaseDataElement`，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 中的数据元素[文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)了解更多信息。
+
+`SegDataSample` 中的参数分为几个部分：
+
+- `gt_sem_seg`（`PixelData`）- 语义分割的标注。
+- `pred_sem_seg`（`PixelData`）- 语义分割的预测。
+- `seg_logits`（`PixelData`）- 模型最后一层的输出结果。
+
+**注意：** [PixelData](https://github.com/open-mmlab/mmengine/blob/main/mmengine/structures/pixel_data.py) 是像素级标注或预测的数据结构，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 中的 PixelData [文档](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html)了解更多信息。
+
+示例：
+
+```python
+from mmseg.apis import init_model, inference_model
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+img_path = 'demo/demo.png'
+
+
+model = init_model(config_path, checkpoint_path)
+result = inference_model(model, img_path)
+```
+
+### mmseg.apis.show_result_pyplot
+
+在图像上可视化分割结果。
+
+参数：
+
+- model（nn.Module）- 加载的分割器。
+- img（str 或 np.ndarray）- 图像文件名或加载的图像。
+- result（`SegDataSample`）- SegDataSample 预测结果。
+- opacity（float）- 绘制分割图的不透明度。默认值为 `0.5`，必须在 `(0，1]` 范围内。
+- title（str）- pyplot 图的标题。默认值为 ''。
+- draw_gt（bool）- 是否绘制 GT SegDataSample。默认为 `True`。
+- draw_pred（draws_pred）- 是否绘制预测 SegDataSample。默认为 `True`。
+- wait_time（float）- 显示的间隔，0 是表示“无限”的特殊值。默认为 `0`。
+- show（bool）- 是否展示绘制的图像。默认为 `True`。
+- save_dir（str，可选）- 为所有存储后端保存的文件路径。如果为 `None`，则后端存储将不会保存任何数据。
+- out_file（str，可选）- 输出文件的路径。默认为 `None`。
+
+返回值：
+
+- np.ndarray：通道为 RGB 的绘制图像。
+
+示例：
+
+```python
+from mmseg.apis import init_model, inference_model, show_result_pyplot
+
+config_path = 'configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_path = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+img_path = 'demo/demo.png'
+
+
+# 从配置文件和权重文件构建模型
+model = init_model(config_path, checkpoint_path, device='cuda:0')
+
+# 推理给定图像
+result = inference_model(model, img_path)
+
+# 展示分割结果
+vis_image = show_result_pyplot(model, img_path, result)
+
+# 保存可视化结果，输出图像将在 `workdirs/result.png` 路径下找到
+vis_iamge = show_result_pyplot(model, img_path, result, out_file='work_dirs/result.png')
+
+# 修改展示图像的时间，注意 0 是表示“无限”的特殊值
+vis_image = show_result_pyplot(model, img_path, result, wait_time=5)
+```
+
+**注意：** 如果当前设备没有图形用户界面，建议将 `show` 设置为 `False`，并指定 `out_file` 或 `save_dir` 来保存结果。如果您想在窗口上显示结果，则不需要特殊设置。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/4_train_test.md b/internlm_langchain/knowledge_base/MMSegmentation/content/4_train_test.md
new file mode 100644
index 00000000..f821acaf
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/4_train_test.md
@@ -0,0 +1,317 @@
+# 教程4：使用现有模型进行训练和测试
+
+MMSegmentation 支持在多种设备上训练和测试模型。如下文，具体方式分别为单GPU、分布式以及计算集群的训练和测试。通过本教程，您将知晓如何用 MMSegmentation 提供的脚本进行训练和测试。
+
+## 在单GPU上训练和测试
+
+### 在单GPU上训练
+
+`tools/train.py` 文件提供了在单GPU上部署训练任务的方法。
+
+基础用法如下:
+
+```shell
+python tools/train.py ${配置文件} [可选参数]
+```
+
+- `--work-dir ${工作路径}`: 重新指定工作路径
+- `--amp`: 使用自动混合精度计算
+- `--resume`: 从工作路径中保存的最新检查点文件（checkpoint）恢复训练
+- `--cfg-options ${需更覆盖的配置}`: 覆盖已载入的配置中的部分设置，并且 以 xxx=yyy 格式的键值对 将被合并到配置文件中。
+ 比如： '--cfg-option model.encoder.in_channels=6'， 更多细节请看[指导](./1_config.md#Modify-config-through-script-arguments)。
+
+下面是对于多GPU测试的可选参数:
+
+- `--launcher`: 执行器的启动方式。允许选择的参数值有 `none`, `pytorch`, `slurm`, `mpi`。特别的，如果设置为none，测试将非分布式模式下进行。
+- `--local_rank`: 分布式中进程的序号。如果没有指定，默认设置为0。
+
+**注意：** 命令行参数 `--resume` 和在配置文件中的参数 `load_from` 的不同之处：
+
+`--resume` 只决定是否继续使用工作路径中最新的检查点，它常常用于恢复被意外打断的训练。
+
+`load_from` 会明确指定被载入的检查点文件，且训练迭代器将从0开始，通常用于微调模型。
+
+如果您希望从指定的检查点上恢复训练您可以使用：
+
+```python
+python tools/train.py ${配置文件} --resume --cfg-options load_from=${检查点}
+```
+
+**在 CPU 上训练**: 如果机器没有 GPU，则在 CPU 上训练的过程是与单GPU训练一致的。如果机器有 GPU 但是不希望使用它们，我们只需要在训练前通过以下方式关闭 GPU 训练功能。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+然后运行[上方](###在单GPU上训练)脚本。
+
+### 在单GPU上测试
+
+`tools/test.py` 文件提供了在单 GPU 上启动测试任务的方法。
+
+基础用法如下:
+
+```shell
+python tools/test.py ${配置文件} ${模型权重文件} [可选参数]
+```
+
+这个工具有几个可选参数，包括：
+
+- `--work-dir`: 如果指定了路径，结果会保存在该路径下。如果没有指定则会保存在 `work_dirs/{配置文件名}` 路径下.
+- `--show`: 当 `--show-dir` 没有指定时，可以使用该参数，在程序运行过程中显示预测结果。
+- `--show-dir`: 绘制了分割掩膜图片的存储文件夹。如果指定了该参数，则可视化的分割掩膜将被保存到 `work_dir/timestamp/{指定路径}`.
+- `--wait-time`: 多次可视化结果的时间间隔。当 `--show` 为激活状态时发挥作用。默认为2。
+- `--cfg-options`: 如果被具体指定，以 xxx=yyy 形式的键值对将被合并入配置文件中。
+
+**在CPU上测试**: 如果机器没有GPU，则在CPU上训练的过程是与单GPU训练一致的。如果机器有GPU，但是不希望使用它们，我们只需要在训练前通过以下方式关闭GPUs训练功能。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+然后运行[上方](###在单GPU上测试)脚本。
+
+## 多GPU、多机器上训练和测试
+
+### 在多GPU上训练
+
+OpenMMLab2.0 通过 `MMDistributedDataParallel`实现 **分布式** 训练。
+
+`tools/dist_train.sh` 文件提供了在在多GPU上部署训练任务的方法。
+
+基础用法如下:
+
+```shell
+sh tools/dist_train.sh ${配置文件} ${GPU数量} [可选参数]
+```
+
+可选参数与[上方](###在单GPU上训练)相同并且还增加了可以指定gpu数量的参数。
+
+示例:
+
+```shell
+# 模型训练的检查点和日志保存在这个路径下： WORK_DIR=work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512/
+# 如果工作路径没有被设定，它将会被自动生成。
+sh tools/dist_train.sh configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py 8 --work-dir work_dirs/pspnet_r50-d8_4xb4-80k_ade20k-512x512
+```
+
+**注意**: 在训练过程中，检查点和日志保存在`work_dirs/`下的配置文件的相同文件夹结构下。
+不推荐自定义的工作路径，因为评估脚本依赖于源自配置文件名的路径。如果您希望将权重保存在其他地方，请用符号链接，例如：
+
+```shell
+ln -s ${您的工作路径} ${MMSEG 路径}/work_dirs
+```
+
+### 在多GPU上测试
+
+`tools/dist_test.sh` 文件提供了在多GPU上启动测试任务的方法。
+
+基础用法如下:
+
+```shell
+sh tools/dist_test.sh ${配置文件} ${检查点文件} ${GPU数量} [可选参数]
+```
+
+可选参数与[上方](###在单GPU上测试)相同并且增加了可以指定 gpu 数量的参数。
+
+示例:
+
+```shell
+./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+ checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth 4
+```
+
+### 在单台机器上启动多个任务
+
+如果您在单个机器上运行多个任务，比如：在8卡GPU的单个机器上执行2个各需4卡GPU的训练任务，您需要为每个任务具体指定不同端口（默认29500），从而避免通讯冲突。否则，会有报错信息——`RuntimeError: Address already in use`（运行错误：地址被使用）。
+
+如果您使用 `dist_train.sh` 来启动训练任务，您可以通过环境变量 `PORT` 设置端口。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 sh tools/dist_train.sh ${配置文件} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 sh tools/dist_train.sh ${配置文件} 4
+```
+
+### 在多台机器上训练
+
+MMSegmentation 的分布式训练依赖 `torch.distributed`。
+因此， 可以通过 PyTorch 的 [运行工具 launch utility](https://pytorch.org/docs/stable/distributed.html#launch-utility) 来进行分布式训练。
+
+如果您启动的多台机器简单地通过以太网连接，您可以直接运行下方命令：
+
+在第一个机器上:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=${主节点端口} MASTER_ADDR=${主节点地址} sh tools/dist_train.sh ${配置文件} ${GPUS}
+```
+
+在第二个机器上:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=${主节点端口} MASTER_ADDR=${主节点地址} sh tools/dist_train.sh ${配置文件} ${GPUS}
+```
+
+通常，如果您没有使用像无限带宽一类的高速网络，这个会过程比较慢。
+
+## 通过 Slurm 管理任务
+
+[Slurm](https://slurm.schedmd.com/) 是一个很好的计算集群作业调度系统。
+
+### 通过 Slurm 在集群上训练
+
+在一个由Slurm管理的集群上，您可以使用`slurm_train.sh`来启动训练任务。它同时支持单节点和多节点的训练。
+
+基础用法如下：
+
+```shell
+[GPUS=${GPUS}] sh tools/slurm_train.sh ${分区} ${任务名} ${配置文件} [可选参数]
+```
+
+下方是一个通过名为 `dev` 的 Slurm 分区，调用4个 GPU 来训练 PSPNet，并设置工作路径为共享文件系统。
+
+```shell
+GPUS=4 sh tools/slurm_train.sh dev pspnet configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py --work-dir work_dir/pspnet
+```
+
+您可以检查 [源码](../../../tools/slurm_train.sh) 来查看全部的参数和环境变量。
+
+### 通过 Slurm 在集群上测试
+
+与训练任务相同， MMSegmentation 提供 `slurm_test.sh` 文件来启动测试任务。
+
+基础用法如下：
+
+```shell
+[GPUS=${GPUS}] sh tools/slurm_test.sh ${分区} ${任务名} ${配置文件} ${检查点文件} [可选参数]
+```
+
+您可以通过 [源码](../../../tools/slurm_test.sh) 来查看全部的参数和环境变量。
+
+**注意：** 使用 Slurm 时，需要设置端口，可从以下方式中选取一种。
+
+1. 我们更推荐的通过`--cfg-options`设置端口，因为这不会改变原始配置：
+
+ ```shell
+ GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径} --cfg-options env_cfg.dist_cfg.port=29500
+ GPUS=4 GPUS_PER_NODE=4 sh tools/slurm_train.sh ${任务名} ${工作路径} config2.py ${工作路径} --cfg-options env_cfg.dist_cfg.port=29501
+ ```
+
+2. 通过修改配置文件设置不同的通讯端口：
+
+ 在 `config1.py`中:
+
+ ```python
+ enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29500))
+ ```
+
+ 在 `config2.py`中：
+
+ ```python
+ enf_cfg = dict(dist_cfg=dict(backend='nccl', port=29501))
+ ```
+
+ 然后您可以通过 config1.py 和 config2.py 同时启动两个任务：
+
+ ```shell
+ CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径}
+ CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 sh tools/slurm_train.sh ${分区} ${任务名} config2.py ${工作路径}
+ ```
+
+3. 在命令行中通过环境变量 `MASTER_PORT` 设置端口 ：
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 MASTER_PORT=29500 sh tools/slurm_train.sh ${分区} ${任务名} config1.py ${工作路径}
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 MASTER_PORT=29501 sh tools/slurm_train.sh ${分区} ${任务名} config2.py ${工作路径}
+```
+
+## 测试并保存分割结果
+
+### 基础使用
+
+当需要保存测试输出的分割结果，用 `--out` 指定分割结果输出路径
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
+```
+
+以保存模型 `fcn_r50-d8_4xb4-80k_ade20k-512x512` 在 ADE20K 验证数据集上的结果为例：
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth --out work_dirs/format_results
+```
+
+或者通过配置文件定义 `output_dir`。例如在 `configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py` 添加 `test_evaluator` 定义：
+
+```python
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'], output_dir='work_dirs/format_results')
+```
+
+然后执行相同功能的命令不需要再使用 `--out`：
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+```
+
+当测试的数据集没有提供标注，评测时没有真值可以参与计算，因此需要设置 `format_only=True`，
+同时需要修改 `test_dataloader`，由于没有标注，我们需要在数据增强变换中删掉 `dict(type='LoadAnnotations')`，以下是一个配置示例：
+
+```python
+test_evaluator = dict(
+ type='IoUMetric',
+ iou_metrics=['mIoU'],
+ format_only=True,
+ output_dir='work_dirs/format_results')
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type = 'ADE20KDataset'
+ data_root='data/ade/release_test',
+ data_prefix=dict(img_path='testing'),
+ # 测试数据变换中没有加载标注
+ pipeline=[
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+ dict(type='PackSegInputs')
+ ]))
+```
+
+然后执行测试命令：
+
+```shell
+python tools/test.py configs/fcn/fcn_r50-d8_4xb4-80k_ade20k-512x512.py ckpt/fcn_r50-d8_512x512_80k_ade20k_20200614_144016-f8ac5082.pth
+```
+
+### 测试 Cityscapes 数据集并保存输出分割结果
+
+推荐使用 `CityscapesMetric` 来保存模型在 Cityscapes 数据集上的测试结果，以下是一个配置示例：
+
+```python
+test_evaluator = dict(
+ type='CityscapesMetric',
+ format_only=True,
+ keep_results=True,
+ output_dir='work_dirs/format_results')
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type='CityscapesDataset',
+ data_root='data/cityscapes/',
+ data_prefix=dict(img_path='leftImg8bit/test'),
+ pipeline=[
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+ dict(type='PackSegInputs')
+ ]))
+```
+
+然后执行相同的命令，例如：
+
+```shell
+python tools/test.py configs/fcn/fcn_r18-d8_4xb2-80k_cityscapes-512x1024.py ckpt/fcn_r18-d8_512x1024_80k_cityscapes_20201225_021327-6c50f8b4.pth
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/5_deployment.md b/internlm_langchain/knowledge_base/MMSegmentation/content/5_deployment.md
new file mode 100644
index 00000000..6a2fc69a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/5_deployment.md
@@ -0,0 +1,242 @@
+# 教程5：模型部署
+
+# MMSegmentation 模型部署
+
+- [教程5：模型部署](#教程5模型部署)
+- [MMSegmentation 模型部署](#mmsegmentation-模型部署)
+ - [安装](#安装)
+ - [安装 mmseg](#安装-mmseg)
+ - [安装 mmdeploy](#安装-mmdeploy)
+ - [模型转换](#模型转换)
+ - [模型规范](#模型规范)
+ - [模型推理](#模型推理)
+ - [后端模型推理](#后端模型推理)
+ - [SDK 模型推理](#sdk-模型推理)
+ - [模型支持列表](#模型支持列表)
+ - [注意事项](#注意事项)
+
+______________________________________________________________________
+
+[MMSegmentation](https://github.com/open-mmlab/mmsegmentation/tree/main) 又称`mmseg`，是一个基于 PyTorch 的开源对象分割工具箱。它是 [OpenMMLab](https://openmmlab.com/) 项目的一部分。
+
+## 安装
+
+### 安装 mmseg
+
+请参考[官网安装指南](https://mmsegmentation.readthedocs.io/en/latest/get_started.html)。
+
+### 安装 mmdeploy
+
+mmdeploy 有以下几种安装方式:
+
+**方式一：** 安装预编译包
+
+请参考[安装概述](https://mmdeploy.readthedocs.io/zh_CN/latest/get_started.html#mmdeploy)
+
+**方式二：** 一键式脚本安装
+
+如果部署平台是 **Ubuntu 18.04 及以上版本**， 请参考[脚本安装说明](../01-how-to-build/build_from_script.md)，完成安装过程。
+比如，以下命令可以安装 mmdeploy 以及配套的推理引擎——`ONNX Runtime`.
+
+```shell
+git clone --recursive -b main https://github.com/open-mmlab/mmdeploy.git
+cd mmdeploy
+python3 tools/scripts/build_ubuntu_x64_ort.py $(nproc)
+export PYTHONPATH=$(pwd)/build/lib:$PYTHONPATH
+export LD_LIBRARY_PATH=$(pwd)/../mmdeploy-dep/onnxruntime-linux-x64-1.8.1/lib/:$LD_LIBRARY_PATH
+```
+
+**说明**:
+
+- 把 `$(pwd)/build/lib` 添加到 `PYTHONPATH`，目的是为了加载 mmdeploy SDK python 包 `mmdeploy_runtime`，在章节 [SDK模型推理](#sdk模型推理)中讲述其用法。
+- 在[使用 ONNX Runtime推理后端模型](#后端模型推理)时，需要加载自定义算子库，需要把 ONNX Runtime 库的路径加入环境变量 `LD_LIBRARY_PATH`中。
+ **方式三：** 源码安装
+
+在方式一、二都满足不了的情况下，请参考[源码安装说明](../01-how-to-build/build_from_source.md) 安装 mmdeploy 以及所需推理引擎。
+
+## 模型转换
+
+你可以使用 [tools/deploy.py](https://github.com/open-mmlab/mmdeploy/tree/main/tools/deploy.py) 把 mmseg 模型一键式转换为推理后端模型。
+该工具的详细使用说明请参考[这里](https://github.com/open-mmlab/mmdeploy/tree/main/docs/en/02-how-to-run/convert_model.md#usage).
+
+以下，我们将演示如何把 `unet` 转换为 onnx 模型。
+
+```shell
+cd mmdeploy
+
+# download unet model from mmseg model zoo
+mim download mmsegmentation --config unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024 --dest .
+
+# convert mmseg model to onnxruntime model with dynamic shape
+python tools/deploy.py \
+ configs/mmseg/segmentation_onnxruntime_dynamic.py \
+ unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py \
+ fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes_20211210_145204-6860854e.pth \
+ demo/resources/cityscapes.png \
+ --work-dir mmdeploy_models/mmseg/ort \
+ --device cpu \
+ --show \
+ --dump-info
+```
+
+转换的关键之一是使用正确的配置文件。项目中已内置了各后端部署[配置文件](https://github.com/open-mmlab/mmdeploy/tree/main/configs/mmseg)。
+文件的命名模式是：
+
+```
+segmentation_{backend}-{precision}_{static | dynamic}_{shape}.py
+```
+
+其中：
+
+- **{backend}:** 推理后端名称。比如，onnxruntime、tensorrt、pplnn、ncnn、openvino、coreml 等等
+- **{precision}:** 推理精度。比如，fp16、int8。不填表示 fp32
+- **{static | dynamic}:** 动态、静态 shape
+- **{shape}:** 模型输入的 shape 或者 shape 范围
+
+在上例中，你也可以把 `unet` 转为其他后端模型。比如使用`segmentation_tensorrt-fp16_dynamic-512x1024-2048x2048.py`，把模型转为 tensorrt-fp16 模型。
+
+```{tip}
+当转 tensorrt 模型时, --device 需要被设置为 "cuda"
+```
+
+## 模型规范
+
+在使用转换后的模型进行推理之前，有必要了解转换结果的结构。 它存放在 `--work-dir` 指定的路路径下。
+
+上例中的`mmdeploy_models/mmseg/ort`，结构如下：
+
+```
+mmdeploy_models/mmseg/ort
+├── deploy.json
+├── detail.json
+├── end2end.onnx
+└── pipeline.json
+```
+
+重要的是：
+
+- **end2end.onnx**: 推理引擎文件。可用 ONNX Runtime 推理
+- \***.json**: mmdeploy SDK 推理所需的 meta 信息
+
+整个文件夹被定义为**mmdeploy SDK model**。换言之，**mmdeploy SDK model**既包括推理引擎，也包括推理 meta 信息。
+
+## 模型推理
+
+### 后端模型推理
+
+以上述模型转换后的 `end2end.onnx` 为例，你可以使用如下代码进行推理：
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg = 'configs/mmseg/segmentation_onnxruntime_dynamic.py'
+model_cfg = './unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py'
+device = 'cpu'
+backend_model = ['./mmdeploy_models/mmseg/ort/end2end.onnx']
+image = './demo/resources/cityscapes.png'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+ result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+ image=image,
+ model=model,
+ result=result[0],
+ window_name='visualize',
+ output_file='./output_segmentation.png')
+```
+
+### SDK 模型推理
+
+你也可以参考如下代码，对 SDK model 进行推理：
+
+```python
+from mmdeploy_runtime import Segmentor
+import cv2
+import numpy as np
+
+img = cv2.imread('./demo/resources/cityscapes.png')
+
+# create a classifier
+segmentor = Segmentor(model_path='./mmdeploy_models/mmseg/ort', device_name='cpu', device_id=0)
+# perform inference
+seg = segmentor(img)
+
+# visualize inference result
+## random a palette with size 256x3
+palette = np.random.randint(0, 256, size=(256, 3))
+color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)
+for label, color in enumerate(palette):
+ color_seg[seg == label, :] = color
+# convert to BGR
+color_seg = color_seg[..., ::-1]
+img = img * 0.5 + color_seg * 0.5
+img = img.astype(np.uint8)
+cv2.imwrite('output_segmentation.png', img)
+```
+
+除了python API，mmdeploy SDK 还提供了诸如 C、C++、C#、Java等多语言接口。
+你可以参考[样例](https://github.com/open-mmlab/mmdeploy/tree/main/demo)学习其他语言接口的使用方法。
+
+## 模型支持列表
+
+| Model | TorchScript | OnnxRuntime | TensorRT | ncnn | PPLNN | OpenVino |
+| :-------------------------------------------------------------------------------------------------------- | :---------: | :---------: | :------: | :--: | :---: | :------: |
+| [FCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fcn) | Y | Y | Y | Y | Y | Y |
+| [PSPNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/pspnet)[\*](#static_shape) | Y | Y | Y | Y | Y | Y |
+| [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3) | Y | Y | Y | Y | Y | Y |
+| [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus) | Y | Y | Y | Y | Y | Y |
+| [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastscnn)[\*](#static_shape) | Y | Y | Y | N | Y | Y |
+| [UNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/unet) | Y | Y | Y | Y | Y | Y |
+| [ANN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ann)[\*](#static_shape) | Y | Y | Y | N | N | N |
+| [APCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/apcnet) | Y | Y | Y | Y | N | N |
+| [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv1) | Y | Y | Y | Y | N | Y |
+| [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/bisenetv2) | Y | Y | Y | Y | N | Y |
+| [CGNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/cgnet) | Y | Y | Y | Y | N | Y |
+| [DMNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dmnet) | ? | Y | N | N | N | N |
+| [DNLNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dnlnet) | ? | Y | Y | Y | N | Y |
+| [EMANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/emanet) | Y | Y | Y | N | N | Y |
+| [EncNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/encnet) | Y | Y | Y | N | N | Y |
+| [ERFNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/erfnet) | Y | Y | Y | Y | N | Y |
+| [FastFCN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/fastfcn) | Y | Y | Y | Y | N | Y |
+| [GCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/gcnet) | Y | Y | Y | N | N | N |
+| [ICNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/icnet)[\*](#static_shape) | Y | Y | Y | N | N | Y |
+| [ISANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/isanet)[\*](#static_shape) | N | Y | Y | N | N | Y |
+| [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/nonlocal_net) | ? | Y | Y | Y | N | Y |
+| [OCRNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ocrnet) | Y | Y | Y | Y | N | Y |
+| [PointRend](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/point_rend)[\*](#static_shape) | Y | Y | Y | N | N | N |
+| [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/sem_fpn) | Y | Y | Y | Y | N | Y |
+| [STDC](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/stdc) | Y | Y | Y | Y | N | Y |
+| [UPerNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/upernet)[\*](#static_shape) | N | Y | Y | N | N | N |
+| [DANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/danet) | ? | Y | Y | N | N | Y |
+| [Segmenter](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segmenter)[\*](#static_shape) | N | Y | Y | Y | N | Y |
+| [SegFormer](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/segformer)[\*](#static_shape) | ? | Y | Y | N | N | Y |
+| [SETR](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/setr) | ? | Y | N | N | N | Y |
+| [CCNet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/ccnet) | ? | N | N | N | N | N |
+| [PSANet](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/psanet) | ? | N | N | N | N | N |
+| [DPT](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/dpt) | ? | N | N | N | N | N |
+
+## 注意事项
+
+- 所有 mmseg 模型仅支持 "whole" 推理模式。
+
+- PSPNet，Fast-SCNN 仅支持静态输入，因为多数推理框架的 [nn.AdaptiveAvgPool2d](https://github.com/open-mmlab/mmsegmentation/blob/0c87f7a0c9099844eff8e90fa3db5b0d0ca02fee/mmseg/models/decode_heads/psp_head.py#L38) 不支持动态输入。
+
+- 对于仅支持静态形状的模型，应使用静态形状的部署配置文件，例如 `configs/mmseg/segmentation_tensorrt_static-1024x2048.py`
+
+- 对于喜欢部署模型生成概率特征图的用户，将 `codebase_config = dict(with_argmax=False)` 放在部署配置中就足够了。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/add_datasets.md b/internlm_langchain/knowledge_base/MMSegmentation/content/add_datasets.md
new file mode 100644
index 00000000..22fbf346
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/add_datasets.md
@@ -0,0 +1,199 @@
+# 新增自定义数据集
+
+## 新增自定义数据集
+
+在这里，我们展示如何构建一个新的数据集。
+
+1. 创建一个新文件 `mmseg/datasets/example.py`
+
+ ```python
+ from mmseg.registry import DATASETS
+ from .basesegdataset import BaseSegDataset
+
+
+ @DATASETS.register_module()
+ class ExampleDataset(BaseSegDataset):
+
+ METAINFO = dict(
+ classes=('xxx', 'xxx', ...),
+ palette=[[x, x, x], [x, x, x], ...])
+
+ def __init__(self, aeg1, arg2):
+ pass
+ ```
+
+2. 在 `mmseg/datasets/__init__.py` 中导入模块
+
+ ```python
+ from .example import ExampleDataset
+ ```
+
+3. 通过创建一个新的数据集配置文件 `configs/_base_/datasets/example_dataset.py` 来使用它
+
+ ```python
+ dataset_type = 'ExampleDataset'
+ data_root = 'data/example/'
+ ...
+ ```
+
+4. 在 `mmseg/utils/class_names.py` 中补充数据集元信息
+
+ ```python
+ def example_classes():
+ return [
+ 'xxx', 'xxx',
+ ...
+ ]
+
+ def example_palette():
+ return [
+ [x, x, x], [x, x, x],
+ ...
+ ]
+ dataset_aliases ={
+ 'example': ['example', ...],
+ ...
+ }
+ ```
+
+**注意：** 如果新数据集不满足 mmseg 的要求，则需要在 `tools/dataset_converters/` 中准备一个数据集预处理脚本
+
+## 通过重新组织数据来定制数据集
+
+最简单的方法是将您的数据集进行转化，并组织成文件夹的形式。
+
+如下的文件结构就是一个例子。
+
+```none
+├── data
+│ ├── my_dataset
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ │ ├── xxx{img_suffix}
+│ │ │ │ ├── yyy{img_suffix}
+│ │ │ │ ├── zzz{img_suffix}
+│ │ │ ├── val
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ │ ├── xxx{seg_map_suffix}
+│ │ │ │ ├── yyy{seg_map_suffix}
+│ │ │ │ ├── zzz{seg_map_suffix}
+│ │ │ ├── val
+
+```
+
+一个训练对将由 img_dir/ann_dir 里同样首缀的文件组成。
+
+有些数据集不会发布测试集或测试集的标注，如果没有测试集的标注，我们就无法在本地进行评估模型，因此我们在配置文件中将验证集设置为默认测试集。
+
+关于如何构建自己的数据集或实现新的数据集类，请参阅[数据集指南](./datasets.md)以获取更多详细信息。
+
+**注意：** 标注是跟图像同样的形状 (H, W)，其中的像素值的范围是 `[0, num_classes - 1]`。
+您也可以使用 [pillow](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#palette) 的 `'P'` 模式去创建包含颜色的标注。
+
+## 通过混合数据去定制数据集
+
+MMSegmentation 同样支持混合数据集去训练。
+当前它支持拼接 (concat), 重复 (repeat) 和多图混合 (multi-image mix) 数据集。
+
+### 重复数据集
+
+我们使用 `RepeatDataset` 作为包装 (wrapper) 去重复数据集。
+例如，假设原始数据集是 `Dataset_A`，为了重复它，配置文件如下：
+
+```python
+dataset_A_train = dict(
+ type='RepeatDataset',
+ times=N,
+ dataset=dict( # 这是 Dataset_A 数据集的原始配置
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+)
+```
+
+### 拼接数据集
+
+如果要拼接不同的数据集，可以按如下方式连接数据集配置。
+
+```python
+dataset_A_train = dict()
+dataset_B_train = dict()
+concatenate_dataset = dict(
+ type='ConcatDataset',
+ datasets=[dataset_A_train, dataset_B_train])
+```
+
+下面是一个更复杂的示例，它分别重复 `Dataset_A` 和 `Dataset_B` N 次和 M 次，然后连接重复的数据集。
+
+```python
+dataset_A_train = dict(
+ type='RepeatDataset',
+ times=N,
+ dataset=dict(
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+)
+dataset_A_val = dict(
+ ...
+ pipeline=test_pipeline
+)
+dataset_A_test = dict(
+ ...
+ pipeline=test_pipeline
+)
+dataset_B_train = dict(
+ type='RepeatDataset',
+ times=M,
+ dataset=dict(
+ type='Dataset_B',
+ ...
+ pipeline=train_pipeline
+ )
+)
+train_dataloader = dict(
+ dataset=dict(
+ type='ConcatDataset',
+ datasets=[dataset_A_train, dataset_B_train]))
+
+val_dataloader = dict(dataset=dataset_A_val)
+test_dataloader = dict(dataset=dataset_A_test)
+
+```
+
+您可以参考 mmengine 的基础数据集[教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/basedataset.html)以了解更多详细信息
+
+### 多图混合集
+
+我们使用 `MultiImageMixDataset` 作为包装（wrapper）去混合多个数据集的图片。
+`MultiImageMixDataset`可以被类似 mosaic 和 mixup 的多图混合数据増广使用。
+
+`MultiImageMixDataset` 与 `Mosaic` 数据増广一起使用的例子：
+
+```python
+train_pipeline = [
+ dict(type='RandomMosaic', prob=1),
+ dict(type='Resize', img_scale=(1024, 512), keep_ratio=True),
+ dict(type='RandomFlip', prob=0.5),
+ dict(type='PackSegInputs')
+]
+
+train_dataset = dict(
+ type='MultiImageMixDataset',
+ dataset=dict(
+ type=dataset_type,
+ reduce_zero_label=False,
+ img_dir=data_root + "images/train",
+ ann_dir=data_root + "annotations/train",
+ pipeline=[
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ ]
+ ),
+ pipeline=train_pipeline
+)
+
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/add_metrics.md b/internlm_langchain/knowledge_base/MMSegmentation/content/add_metrics.md
new file mode 100644
index 00000000..0637b447
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/add_metrics.md
@@ -0,0 +1,81 @@
+# 新增评测指标
+
+## 使用 MMSegmentation 的源代码进行开发
+
+在这里，我们用 `CustomMetric` 作为例子来展示如何开发一个新的评测指标。
+
+1. 创建一个新文件 `mmseg/evaluation/metrics/custom_metric.py`。
+
+ ```python
+ from typing import List, Sequence
+
+ from mmengine.evaluator import BaseMetric
+
+ from mmseg.registry import METRICS
+
+
+ @METRICS.register_module()
+ class CustomMetric(BaseMetric):
+
+ def __init__(self, arg1, arg2):
+ """
+ The metric first processes each batch of data_samples and predictions,
+ and appends the processed results to the results list. Then it
+ collects all results together from all ranks if distributed training
+ is used. Finally, it computes the metrics of the entire dataset.
+ """
+
+ def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+ pass
+
+ def compute_metrics(self, results: list) -> dict:
+ pass
+
+ def evaluate(self, size: int) -> dict:
+ pass
+ ```
+
+ 在上面的示例中，`CustomMetric` 是 `BaseMetric` 的子类。它有三个方法：`process`，`compute_metrics` 和 `evaluate`。
+
+ - `process()` 处理一批数据样本和预测。处理后的结果需要显示地传给 `self.results` ，将在处理所有数据样本后用于计算指标。更多细节请参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/evaluation.md)
+
+ - `compute_metrics()` 用于从处理后的结果中计算指标。
+
+ - `evaluate()` 是一个接口，用于计算指标并返回结果。它将由 `ValLoop` 或 `TestLoop` 在 `Runner` 中调用。在大多数情况下，您不需要重写此方法，但如果您想做一些额外的工作，可以重写它。
+
+ **注意：** 您可以在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L366) 找到 `Runner` 调用 `evaluate()` 方法的过程。`Runner` 是训练和测试过程的执行器，您可以在[训练引擎文档](./engine.md)中找到有关它的详细信息。
+
+2. 在 `mmseg/evaluation/metrics/__init__.py` 中导入新的指标。
+
+ ```python
+ from .custom_metric import CustomMetric
+ __all__ = ['CustomMetric', ...]
+ ```
+
+3. 在配置文件中设置新的评测指标
+
+ ```python
+ val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+ test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+ ```
+
+## 使用发布版本的 MMSegmentation 进行开发
+
+上面的示例展示了如何使用 MMSegmentation 的源代码开发新指标。如果您想使用 MMSegmentation 的发布版本开发新指标，可以按照以下步骤操作。
+
+1. 创建一个新文件 `/Path/to/metrics/custom_metric.py`，实现 `process`，`compute_metrics` 和 `evaluate` 方法，`evaluate` 方法是可选的。
+
+2. 在代码或配置文件中导入新的指标。
+
+ ```python
+ from path.to.metrics import CustomMetric
+ ```
+
+ 或者
+
+ ```python
+ custom_imports = dict(imports=['/Path/to/metrics'], allow_failed_imports=False)
+
+ val_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+ test_evaluator = dict(type='CustomMetric', arg1=xxx, arg2=xxx)
+ ```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/add_models.md b/internlm_langchain/knowledge_base/MMSegmentation/content/add_models.md
new file mode 100644
index 00000000..e05c07c8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/add_models.md
@@ -0,0 +1,260 @@
+# 新增模块
+
+## 开发新组件
+
+我们可以自定义 [模型文档](./models.md) 中介绍的所有组件，例如**主干网络（backbone）**、**头（head）**、**损失函数（loss function）**和**数据预处理器（data preprocessor）**。
+
+### 添加新的主干网络（backbone）
+
+在这里，我们以 MobileNet 为例展示如何开发新的主干网络。
+
+1. 创建一个新文件 `mmseg/models/backbones/mobilenet.py`。
+
+ ```python
+ import torch.nn as nn
+
+ from mmseg.registry import MODELS
+
+
+ @MODELS.register_module()
+ class MobileNet(nn.Module):
+
+ def __init__(self, arg1, arg2):
+ pass
+
+ def forward(self, x): # should return a tuple
+ pass
+
+ def init_weights(self, pretrained=None):
+ pass
+ ```
+
+2. 在 `mmseg/models/backbones/__init__.py` 中引入模块。
+
+ ```python
+ from .mobilenet import MobileNet
+ ```
+
+3. 在配置文件中使用它。
+
+ ```python
+ model = dict(
+ ...
+ backbone=dict(
+ type='MobileNet',
+ arg1=xxx,
+ arg2=xxx),
+ ...
+ ```
+
+### 添加新的头（head）
+
+在 MMSegmentation 中，我们提供 [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/decode_heads/decode_head.py#L17) 用于开发所有分割头。
+所有新实现的解码头都应该从中派生出来。
+接下来我们以 [PSPNet](https://arxiv.org/abs/1612.01105) 为例说明如何开发新的头。
+
+首先，在 `mmseg/models/decode_heads/psp_head.py` 中添加一个新的解码头。
+PSPNet 实现了用于分割解码的解码头。
+为了实现解码头，在新模块中我们需要执行以下三个函数。
+
+```python
+from mmseg.registry import MODELS
+
+@MODELS.register_module()
+class PSPHead(BaseDecodeHead):
+
+ def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+ super(PSPHead, self).__init__(**kwargs)
+
+ def init_weights(self):
+ pass
+
+ def forward(self, inputs):
+ pass
+```
+
+接下来，用户需要在 `mmseg/models/decode_heads/__init__.py` 中添加模块，这样相应的注册器就可以找到并加载它们。
+
+PSPNet 的配置文件如下
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+ type='EncoderDecoder',
+ pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
+ backbone=dict(
+ type='ResNetV1c',
+ depth=50,
+ num_stages=4,
+ out_indices=(0, 1, 2, 3),
+ dilations=(1, 1, 2, 4),
+ strides=(1, 2, 1, 1),
+ norm_cfg=norm_cfg,
+ norm_eval=False,
+ style='pytorch',
+ contract_dilation=True),
+ decode_head=dict(
+ type='PSPHead',
+ in_channels=2048,
+ in_index=3,
+ channels=512,
+ pool_scales=(1, 2, 3, 6),
+ dropout_ratio=0.1,
+ num_classes=19,
+ norm_cfg=norm_cfg,
+ align_corners=False,
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+
+```
+
+### 添加新的损失函数（loss）
+
+假设您想为分割解码添加一个叫做 `MyLoss` 的新的损失函数。
+要添加新的损失函数，用户需要在 `mmseg/models/loss/my_loss.py` 中实现它。
+修饰器 `weighted_loss` 可以对损失的每个元素进行加权。
+
+```python
+import torch
+import torch.nn as nn
+
+from mmseg.registry import MODELS
+from .utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+ assert pred.size() == target.size() and target.numel() > 0
+ loss = torch.abs(pred - target)
+ return loss
+
+@MODELS.register_module()
+class MyLoss(nn.Module):
+
+ def __init__(self, reduction='mean', loss_weight=1.0):
+ super(MyLoss, self).__init__()
+ self.reduction = reduction
+ self.loss_weight = loss_weight
+
+ def forward(self,
+ pred,
+ target,
+ weight=None,
+ avg_factor=None,
+ reduction_override=None):
+ assert reduction_override in (None, 'none', 'mean', 'sum')
+ reduction = (
+ reduction_override if reduction_override else self.reduction)
+ loss = self.loss_weight * my_loss(
+ pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+ return loss
+```
+
+然后，用户需要将其添加到 `mmseg/models/loss/__init__.py` 中。
+
+```python
+from .my_loss import MyLoss, my_loss
+
+```
+
+要使用它，请修改 `loss_xx` 字段。
+然后需要修改头中的 `loss_decode` 字段。
+`loss_weight` 可用于平衡多重损失。
+
+```python
+loss_decode=dict(type='MyLoss', loss_weight=1.0))
+```
+
+### 添加新的数据预处理器（data preprocessor）
+
+在 MMSegmentation 1.x 版本中，我们使用 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/data_preprocessor.py#L13) 将数据复制到目标设备，并将数据预处理为默认的模型输入格式。这里我们将展示如何开发一个新的数据预处理器。
+
+1. 创建一个新文件 `mmseg/models/my_datapreprocessor.py`。
+
+ ```python
+ from mmengine.model import BaseDataPreprocessor
+
+ from mmseg.registry import MODELS
+
+ @MODELS.register_module()
+ class MyDataPreProcessor(BaseDataPreprocessor):
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+
+ def forward(self, data: dict, training: bool=False) -> Dict[str, Any]:
+ # TODO Define the logic for data pre-processing in the forward method
+ pass
+ ```
+
+2. 在 `mmseg/models/__init__.py` 中导入数据预处理器
+
+ ```python
+ from .my_datapreprocessor import MyDataPreProcessor
+ ```
+
+3. 在配置文件中使用它。
+
+ ```python
+ model = dict(
+ data_preprocessor=dict(type='MyDataPreProcessor)
+ ...
+ )
+ ```
+
+## 开发新的分割器（segmentor）
+
+分割器是一种户可以通过添加自定义组件和定义算法执行逻辑来自定义其算法的算法架构。请参考[模型文档](./models.md)了解更多详情。
+
+由于 MMSegmentation 中的 [BaseSegmenter](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) 统一了前向过程的三种模式，为了开发新的分割器，用户需要重写与 `loss`、`predict` 和 `tensor` 相对应的 `loss`、`predict` 和 `_forward` 方法。
+
+这里我们将展示如何开发一个新的分割器。
+
+1. 创建一个新文件 `mmseg/models/segmentors/my_segmentor.py`。
+
+ ```python
+ from typing import Dict, Optional, Union
+
+ import torch
+
+ from mmseg.registry import MODELS
+ from mmseg.models import BaseSegmentor
+
+ @MODELS.register_module()
+ class MySegmentor(BaseSegmentor):
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+ # TODO users should build components of the network here
+
+ def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
+ """Calculate losses from a batch of inputs and data samples."""
+ pass
+
+ def predict(self, inputs: Tensor, data_samples: OptSampleList=None) -> SampleList:
+ """Predict results from a batch of inputs and data samples with post-
+ processing."""
+ pass
+
+ def _forward(self,
+ inputs: Tensor,
+ data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
+ """Network forward process.
+
+ Usually includes backbone, neck and head forward without any post-
+ processing.
+ """
+ pass
+ ```
+
+2. 在 `mmseg/models/segmentors/__init__.py` 中导入分割器。
+
+ ```python
+ from .my_segmentor import MySegmentor
+ ```
+
+3. 在配置文件中使用它。
+
+ ```python
+ model = dict(
+ type='MySegmentor'
+ ...
+ )
+ ```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/add_transforms.md b/internlm_langchain/knowledge_base/MMSegmentation/content/add_transforms.md
new file mode 100644
index 00000000..d7206680
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/add_transforms.md
@@ -0,0 +1,51 @@
+# 新增数据增强
+
+## 自定义数据增强
+
+自定义数据增强必须继承 `BaseTransform` 并实现 `transform` 函数。这里我们使用一个简单的翻转变换作为示例：
+
+```python
+import random
+import mmcv
+from mmcv.transforms import BaseTransform, TRANSFORMS
+
+@TRANSFORMS.register_module()
+class MyFlip(BaseTransform):
+ def __init__(self, direction: str):
+ super().__init__()
+ self.direction = direction
+
+ def transform(self, results: dict) -> dict:
+ img = results['img']
+ results['img'] = mmcv.imflip(img, direction=self.direction)
+ return results
+```
+
+此外，新的类需要被导入。
+
+```python
+from .my_pipeline import MyFlip
+```
+
+这样，我们就可以实例化一个 `MyFlip` 对象并使用它来处理数据字典。
+
+```python
+import numpy as np
+
+transform = MyFlip(direction='horizontal')
+data_dict = {'img': np.random.rand(224, 224, 3)}
+data_dict = transform(data_dict)
+processed_img = data_dict['img']
+```
+
+或者，我们可以在配置文件中的数据流程中使用 `MyFlip` 变换。
+
+```python
+pipeline = [
+ ...
+ dict(type='MyFlip', direction='horizontal'),
+ ...
+]
+```
+
+需要注意，如果要在配置文件中使用 `MyFlip`，必须确保在运行时导入了包含 `MyFlip` 的文件。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/contribute_dataset.md b/internlm_langchain/knowledge_base/MMSegmentation/content/contribute_dataset.md
new file mode 100644
index 00000000..4222de32
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/contribute_dataset.md
@@ -0,0 +1,461 @@
+# 在 mmsegmentation projects 中贡献一个标准格式的数据集
+
+- 在开始您的贡献流程前，请先阅读[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)，以详细的了解 OpenMMLab 代码库的代码贡献流程。
+- 该教程以 [Gaofen Image Dataset (GID)](https://www.sciencedirect.com/science/article/pii/S0034425719303414) 高分 2 号卫星所拍摄的遥感图像语义分割数据集作为样例，来演示在 mmsegmentation 中的数据集贡献流程。
+
+## 步骤 1： 配置 mmsegmentation 开发所需必要环境
+
+- 开发所必需的环境安装请参考[中文快速入门指南](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/zh_cn/get_started.md)或[英文 get_started](https://github.com/open-mmlab/mmsegmentation/blob/main/docs/en/get_started.md)。
+
+- 如果您已安装了最新版的 pytorch、mmcv、mmengine，那么您可以跳过步骤 1 至[步骤 2](<#[步骤-2](#%E6%AD%A5%E9%AA%A4-2%E4%BB%A3%E7%A0%81%E8%B4%A1%E7%8C%AE%E5%89%8D%E7%9A%84%E5%87%86%E5%A4%87%E5%B7%A5%E4%BD%9C)>)。
+
+- **注：** 在此处无需安装 mmsegmentation，只需安装开发 mmsegmentation 所必需的 pytorch、mmcv、mmengine 等即可。
+
+**新建虚拟环境（如已有合适的开发环境，可跳过）**
+
+- 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda
+- 创建一个 conda 环境，并激活
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**安装 pytorch （如环境下已安装 pytorch，可跳过）**
+
+- 参考 [official instructions](https://pytorch.org/get-started/locally/) 安装 **PyTorch**
+
+**使用 mim 安装 mmcv、mmengine**
+
+- 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+## 步骤 2：代码贡献前的准备工作
+
+### 2.1 Fork mmsegmentation 仓库
+
+- 通过浏览器打开[mmsegmentation 官方仓库](https://github.com/open-mmlab/mmsegmentation/tree/main)。
+- 登录您的 GitHub 账户，以下步骤均需在 GitHub 登录的情况下进行。
+- Fork mmsegmentation 仓库
+ 
+- Fork 之后，mmsegmentation 仓库将会出现在您的个人仓库中。
+
+### 2.2 在您的代码编写软件中 git clone mmsegmentation
+
+这里以 VSCODE 为例
+
+- 打开 VSCODE，新建终端窗口并激活您在[步骤 1 ](#%E6%AD%A5%E9%AA%A4-1-%E9%85%8D%E7%BD%AE-mmsegmentation-%E5%BC%80%E5%8F%91%E6%89%80%E9%9C%80%E5%BF%85%E8%A6%81%E7%8E%AF%E5%A2%83)中所安装的虚拟环境。
+- 在您 GitHub 的个人仓库中找到您 Fork 的 mmsegmentation 仓库，复制其链接。
+ 
+- 在终端中执行命令
+ ```bash
+ git clone {您所复制的个人仓库的链接}
+ ```
+ 
+ **注：** 如提示以下信息，请在 GitHub 中添加 [SSH 秘钥](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent)
+ 
+- 进入 mmsegmentation 目录（之后的操作均在 mmsegmentation 目录下）。
+ ```bash
+ cd mmsegmentation
+ ```
+- 在终端中执行以下命令，添加官方仓库为上游仓库。
+ ```bash
+ git remote add upstream git@github.com:open-mmlab/mmsegmentation.git
+ ```
+- 使用以下命令检查 remote 是否添加成功。
+ ```bash
+ git remote -v
+ ```
+ 
+
+### 2.3 切换目录至 mmsegmentation 并从源码安装mmsegmentation
+
+在`mmsegmentation`目录下执行`pip install -v -e .`，通过源码构建方式安装 mmsegmentaion 库。
+安装完成后，您将能看到如下图所示的文件树。
+
+
+### 2.4 切换分支为 dev-1.x
+
+正如您在[ mmsegmentation 官网](https://github.com/open-mmlab/mmsegmentation/tree/main)所见，该仓库有许多分支，默认分支`main`为稳定的发行版本，以及用于贡献者进行开发的`dev-1.x`分支。`dev-1.x`分支是贡献者们用来提交创意和 PR 的分支，`dev-1.x`分支的内容会被周期性的合入到`main`分支。
+
+
+回到 VSCODE 中，在终端执行命令
+
+```bash
+git checkout dev-1.x
+```
+
+### 2.5 创新属于自己的新分支
+
+在基于`dev-1.x`分支下，使用如下命令，创建属于您自己的分支。
+
+```bash
+# git checkout -b 您的GitHubID/您的分支想要实现的功能的名字
+# git checkout -b AI-Tianlong/support_GID_dataset
+git checkout -b {您的GitHubID/您的分支想要实现的功能的名字}
+```
+
+### 2.6 配置 pre-commit
+
+OpenMMLab 仓库对代码质量有着较高的要求，所有提交的 PR 必须要通过代码格式检查。pre-commit 详细配置参阅[配置 pre-commit](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html#pre-commit)。
+
+## 步骤 3：在`mmsegmentation/projects`下贡献您的代码
+
+**先对 GID 数据集进行分析**
+
+这里以贡献高分 2 号遥感图像语义分割数据集 GID 为例，GID 数据集是由我国自主研发的高分 2 号卫星所拍摄的光学遥感图像所创建，经图像预处理后共提供了 150 张 6800x7200 像素的 RGB 三通道遥感图像。并提供了两种不同类别数的数据标注，一种是包含 5 类有效物体的 RGB 标签，另一种是包含 15 类有效物体的 RGB 标签。本教程将针对 5 类标签进行数据集贡献流程讲解。
+
+GID 的 5 类有效标签分别为：0-背景-\[0,0,0\](mask 标签值-标签名称-RGB 标签值)、1-建筑-\[255,0,0\]、2-农田-\[0,255,0\]、3-森林-\[0,0,255\]、4-草地-\[255,255,0\]、5-水-\[0,0,255\]。在语义分割任务中，标签是与原图尺寸一致的单通道图像，标签图像中的像素值为真实样本图像中对应像素所包含的物体的类别。GID 数据集提供的是具有 RGB 三通道的彩色标签，为了模型的训练需要将 RGB 标签转换为 mask 标签。并且由于图像尺寸为 6800x7200 像素，对于神经网络的训练来有些过大，所以将每张图像裁切成了没有重叠的 512x512 的图像以便进行训练。
+
+
+### 3.1 在`mmsegmentation/projects`下创建新的项目文件夹
+
+在`mmsegmentation/projects`下创建文件夹`gid_dataset`
+
+
+### 3.2 贡献您的数据集代码
+
+为了最终能将您在 projects 中贡献的代码更加顺畅的移入核心库中（对代码要求质量更高），非常建议按照核心库的目录来编辑您的数据集文件。
+关于数据集有 4 个必要的文件：
+
+- **1** `mmseg/datasets/gid.py` 定义了数据集的尾缀、CLASSES、PALETTE、reduce_zero_label等
+- **2** `configs/_base_/gid.py` GID 数据集的配置文件，定义了数据集的`dataset_type`（数据集类型，`mmseg/datasets/gid.py`中注册的数据集的类名）、`data_root`(数据集所在的根目录，建议将数据集通过软连接的方式将数据集放至`mmsegmentation/data`)、`train_pipline`(训练的数据流)、`test_pipline`(测试和验证时的数据流)、`img_rations`(多尺度预测时的多尺度配置)、`tta_pipeline`（多尺度预测）、`train_dataloader`(训练集的数据加载器)、`val_dataloader`(验证集的数据加载器)、`test_dataloader`(测试集的数据加载器)、`val_evaluator`(验证集的评估器)、`test_evaluator`(测试集的评估器)。
+- **3** 使用了 GID 数据集的模型训练配置文件
+ 这个是可选的，但是强烈建议您添加。在核心库中，所贡献的数据集需要和参考文献中所提出的结果精度对齐，为了后期将您贡献的代码合并入核心库。如您的算力充足，最好能提供对应的模型配置文件在您贡献的数据集上所验证的结果以及相应的权重文件，并撰写较为详细的README.md文档。[示例参考结果](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#mapillary-vistas-v12)
+ 
+- **4** 使用如下命令格式： 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`来添加您的数据集介绍，包括但不限于数据集的下载方式，数据集目录结构、数据集生成等一些必要性的文字性描述和运行命令。以更好地帮助用户能更快的实现数据集的准备工作。
+
+### 3.3 贡献`tools/dataset_converters/gid.py`
+
+由于 GID 数据集是由未经过切分的 6800x7200 图像所构成的数据集，并且没有划分训练集、验证集与测试集。以及其标签为 RGB 彩色标签，需要将标签转换为单通道的 mask label。为了方便训练，首先将 GID 数据集进行裁切和标签转换，并进行数据集划分，构建为 mmsegmentation 所支持的格式。
+
+```python
+# tools/dataset_converters/gid.py
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+from PIL import Image
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+
+def parse_args():
+ parser = argparse.ArgumentParser(
+ description='Convert GID dataset to mmsegmentation format')
+ parser.add_argument('dataset_img_path', help='GID images folder path')
+ parser.add_argument('dataset_label_path', help='GID labels folder path')
+ parser.add_argument('--tmp_dir', help='path of the temporary directory')
+ parser.add_argument('-o', '--out_dir', help='output path', default='data/gid')
+ parser.add_argument(
+ '--clip_size',
+ type=int,
+ help='clipped size of image after preparation',
+ default=256)
+ parser.add_argument(
+ '--stride_size',
+ type=int,
+ help='stride of clipping original images',
+ default=256)
+ args = parser.parse_args()
+ return args
+
+GID_COLORMAP = dict(
+ Background=(0, 0, 0), #0-背景-黑色
+ Building=(255, 0, 0), #1-建筑-红色
+ Farmland=(0, 255, 0), #2-农田-绿色
+ Forest=(0, 0, 255), #3-森林-蓝色
+ Meadow=(255, 255, 0),#4-草地-黄色
+ Water=(0, 0, 255)#5-水-蓝色
+)
+palette = list(GID_COLORMAP.values())
+classes = list(GID_COLORMAP.keys())
+
+#############用列表来存一个 RGB 和一个类别的对应################
+def colormap2label(palette):
+ colormap2label_list = np.zeros(256**3, dtype = np.longlong)
+ for i, colormap in enumerate(palette):
+ colormap2label_list[(colormap[0] * 256 + colormap[1])*256+colormap[2]] = i
+ return colormap2label_list
+
+#############给定那个列表，和vis_png然后生成masks_png################
+def label_indices(RGB_label, colormap2label_list):
+ RGB_label = RGB_label.astype('int32')
+ idx = (RGB_label[:, :, 0] * 256 + RGB_label[:, :, 1]) * 256 + RGB_label[:, :, 2]
+ # print(idx.shape)
+ return colormap2label_list[idx]
+
+def RGB2mask(RGB_label, colormap2label_list):
+ # RGB_label = np.array(Image.open(RGB_label).convert('RGB')) #打开RGB_png
+ mask_label = label_indices(RGB_label, colormap2label_list) # .numpy()
+ return mask_label
+
+colormap2label_list = colormap2label(palette)
+
+def clip_big_image(image_path, clip_save_dir, args, to_label=False):
+ """
+ Original image of GID dataset is very large, thus pre-processing
+ of them is adopted. Given fixed clip size and stride size to generate
+ clipped image, the intersection of width and height is determined.
+ For example, given one 6800 x 7200 original image, the clip size is
+ 256 and stride size is 256, thus it would generate 29 x 27 = 783 images
+ whose size are all 256 x 256.
+
+ """
+
+ image = mmcv.imread(image_path, channel_order='rgb')
+ # image = mmcv.bgr2gray(image)
+
+ h, w, c = image.shape
+ clip_size = args.clip_size
+ stride_size = args.stride_size
+
+ num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
+ (h - clip_size) /
+ stride_size) * stride_size + clip_size >= h else math.ceil(
+ (h - clip_size) / stride_size) + 1
+ num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
+ (w - clip_size) /
+ stride_size) * stride_size + clip_size >= w else math.ceil(
+ (w - clip_size) / stride_size) + 1
+
+ x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+ xmin = x * clip_size
+ ymin = y * clip_size
+
+ xmin = xmin.ravel()
+ ymin = ymin.ravel()
+ xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
+ np.zeros_like(xmin))
+ ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
+ np.zeros_like(ymin))
+ boxes = np.stack([
+ xmin + xmin_offset, ymin + ymin_offset,
+ np.minimum(xmin + clip_size, w),
+ np.minimum(ymin + clip_size, h)
+ ], axis=1)
+
+ if to_label:
+ image = RGB2mask(image, colormap2label_list) #这里得改一下
+
+ for count, box in enumerate(boxes):
+ start_x, start_y, end_x, end_y = box
+ clipped_image = image[start_y:end_y,
+ start_x:end_x] if to_label else image[
+ start_y:end_y, start_x:end_x, :]
+ img_name = osp.basename(image_path).replace('.tif', '')
+ img_name = img_name.replace('_label', '')
+ if count % 3 == 0:
+ mmcv.imwrite(
+ clipped_image.astype(np.uint8),
+ osp.join(
+ clip_save_dir.replace('train', 'val'),
+ f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+ else:
+ mmcv.imwrite(
+ clipped_image.astype(np.uint8),
+ osp.join(
+ clip_save_dir,
+ f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+ count += 1
+
+def main():
+ args = parse_args()
+
+ """
+ According to this paper: https://ieeexplore.ieee.org/document/9343296/
+ select 15 images contained in GID, , which cover the whole six
+ categories, to generate train set and validation set.
+
+ According to Paper: https://ieeexplore.ieee.org/document/9343296/
+
+ """
+
+ if args.out_dir is None:
+ out_dir = osp.join('data', 'gid')
+ else:
+ out_dir = args.out_dir
+
+ print('Making directories...')
+ mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+ mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+ mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+ mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+ src_path_list = glob.glob(os.path.join(args.dataset_img_path, '*.tif'))
+ print(f'Find {len(src_path_list)} pictures')
+
+ prog_bar = ProgressBar(len(src_path_list))
+
+ dst_img_dir = osp.join(out_dir, 'img_dir', 'train')
+ dst_label_dir = osp.join(out_dir, 'ann_dir', 'train')
+
+ for i, img_path in enumerate(src_path_list):
+ label_path = osp.join(args.dataset_label_path, osp.basename(img_path.replace('.tif', '_label.tif')))
+
+ clip_big_image(img_path, dst_img_dir, args, to_label=False)
+ clip_big_image(label_path, dst_label_dir, args, to_label=True)
+ prog_bar.update()
+
+ print('Done!')
+
+if __name__ == '__main__':
+ main()
+```
+
+### 3.4 贡献`mmseg/datasets/gid.py`
+
+可参考[`projects/mapillary_dataset/mmseg/datasets/mapillary.py`](https://github.com/open-mmlab/mmsegmentation/blob/main/projects/mapillary_dataset/mmseg/datasets/mapillary.py)并在此基础上修改相应变量以适配您的数据集。
+
+```python
+# mmseg/datasets/gid.py
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets.basesegdataset import BaseSegDataset
+from mmseg.registry import DATASETS
+
+# 注册数据集类
+@DATASETS.register_module()
+class GID_Dataset(BaseSegDataset):
+ """Gaofen Image Dataset (GID)
+
+ Dataset paper link:
+ https://www.sciencedirect.com/science/article/pii/S0034425719303414
+ https://x-ytong.github.io/project/GID.html
+
+ GID 6 classes: background(others), built-up, farmland, forest, meadow, water
+
+ In This example, select 10 images from GID dataset as training set,
+ and select 5 images as validation set.
+ The selected images are listed as follows:
+
+ GF2_PMS1__L1A0000647767-MSS1
+ GF2_PMS1__L1A0001064454-MSS1
+ GF2_PMS1__L1A0001348919-MSS1
+ GF2_PMS1__L1A0001680851-MSS1
+ GF2_PMS1__L1A0001680853-MSS1
+ GF2_PMS1__L1A0001680857-MSS1
+ GF2_PMS1__L1A0001757429-MSS1
+ GF2_PMS2__L1A0000607681-MSS2
+ GF2_PMS2__L1A0000635115-MSS2
+ GF2_PMS2__L1A0000658637-MSS2
+ GF2_PMS2__L1A0001206072-MSS2
+ GF2_PMS2__L1A0001471436-MSS2
+ GF2_PMS2__L1A0001642620-MSS2
+ GF2_PMS2__L1A0001787089-MSS2
+ GF2_PMS2__L1A0001838560-MSS2
+
+ The ``img_suffix`` is fixed to '.tif' and ``seg_map_suffix`` is
+ fixed to '.tif' for GID.
+ """
+ METAINFO = dict(
+ classes=('Others', 'Built-up', 'Farmland', 'Forest',
+ 'Meadow', 'Water'),
+
+ palette=[[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 255, 255],
+ [255, 255, 0], [0, 0, 255]])
+
+ def __init__(self,
+ img_suffix='.png',
+ seg_map_suffix='.png',
+ reduce_zero_label=None,
+ **kwargs) -> None:
+ super().__init__(
+ img_suffix=img_suffix,
+ seg_map_suffix=seg_map_suffix,
+ reduce_zero_label=reduce_zero_label,
+ **kwargs)
+```
+
+### 3.5 贡献使用 GID 的训练 config file
+
+```python
+_base_ = [
+ '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
+ './_base_/datasets/gid.py',
+ '../../../configs/_base_/default_runtime.py',
+ '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+ imports=['projects.gid_dataset.mmseg.datasets.gid'])
+
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+ data_preprocessor=data_preprocessor,
+ pretrained='open-mmlab://resnet101_v1c',
+ backbone=dict(depth=101),
+ decode_head=dict(num_classes=6),
+ auxiliary_head=dict(num_classes=6))
+
+```
+
+### 3.6 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`
+
+**Gaofen Image Dataset (GID)**
+
+- GID 数据集可在[此处](https://x-ytong.github.io/project/Five-Billion-Pixels.html)进行下载。
+- GID 数据集包含 150 张 6800x7200 的大尺寸图像，标签为 RGB 标签。
+- 此处选择 15 张图像生成训练集和验证集，该 15 张图像包含了所有六类信息。所选的图像名称如下：
+
+```None
+ GF2_PMS1__L1A0000647767-MSS1
+ GF2_PMS1__L1A0001064454-MSS1
+ GF2_PMS1__L1A0001348919-MSS1
+ GF2_PMS1__L1A0001680851-MSS1
+ GF2_PMS1__L1A0001680853-MSS1
+ GF2_PMS1__L1A0001680857-MSS1
+ GF2_PMS1__L1A0001757429-MSS1
+ GF2_PMS2__L1A0000607681-MSS2
+ GF2_PMS2__L1A0000635115-MSS2
+ GF2_PMS2__L1A0000658637-MSS2
+ GF2_PMS2__L1A0001206072-MSS2
+ GF2_PMS2__L1A0001471436-MSS2
+ GF2_PMS2__L1A0001642620-MSS2
+ GF2_PMS2__L1A0001787089-MSS2
+ GF2_PMS2__L1A0001838560-MSS2
+```
+
+执行以下命令进行裁切及标签的转换，需要修改为您所存储 15 张图像及标签的路径。
+
+```
+python projects/gid_dataset/tools/dataset_converters/gid.py [15 张图像的路径] [15 张标签的路径]
+```
+
+完成裁切后的 GID 数据结构如下：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│ ├── gid
+│ │ ├── ann_dir
+| │ │ │ ├── train
+| │ │ │ ├── val
+│ │ ├── img_dir
+| │ │ │ ├── train
+| │ │ │ ├── val
+
+```
+
+### 3.7 贡献的代码及文档通过`pre-commit`检查
+
+使用命令
+
+```bash
+git add .
+git commit -m "添加描述"
+git push
+```
+
+### 3.8 在 GitHub 中向 mmsegmentation 提交 PR
+
+具体步骤可见[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/customize_runtime.md b/internlm_langchain/knowledge_base/MMSegmentation/content/customize_runtime.md
new file mode 100644
index 00000000..a80aca63
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/customize_runtime.md
@@ -0,0 +1,162 @@
+# 自定义运行设定
+
+## 实现自定义钩子
+
+### Step 1: 创建一个新的钩子
+
+MMEngine 已实现了训练和测试常用的[钩子](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md),
+当有定制化需求时, 可以按照如下示例实现适用于自身训练需求的钩子, 例如想修改一个超参数 `model.hyper_paramete` 的值, 让它随着训练迭代次数而变化:
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence
+
+from mmengine.hooks import Hook
+from mmengine.model import is_model_wrapper
+
+from mmseg.registry import HOOKS
+
+
+@HOOKS.register_module()
+class NewHook(Hook):
+ """Docstring for NewHook.
+ """
+
+ def __init__(self, a: int, b: int) -> None:
+ self.a = a
+ self.b = b
+
+ def before_train_iter(self,
+ runner,
+ batch_idx: int,
+ data_batch: Optional[Sequence[dict]] = None) -> None:
+ cur_iter = runner.iter
+ # 当模型被包在 wrapper 里时获取这个模型
+ if is_model_wrapper(runner.model):
+ model = runner.model.module
+ model.hyper_parameter = self.a * cur_iter + self.b
+```
+
+### Step 2: 导入一个新的钩子
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
+假设 NewHook 在 `mmseg/engine/hooks/new_hook.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/hooks/__init__.py` 来导入它.
+ 新定义的模块应该在 `mmseg/engine/hooks/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .new_hook import NewHook
+
+__all__ = [..., NewHook]
+```
+
+- 在配置文件里使用 custom_imports 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.hooks.new_hook'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+可以按照如下方式, 在训练或测试中配置并使用自定义的钩子. 不同钩子在同一位点的优先级可以参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md#%E5%86%85%E7%BD%AE%E9%92%A9%E5%AD%90), 自定义钩子如果没有指定优先, 默认是 `NORMAL`.
+
+```python
+custom_hooks = [
+ dict(type='NewHook', a=a_value, b=b_value, priority='ABOVE_NORMAL')
+]
+```
+
+## 实现自定义优化器
+
+### Step 1: 创建一个新的优化器
+
+如果增加一个叫作 `MyOptimizer` 的优化器, 它有参数 `a`, `b` 和 `c`. 推荐在 `mmseg/engine/optimizers/my_optimizer.py` 文件中实现
+
+```python
+from mmseg.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+ def __init__(self, a, b, c)
+```
+
+### Step 2: 导入一个新的优化器
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
+假设 `MyOptimizer` 在 `mmseg/engine/optimizers/my_optimizer.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
+ 新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- 在配置文件里使用 `custom_imports` 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+随后需要修改配置文件 `optim_wrapper` 里的 `optimizer` 参数, 如果要使用你自己的优化器 `MyOptimizer`, 字段可以被修改成:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+ optimizer=dict(type='MyOptimizer',
+ a=a_value, b=b_value, c=c_value),
+ clip_grad=None)
+```
+
+## 实现自定义优化器封装构造器
+
+### Step 1: 创建一个新的优化器封装构造器
+
+构造器可以用来创建优化器, 优化器包, 以及自定义模型网络不同层的超参数. 一些模型的优化器可能会根据特定的参数而调整, 例如 BatchNorm 层的 weight decay. 使用者可以通过自定义优化器构造器来精细化设定不同参数的优化策略.
+
+```python
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
+ def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
+
+ def __call__(self, model):
+
+ return my_optimizer
+```
+
+默认的优化器构造器在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 被实现, 它也可以用来作为新的优化器构造器的模板.
+
+### Step 2: 导入一个新的优化器封装构造器
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面, 假设 `MyOptimizerConstructor` 在 `mmseg/engine/optimizers/my_optimizer_constructor.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
+ 新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .my_optimizer_constructor import MyOptimizerConstructor
+```
+
+- 在配置文件里使用 `custom_imports` 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer_constructor'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+随后需要修改配置文件 `optim_wrapper` 里的 `constructor` 参数, 如果要使用你自己的优化器封装构造器 `MyOptimizerConstructor`, 字段可以被修改成:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+ constructor='MyOptimizerConstructor',
+ clip_grad=None)
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/data_flow.md b/internlm_langchain/knowledge_base/MMSegmentation/content/data_flow.md
new file mode 100644
index 00000000..20dbe07e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/data_flow.md
@@ -0,0 +1,90 @@
+# 数据流
+
+在本章节中，我们将介绍 [Runner](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html) 管理的内部模块之间的数据流和数据格式约定。
+
+## 数据流概述
+
+[Runner](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 相当于 MMEngine 中的“集成器”。它覆盖了框架的所有方面，并肩负着组织和调度几乎所有模块的责任，这意味着各模块之间的数据流也由 `Runner` 控制。 如 [MMEngine 中的 Runner 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)所示，下图展示了基本的数据流。
+
+
+
+虚线边框、灰色填充形状代表不同的数据格式，而实心框表示模块/方法。由于 MMEngine 极大的灵活性和可扩展性，一些重要的基类可以被继承，并且它们的方法可以被覆写。 上图所示数据流仅适用于当用户没有自定义 `Runner` 中的 `TrainLoop`、`ValLoop` 和 `TestLoop`，并且没有在其自定义模型中覆写 `train_step`、`val_step` 和 `test_step` 方法时。MMSegmentation 中 loop 的默认设置如下：使用`IterBasedTrainLoop` 训练模型，共计 20000 次迭代，并且在每 2000 次迭代后进行一次验证。
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+```
+
+在上图中，红色线表示 [train_step](./models.md#train_step)，在每次训练迭代中，数据加载器（dataloader）从存储中加载图像并传输到数据预处理器（data preprocessor），数据预处理器会将图像放到特定的设备上，并将数据堆叠到批处理中，之后模型接受批处理数据作为输入，最后将模型的输出发送给优化器（optimizer）。蓝色线表示 [val_step](./models.md#val_step) 和 [test_step](./models.md#test_step)。这两个过程的数据流除了模型输出与 `train_step` 不同外，其余均和 `train_step` 类似。由于在评估时模型参数会被冻结，因此模型的输出将被传递给 [Evaluator](./evaluation.md#ioumetric)。
+来计算指标。
+
+## MMSegmentation 中的数据流约定
+
+在上面的图中，我们可以看到基本的数据流。在本节中，我们将分别介绍数据流中涉及的数据的格式约定。
+
+### 数据加载器到数据预处理器
+
+数据加载器（DataLoader）是 MMEngine 的训练和测试流程中的一个重要组件。
+从概念上讲，它源于 [PyTorch](https://pytorch.org/) 并保持一致。DataLoader 从文件系统加载数据，原始数据通过数据准备流程后被发送给数据预处理器。
+
+MMSegmentation 在 [PackSegInputs](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/transforms/formatting.py#L12) 中定义了默认数据格式， 它是 `train_pipeline` 和 `test_pipeline` 的最后一个组件。有关数据转换 `pipeline` 的更多信息，请参阅[数据转换文档](./transforms.md)。
+
+在没有任何修改的情况下，PackSegInputs 的返回值通常是一个包含 `inputs` 和 `data_samples` 的 `dict`。以下伪代码展示了 mmseg 中数据加载器输出的数据类型，它是从数据集中获取的一批数据样本，数据加载器将它们打包成一个字典列表。`inputs` 是输入进模型的张量列表，`data_samples` 包含了输入图像的 meta information 和相应的 ground truth。
+
+```python
+dict(
+ inputs=List[torch.Tensor],
+ data_samples=List[SegDataSample]
+)
+```
+
+**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用于连接不同组件。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，更多信息请在 [MMEngine](https://github.com/open-mmlab/mmengine) 中参阅 [SegDataSample 文档](./structures.md)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)。
+
+### 数据预处理器到模型
+
+虽然在[上面的图](##数据流概述)中分开绘制了数据预处理器和模型，但数据预处理器是模型的一部分，因此可以在[模型教程](./models.md)中找到数据预处理器章节。
+
+数据预处理器的返回值是一个包含 `inputs` 和 `data_samples` 的字典，其中 `inputs` 是批处理图像的 4D 张量，`data_samples` 中添加了一些用于数据预处理的额外元信息。当传递给网络时，字典将被解包为两个值。 以下伪代码展示了数据预处理器的返回值和模型的输入值。
+
+```python
+dict(
+ inputs=torch.Tensor,
+ data_samples=List[SegDataSample]
+)
+```
+
+```python
+class Network(BaseSegmentor):
+
+ def forward(self, inputs: torch.Tensor, data_samples: List[SegDataSample], mode: str):
+ pass
+```
+
+**注意：** 模型的前向传播有 3 种模式，由输入参数 mode 控制，更多信息请参阅[模型教程](./models.md)。
+
+### 模型输出
+
+如[模型教程](./models.md#forward) ***（[中文链接待更新](./models.md#forward)）*** 所提到的 3 种前向传播具有 3 种输出。
+`train_step` 和 `test_step`（或 `val_step`）分别对应于 `'loss'` 和 `'predict'`。
+
+在 `test_step` 或 `val_step` 中，推理结果会被传递给 `Evaluator` 。您可以参阅[评估文档](./evaluation.md)来获取更多关于 `Evaluator` 的信息。
+
+在推理后，MMSegmentation 中的 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) 会对推理结果进行简单的后处理以打包推理结果。神经网络生成的分割 logits，经过 `argmax` 操作后的分割 mask 和 ground truth（如果存在）将被打包到类似 `SegDataSample` 的实例。 [postprocess_result](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L132) 的返回值是一个 **`SegDataSample`的`List`**。下图显示了这些 `SegDataSample` 实例的关键属性。
+
+
+
+与数据预处理器一致，损失函数也是模型的一部分，它是[解码头](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L142)的属性之一。
+
+在 MMSegmentation 中，`decode_head` 的 [loss_by_feat](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L291) 方法是用于计算损失的统一接口。
+
+参数：
+
+- seg_logits (Tensor)：解码头前向函数的输出
+- batch_data_samples (List\[SegDataSample\])：分割数据样本，通常包括如 `metainfo` 和 `gt_sem_seg` 等信息
+
+返回值：
+
+- dict\[str, Tensor\]：一个损失组件的字典
+
+**注意：** `train_step` 将损失传递进 OptimWrapper 以更新模型中的权重，更多信息请参阅 [train_step](./models.md#train_step)。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/datasets.md b/internlm_langchain/knowledge_base/MMSegmentation/content/datasets.md
new file mode 100644
index 00000000..b45f2d22
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/datasets.md
@@ -0,0 +1,363 @@
+# 数据集
+
+在 MMSegmentation 算法库中, 所有 Dataset 类的功能有两个: 加载[预处理](../user_guides/2_dataset_prepare.md) 之后的数据集的信息, 和将数据送入[数据集变换流水线](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L141) 中, 进行[数据变换操作](./transforms.md). 加载的数据集信息包括两类: 元信息 (meta information), 数据集本身的信息, 例如数据集总共的类别, 和它们对应调色盘信息: 数据信息 (data information) 是指每组数据中图片和对应标签的路径. 下文中介绍了 MMSegmentation 1.x 中数据集的常用接口, 和 mmseg 数据集基类中数据信息加载与修改数据集类别的逻辑, 以及数据集与数据变换流水线 (pipeline) 的关系.
+
+## 常用接口
+
+以 Cityscapes 为例, 介绍数据集常用接口. 如需运行以下示例, 请在当前工作目录下的 `data` 目录下载并[预处理](../user_guides/2_dataset_prepare.md#cityscapes) Cityscapes 数据集.
+
+实例化 Cityscapes 训练数据集:
+
+```python
+from mmengine.registry import init_default_scope
+from mmseg.datasets import CityscapesDataset
+
+init_default_scope('mmseg')
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+ dict(type='RandomFlip', prob=0.5),
+ dict(type='PackSegInputs')
+]
+
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False, pipeline=train_pipeline)
+```
+
+查看训练数据集长度:
+
+```python
+print(len(dataset))
+
+2975
+```
+
+获取数据信息, 数据信息的类型是一个字典, 包括 `'img_path'` 字段的存放图片的路径和 `'seg_map_path'` 字段存放分割标注的路径, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`(主要功能在下文中介绍), 还有存放已加载标签字段 `'seg_fields'`, 和当前样本的索引字段 `'sample_idx'`.
+
+```python
+# 获取数据集中第一组样本的数据信息
+print(dataset.get_data_info(0))
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
+
+获取数据集元信息, MMSegmentation 的数据集元信息的类型同样是一个字典, 包括 `'classes'` 字段存放数据集类别, `'palette'` 存放数据集类别对应的可视化时调色盘的颜色, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`.
+
+```python
+print(dataset.metainfo)
+
+{'classes': ('road',
+ 'sidewalk',
+ 'building',
+ 'wall',
+ 'fence',
+ 'pole',
+ 'traffic light',
+ 'traffic sign',
+ 'vegetation',
+ 'terrain',
+ 'sky',
+ 'person',
+ 'rider',
+ 'car',
+ 'truck',
+ 'bus',
+ 'train',
+ 'motorcycle',
+ 'bicycle'),
+ 'palette': [[128, 64, 128],
+ [244, 35, 232],
+ [70, 70, 70],
+ [102, 102, 156],
+ [190, 153, 153],
+ [153, 153, 153],
+ [250, 170, 30],
+ [220, 220, 0],
+ [107, 142, 35],
+ [152, 251, 152],
+ [70, 130, 180],
+ [220, 20, 60],
+ [255, 0, 0],
+ [0, 0, 142],
+ [0, 0, 70],
+ [0, 60, 100],
+ [0, 80, 100],
+ [0, 0, 230],
+ [119, 11, 32]],
+ 'label_map': None,
+ 'reduce_zero_label': False}
+```
+
+数据集 `__getitem__` 方法的返回值, 是经过数据增强的样本数据的输出, 同样也是一个字典, 包括两个字段, `'inputs'` 字段是当前样本经过数据增强操作的图像, 类型为 torch.Tensor, `'data_samples'` 字段存放的数据类型是 MMSegmentation 1.x 新添加的数据结构 [`Segdatasample`](./structures.md), 其中`gt_sem_seg` 字段是经过数据增强的标签数据.
+
+```python
+print(dataset[0])
+
+{'inputs': tensor([[[131, 130, 130, ..., 23, 23, 23],
+ [132, 132, 132, ..., 23, 22, 23],
+ [134, 133, 133, ..., 23, 23, 23],
+ ...,
+ [ 66, 67, 67, ..., 71, 71, 71],
+ [ 66, 67, 66, ..., 68, 68, 68],
+ [ 67, 67, 66, ..., 70, 70, 70]],
+
+ [[143, 143, 142, ..., 28, 28, 29],
+ [145, 145, 145, ..., 28, 28, 29],
+ [145, 145, 145, ..., 27, 28, 29],
+ ...,
+ [ 75, 75, 76, ..., 80, 81, 81],
+ [ 75, 76, 75, ..., 80, 80, 80],
+ [ 77, 76, 76, ..., 82, 82, 82]],
+
+ [[126, 125, 126, ..., 21, 21, 22],
+ [127, 127, 128, ..., 21, 21, 22],
+ [127, 127, 126, ..., 21, 21, 22],
+ ...,
+ [ 63, 63, 64, ..., 69, 69, 70],
+ [ 64, 65, 64, ..., 69, 69, 69],
+ [ 65, 66, 66, ..., 72, 71, 71]]], dtype=torch.uint8),
+ 'data_samples':
+ _gt_sem_seg:
+ )}
+```
+
+## BaseSegDataset
+
+由于 MMSegmentation 中的所有数据集的基本功能均包括(1) 加载[数据集预处理](../user_guides/2_dataset_prepare.md) 之后的数据信息和 (2) 将数据送入数据变换流水线中进行数据变换, 因此在 MMSegmentation 中将其中的共同接口抽象成 [`BaseSegDataset`](https://mmsegmentation.readthedocs.io/zh_CN/latest/api.html?highlight=BaseSegDataset#mmseg.datasets.BaseSegDataset)，它继承自 [MMEngine 的 `BaseDataset`](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/basedataset.md), 遵循 OpenMMLab 数据集初始化统一流程, 支持高效的内部数据存储格式, 支持数据集拼接、数据集重复采样等功能.
+在 MMSegmentation BaseSegDataset 中重新定义了**数据信息加载方法**（`load_data_list`）和并新增了 `get_label_map` 方法用来**修改数据集的类别信息**.
+
+### 数据信息加载
+
+数据信息加载的内容是样本数据的图片路径和标签路径, 具体实现在 MMSegmentation 的 BaseSegDataset 的 [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231) 中.
+主要有两种获取图片和标签的路径方法, 如果当数据集目录按以下目录结构组织, [`load_data_list`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L231)) 会根据数据路径和后缀来解析.
+
+```
+├── data
+│ ├── my_dataset
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ │ ├── xxx{img_suffix}
+│ │ │ │ ├── yyy{img_suffix}
+│ │ │ ├── val
+│ │ │ │ ├── zzz{img_suffix}
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ │ ├── xxx{seg_map_suffix}
+│ │ │ │ ├── yyy{seg_map_suffix}
+│ │ │ ├── val
+│ │ │ │ ├── zzz{seg_map_suffix}
+```
+
+例如 ADE20k 数据集结构如下所示:
+
+```
+├── ade
+│ ├── ADEChallengeData2016
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ │ ├── ADE_train_00000001.png
+│ │ │ │ ├── ...
+│ │ │ │── validation
+│ │ │ │ ├── ADE_val_00000001.png
+│ │ │ │ ├── ...
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ │ ├── ADE_train_00000001.jpg
+│ │ │ │ ├── ...
+│ │ │ ├── validation
+│ │ │ │ ├── ADE_val_00000001.jpg
+│ │ │ │ ├── ...
+```
+
+实例化 ADE20k 数据集时，输入图片和标签的路径和后缀:
+
+```python
+from mmseg.datasets import ADE20KDataset
+
+ADE20KDataset(data_root = 'data/ade/ADEChallengeData2016',
+ data_prefix=dict(img_path='images/training', seg_map_path='annotations/training'),
+ img_suffix='.jpg',
+ seg_map_suffix='.png',
+ reduce_zero_label=True）
+```
+
+如果数据集有标注文件, 实例化数据集时会根据输入的数据集标注文件加载数据信息. 例如, PascalContext 数据集实例, 输入标注文件的内容为:
+
+```python
+2008_000008
+...
+```
+
+实例化时需要定义 `ann_file`
+
+```python
+PascalContextDataset(data_root='data/VOCdevkit/VOC2010/',
+ data_prefix=dict(img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+ ann_file='ImageSets/SegmentationContext/train.txt')
+```
+
+### 数据集类别修改
+
+- 通过输入 metainfo 修改
+ `BaseSegDataset` 的子类元信息在数据集实现时定义为类变量，例如 Cityscapes 的 `METAINFO` 变量:
+
+```python
+class CityscapesDataset(BaseSegDataset):
+ """Cityscapes dataset.
+
+ The ``img_suffix`` is fixed to '_leftImg8bit.png' and ``seg_map_suffix`` is
+ fixed to '_gtFine_labelTrainIds.png' for Cityscapes dataset.
+ """
+ METAINFO = dict(
+ classes=('road', 'sidewalk', 'building', 'wall', 'fence', 'pole',
+ 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+ 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train',
+ 'motorcycle', 'bicycle'),
+ palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156],
+ [190, 153, 153], [153, 153, 153], [250, 170,
+ 30], [220, 220, 0],
+ [107, 142, 35], [152, 251, 152], [70, 130, 180],
+ [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70],
+ [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]])
+
+```
+
+这里的 `'classes'` 中定义了 Cityscapes 数据集标签中的类别名, 如果训练时只关注几个交通工具类别, **忽略其他类别**,
+在实例化 Cityscapes 数据集时通过定义 `metainfo` 输入参数的 classes 的字段来修改数据集的元信息:
+
+```python
+from mmseg.datasets import CityscapesDataset
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+# metainfo 中只保留以下 classes
+metainfo=dict(classes=( 'car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'))
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, metainfo=metainfo)
+
+print(dataset.metainfo)
+
+{'classes': ('car', 'truck', 'bus', 'train', 'motorcycle', 'bicycle'),
+ 'palette': [[0, 0, 142],
+ [0, 0, 70],
+ [0, 60, 100],
+ [0, 80, 100],
+ [0, 0, 230],
+ [119, 11, 32],
+ [128, 64, 128],
+ [244, 35, 232],
+ [70, 70, 70],
+ [102, 102, 156],
+ [190, 153, 153],
+ [153, 153, 153],
+ [250, 170, 30],
+ [220, 220, 0],
+ [107, 142, 35],
+ [152, 251, 152],
+ [70, 130, 180],
+ [220, 20, 60],
+ [255, 0, 0]],
+ # 类别索引为 255 的像素，在计算损失时会被忽略
+ 'label_map': {0: 255,
+ 1: 255,
+ 2: 255,
+ 3: 255,
+ 4: 255,
+ 5: 255,
+ 6: 255,
+ 7: 255,
+ 8: 255,
+ 9: 255,
+ 10: 255,
+ 11: 255,
+ 12: 255,
+ 13: 0,
+ 14: 1,
+ 15: 2,
+ 16: 3,
+ 17: 4,
+ 18: 5},
+ 'reduce_zero_label': False}
+```
+
+可以看到, 数据集元信息的类别和默认 Cityscapes 不同. 并且, 定义了标签重映射的字段 `label_map` 用来修改每个分割掩膜上的像素的类别索引, 分割标签类别会根据 `label_map`, 将类别重映射, [具体实现](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L151):
+
+```python
+gt_semantic_seg_copy = gt_semantic_seg.copy()
+for old_id, new_id in results['label_map'].items():
+ gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
+```
+
+- 通过 `reduce_zero_label` 修改
+ 对于常见的忽略 0 号标签的场景, `BaseSegDataset` 的子类中可以用 `reduce_zero_label` 输入参数来控制。`reduce_zero_label` (默认为 `False`)
+ 用来控制是否将标签 0 忽略, 当该参数为 `True` 时(最常见的应用是 ADE20k 数据集), 对分割标签中第 0 个类别对应的类别索引改为 255 (MMSegmentation 模型中计算损失时, 默认忽略 255), 其他类别对应的类别索引减一:
+
+```python
+gt_semantic_seg[gt_semantic_seg == 0] = 255
+gt_semantic_seg = gt_semantic_seg - 1
+gt_semantic_seg[gt_semantic_seg == 254] = 255
+```
+
+## 数据集与数据变换流水线
+
+在常用接口的例子中可以看到, 输入的参数中定义了数据变换流水线参数 `pipeline`, 数据集 `__getitem__` 方法返回经过数据变换的值.
+当数据集输入参数没有定义 pipeline, 返回值和 `get_data_info` 方法返回值相同, 例如:
+
+```python
+from mmseg.datasets import CityscapesDataset
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False)
+
+print(dataset[0])
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/engine.md b/internlm_langchain/knowledge_base/MMSegmentation/content/engine.md
new file mode 100644
index 00000000..79b4c8d2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/engine.md
@@ -0,0 +1,281 @@
+# 训练引擎
+
+MMEngine 定义了一些[基础循环控制器](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py) 例如基于轮次的训练循环 (`EpochBasedTrainLoop`), 基于迭代次数的训练循环 (`IterBasedTrainLoop`), 标准的验证循环 (`ValLoop`) 和标准的测试循环 (`TestLoop`).
+OpenMMLab 的算法库如 MMSegmentation 将模型训练, 测试和推理抽象为执行器(`Runner`) 来处理. 用户可以直接使用 MMEngine 中的默认执行器, 也可以对执行器进行修改以满足定制化需求. 这个文档主要介绍用户如何配置已有的运行设定, 钩子和优化器的基本概念与使用方法.
+
+## 配置运行设定
+
+### 配置训练长度
+
+循环控制器指的是训练, 验证和测试时的执行流程, 在配置文件里面使用 `train_cfg`, `val_cfg` 和 `test_cfg` 来构建这些流程. MMSegmentation 在 `configs/_base_/schedules` 文件夹里面的 `train_cfg` 设置常用的训练长度.
+例如, 使用基于迭代次数的训练循环 (`IterBasedTrainLoop`) 去训练 80,000 个迭代次数, 并且每 8,000 iteration 做一次验证, 可以如下设置:
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+```
+
+### 配置训练优化器
+
+这里是一个 SGD 优化器的例子:
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+ clip_grad=None)
+```
+
+OpenMMLab 支持 PyTorch 里面所有的优化器, 更多细节可以参考 MMEngine [优化器文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md).
+
+需要强调的是, `optim_wrapper` 是 `runner` 的变量, 所以需要配置优化器时配置的字段是 `optim_wrapper` 字段. 更多关于优化器的使用方法, 可以看下面优化器的章节.
+
+### 配置训练参数调度器
+
+在配置训练参数调度器前, 推荐先了解 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/param_scheduler.md) 里面关于参数调度器的基本概念.
+
+以下是一个参数调度器的例子, 训练时前 1,000 个 iteration 时采用线性变化的学习率策略作为训练预热, 从 1,000 iteration 之后直到最后 16,000 个 iteration 时则采用默认的多项式学习率衰减:
+
+```python
+param_scheduler = [
+ dict(type='LinearLR', by_epoch=False, start_factor=0.1, begin=0, end=1000),
+ dict(
+ type='PolyLR',
+ eta_min=1e-4,
+ power=0.9,
+ begin=1000,
+ end=160000,
+ by_epoch=False,
+ )
+]
+```
+
+注意: 当修改 `train_cfg` 里面 `max_iters` 的时候, 请确保参数调度器 `param_scheduler` 里面的参数也被同时修改.
+
+## 钩子 (Hook)
+
+### 介绍
+
+OpenMMLab 将模型训练和测试过程抽象为 `Runner`, 插入钩子可以实现在 `Runner` 中不同的训练和测试节点 (例如 "每个训练 iter 前后", "每个验证 iter 前后" 等不同阶段) 所需要的相应功能. 更多钩子机制的介绍可以参考[这里](https://www.calltutors.com/blog/what-is-hook).
+
+`Runner` 中所使用的钩子分为两类:
+
+- 默认钩子 (default hooks)
+
+它们实现了训练时所必需的功能, 在配置文件中用 `default_hooks` 定义传给 `Runner`, `Runner` 通过 [`register_default_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1780) 方法注册.
+钩子有对应的优先级, 优先级越高, 越早被执行器调用. 如果优先级一样, 被调用的顺序和钩子注册的顺序一致.
+不建议用户修改默认钩子的优先级, 可以参考 [mmengine hooks 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md) 了解钩子优先级的定义.
+下面是 MMSegmentation 中所用到的默认钩子：
+
+| 钩子 | 功能 | 优先级 |
+| :--------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | :---------------: |
+| [IterTimerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/iter_timer_hook.py) | 记录 iteration 花费的时间. | NORMAL (50) |
+| [LoggerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py) | 从 `Runner` 里不同的组件中收集日志记录, 并将其输出到终端, JSON 文件, tensorboard, wandb 等下游. | BELOW_NORMAL (60) |
+| [ParamSchedulerHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/param_scheduler_hook.py) | 更新优化器里面的一些超参数, 例如学习率的动量. | LOW (70) |
+| [CheckpointHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py) | 规律性地保存 checkpoint 文件. | VERY_LOW (90) |
+| [DistSamplerSeedHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sampler_seed_hook.py) | 确保分布式采样器 shuffle 是打开的. | NORMAL (50) |
+| [SegVisualizationHook](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/visualization/local_visualizer.py) | 可视化验证和测试过程里的预测结果. | NORMAL (50) |
+
+MMSegmentation 会在 [`defualt_hooks`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/schedules/schedule_160k.py#L19-L25) 里面注册一些训练所必需功能的钩子::
+
+```python
+default_hooks = dict(
+ timer=dict(type='IterTimerHook'),
+ logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+ param_scheduler=dict(type='ParamSchedulerHook'),
+ checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
+ sampler_seed=dict(type='DistSamplerSeedHook'),
+ visualization=dict(type='SegVisualizationHook'))
+```
+
+以上默认钩子除 `SegVisualizationHook` 外都是在 MMEngine 中所实现, `SegVisualizationHook` 是在 MMSegmentation 里被实现的钩子, 之后会专门介绍.
+
+- 修改默认的钩子
+
+以 `default_hooks` 里面的 `logger` 和 `checkpoint` 为例, 我们来介绍如何修改 `default_hooks` 中默认的钩子.
+
+(1) 模型保存配置
+
+`default_hooks` 使用 `checkpoint` 字段来初始化[模型保存钩子 (CheckpointHook)](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19).
+
+```python
+checkpoint = dict(type='CheckpointHook', interval=1)
+```
+
+用户可以设置 `max_keep_ckpts` 来只保存少量的检查点或者用 `save_optimizer` 来决定是否保存 optimizer 的信息.
+更多相关参数的细节可以参考[这里](https://mmengine.readthedocs.io/zh_CN/latest/api/generated/mmengine.hooks.CheckpointHook.html#checkpointhook).
+
+(2) 日志配置
+
+`日志钩子 (LoggerHook)` 被用来收集 `执行器 (Runner)` 里面不同组件的日志信息然后写入终端, JSON 文件, tensorboard 和 wandb 等地方.
+
+```python
+logger=dict(type='LoggerHook', interval=10)
+```
+
+在最新的 1.x 版本的 MMSegmentation 里面, 一些日志钩子 (LoggerHook) 例如 `TextLoggerHook`, `WandbLoggerHook` 和 `TensorboardLoggerHook` 将不再被使用.
+作为替代, MMEngine 使用 `LogProcessor` 来处理上述钩子处理的信息, 它们现在在 [`MessageHub`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/logging/message_hub.py#L17),
+[`WandbVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L324) 和 [`TensorboardVisBackend`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py#L472) 里面.
+
+具体使用方法如下, 配置可视化器和同时指定可视化后端, 这里使用 Tensorboard 作为可视化器的后端:
+
+```python
+# TensorboardVisBackend
+visualizer = dict(
+ type='SegLocalVisualizer', vis_backends=[dict(type='TensorboardVisBackend')], name='visualizer')
+```
+
+关于更多相关用法, 可以参考 [MMEngine 可视化后端用户教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md).
+
+- 自定义钩子 (custom hooks)
+
+自定义钩子在配置通过 `custom_hooks` 定义, `Runner` 通过 [`register_custom_hooks`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L1820) 方法注册.
+自定义钩子优先级需要在配置文件里设置, 如果没有设置, 则会被默认设置为 `NORMAL`. 下面是部分 MMEngine 中实现的自定义钩子:
+
+| 钩子 | 用法 |
+| :----------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------: |
+| [EMAHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/ema_hook.py) | 在模型训练时使用指数滑动平均 (Exponential Moving Average, EMA). |
+| [EmptyCacheHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/empty_cache_hook.py) | 在训练时释放所有没有被缓存占用的 GPU 显存. |
+| [SyncBuffersHook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/sync_buffer_hook.py) | 在每个训练 Epoch 结束时同步模型 buffer 里的参数例如 BN 里的 `running_mean` 和 `running_var`. |
+
+以下是 `EMAHook` 的用例, 配置文件中, 将已经实现的自定义钩子的配置作为 `custom_hooks` 列表中的成员.
+
+```python
+custom_hooks = [
+ dict(type='EMAHook', start_iters=500, priority='NORMAL')
+]
+```
+
+### SegVisualizationHook
+
+MMSegmentation 实现了 [`SegVisualizationHook`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/hooks/visualization_hook.py#L17), 用来在验证和测试时可视化预测结果.
+`SegVisualizationHook` 重写了基类 `Hook` 中的 `_after_iter` 方法, 在验证或测试时, 根据指定的迭代次数间隔调用 `visualizer` 的 `add_datasample` 方法绘制语义分割结果, 具体实现如下:
+
+```python
+...
+@HOOKS.register_module()
+class SegVisualizationHook(Hook):
+...
+ def _after_iter(self,
+ runner: Runner,
+ batch_idx: int,
+ data_batch: dict,
+ outputs: Sequence[SegDataSample],
+ mode: str = 'val') -> None:
+...
+ # 如果是训练阶段或者 self.draw 为 False 则直接跳出
+ if self.draw is False or mode == 'train':
+ return
+...
+ if self.every_n_inner_iters(batch_idx, self.interval):
+ for output in outputs:
+ img_path = output.img_path
+ img_bytes = self.file_client.get(img_path)
+ img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+ window_name = f'{mode}_{osp.basename(img_path)}'
+
+ self._visualizer.add_datasample(
+ window_name,
+ img,
+ data_sample=output,
+ show=self.show,
+ wait_time=self.wait_time,
+ step=runner.iter)
+
+```
+
+关于可视化更多的细节可以查看[这里](../user_guides/visualization.md).
+
+## 优化器
+
+在上面配置运行设定里, 我们给出了配置训练优化器的简单示例. 本章节将进一步详细介绍在 MMSegmentation 里如何配置优化器.
+
+### 优化器封装
+
+OpenMMLab 2.0 设计了优化器封装, 它支持不同的训练策略, 包括混合精度训练、梯度累加和梯度截断等, 用户可以根据需求选择合适的训练策略.
+优化器封装还定义了一套标准的参数更新流程, 用户可以基于这一套流程, 在同一套代码里, 实现不同训练策略的切换. 如果想了解更多, 可以参考 [MMEngine 优化器封装文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md).
+
+以下是 MMSegmentation 中常用的使用方法:
+
+#### 配置 PyTorch 支持的优化器
+
+OpenMMLab 2.0 支持 PyTorch 原生所有优化器, 参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md#%E7%AE%80%E5%8D%95%E9%85%8D%E7%BD%AE).
+
+在配置文件中设置训练时 `Runner` 所使用的优化器, 需要定义 `optim_wrapper`, 而不是 `optimizer`, 下面是一个配置训练中优化器的例子:
+
+```python
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005),
+ clip_grad=None)
+```
+
+#### 配置梯度裁剪
+
+当模型训练需要使用梯度裁剪的训练技巧式, 可以按照如下示例进行配置:
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer,
+ clip_grad=dict(max_norm=0.01, norm_type=2))
+```
+
+这里 `max_norm` 指的是裁剪后梯度的最大值, `norm_type` 指的是裁剪梯度时使用的范数. 相关方法可参考 [torch.nn.utils.clip_grad_norm\_](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html).
+
+#### 配置混合精度训练
+
+当需要使用混合精度训练降低内存时, 可以使用 `AmpOptimWrapper`, 具体配置如下:
+
+```python
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+optim_wrapper = dict(type='AmpOptimWrapper', optimizer=optimizer)
+```
+
+[`AmpOptimWrapper`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/amp_optimizer_wrapper.py#L20) 中 `loss_scale` 的默认设置是 `dynamic`.
+
+#### 配置模型网络不同层的超参数
+
+在模型训练中, 如果想在优化器里为不同参数分别设置优化策略, 例如设置不同的学习率、权重衰减等超参数, 可以通过设置配置文件里 `optim_wrapper` 中的 `paramwise_cfg` 来实现.
+
+下面的配置文件以 [ViT `optim_wrapper`](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/vit/vit_vit-b16-ln_mln_upernet_8xb2-160k_ade20k-512x512.py#L15-L27) 为例介绍 `paramwise_cfg` 参数使用.
+训练时将 `pos_embed`, `mask_token`, `norm` 模块的 weight decay 参数的系数设置成 0.
+即: 在训练时, 这些模块的 weight decay 将被变为 `weight_decay * decay_mult`=0.
+
+```python
+optimizer = dict(
+ type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01)
+optim_wrapper = dict(
+ type='OptimWrapper',
+ optimizer=optimizer,
+ paramwise_cfg=dict(
+ custom_keys={
+ 'pos_embed': dict(decay_mult=0.),
+ 'cls_token': dict(decay_mult=0.),
+ 'norm': dict(decay_mult=0.)
+ }))
+```
+
+其中 `decay_mult` 指的是对应参数的权重衰减的系数.
+关于更多 `paramwise_cfg` 的使用可以在 [MMEngine 优化器封装文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/optim_wrapper.md) 里面查到.
+
+### 优化器封装构造器
+
+默认的优化器封装构造器 [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 根据输入的 `optim_wrapper` 和 `optim_wrapper` 中定义的 `paramwise_cfg` 来构建训练中使用的优化器. 当 [`DefaultOptimWrapperConstructor`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 功能不能满足需求时, 可以自定义优化器封装构造器来实现超参数的配置.
+
+MMSegmentation 中的实现了 [`LearningRateDecayOptimizerConstructor`](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/engine/optimizers/layer_decay_optimizer_constructor.py#L104), 可以对以 ConvNeXt, BEiT 和 MAE 为骨干网络的模型训练时, 骨干网络的模型参数的学习率按照定义的衰减比例（`decay_rate`）逐层递减, 在配置文件中的配置如下:
+
+```python
+optim_wrapper = dict(
+ _delete_=True,
+ type='AmpOptimWrapper',
+ optimizer=dict(
+ type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05),
+ paramwise_cfg={
+ 'decay_rate': 0.9,
+ 'decay_type': 'stage_wise',
+ 'num_layers': 12
+ },
+ constructor='LearningRateDecayOptimizerConstructor',
+ loss_scale='dynamic')
+```
+
+`_delete_=True` 的作用是 OpenMMLab Config 中的忽略继承的配置, 在该代码片段中忽略继承的 `optim_wrapper` 配置, 更多 `_delete_` 字段的内容可以参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/config.md#%E5%88%A0%E9%99%A4%E5%AD%97%E5%85%B8%E4%B8%AD%E7%9A%84-key).
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/evaluation.md b/internlm_langchain/knowledge_base/MMSegmentation/content/evaluation.md
new file mode 100644
index 00000000..dc93a46e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/evaluation.md
@@ -0,0 +1,158 @@
+# 模型评测
+
+模型评测过程会分别在 [ValLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L300) 和 [TestLoop](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L373) 中被执行，用户可以在训练期间或使用配置文件中简单设置的测试脚本进行模型性能评估。`ValLoop` 和 `TestLoop` 属于 [Runner](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py#L59)，它们会在第一次被调用时构建。由于 `dataloader` 与 `evaluator` 是必需的参数，所以要成功构建 `ValLoop`，在构建 `Runner` 时必须设置 `val_dataloader` 和 `val_evaluator`，`TestLoop` 亦然。有关 Runner 设计的更多信息，请参阅 [MMEngine](https://github.com/open-mmlab/mmengine) 的[文档](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md)。
+
+
+ 
+ 测试/验证 数据流
+
+
+在 MMSegmentation 中，默认情况下，我们将 dataloader 和 metrics 的设置写在数据集配置文件中，并将 evaluation loop 的配置写在 `schedule_x` 配置文件中。
+
+例如，在 ADE20K 配置文件 `configs/_base_/dataset/ADE20K.py` 中，在第37到48行，我们配置了 `val_dataloader`，在第51行，我们选择 `IoUMetric` 作为 evaluator，并设置 `mIoU` 作为指标：
+
+```python
+val_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(
+ img_path='images/validation',
+ seg_map_path='annotations/validation'),
+ pipeline=test_pipeline))
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+```
+
+为了能够在训练期间进行评估模型，我们将评估配置添加到了 `configs/schedules/schedule_40k.py` 文件的第15至16行：
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+```
+
+使用以上两种设置，MMSegmentation 在 40K 迭代训练期间，每 4000 次迭代进行一次模型 **mIoU** 指标的评估。
+
+如果我们希望在训练后测试模型，则需要将 `test_dataloader`、`test_evaluator` 和 `test_cfg` 配置添加到配置文件中。
+
+```python
+test_dataloader = dict(
+ batch_size=1,
+ num_workers=4,
+ persistent_workers=True,
+ sampler=dict(type='DefaultSampler', shuffle=False),
+ dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(
+ img_path='images/validation',
+ seg_map_path='annotations/validation'),
+ pipeline=test_pipeline))
+
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_cfg = dict(type='TestLoop')
+```
+
+在 MMSegmentation 中，默认情况下，`test_dataloader` 和 `test_evaluator` 的设置与 `ValLoop` 的 dataloader 和 evaluator 相同，我们可以修改这些设置以满足我们的需要。
+
+## IoUMetric
+
+MMSegmentation 基于 [MMEngine](https://github.com/open-mmlab/mmengine) 提供的 [BaseMetric](https://github.com/open-mmlab/mmengine/blob/main/mmengine/evaluator/metric.py) 实现 [IoUMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/iou_metric.py) 和 [CityscapesMetric](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/evaluation/metrics/citys_metric.py)，以评估模型的性能。有关统一评估接口的更多详细信息，请参阅[文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html)。
+
+这里我们简要介绍 `IoUMetric` 的参数和两种主要方法。
+
+除了 `collect_device` 和 `prefix` 之外，`IoUMetric` 的构建还包含一些其他参数。
+
+构造函数的参数：
+
+- ignore_index（int）- 将在评估中忽略的类别索引。默认值：255。
+- iou_metrics（list\[str\] | str）- 需要计算的指标，可选项包括 'mIoU'、'mDice' 和 'mFscore'。
+- nan_to_num（int，可选）- 如果指定，NaN 值将被用户定义的数字替换。默认值：None。
+- beta（int）- 决定综合评分中 recall 的权重。默认值：1。
+- collect_device（str）- 用于在分布式训练期间从不同进程收集结果的设备名称。必须是 'cpu' 或 'gpu'。默认为 'cpu'。
+- prefix（str，可选）- 将添加到指标名称中的前缀，以消除不同 evaluator 的同名指标的歧义。如果参数中未提供前缀，则将使用 self.default_prefix 进行替代。默认为 None。
+
+`IoUMetric` 实现 IoU 指标的计算，`IoUMetric` 的两个核心方法是 `process` 和 `compute_metrics`。
+
+- `process` 方法处理一批 data 和 data_samples。
+- `compute_metrics` 方法根据处理的结果计算指标。
+
+### IoUMetric.process
+
+参数：
+
+- data_batch（Any）- 来自 dataloader 的一批数据。
+- data_samples（Sequence\[dict\]）- 模型的一批输出。
+
+返回值：
+
+此方法没有返回值，因为处理的结果将存储在 `self.results` 中，以在处理完所有批次后进行指标的计算。
+
+### IoUMetric.compute_metrics
+
+参数：
+
+- results（list）- 每个批次的处理结果。
+
+返回值：
+
+- Dict\[str，float\] - 计算的指标。指标的名称为 key，值是相应的结果。key 主要包括 **aAcc**、**mIoU**、**mAcc**、**mDice**、**mFscore**、**mPrecision**、**mPrecall**。
+
+## CityscapesMetric
+
+`CityscapesMetric` 使用由 Cityscapes 官方提供的 [CityscapesScripts](https://github.com/mcordts/cityscapesScripts) 进行模型性能的评估。
+
+### 使用方法
+
+在使用之前，请先安装 `cityscapesscripts` 包：
+
+```shell
+pip install cityscapesscripts
+```
+
+由于 `IoUMetric` 在 MMSegmentation 中作为默认的 evaluator 使用，如果您想使用 `CityscapesMetric`，则需要自定义配置文件。在自定义配置文件中，应按如下方式替换默认 evaluator。
+
+```python
+val_evaluator = dict(type='CityscapesMetric', output_dir='tmp')
+test_evaluator = val_evaluator
+```
+
+### 接口
+
+构造函数的参数：
+
+- output_dir (str) - 预测结果输出的路径
+- ignore_index (int) - 将在评估中忽略的类别索引。默认值：255。
+- format_only (bool) - 只为提交进行结果格式化而不进行评估。当您希望将结果格式化为特定格式并将其提交给测试服务器时有用。默认为 False。
+- keep_results (bool) - 是否保留结果。当 `format_only` 为 True 时，`keep_results` 必须为 True。默认为 False。
+- collect_device (str) - 用于在分布式训练期间从不同进程收集结果的设备名称。必须是 'cpu' 或 'gpu'。默认为 'cpu'。
+- prefix (str，可选) - 将添加到指标名称中的前缀，以消除不同 evaluator 的同名指标的歧义。如果参数中未提供前缀，则将使用 self.default_prefix 进行替代。默认为 None。
+
+#### CityscapesMetric.process
+
+该方法将在图像上绘制 mask，并将绘制的图像保存到 `work_dir` 中。
+
+参数：
+
+- data_batch（dict）- 来自 dataloader 的一批数据。
+- data_samples（Sequence\[dict\]）- 模型的一批输出。
+
+返回值：
+
+此方法没有返回值，因为处理的结果将存储在 `self.results` 中，以在处理完所有批次后进行指标的计算。
+
+#### CityscapesMetric.compute_metrics
+
+此方法将调用 `cityscapessscripts.evaluation.evalPixelLevelSemanticLabeling` 工具来计算指标。
+
+参数：
+
+- results（list）- 数据集的测试结果。
+
+返回值：
+
+- dict\[str:float\] - Cityscapes 评测结果。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/faq.md b/internlm_langchain/knowledge_base/MMSegmentation/content/faq.md
new file mode 100644
index 00000000..fa97963e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/faq.md
@@ -0,0 +1,121 @@
+# 常见问题解答（FAQ）
+
+我们在这里列出了使用时的一些常见问题及其相应的解决方案。 如果您发现有一些问题被遗漏，请随时提 PR 丰富这个列表。 如果您无法在此获得帮助，请使用 [issue 模板](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/.github/ISSUE_TEMPLATE/error-report.md/)创建问题，但是请在模板中填写所有必填信息，这有助于我们更快定位问题。
+
+## 安装
+
+兼容的 MMSegmentation 和 MMCV 版本如下。请安装正确版本的 MMCV 以避免安装问题。
+
+| MMSegmentation version | MMCV version | MMEngine version | MMClassification (optional) version | MMDetection (optional) version |
+| :--------------------: | :----------------------------: | :---------------: | :---------------------------------: | :----------------------------: |
+| dev-1.x branch | mmcv >= 2.0.0 | MMEngine >= 0.7.4 | mmpretrain>=1.0.0rc7 | mmdet >= 3.0.0 |
+| main branch | mmcv >= 2.0.0 | MMEngine >= 0.7.4 | mmpretrain>=1.0.0rc7 | mmdet >= 3.0.0 |
+| 1.1.1 | mmcv >= 2.0.0 | MMEngine >= 0.7.4 | mmpretrain>=1.0.0rc7 | mmdet >= 3.0.0 |
+| 1.1.0 | mmcv >= 2.0.0 | MMEngine >= 0.7.4 | mmpretrain>=1.0.0rc7 | mmdet >= 3.0.0 |
+| 1.0.0 | mmcv >= 2.0.0rc4 | MMEngine >= 0.7.1 | mmcls==1.0.0rc6 | mmdet >= 3.0.0 |
+| 1.0.0rc6 | mmcv >= 2.0.0rc4 | MMEngine >= 0.5.0 | mmcls>=1.0.0rc0 | mmdet >= 3.0.0rc6 |
+| 1.0.0rc5 | mmcv >= 2.0.0rc4 | MMEngine >= 0.2.0 | mmcls>=1.0.0rc0 | mmdet>=3.0.0rc6 |
+| 1.0.0rc4 | mmcv == 2.0.0rc3 | MMEngine >= 0.1.0 | mmcls>=1.0.0rc0 | mmdet>=3.0.0rc4, \<=3.0.0rc5 |
+| 1.0.0rc3 | mmcv == 2.0.0rc3 | MMEngine >= 0.1.0 | mmcls>=1.0.0rc0 | mmdet>=3.0.0rc4, \<=3.0.0rc5 |
+| 1.0.0rc2 | mmcv == 2.0.0rc3 | MMEngine >= 0.1.0 | mmcls>=1.0.0rc0 | mmdet>=3.0.0rc4, \<=3.0.0rc5 |
+| 1.0.0rc1 | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 | mmcls>=1.0.0rc0 | Not required |
+| 1.0.0rc0 | mmcv >= 2.0.0rc1, \<=2.0.0rc3> | MMEngine >= 0.1.0 | mmcls>=1.0.0rc0 | Not required |
+
+如果您已经安装了版本不合适的 mmcv，请先运行`pip uninstall mmcv`卸载已安装的 mmcv，如您先前安装的为 mmcv-full（存在于 OpenMMLab 1.x），请运行`pip uninstall mmcv-full`进行卸载。
+
+- 如出现 "No module named 'mmcv'"
+ 1. 使用`pip uninstall mmcv`卸载环境中现有的 mmcv
+ 2. 按照[安装说明](../get_started.md)安装对应的 mmcv
+
+## 如何获知模型训练时需要的显卡数量
+
+- 看模型的 config 文件命名。可以参考[了解配置文件](../user_guides/1_config.md)中的`配置文件命名风格`部分。比如，对于名字为`segformer_mit-b0_8xb1-160k_cityscapes-1024x1024.py`的 config 文件，`8xb1`代表训练其对应的模型需要的卡数为 8，每张卡中的 batch size 为 1。
+- 看模型的 log 文件。点开该模型的 log 文件，并在其中搜索`nGPU`，在`nGPU`后的数字个数即训练时所需的卡数。比如，在 log 文件中搜索`nGPU`得到`nGPU 0,1,2,3,4,5,6,7`的记录，则说明训练该模型需要使用八张卡。
+
+## auxiliary head 是什么
+
+简单来说，这是一个提高准确率的深度监督技术。在训练阶段，`decode_head`用于输出语义分割的结果，`auxiliary_head` 只是增加了一个辅助损失，其产生的分割结果对你的模型结果没有影响，仅在在训练中起作用。您可以阅读这篇[论文](https://arxiv.org/pdf/1612.01105.pdf)了解更多信息。
+
+## 运行测试脚本时如何输出绘制分割掩膜的图像
+
+在测试脚本中，我们提供了`--out`参数来控制是否输出保存预测的分割掩膜图像。您可以运行以下命令输出测试结果：
+
+```shell
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} --out ${OUTPUT_DIR}
+```
+
+更多用例细节可查阅[文档](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/docs/zh_cn/user_guides/4_train_test.md#%E6%B5%8B%E8%AF%95%E5%B9%B6%E4%BF%9D%E5%AD%98%E5%88%86%E5%89%B2%E7%BB%93%E6%9E%9C)，[PR #2712](https://github.com/open-mmlab/mmsegmentation/pull/2712) 以及[迁移文档](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/docs/zh_cn/migration/interface.md#%E6%B5%8B%E8%AF%95%E5%90%AF%E5%8A%A8)了解相关说明。
+
+## 如何处理二值分割任务?
+
+MMSegmentation 使用 `num_classes` 和 `out_channels` 来控制模型最后一层 `self.conv_seg` 的输出。更多细节可以参考 [这里](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/models/decode_heads/decode_head.py)。
+
+`num_classes` 应该和数据集本身类别个数一致，当是二值分割时，数据集只有前景和背景两类，所以 `num_classes` 为 2. `out_channels` 控制模型最后一层的输出的通道数，通常和 `num_classes` 相等，但当二值分割时候，可以有两种处理方法, 分别是：
+
+- 设置 `out_channels=2`，在训练时以 Cross Entropy Loss 作为损失函数，在推理时使用 `F.softmax()` 归一化 logits 值，然后通过 `argmax()` 得到每个像素的预测结果。
+
+- 设置 `out_channels=1`，在训练时以 Binary Cross Entropy Loss 作为损失函数，在推理时使用 `F.sigmoid()` 和 `threshold` 得到预测结果，`threshold` 默认为 0.3。
+
+对于实现上述两种计算二值分割的方法，需要在 `decode_head` 和 `auxiliary_head` 的配置里修改。下面是对样例 [pspnet_unet_s5-d16.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/configs/_base_/models/pspnet_unet_s5-d16.py) 做出的对应修改。
+
+- (1) `num_classes=2`, `out_channels=2` 并在 `CrossEntropyLoss` 里面设置 `use_sigmoid=False`。
+
+```python
+decode_head=dict(
+ type='PSPHead',
+ in_channels=64,
+ in_index=4,
+ num_classes=2,
+ out_channels=2,
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+auxiliary_head=dict(
+ type='FCNHead',
+ in_channels=128,
+ in_index=3,
+ num_classes=2,
+ out_channels=2,
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+```
+
+- (2) `num_classes=2`, `out_channels=1` 并在 `CrossEntropyLoss` 里面设置 `use_sigmoid=True`.
+
+```python
+decode_head=dict(
+ type='PSPHead',
+ in_channels=64,
+ in_index=4,
+ num_classes=2,
+ out_channels=1,
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+auxiliary_head=dict(
+ type='FCNHead',
+ in_channels=128,
+ in_index=3,
+ num_classes=2,
+ out_channels=1,
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
+```
+
+## `reduce_zero_label` 的作用
+
+数据集中 `reduce_zero_label` 参数类型为布尔类型，默认为 False，它的功能是为了忽略数据集 label 0。具体做法是将 label 0 改为 255，其余 label 相应编号减 1，同时 decode head 里将 255 设为 ignore index，即不参与 loss 计算。
+以下是 `reduce_zero_label` 具体实现逻辑:
+
+```python
+if self.reduce_zero_label:
+ # avoid using underflow conversion
+ gt_semantic_seg[gt_semantic_seg == 0] = 255
+ gt_semantic_seg = gt_semantic_seg - 1
+ gt_semantic_seg[gt_semantic_seg == 254] = 255
+```
+
+关于您的数据集是否需要使用 reduce_zero_label，有以下两类情况：
+
+- 例如在 [Potsdam](https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/user_guides/2_dataset_prepare.md#isprs-potsdam) 数据集上，有 0-不透水面、1-建筑、2-低矮植被、3-树、4-汽车、5-杂乱，六类。但该数据集提供了两种 RGB 标签，一种为图像边缘处有黑色像素的标签，另一种是没有黑色边缘的标签。对于有黑色边缘的标签，在 [dataset_converters.py](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/tools/dataset_converters/potsdam.py)中，其将黑色边缘转换为 label 0，其余标签分别为 1-不透水面、2-建筑、3-低矮植被、4-树、5-汽车、6-杂乱，那么此时，就应该在数据集 [potsdam.py](https://github.com/open-mmlab/mmsegmentation/blob/ff95416c3b5ce8d62b9289f743531398efce534f/mmseg/datasets/potsdam.py#L23) 中将`reduce_zero_label=True`。如果使用的是没有黑色边缘的标签，那么 mask label 中只有 0-5，此时就应该使`reduce_zero_label=False`。需要结合您的实际情况来使用。
+- 例如在第 0 类为 background 类别的数据集上，如果您最终是需要将背景和您的其余类别分开时，是不需要使用`reduce_zero_label`的，此时在数据集中应该将其设置为`reduce_zero_label=False`
+
+**注意:** 使用 `reduce_zero_label` 请确认数据集原始类别个数，如果只有两类，需要关闭 `reduce_zero_label` 即设置 `reduce_zero_label=False`。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/get_started.md b/internlm_langchain/knowledge_base/MMSegmentation/content/get_started.md
new file mode 100644
index 00000000..b92ab334
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/get_started.md
@@ -0,0 +1,209 @@
+# 开始：安装和运行 MMSeg
+
+## 预备知识
+
+本教程中，我们将会演示如何使用 PyTorch 准备环境。
+
+MMSegmentation 可以在 Linux, Windows 和 macOS 系统上运行，并且需要安装 Python 3.7+, CUDA 10.2+ 和 PyTorch 1.8+
+
+**注意:**
+如果您已经安装了 PyTorch, 可以跳过该部分，直接到[下一小节](##安装)。否则，您可以按照以下步骤操作。
+
+**步骤 0.** 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda
+
+**步骤 1.** 创建一个 conda 环境，并激活
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**Step 2.** 参考 [official instructions](https://pytorch.org/get-started/locally/) 安装 PyTorch
+
+在 GPU 平台上：
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+在 CPU 平台上
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## 安装
+
+我们建议用户遵循我们的最佳实践来安装 MMSegmentation 。但是整个过程是高度自定义的。更多信息请参见[自定义安装](##自定义安装)部分。
+
+### 最佳实践
+
+**步骤 0.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**步骤 1.** 安装 MMSegmentation
+
+情况 a: 如果您想立刻开发和运行 mmsegmentation，您可通过源码安装：
+
+```shell
+git clone -b main https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -v -e .
+# '-v' 表示详细模式，更多的输出
+# '-e' 表示以可编辑模式安装工程，
+# 因此对代码所做的任何修改都生效，无需重新安装
+```
+
+情况 b: 如果您把 mmsegmentation 作为依赖库或者第三方库，可以通过 pip 安装：
+
+```shell
+pip install "mmsegmentation>=1.0.0"
+```
+
+### 验证是否安装成功
+
+为了验证 MMSegmentation 是否正确安装，我们提供了一些示例代码来运行一个推理 demo 。
+
+**步骤 1.** 下载配置文件和模型文件
+
+```shell
+mim download mmsegmentation --config pspnet_r50-d8_4xb2-40k_cityscapes-512x1024 --dest .
+```
+
+该下载过程可能需要花费几分钟，这取决于您的网络环境。当下载结束，您将看到以下两个文件在您当前工作目录：`pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py` 和 `pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth`
+
+**步骤 2.** 验证推理 demo
+
+选项 (a). 如果您通过源码安装了 mmsegmentation，运行以下命令即可：
+
+```shell
+python demo/image_demo.py demo/demo.png configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --out-file result.jpg
+```
+
+您将在当前文件夹中看到一个新图像 `result.jpg`，其中所有目标都覆盖了分割 mask
+
+选项 (b). 如果您通过 pip 安装 mmsegmentation, 打开您的 python 解释器，复制粘贴以下代码：
+
+```python
+from mmseg.apis import inference_model, init_model, show_result_pyplot
+import mmcv
+
+config_file = 'pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py'
+checkpoint_file = 'pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# 根据配置文件和模型文件建立模型
+model = init_model(config_file, checkpoint_file, device='cuda:0')
+
+# 在单张图像上测试并可视化
+img = 'demo/demo.png' # or img = mmcv.imread(img), 这样仅需下载一次
+result = inference_model(model, img)
+# 在新的窗口可视化结果
+show_result_pyplot(model, img, result, show=True)
+# 或者将可视化结果保存到图像文件夹中
+# 您可以修改分割 map 的透明度 (0, 1].
+show_result_pyplot(model, img, result, show=True, out_file='result.jpg', opacity=0.5)
+# 在一段视频上测试并可视化分割结果
+video = mmcv.VideoReader('video.mp4')
+for frame in video:
+ result = inference_segmentor(model, frame)
+ show_result_pyplot(model, result, wait_time=1)
+```
+
+您可以修改上面的代码来测试单个图像或视频，这两个选项都可以验证安装是否成功。
+
+### 自定义安装
+
+#### CUDA 版本
+
+当安装 PyTorch 的时候，您需要指定 CUDA 的版本， 如果您不确定选择哪个版本，请遵循我们的建议：
+
+- 对于基于 Ampere 的 NVIDIA GPUs, 例如 GeForce 30 系列和 NVIDIA A100, 必须要求是 CUDA 11.
+- 对于更老的 NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 提供了更好的兼容性，以及更加的轻量化
+
+请确保 GPU 驱动满足最小的版本需求。详情请参考这个[表格](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)
+
+**注意:**
+如果您按照我们的最佳实践，安装 CUDA 运行库就足够了，因为不需要 CUDA 代码在本地编译。 但是如果您希望从源码编译 MMCV 或者需要开发其他的 CUDA 算子，您需要从 NVIDIA 的[官网](https://developer.nvidia.com/cuda-downloads)安装完整的 CUDA 工具，同时它的版本需要与 PyTorch 的 CUDA 版本匹配。即 `conda install` 命令中指定的 cudatoolkit 版本。
+
+#### 不使用 MIM 安装 MMCV
+
+MMCV 包含 C++ 和 CUDA 扩展，因此与 PyTorch 的依赖方式比较复杂。MIM 自动解决了这种依赖关系，使安装更容易。然而，MIM 也并不是必须的。
+
+为了使用 pip 而不是 MIM 安装 MMCV, 请参考 [MMCV 安装指南](https://mmcv.readthedocs.io/en/latest/get_started/installation.html). 这需要手动指定一个基于 PyTorch 版本及其 CUDA 版本的 find-url.
+
+例如，以下命令可为 PyTorch 1.10.x and CUDA 11.3 安装 mmcv==2.0.0
+
+```shell
+pip install mmcv==2.0.0 -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html
+```
+
+#### 在仅有 CPU 的平台安装
+
+MMSegmentation 可以在仅有 CPU 的版本上运行。在 CPU 模式，您可以训练（需要 MMCV 版本 >= 2.0.0），测试和推理模型。
+
+#### 在 Google Colab 上安装
+
+[Google Colab](https://research.google.com/) 通常已经安装了 PyTorch，因此我们仅需要通过以下命令安装 MMCV 和 MMSegmentation。
+
+**步骤 1.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv)
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0"
+```
+
+**Step 2.** 通过源码安装 MMSegmentation
+
+```shell
+!git clone https://github.com/open-mmlab/mmsegmentation.git
+%cd mmsegmentation
+!git checkout main
+!pip install -e .
+```
+
+**Step 3.** 验证
+
+```python
+import mmseg
+print(mmseg.__version__)
+# 示例输出: 1.0.0
+```
+
+**注意:**
+在 Jupyter 中, 感叹号 `!` 用于调用外部可执行命令，`%cd` 是一个 [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) 可以改变当前 python 的工作目录。
+
+### 通过 Docker 使用 MMSegmentation
+
+我们提供了一个 [Dockerfile](https://github.com/open-mmlab/mmsegmentation/blob/master/docker/Dockerfile) 来建立映像。确保您的 [docker 版本](https://docs.docker.com/engine/install/) >=19.03.
+
+```shell
+# 通过 PyTorch 1.11, CUDA 11.3 建立映像
+# 如果您使用其他版本，修改 Dockerfile 即可
+docker build -t mmsegmentation docker/
+```
+
+运行：
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmsegmentation/data mmsegmentation
+```
+
+### 可选依赖
+
+#### 安装 GDAL
+
+[GDAL](https://gdal.org/) 是一个用于栅格和矢量地理空间数据格式的转换库。安装 GDAL 可以读取复杂格式和极大的遥感图像。
+
+```shell
+conda install GDAL
+```
+
+## 问题解答
+
+如果您在安装过程中遇到了其他问题，请第一时间查阅 [FAQ](notes/faq.md) 文件。如果没有找到答案，您也可以在 GitHub 上提出 [issue](https://github.com/open-mmlab/mmsegmentation/issues/new/choose)
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/interface.md b/internlm_langchain/knowledge_base/MMSegmentation/content/interface.md
new file mode 100644
index 00000000..42f91bf5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/interface.md
@@ -0,0 +1,523 @@
+# 从 MMSegmentation 0.x 迁移
+
+## 引言
+
+本指南介绍了 MMSegmentation 0.x 和 MMSegmentation1.x 在表现和 API 方面的基本区别，以及这些与迁移过程的关系。
+
+## 新的依赖
+
+MMSegmentation 1.x 依赖于一些新的软件包，您可以准备一个新的干净环境，然后根据[安装教程](../get_started.md)重新安装。
+
+或手动安装以下软件包。
+
+1. [MMEngine](https://github.com/open-mmlab/mmengine)：MMEngine 是 OpenMMLab 2.0 架构的核心，我们将许多与计算机视觉无关的内容从 MMCV 拆分到 MMEngine 中。
+
+2. [MMCV](https://github.com/open-mmlab/mmcv)：OpenMMLab 的计算机视觉包。这不是一个新的依赖，但您需要将其升级到 **2.0.0** 或以上的版本。
+
+3. [MMClassification](https://github.com/open-mmlab/mmclassification)（可选）：OpenMMLab 的图像分类工具箱和基准。这不是一个新的依赖，但您需要将其升级到 **1.0.0rc6** 版本。
+
+4. [MMDetection](https://github.com/open-mmlab/mmdetection)(可选): OpenMMLab 的目标检测工具箱和基准。这不是一个新的依赖，但您需要将其升级到 **3.0.0** 或以上的版本。
+
+## 启动训练
+
+OpenMMLab 2.0 的主要改进是发布了 MMEngine，它为启动训练任务的统一接口提供了通用且强大的执行器。
+
+与 MMSeg 0.x 相比，MMSeg 1.x 在 `tools/train.py` 中提供的命令行参数更少
+
+
+
+
+## 测试启动
+
+与训练启动类似，MMSegmentation 1.x 的测试启动脚本在 tools/test.py 中仅提供关键命令行参数，以下是测试启动脚本的区别，更多关于测试启动的细节请参考[这里](../user_guides/4_train_test.md)。
+
+
+
+
+## 配置文件
+
+### 模型设置
+
+`model.backend`、`model.neck`、`model.decode_head` 和 `model.loss` 字段没有更改。
+
+添加 `model.data_preprocessor` 字段以配置 `DataPreProcessor`，包括：
+
+- `mean`（Sequence，可选）：R、G、B 通道的像素平均值。默认为 None。
+
+- `std`（Sequence，可选）：R、G、B 通道的像素标准差。默认为 None。
+
+- `size`（Sequence，可选）：固定的填充大小。
+
+- `size_divisor`（int，可选）：填充图像可以被当前值整除。
+
+- `seg_pad_val`（float，可选）：分割图的填充值。默认值：255。
+
+- `padding_mode`（str）：填充类型。默认值：'constant'。
+
+ - constant：常量值填充，值由 pad_val 指定。
+
+- `bgr_to_rgb`（bool）：是否将图像从 BGR 转换为 RGB。默认为 False。
+
+- `rgb_to_bgr`（bool）：是否将图像从 RGB 转换为 BGR。默认为 False。
+
+**注：**
+有关详细信息，请参阅[模型文档](../advanced_guides/models.md)。
+
+### 数据集设置
+
+**data** 的更改：
+
+原版 `data` 字段被拆分为 `train_dataloader`、`val_dataloader` 和 `test_dataloader`，允许我们以细粒度配置它们。例如，您可以在训练和测试期间指定不同的采样器和批次大小。
+`samples_per_gpu` 重命名为 `batch_size`。
+`workers_per_gpu` 重命名为 `num_workers`。
+
+
+
+
+**数据增强变换流程**变更
+
+- 原始格式转换 **`ToTensor`**、**`ImageToTensor`**、**`Collect`** 组合为 [`PackSegInputs`](mmseg.datasets.transforms.PackSegInputs)
+- 我们不建议在数据集流程中执行 **`Normalize`** 和 **Pad**。请将其从流程中删除，并将其设置在 `data_preprocessor` 字段中。
+- MMSeg 1.x 中原始的 **`Resize`** 已更改为 **`RandomResize `**，输入参数 `img_scale` 重命名为 `scale`，`keep_ratio` 的默认值修改为 False。
+- 原始的 `test_pipeline` 将单尺度和多尺度测试结合在一起，在 MMSeg 1.x 中，我们将其分为 `test_pipeline` 和 `tta_pipeline`。
+
+**注：**
+我们将一些数据转换工作转移到数据预处理器中，如归一化，请参阅[文档](package.md)了解更多详细信息。
+
+训练流程
+
+
+
+
+测试流程
+
+
+
+
+**`evaluation`** 中的更改：
+
+- **`evaluation`** 字段被拆分为 `val_evaluator` 和 `test_evaluator `。而且不再支持 `interval` 和 `save_best` 参数。
+ `interval` 已移动到 `train_cfg.val_interval`，`save_best` 已移动到 `default_hooks.checkpoint.save_best`。`pre_eval` 已删除。
+- `IoU` 已更改为 `IoUMetric`。
+
+
+
+
+### Optimizer 和 Schedule 设置
+
+**`optimizer`** 和 **`optimizer_config`** 中的更改：
+
+- 现在我们使用 `optim_wrapper` 字段来指定优化过程的所有配置。以及 `optimizer` 是 `optim_wrapper` 的一个子字段。
+- `paramwise_cfg` 也是 `optim_wrapper` 的一个子字段，以替代 `optimizer`。
+- `optimizer_config` 现在被删除，它的所有配置都被移动到 `optim_wrapper` 中。
+- `grad_clip` 重命名为 `clip_grad`。
+
+
+
+
+**`lr_config`** 中的更改：
+
+- 我们将 `lr_config` 字段删除，并使用新的 `param_scheduler` 替代。
+- 我们删除了与 `warmup` 相关的参数，因为我们使用 scheduler 组合来实现该功能。
+
+新的 scheduler 组合机制非常灵活，您可以使用它来设计多种学习率/动量曲线。有关详细信息，请参见[教程](TODO)。
+
+
+
+
+**`runner`** 中的更改：
+
+原版 `runner` 字段中的大多数配置被移动到 `train_cfg`、`val_cfg` 和 `test_cfg` 中，以在训练、验证和测试中配置 loop。
+
+
+
+
+事实上，在 OpenMMLab 2.0 中，我们引入了 `Loop` 来控制训练、验证和测试中的行为。`Runner` 的功能也发生了变化。您可以在 [MMMEngine](https://github.com/open-mmlab/mmengine/) 的[执行器教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 中找到更多的详细信息。
+
+### 运行时设置
+
+**`checkpoint_config`** 和 **`log_config`** 中的更改：
+
+`checkpoint_config` 被移动到 `default_hooks.checkpoint` 中，`log_config` 被移动到 `default_hooks.logger` 中。
+并且我们将许多钩子设置从脚本代码移动到运行时配置的 `default_hooks` 字段中。
+
+```python
+default_hooks = dict(
+ # 记录每次迭代的时间。
+ timer=dict(type='IterTimerHook'),
+
+ # 每50次迭代打印一次日志。
+ logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+
+ # 启用参数调度程序。
+ param_scheduler=dict(type='ParamSchedulerHook'),
+
+ # 每2000次迭代保存一次检查点。
+ checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+
+ # 在分布式环境中设置采样器种子。
+ sampler_seed=dict(type='DistSamplerSeedHook'),
+
+ # 验证结果可视化。
+ visualization=dict(type='SegVisualizationHook'))
+```
+
+此外，我们将原版 logger 拆分为 logger 和 visualizer。logger 用于记录信息，visualizer 用于在不同的后端显示 logger，如 terminal 和 TensorBoard。
+
+
+
+
+**`load_from`** 和 **`resume_from`** 中的更改：
+
+- 删除 `resume_from`。我们使用 `resume` 和 `load_from` 来替换它。
+ - 如果 `resume=True` 且 `load_from` 为 **not None**，则从 `load_from` 中的检查点恢复训练。
+ - 如果 `resume=True` 且 `load_from` 为 **None**，则尝试从工作目录中的最新检查点恢复。
+ - 如果 `resume=False` 且 `load_from` 为 **not None**，则只加载检查点，而不继续训练。
+ - 如果 `resume=False` 且 `load_from` 为 **None**，则不加载或恢复。
+
+**`dist_params`** 中的更改：`dist_params` 字段现在是 `env_cfg` 的子字段。并且 `env_cfg` 中还有一些新的配置。
+
+```python
+env_cfg = dict(
+ # 是否启用 cudnn_benchmark
+ cudnn_benchmark=False,
+
+ # 设置多进程参数
+ mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+
+ # 设置分布式参数
+ dist_cfg=dict(backend='nccl'),
+)
+```
+
+**`workflow`** 的改动:`workflow` 相关功能被删除。
+
+新字段 **`visualizer`**：visualizer 是 OpenMMLab 2.0 体系结构中的新设计。我们在 runner 中使用 visualizer 实例来处理结果和日志可视化，并保存到不同的后端。更多详细信息，请参阅[可视化教程](../user_guides/visualization.md)。
+
+新字段 **`default_scope`**：搜索所有注册模块的起点。MMSegmentation 中的 `default_scope` 为 `mmseg`。请参见[注册器教程](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/registry.md)了解更多详情。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/model_zoo.md b/internlm_langchain/knowledge_base/MMSegmentation/content/model_zoo.md
new file mode 100644
index 00000000..bd572157
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/model_zoo.md
@@ -0,0 +1,152 @@
+# 标准与模型库
+
+## 共同设定
+
+- 我们默认使用 4 卡分布式训练
+- 所有 PyTorch 风格的 ImageNet 预训练网络由我们自己训练，和 [论文](https://arxiv.org/pdf/1812.01187.pdf) 保持一致。
+ 我们的 ResNet 网络是基于 ResNetV1c 的变种，在这里输入层的 7x7 卷积被 3个 3x3 取代
+- 为了在不同的硬件上保持一致，我们以 `torch.cuda.max_memory_allocated()` 的最大值作为 GPU 占用率，同时设置 `torch.backends.cudnn.benchmark=False`。
+ 注意，这通常比 `nvidia-smi` 显示的要少
+- 我们以网络 forward 和后处理的时间加和作为推理时间，除去数据加载时间。我们使用脚本 `tools/benchmark.py` 来获取推理时间，它在 `torch.backends.cudnn.benchmark=False` 的设定下，计算 200 张图片的平均推理时间
+- 在框架中，有两种推理模式
+ - `slide` 模式（滑动模式）：测试的配置文件字段 `test_cfg` 会是 `dict(mode='slide', crop_size=(769, 769), stride=(513, 513))`.
+ 在这个模式下，从原图中裁剪多个小图分别输入网络中进行推理。小图的大小和小图之间的距离由 `crop_size` 和 `stride` 决定，重合区域会进行平均
+ - `whole` 模式 （全图模式）：测试的配置文件字段 `test_cfg` 会是 `dict(mode='whole')`. 在这个模式下，全图会被直接输入到网络中进行推理。
+ 对于 769x769 下训练的模型，我们默认使用 `slide` 进行推理，其余模型用 `whole` 进行推理
+- 对于输入大小为 8x+1 （比如769），我们使用 `align_corners=True`。其余情况，对于输入大小为 8x (比如 512，1024)，我们使用 `align_corners=False`
+
+## 基线
+
+### FCN
+
+请参考 [FCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fcn) 获得详细信息。
+
+### PSPNet
+
+请参考 [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/pspnet) 获得详细信息。
+
+### DeepLabV3
+
+请参考 [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3) 获得详细信息。
+
+### PSANet
+
+请参考 [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/psanet) 获得详细信息。
+
+### DeepLabV3+
+
+请参考 [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3plus) 获得详细信息。
+
+### UPerNet
+
+请参考 [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/upernet) 获得详细信息。
+
+### NonLocal Net
+
+请参考 [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/nlnet) 获得详细信息。
+
+### EncNet
+
+请参考 [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/encnet) 获得详细信息。
+
+### CCNet
+
+请参考 [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ccnet) 获得详细信息。
+
+### DANet
+
+请参考 [DANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/danet) 获得详细信息。
+
+### APCNet
+
+请参考 [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/apcnet) 获得详细信息。
+
+### HRNet
+
+请参考 [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/hrnet) 获得详细信息。
+
+### GCNet
+
+请参考 [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/gcnet) 获得详细信息。
+
+### DMNet
+
+请参考 [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dmnet) 获得详细信息。
+
+### ANN
+
+请参考 [ANN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ann) 获得详细信息。
+
+### OCRNet
+
+请参考 [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ocrnet) 获得详细信息。
+
+### Fast-SCNN
+
+请参考 [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastscnn) 获得详细信息。
+
+### ResNeSt
+
+请参考 [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/resnest) 获得详细信息。
+
+### Semantic FPN
+
+请参考 [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/semfpn) 获得详细信息。
+
+### PointRend
+
+请参考 [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/point_rend) 获得详细信息。
+
+### MobileNetV2
+
+请参考 [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v2) 获得详细信息。
+
+### MobileNetV3
+
+请参考 [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v3) 获得详细信息。
+
+### EMANet
+
+请参考 [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet) 获得详细信息。
+
+### DNLNet
+
+请参考 [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dnlnet) 获得详细信息。
+
+### CGNet
+
+请参考 [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/cgnet) 获得详细信息。
+
+### Mixed Precision (FP16) Training
+
+请参考 [Mixed Precision (FP16) Training 在 BiSeNetV2 训练的样例](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv2/bisenetv2_fcn_fp16_4x4_1024x1024_160k_cityscapes.py) 获得详细信息。
+
+## 速度标定（待更新）
+
+### 硬件
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### 软件环境
+
+- Python 3.7
+- PyTorch 1.5
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### 训练速度
+
+为了公平比较，我们全部使用 ResNet-101V1c 进行标定。输入大小为 1024x512，批量样本数为 2。
+
+训练速度如下表，指标为每次迭代的时间，以秒为单位，越低越快。
+
+| Implementation | PSPNet (s/iter) | DeepLabV3+ (s/iter) |
+| --------------------------------------------------------------------------- | --------------- | ------------------- |
+| [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) | **0.83** | **0.85** |
+| [SegmenTron](https://github.com/LikeLy-Journey/SegmenTron) | 0.84 | 0.85 |
+| [CASILVision](https://github.com/CSAILVision/semantic-segmentation-pytorch) | 1.15 | N/A |
+| [vedaseg](https://github.com/Media-Smart/vedaseg) | 0.95 | 1.25 |
+
+注意：DeepLabV3+ 的输出步长为 8。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/models.md b/internlm_langchain/knowledge_base/MMSegmentation/content/models.md
new file mode 100644
index 00000000..6eb22517
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/models.md
@@ -0,0 +1,177 @@
+# 模型
+
+我们通常将深度学习任务中的神经网络定义为模型，这个模型即是算法的核心。[MMEngine](https://github.com/open-mmlab/mmengine) 抽象出了一个统一模型 [BaseModel](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/base_model.py#L16) 以标准化训练、测试和其他过程。MMSegmentation 实现的所有模型都继承自 `BaseModel`，并且在 MMSegmention 中，我们实现了前向传播并为语义分割算法添加了一些功能。
+
+## 常用组件
+
+### 分割器（Segmentor）
+
+在 MMSegmentation 中，我们将网络架构抽象为**分割器**，它是一个包含网络所有组件的模型。我们已经实现了**编码器解码器（EncoderDecoder）**和**级联编码器解码器（CascadeEncoderDecoder）**，它们通常由**数据预处理器**、**骨干网络**、**解码头**和**辅助头**组成。
+
+### 数据预处理器（Data preprocessor）
+
+**数据预处理器**是将数据复制到目标设备并将数据预处理为模型输入格式的部分。
+
+### 主干网络（Backbone）
+
+**主干网络**是将图像转换为特征图的部分，例如没有最后全连接层的 **ResNet-50**。
+
+### 颈部（Neck）
+
+**颈部**是连接主干网络和头的部分。它对主干网络生成的原始特征图进行一些改进或重新配置。例如 **Feature Pyramid Network（FPN）**。
+
+### 解码头（Decode head）
+
+**解码头**是将特征图转换为分割掩膜的部分，例如 **PSPNet**。
+
+### 辅助头（Auxiliary head）
+
+**辅助头**是一个可选组件，它将特征图转换为仅用于计算辅助损失的分割掩膜。
+
+## 基本接口
+
+MMSegmentation 封装 `BaseModel` 并实现了 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/segmentors/base.py#L15) 类，主要提供 `forward`、`train_step`、`val_step` 和 `test_step` 接口。接下来将详细介绍这些接口。
+
+### forward
+
+
+ 
+ 编码器解码器数据流
+
+
+
+ 
级联编码器解码器数据流
+
+
+`forward` 方法返回训练、验证、测试和简单推理过程的损失或预测。
+
+该方法应接受三种模式：“tensor”、“predict” 和 “loss”：
+
+- “tensor”：前向推理整个网络并返回张量或张量数组，无需任何后处理，与常见的 `nn.Module` 相同。
+- “predict”：前向推理并返回预测值，这些预测值将被完全处理到 `SegDataSample` 列表中。
+- “loss”：前向推理并根据给定的输入和数据样本返回损失的`字典`。
+
+**注：**[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用作不同组件之间的接口。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，请参阅 [MMMEngine](https://github.com/open-mmlab/mmengine) 中的 [SegDataSample 文档](https://mmsegmentation.readthedocs.io/zh_CN/1.x/advanced_guides/structures.html)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)了解更多信息。
+
+注意，此方法不处理在 `train_step` 方法中完成的反向传播或优化器更新。
+
+参数：
+
+- inputs（torch.Tensor）- 通常为形状是（N, C, ...) 的输入张量。
+- data_sample（list\[[SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py)\]) - 分割数据样本。它通常包括 `metainfo` 和 `gt_sem_seg` 等信息。默认值为 None。
+- mode (str) - 返回什么类型的值。默认为 'tensor'。
+
+返回值：
+
+- `dict` 或 `list`：
+ - 如果 `mode == "loss"`，则返回用于反向过程和日志记录的损失张量`字典`。
+ - 如果 `mode == "predict"`，则返回 `SegDataSample` 的`列表`，推理结果将被递增地添加到传递给 forward 方法的 `data_sample` 参数中，每个 `SegDataSeample` 包含以下关键词：
+ - pred_sm_seg (`PixelData`)：语义分割的预测。
+ - seg_logits (`PixelData`)：标准化前语义分割的预测指标。
+ - 如果 `mode == "tensor"`，则返回`张量`或`张量数组`的`字典`以供自定义使用。
+
+### 预测模式
+
+我们在[配置文档](../user_guides/1_config.md)中简要描述了模型配置的字段，这里我们详细介绍 `model.test_cfg` 字段。`model.test_cfg` 用于控制前向行为，`"predict"` 模式下的 `forward` 方法可以在两种模式下运行：
+
+- `whole_inference`：如果 `cfg.model.test_cfg.mode == 'whole'`，则模型将使用完整图像进行推理。
+
+ `whole_inference` 模式的一个示例配置：
+
+ ```python
+ model = dict(
+ type='EncoderDecoder'
+ ...
+ test_cfg=dict(mode='whole')
+ )
+ ```
+
+- `slide_inference`：如果 `cfg.model.test_cfg.mode == ‘slide’`，则模型将通过滑动窗口进行推理。**注意：** 如果选择 `slide` 模式，还应指定 `cfg.model.test_cfg.stride` 和 `cfg.model.test_cfg.crop_size`。
+
+ `slide_inference` 模式的一个示例配置：
+
+ ```python
+ model = dict(
+ type='EncoderDecoder'
+ ...
+ test_cfg=dict(mode='slide', crop_size=256, stride=170)
+ )
+ ```
+
+### train_step
+
+`train_step` 方法调用 `loss` 模式的前向接口以获得损失`字典`。`BaseModel` 类实现默认的模型训练过程，包括预处理、模型前向传播、损失计算、优化和反向传播。
+
+参数：
+
+- data (dict or tuple or list) - 从数据集采样的数据。在 MMSegmentation 中，数据字典包含 `inputs` 和 `data_samples` 两个字段。
+- optim_wrapper (OptimWrapper) - 用于更新模型参数的 OptimWrapper 实例。
+
+**注：**[OptimWrapper](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/optimizer_wrapper.py#L17) 提供了一个用于更新参数的通用接口，请参阅 [MMMEngine](https://github.com/open-mmlab/mmengine) 中的优化器封装[文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html)了解更多信息。
+
+返回值：
+
+-Dict\[str, `torch.Tensor`\]：用于记录日志的张量的`字典`。
+
+
+ 
+ train_step 数据流
+
+
+### val_step
+
+`val_step` 方法调用 `predict` 模式的前向接口并返回预测结果，预测结果将进一步被传递给评测器的进程接口和钩子的 `after_val_inter` 接口。
+
+参数：
+
+- data (`dict` or `tuple` or `list`) - 从数据集中采样的数据。在 MMSegmentation 中，数据字典包含 `inputs` 和 `data_samples` 两个字段。
+
+返回值：
+
+- `list` - 给定数据的预测结果。
+
+
+ 
+ test_step/val_step 数据流
+
+
+### test_step
+
+`BaseModel` 中 `test_step` 与 `val_step` 的实现相同。
+
+## 数据预处理器（Data Preprocessor）
+
+MMSegmentation 实现的 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) 继承自由 [MMEngine](https://github.com/open-mmlab/mmengine) 实现的 [BaseDataPreprocessor](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/base_model/data_preprocessor.py#L18)，提供数据预处理和将数据复制到目标设备的功能。
+
+Runner 在构建阶段将模型传送到指定的设备，而 [SegDataPreProcessor](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/models/data_preprocessor.py#L13) 在 `train_step`、`val_step` 和 `test_step` 中将数据传送到指定设备，之后处理后的数据将被进一步传递给模型。
+
+`SegDataPreProcessor` 构造函数的参数：
+
+- mean (Sequence\[Number\], 可选) - R、G、B 通道的像素平均值。默认为 None。
+- std (Sequence\[Number\], 可选) - R、G、B 通道的像素标准差。默认为 None。
+- size (tuple, 可选) - 固定的填充大小。
+- size_divisor (int, 可选) - 填充大小的除法因子。
+- pad_val (float, 可选) - 填充值。默认值：0。
+- seg_pad_val (float, 可选) - 分割图的填充值。默认值：255。
+- bgr_to_rgb (bool) - 是否将图像从 BGR 转换为 RGB。默认为 False。
+- rgb_to_bgr (bool) - 是否将图像从 RGB 转换为 BGR。默认为 False。
+- batch_augments (list\[dict\], 可选) - 批量化的数据增强。默认值为 None。
+
+数据将按如下方式处理：
+
+- 收集数据并将其移动到目标设备。
+- 用定义的 `pad_val` 将输入填充到输入大小，并用定义的 `seg_Pad_val` 填充分割图。
+- 将输入堆栈到 batch_input。
+- 如果输入的形状为 (3, H, W)，则将输入从 BGR 转换为 RGB。
+- 使用定义的标准差和平均值标准化图像。
+- 在训练期间进行如 Mixup 和 Cutmix 的批量化数据增强。
+
+`forward` 方法的参数：
+
+- data (dict) - 从数据加载器采样的数据。
+- training (bool) - 是否启用训练时数据增强。
+
+`forward` 方法的返回值：
+
+- Dict：与模型输入格式相同的数据。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/modelzoo_statistics.md b/internlm_langchain/knowledge_base/MMSegmentation/content/modelzoo_statistics.md
new file mode 100644
index 00000000..b057575a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/modelzoo_statistics.md
@@ -0,0 +1,102 @@
+# 模型库统计数据
+
+- 论文数量: 47
+
+ - ALGORITHM: 36
+ - BACKBONE: 11
+
+- 模型数量: 612
+
+ - \[ALGORITHM\] [ANN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ann) (16 ckpts)
+
+ - \[ALGORITHM\] [APCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/apcnet) (12 ckpts)
+
+ - \[BACKBONE\] [BEiT](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/beit) (2 ckpts)
+
+ - \[ALGORITHM\] [BiSeNetV1](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv1) (11 ckpts)
+
+ - \[ALGORITHM\] [BiSeNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/bisenetv2) (4 ckpts)
+
+ - \[ALGORITHM\] [CCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ccnet) (16 ckpts)
+
+ - \[ALGORITHM\] [CGNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/cgnet) (2 ckpts)
+
+ - \[BACKBONE\] [ConvNeXt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/convnext) (6 ckpts)
+
+ - \[ALGORITHM\] [DANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/danet) (16 ckpts)
+
+ - \[ALGORITHM\] [DeepLabV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3) (41 ckpts)
+
+ - \[ALGORITHM\] [DeepLabV3+](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/deeplabv3plus) (42 ckpts)
+
+ - \[ALGORITHM\] [DMNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dmnet) (12 ckpts)
+
+ - \[ALGORITHM\] [DNLNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dnlnet) (12 ckpts)
+
+ - \[ALGORITHM\] [DPT](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/dpt) (1 ckpts)
+
+ - \[ALGORITHM\] [EMANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/emanet) (4 ckpts)
+
+ - \[ALGORITHM\] [EncNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/encnet) (12 ckpts)
+
+ - \[ALGORITHM\] [ERFNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/erfnet) (1 ckpts)
+
+ - \[ALGORITHM\] [FastFCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastfcn) (12 ckpts)
+
+ - \[ALGORITHM\] [Fast-SCNN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fastscnn) (1 ckpts)
+
+ - \[ALGORITHM\] [FCN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fcn) (41 ckpts)
+
+ - \[ALGORITHM\] [GCNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/gcnet) (16 ckpts)
+
+ - \[BACKBONE\] [HRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/hrnet) (37 ckpts)
+
+ - \[ALGORITHM\] [ICNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/icnet) (12 ckpts)
+
+ - \[ALGORITHM\] [ISANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/isanet) (16 ckpts)
+
+ - \[ALGORITHM\] [K-Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/knet) (7 ckpts)
+
+ - \[BACKBONE\] [MAE](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mae) (1 ckpts)
+
+ - \[ALGORITHM\] [Mask2Former](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mask2former) (13 ckpts)
+
+ - \[ALGORITHM\] [MaskFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/maskformer) (4 ckpts)
+
+ - \[BACKBONE\] [MobileNetV2](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v2) (8 ckpts)
+
+ - \[BACKBONE\] [MobileNetV3](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/mobilenet_v3) (4 ckpts)
+
+ - \[ALGORITHM\] [NonLocal Net](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/nonlocal_net) (16 ckpts)
+
+ - \[ALGORITHM\] [OCRNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/ocrnet) (24 ckpts)
+
+ - \[ALGORITHM\] [PointRend](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/point_rend) (4 ckpts)
+
+ - \[BACKBONE\] [PoolFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/poolformer) (5 ckpts)
+
+ - \[ALGORITHM\] [PSANet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/psanet) (16 ckpts)
+
+ - \[ALGORITHM\] [PSPNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/pspnet) (54 ckpts)
+
+ - \[BACKBONE\] [ResNeSt](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/resnest) (8 ckpts)
+
+ - \[ALGORITHM\] [SegFormer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/segformer) (13 ckpts)
+
+ - \[ALGORITHM\] [Segmenter](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/segmenter) (5 ckpts)
+
+ - \[ALGORITHM\] [Semantic FPN](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/sem_fpn) (4 ckpts)
+
+ - \[ALGORITHM\] [SETR](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/setr) (7 ckpts)
+
+ - \[ALGORITHM\] [STDC](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/stdc) (4 ckpts)
+
+ - \[BACKBONE\] [Swin Transformer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/swin) (6 ckpts)
+
+ - \[BACKBONE\] [Twins](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/twins) (12 ckpts)
+
+ - \[ALGORITHM\] [UNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/unet) (25 ckpts)
+
+ - \[ALGORITHM\] [UPerNet](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/upernet) (16 ckpts)
+
+ - \[BACKBONE\] [Vision Transformer](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/vit) (11 ckpts)
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/npu.md b/internlm_langchain/knowledge_base/MMSegmentation/content/npu.md
new file mode 100644
index 00000000..d50439d0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/npu.md
@@ -0,0 +1,39 @@
+# NPU (华为 昇腾)
+
+## 使用方法
+
+请参考 [MMCV 的安装文档](https://mmcv.readthedocs.io/en/latest/get_started/build.html#build-mmcv-full-on-ascend-npu-machine) 来安装 NPU 版本的 MMCV。
+
+以下展示单机四卡场景的运行指令:
+
+```shell
+bash tools/dist_train.sh configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py 4
+```
+
+以下展示单机单卡下的运行指令:
+
+```shell
+python tools/train.py configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py
+```
+
+## 模型验证结果
+
+| Model | mIoU | Config | Download |
+| :-----------------: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
+| [deeplabv3](<>) | 78.85 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024_20230115_205626.json) |
+| [deeplabv3plus](<>) | 79.23 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/deeplabv3plus/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/deeplabv3plus_r50-d8_4xb2-40k_cityscapes-512x1024_20230116_043450.json) |
+| [hrnet](<>) | 78.1 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/hrnet/fcn_hr18_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_hr18_4xb2-40k_cityscapes-512x1024_20230116_215821.json) |
+| [fcn](<>) | 74.15 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/fcn_r50-d8_4xb2-40k_cityscapes-512x1024_20230111_083014.json) |
+| [icnet](<>) | 69.25 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/icnet/icnet_r50-d8_4xb2-80k_cityscapes-832x832.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/icnet_r50-d8_4xb2-80k_cityscapes-832x832_20230119_002929.json) |
+| [pspnet](<>) | 77.21 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/pspnet/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/pspnet_r50b-d8_4xb2-80k_cityscapes-512x1024_20230114_042721.json) |
+| [unet](<>) | 68.86 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/unet/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/unet-s5-d16_fcn_4xb4-160k_cityscapes-512x1024_20230129_224750.json) |
+| [upernet](<>) | 77.81 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/upernet/upernet_r50_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/upernet_r50_4xb2-40k_cityscapes-512x1024_20230129_014634.json) |
+| [apcnet](<>) | 78.02 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/apcnet/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/apcnet_r50-d8_4xb2-40k_cityscapes-512x1024_20230209_212545.json) |
+| [bisenetv1](<>) | 76.04 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv1/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv1_r50-d32_4xb4-160k_cityscapes-1024x1024_20230201_023946.json) |
+| [bisenetv2](<>) | 72.44 | [config](https://github.com/open-mmlab/mmsegmentation/tree/1.x/configs/bisenetv2/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024.py) | [log](https://download.openmmlab.com/mmsegmentation/v0.5/device/npu/bisenetv2_fcn_4xb4-amp-160k_cityscapes-1024x1024_20230205_215606.json) |
+
+**注意:**
+
+- 如果没有特别标记，NPU 上的使用混合精度训练的结果与使用 FP32 的 GPU 上的结果相同。
+
+**以上模型结果由华为昇腾团队提供**
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/overview.md b/internlm_langchain/knowledge_base/MMSegmentation/content/overview.md
new file mode 100644
index 00000000..ed147956
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/overview.md
@@ -0,0 +1,75 @@
+# 概述
+
+本章节向您介绍 MMSegmentation 框架以及语义分割相关的基本概念。我们还提供了关于 MMSegmentation 的详细教程链接。
+
+## 什么是语义分割？
+
+语义分割是将图像中属于同一目标类别的部分聚类在一起的任务。它也是一种像素级预测任务，因为图像中的每一个像素都将根据类别进行分类。该任务的一些示例基准有 [Cityscapes](https://www.cityscapes-dataset.com/benchmarks/), [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) 和 [ADE20K](https://groups.csail.mit.edu/vision/datasets/ADE20K/) 。通常用平均交并比 (Mean IoU) 和像素准确率 (Pixel Accuracy) 这两个指标来评估模型。
+
+## 什么是 MMSegmentation?
+
+MMSegmentation 是一个工具箱，它为语义分割任务的统一实现和模型评估提供了一个框架，并且高质量实现了常用的语义分割方法和数据集。
+
+MMSeg 主要包含了 apis, structures, datasets, models, engine, evaluation 和 visualization 这七个主要部分。
+
+- **apis** 提供了模型推理的高级api
+
+- **structures** 提供了分割任务的数据结构 `SegDataSample`
+
+- **datasets** 支持用于语义分割的多种数据集
+
+ - **transforms** 包含多种数据增强变换
+
+- **models** 是分割器最重要的部分，包含了分割器的不同组件
+
+ - **segmentors** 定义了所有分割模型类
+ - **data_preprocessors** 用于预处理模型的输入数据
+ - **backbones** 包含各种骨干网络，可将图像映射为特征图
+ - **necks** 包含各种模型颈部组件，用于连接分割头和骨干网络
+ - **decode_heads** 包含各种分割头，将特征图作为输入，并预测分割结果
+ - **losses** 包含各种损失函数
+
+- **engine** 是运行时组件的一部分，扩展了 [MMEngine](https://github.com/open-mmlab/mmengine) 的功能
+
+ - **optimizers** 提供了优化器和优化器封装
+ - **hooks** 提供了 runner 的各种钩子
+
+- **evaluation** 提供了评估模型性能的不同指标
+
+- **visualization** 分割结果的可视化工具
+
+## 如何使用本指南？
+
+以下是详细步骤，将带您一步步学习如何使用 MMSegmentation :
+
+1. 有关安装说明，请参阅 [开始你的第一步](get_started.md)。
+
+2. 对于初学者来说，MMSegmentation 是开始语义分割之旅的最好选择，因为这里实现了许多 SOTA 模型以及经典的模型 [model](model_zoo.md) 。另外，将各类组件和高级 API 結合使用，可以更便捷的执行分割任务。关于 MMSegmentation 的基本用法，请参考下面的教程：
+
+ - [配置](user_guides/1_config.md)
+ - [数据预处理](user_guides/2_dataset_prepare.md)
+ - [推理](user_guides/3_inference.md)
+ - [训练和测试](user_guides/4_train_test.md)
+
+3. 如果你想了解 MMSegmentation 工作的基本类和功能，请参考下面的教程来深入研究：
+
+ - [数据流](advanced_guides/data_flow.md)
+ - [结构](advanced_guides/structures.md)
+ - [模型](advanced_guides/models.md)
+ - [数据集](advanced_guides/datasets.md)
+ - [评估](advanced_guides/evaluation.md)
+
+4. MMSegmentation 也为用户自定义和一些前沿的研究提供了教程，请参考下面的教程来建立你自己的分割项目：
+
+ - [添加新的模型](advanced_guides/add_models.md)
+ - [添加新的数据集](advanced_guides/add_datasets.md)
+ - [添加新的 transform](advanced_guides/add_transforms.md)
+ - [自定义 runtime](advanced_guides/customize_runtime.md)
+
+5. 如果您更熟悉 MMSegmentation v0.x , 以下是 MMSegmentation v0.x 迁移到 v1.x 的文档
+
+ - [迁移](migration/index.rst)
+
+## 参考来源
+
+- https://paperswithcode.com/task/semantic-segmentation/codeless#task-home
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/package.md b/internlm_langchain/knowledge_base/MMSegmentation/content/package.md
new file mode 100644
index 00000000..19e5f18c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/package.md
@@ -0,0 +1,113 @@
+# 包结构更改
+
+本节包含您对 MMSeg 0.x 和 1.x 之间的变化可能感到好奇的内容。
+
+
+
+
+## 已删除的包
+
+### `mmseg.core`
+
+在 OpenMMLab 2.0 中，`core` 包已被删除。`core` 的 `hooks` 和 `optimizers` 被移动到了 `mmseg.engine` 中，而 `core` 中的 `evaluation` 目前是 mmseg.evaluation。
+
+## `mmseg.ops`
+
+`ops` 包含 `encoding` 和 `wrappers`，它们被移到了 `mmseg.models.utils` 中。
+
+## 增加的包
+
+### `mmseg.engine`
+
+OpenMMLab 2.0 增加了一个新的深度学习训练基础库 MMEngine。它是所有 OpenMMLab 代码库的训练引擎。
+mmseg 的 `engine` 包是一些用于语义分割任务的定制模块，如 `SegVisualizationHook` 用于可视化分割掩膜。
+
+### `mmseg.structure`
+
+在 OpenMMLab 2.0 中，我们为计算机视觉任务设计了数据结构，在 mmseg 中，我们在 `structure` 包中实现了 `SegDataSample`。
+
+### `mmseg.evaluation`
+
+我们将所有评估指标都移动到了 `mmseg.evaluation` 中。
+
+### `mmseg.registry`
+
+我们将 MMSegmentation 中所有类型模块的注册实现移动到 `mmseg.registry` 中。
+
+## 修改的包
+
+### `mmseg.apis`
+
+OpenMMLab 2.0 尝试支持计算机视觉的多任务统一接口，并发布了更强的 [`Runner`](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md)，因此 MMSeg 1.x 删除了 `train.py` 和 `test.py` 中的模块，并将 `init_segmentor` 重命名为 `init_model`，将 `inference_segmentor` 重命名为 `inference_model`。
+
+以下是 `mmseg.apis` 的更改：
+
+| 函数 | 变化 |
+| :-------------------: | :--------------------------------------------- |
+| `init_segmentor` | 重命名为 `init_model` |
+| `inference_segmentor` | 重命名为 `inference_model` |
+| `show_result_pyplot` | 基于 `SegLocalVisualizer` 实现 |
+| `train_model` | 删除，使用 `runner.train` 训练。 |
+| `multi_gpu_test` | 删除，使用 `runner.test` 测试。 |
+| `single_gpu_test` | 删除，使用 `runner.test` 测试。 |
+| `set_random_seed` | 删除，使用 `mmengine.runner.set_random_seed`。 |
+| `init_random_seed` | 删除，使用 `mmengine.dist.sync_random_seed`。 |
+
+### `mmseg.datasets`
+
+OpenMMLab 2.0 将 `BaseDataset` 定义为数据集的函数和接口，MMSegmentation 1.x 也遵循此协议，并定义了从 `BaseDataset` 继承的 `BaseSegDataset`。MMCV 2.x 收集多种任务的通用数据转换，例如分类、检测、分割，因此 MMSegmentation 1.x 使用这些数据转换并将其从 mmseg.dataset 中删除。
+
+| 包/模块 | 更改 |
+| :-------------------: | :----------------------------------------------------------------------------------- |
+| `mmseg.pipelines` | 移动到 `mmcv.transforms` 中 |
+| `mmseg.sampler` | 移动到 `mmengine.dataset.sampler` 中 |
+| `CustomDataset` | 重命名为 `BaseSegDataset` 并从 MMEngine 中的 `BaseDataset` 继承 |
+| `DefaultFormatBundle` | 替换为 `PackSegInputs` |
+| `LoadImageFromFile` | 移动到 `mmcv.transforms.LoadImageFromFile` 中 |
+| `LoadAnnotations` | 移动到 `mmcv.transforms.LoadAnnotations` 中 |
+| `Resize` | 移动到 `mmcv.transforms` 中并拆分为 `Resize`，`RandomResize` 和 `RandomChoiceResize` |
+| `RandomFlip` | 移动到 `mmcv.transforms.RandomFlip` 中 |
+| `Pad` | 移动到 `mmcv.transforms.Pad` 中 |
+| `Normalize` | 移动到 `mmcv.transforms.Normalize` 中 |
+| `Compose` | 移动到 `mmcv.transforms.Compose` 中 |
+| `ImageToTensor` | 移动到 `mmcv.transforms.ImageToTensor` 中 |
+
+### `mmseg.models`
+
+`models` 没有太大变化，只是从以前的 `mmseg.ops` 添加了 `encoding` 和 `wrappers`
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/structures.md b/internlm_langchain/knowledge_base/MMSegmentation/content/structures.md
new file mode 100644
index 00000000..958e011a
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/structures.md
@@ -0,0 +1,102 @@
+# 数据结构
+
+为了统一模型和各功能模块之间的输入和输出的接口, 在 OpenMMLab 2.0 MMEngine 中定义了一套抽象数据结构, 实现了基础的增/删/查/改功能, 支持不同设备间的数据迁移, 也支持了如
+`.cpu()`, `.cuda()`, `.get()` 和 `.detach()` 的类字典和张量的操作。具体可以参考 [MMEngine 文档](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/data_element.md)。
+
+同样的, MMSegmentation 亦遵循了 OpenMMLab 2.0 各模块间的接口协议, 定义了 `SegDataSample` 用来封装语义分割任务所需要的数据。
+
+## 语义分割数据 SegDataSample
+
+[SegDataSample](mmseg.structures.SegDataSample) 包括了三个主要数据字段 `gt_sem_seg`, `pred_sem_seg` 和 `seg_logits`, 分别用来存放标注信息, 预测结果和预测的未归一化前的 logits 值。
+
+| 字段 | 类型 | 描述 |
+| -------------- | ------------------------- | ------------------------------- |
+| gt_sem_seg | [`PixelData`](#pixeldata) | 图像标注信息. |
+| pred_instances | [`PixelData`](#pixeldata) | 图像预测结果. |
+| seg_logits | [`PixelData`](#pixeldata) | 模型预测未归一化前的 logits 值. |
+
+以下示例代码展示了 `SegDataSample` 的使用方法：
+
+```python
+import torch
+from mmengine.structures import PixelData
+from mmseg.structures import SegDataSample
+
+img_meta = dict(img_shape=(4, 4, 3),
+ pad_shape=(4, 4, 3))
+data_sample = SegDataSample()
+# 定义 gt_segmentations 用于封装模型的输出信息
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+
+# 增加和处理 SegDataSample 中的属性
+data_sample.gt_sem_seg = gt_segmentations
+assert 'gt_sem_seg' in data_sample
+assert 'data' in data_sample.gt_sem_seg
+assert 'img_shape' in data_sample.gt_sem_seg.metainfo_keys()
+print(data_sample.gt_sem_seg.shape)
+'''
+(4, 4)
+'''
+print(data_sample)
+'''
+
+) at 0x1c2aae44d60>
+'''
+
+# 删除和修改 SegDataSample 中的属性
+data_sample = SegDataSample()
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+data_sample.gt_sem_seg = gt_segmentations
+data_sample.gt_sem_seg.set_metainfo(dict(img_shape=(4,4,9), pad_shape=(4,4,9)))
+del data_sample.gt_sem_seg.img_shape
+
+# 类张量的操作
+data_sample = SegDataSample()
+gt_segmentations = PixelData(metainfo=img_meta)
+gt_segmentations.data = torch.randint(0, 2, (1, 4, 4))
+cuda_gt_segmentations = gt_segmentations.cuda()
+cuda_gt_segmentations = gt_segmentations.to('cuda:0')
+cpu_gt_segmentations = cuda_gt_segmentations.cpu()
+cpu_gt_segmentations = cuda_gt_segmentations.to('cpu')
+```
+
+## 在 SegDataSample 中自定义新的属性
+
+如果你想在 `SegDataSample` 中自定义新的属性，你可以参考下面的 [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 示例:
+
+```python
+class SegDataSample(BaseDataElement):
+ ...
+
+ @property
+ def xxx_property(self) -> xxxData:
+ return self._xxx_property
+
+ @xxx_property.setter
+ def xxx_property(self, value: xxxData) -> None:
+ self.set_field(value, '_xxx_property', dtype=xxxData)
+
+ @xxx_property.deleter
+ def xxx_property(self) -> None:
+ del self._xxx_property
+```
+
+这样一个新的属性 `xxx_property` 就将被增加到 `SegDataSample` 里面了。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/training_tricks.md b/internlm_langchain/knowledge_base/MMSegmentation/content/training_tricks.md
new file mode 100644
index 00000000..e5b8e4da
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/training_tricks.md
@@ -0,0 +1,74 @@
+# 训练技巧
+
+MMSegmentation 支持如下训练技巧：
+
+## 主干网络和解码头组件使用不同的学习率 (Learning Rate, LR)
+
+在语义分割里，一些方法会让解码头组件的学习率大于主干网络的学习率，这样可以获得更好的表现或更快的收敛。
+
+在 MMSegmentation 里面，您也可以在配置文件里添加如下行来让解码头组件的学习率是主干组件的10倍。
+
+```python
+optim_wrapper=dict(
+ paramwise_cfg = dict(
+ custom_keys={
+ 'head': dict(lr_mult=10.)}))
+```
+
+通过这种修改，任何被分组到 `'head'` 的参数的学习率都将乘以10。您也可以参照 [MMEngine 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html#id6) 获取更详细的信息。
+
+## 在线难样本挖掘 (Online Hard Example Mining, OHEM)
+
+MMSegmentation 中实现了像素采样器，训练时可以对特定像素进行采样，例如 OHEM(Online Hard Example Mining)，可以解决样本不平衡问题，
+如下例子是使用 PSPNet 训练并采用 OHEM 策略的配置：
+
+```python
+_base_ = './pspnet_r50-d8_512x1024_40k_cityscapes.py'
+model=dict(
+ decode_head=dict(
+ sampler=dict(type='OHEMPixelSampler', thresh=0.7, min_kept=100000)) )
+```
+
+通过这种方式，只有置信分数在0.7以下的像素值点会被拿来训练。在训练时我们至少要保留100000个像素值点。如果 `thresh` 并未被指定，前 `min_kept`
+个损失的像素值点才会被选择。
+
+## 类别平衡损失 (Class Balanced Loss)
+
+对于不平衡类别分布的数据集，您也许可以改变每个类别的损失权重。这里以 cityscapes 数据集为例：
+
+```python
+_base_ = './pspnet_r50-d8_512x1024_40k_cityscapes.py'
+model=dict(
+ decode_head=dict(
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0,
+ # DeepLab 对 cityscapes 使用这种权重
+ class_weight=[0.8373, 0.9180, 0.8660, 1.0345, 1.0166, 0.9969, 0.9754,
+ 1.0489, 0.8786, 1.0023, 0.9539, 0.9843, 1.1116, 0.9037,
+ 1.0865, 1.0955, 1.0865, 1.1529, 1.0507])))
+```
+
+`class_weight` 将被作为 `weight` 参数，传递给 `CrossEntropyLoss`。详细信息请参照 [PyTorch 文档](https://pytorch.org/docs/stable/nn.html?highlight=crossentropy#torch.nn.CrossEntropyLoss) 。
+
+## 同时使用多种损失函数 (Multiple Losses)
+
+对于训练时损失函数的计算，我们目前支持多个损失函数同时使用。 以 `unet` 使用 `DRIVE` 数据集训练为例，
+使用 `CrossEntropyLoss` 和 `DiceLoss` 的 `1:3` 的加权和作为损失函数。配置文件写为:
+
+```python
+_base_ = './fcn_unet_s5-d16_64x64_40k_drive.py'
+model = dict(
+ decode_head=dict(loss_decode=[
+ dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+ dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+ ]),
+ auxiliary_head=dict(loss_decode=[
+ dict(type='CrossEntropyLoss', loss_name='loss_ce', loss_weight=1.0),
+ dict(type='DiceLoss', loss_name='loss_dice', loss_weight=3.0)
+ ]),
+)
+```
+
+通过这种方式，确定训练过程中损失函数的权重 `loss_weight` 和在训练日志里的名字 `loss_name`。
+
+注意： `loss_name` 的名字必须带有 `loss_` 前缀，这样它才能被包括在计算图里。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/transforms.md b/internlm_langchain/knowledge_base/MMSegmentation/content/transforms.md
new file mode 100644
index 00000000..e5f3bebf
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/transforms.md
@@ -0,0 +1,119 @@
+# 数据增强变化
+
+在本教程中，我们将介绍 MMSegmentation 中数据增强变化流程的设计。
+
+本指南的结构如下：
+
+- [数据增强变化](#数据增强变化)
+ - [数据增强变化流程设计](#数据增强变化流程设计)
+ - [数据加载](#数据加载)
+ - [预处理](#预处理)
+ - [格式修改](#格式修改)
+
+## 数据增强变化流程设计
+
+按照惯例，我们使用 `Dataset` 和 `DataLoader` 多进程地加载数据。`Dataset` 返回与模型 forward 方法的参数相对应的数据项的字典。由于语义分割中的数据可能大小不同，我们在 MMCV 中引入了一种新的 `DataContainer` 类型，以帮助收集和分发不同大小的数据。参见[此处](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py)了解更多详情。
+
+在 MMSegmentation 的 1.x 版本中，所有数据转换都继承自 [`BaseTransform`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/transforms/base.py#L6).
+
+转换的输入和输出类型都是字典。一个简单的示例如下：
+
+```python
+>>> from mmseg.datasets.transforms import LoadAnnotations
+>>> transforms = LoadAnnotations()
+>>> img_path = './data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png.png'
+>>> gt_path = './data/cityscapes/gtFine/train/aachen/aachen_000015_000019_gtFine_instanceTrainIds.png'
+>>> results = dict(
+>>> img_path=img_path,
+>>> seg_map_path=gt_path,
+>>> reduce_zero_label=False,
+>>> seg_fields=[])
+>>> data_dict = transforms(results)
+>>> print(data_dict.keys())
+dict_keys(['img_path', 'seg_map_path', 'reduce_zero_label', 'seg_fields', 'gt_seg_map'])
+```
+
+数据准备流程和数据集是解耦的。通常，数据集定义如何处理标注，数据流程定义准备数据字典的所有步骤。流程由一系列操作组成。每个操作都将字典作为输入，并为接下来的转换输出字典。
+
+操作分为数据加载、预处理、格式修改和测试数据增强。
+
+这里是 PSPNet 的流程示例：
+
+```python
+crop_size = (512, 1024)
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ dict(
+ type='RandomResize',
+ scale=(2048, 1024),
+ ratio_range=(0.5, 2.0),
+ keep_ratio=True),
+ dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+ dict(type='RandomFlip', prob=0.5),
+ dict(type='PhotoMetricDistortion'),
+ dict(type='PackSegInputs')
+]
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+ # add loading annotation after ``Resize`` because ground truth
+ # does not need to resize data transform
+ dict(type='LoadAnnotations'),
+ dict(type='PackSegInputs')
+]
+```
+
+对于每个操作，我们列出了 `添加`/`更新`/`删除` 相关的字典字段。在流程前，我们可以从数据集直接获得的信息是 `img_path` 和 `seg_map_path`。
+
+### 数据加载
+
+`LoadImageFromFile`：从文件加载图像。
+
+- 添加：`img`，`img_shape`，`ori_shape`
+
+`LoadAnnotations`：加载数据集提供的语义分割图。
+
+- 添加：`seg_fields`，`gt_seg_map`
+
+### 预处理
+
+`RandomResize`：随机调整图像和分割图大小。
+
+-添加：`scale`，`scale_factor`，`keep_ratio`
+-更新：`img`，`img_shape`，`gt_seg_map`
+
+`Resize`：调整图像和分割图的大小。
+
+-添加：`scale`，`scale_factor`，`keep_ratio`
+-更新：`img`，`gt_seg_map`，`img_shape`
+
+`RandomCrop`：随机裁剪图像和分割图。
+
+-更新：`img`，`gt_seg_map`，`img_shape`
+
+`RandomFlip`：翻转图像和分割图。
+
+-添加：`flip`，`flip_direction`
+-更新：`img`，`gt_seg_map`
+
+`PhotoMetricDistortion`：按顺序对图像应用光度失真，每个变换的应用概率为 0.5。随机对比度的位置是第二或倒数第二（分别为下面的模式 0 或 1）。
+
+```
+1.随机亮度
+2.随机对比度（模式 0）
+3.将颜色从 BGR 转换为 HSV
+4.随机饱和度
+5.随机色调
+6.将颜色从 HSV 转换为 BGR
+7.随机对比度（模式 1）
+```
+
+- 更新：`img`
+
+### 格式修改
+
+`PackSegInputs`：为语义分段打包输入数据。
+
+- 添加：`inputs`，`data_sample`
+- 删除：由 `meta_keys` 指定的 keys（合并到 data_sample 的 metainfo 中），所有其他 keys
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/useful_tools.md b/internlm_langchain/knowledge_base/MMSegmentation/content/useful_tools.md
new file mode 100644
index 00000000..acbacb95
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/useful_tools.md
@@ -0,0 +1,368 @@
+## 常用工具（待更新）
+
+除了训练和测试的脚本，我们在 `tools/` 文件夹路径下还提供许多有用的工具。
+
+### 计算参数量（params）和计算量（ FLOPs） (试验性)
+
+我们基于 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch)
+提供了一个用于计算给定模型参数量和计算量的脚本。
+
+```shell
+python tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+您将得到如下的结果：
+
+```none
+==============================
+Input shape: (3, 2048, 1024)
+Flops: 1429.68 GMac
+Params: 48.98 M
+==============================
+```
+
+**注意**: 这个工具仍然是试验性的，我们无法保证数字是正确的。您可以拿这些结果做简单的实验的对照，在写技术文档报告或者论文前您需要再次确认一下。
+
+(1) 计算量与输入的形状有关，而参数量与输入的形状无关，默认的输入形状是 (1, 3, 1280, 800)；
+(2) 一些运算操作，如 GN 和其他定制的运算操作没有加入到计算量的计算中。
+
+### 发布模型
+
+在您上传一个模型到云服务器之前，您需要做以下几步：
+(1) 将模型权重转成 CPU 张量；
+(2) 删除记录优化器状态 (optimizer states)的相关信息；
+(3) 计算检查点文件 (checkpoint file) 的哈希编码（hash id）并且将哈希编码加到文件名中。
+
+```shell
+python tools/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+例如，
+
+```shell
+python tools/publish_model.py work_dirs/pspnet/latest.pth psp_r50_hszhao_200ep.pth
+```
+
+最终输出文件将是 `psp_r50_512x1024_40ki_cityscapes-{hash id}.pth`。
+
+### 导出 ONNX (试验性)
+
+我们提供了一个脚本来导出模型到 [ONNX](https://github.com/onnx/onnx) 格式。被转换的模型可以通过工具 [Netron](https://github.com/lutzroeder/netron)
+来可视化。除此以外，我们同样支持对 PyTorch 和 ONNX 模型的输出结果做对比。
+
+```bash
+python tools/pytorch2onnx.py \
+ ${CONFIG_FILE} \
+ --checkpoint ${CHECKPOINT_FILE} \
+ --output-file ${ONNX_FILE} \
+ --input-img ${INPUT_IMG} \
+ --shape ${INPUT_SHAPE} \
+ --rescale-shape ${RESCALE_SHAPE} \
+ --show \
+ --verify \
+ --dynamic-export \
+ --cfg-options \
+ model.test_cfg.mode="whole"
+```
+
+各个参数的描述:
+
+- `config` : 模型配置文件的路径
+- `--checkpoint` : 模型检查点文件的路径
+- `--output-file`: 输出的 ONNX 模型的路径。如果没有专门指定，它默认是 `tmp.onnx`
+- `--input-img` : 用来转换和可视化的一张输入图像的路径
+- `--shape`: 模型的输入张量的高和宽。如果没有专门指定，它将被设置成 `test_pipeline` 的 `img_scale`
+- `--rescale-shape`: 改变输出的形状。设置这个值来避免 OOM，它仅在 `slide` 模式下可以用
+- `--show`: 是否打印输出模型的结构。如果没有被专门指定，它将被设置成 `False`
+- `--verify`: 是否验证一个输出模型的正确性 (correctness)。如果没有被专门指定，它将被设置成 `False`
+- `--dynamic-export`: 是否导出形状变化的输入与输出的 ONNX 模型。如果没有被专门指定，它将被设置成 `False`
+- `--cfg-options`: 更新配置选项
+
+**注意**: 这个工具仍然是试验性的，目前一些自定义操作还没有被支持
+
+### 评估 ONNX 模型
+
+我们提供 `tools/deploy_test.py` 去评估不同后端的 ONNX 模型。
+
+#### 先决条件
+
+- 安装 onnx 和 onnxruntime-gpu
+
+ ```shell
+ pip install onnx onnxruntime-gpu
+ ```
+
+- 参考 [如何在 MMCV 里构建 tensorrt 插件](https://mmcv.readthedocs.io/en/latest/tensorrt_plugin.html#how-to-build-tensorrt-plugins-in-mmcv) 安装TensorRT (可选)
+
+#### 使用方法
+
+```bash
+python tools/deploy_test.py \
+ ${CONFIG_FILE} \
+ ${MODEL_FILE} \
+ ${BACKEND} \
+ --out ${OUTPUT_FILE} \
+ --eval ${EVALUATION_METRICS} \
+ --show \
+ --show-dir ${SHOW_DIRECTORY} \
+ --cfg-options ${CFG_OPTIONS} \
+ --eval-options ${EVALUATION_OPTIONS} \
+ --opacity ${OPACITY} \
+```
+
+各个参数的描述:
+
+- `config`: 模型配置文件的路径
+- `model`: 被转换的模型文件的路径
+- `backend`: 推理的后端，可选项：`onnxruntime`， `tensorrt`
+- `--out`: 输出结果成 pickle 格式文件的路径
+- `--format-only` : 不评估直接给输出结果的格式。通常用在当您想把结果输出成一些测试服务器需要的特定格式时。如果没有被专门指定，它将被设置成 `False`。 注意这个参数是用 `--eval` 来 **手动添加**
+- `--eval`: 评估指标，取决于每个数据集的要求，例如 "mIoU" 是大多数据集的指标而 "cityscapes" 仅针对 Cityscapes 数据集。注意这个参数是用 `--format-only` 来 **手动添加**
+- `--show`: 是否展示结果
+- `--show-dir`: 涂上结果的图像被保存的文件夹的路径
+- `--cfg-options`: 重写配置文件里的一些设置，`xxx=yyy` 格式的键值对将被覆盖到配置文件里
+- `--eval-options`: 自定义的评估的选项， `xxx=yyy` 格式的键值对将成为 `dataset.evaluate()` 函数的参数变量
+- `--opacity`: 涂上结果的分割图的透明度，范围在 (0, 1\] 之间
+
+#### 结果和模型
+
+| 模型 | 配置文件 | 数据集 | 评价指标 | PyTorch | ONNXRuntime | TensorRT-fp32 | TensorRT-fp16 |
+| :--------: | :---------------------------------------------: | :--------: | :------: | :-----: | :---------: | :-----------: | :-----------: |
+| FCN | fcn_r50-d8_512x1024_40k_cityscapes.py | cityscapes | mIoU | 72.2 | 72.2 | 72.2 | 72.2 |
+| PSPNet | pspnet_r50-d8_512x1024_40k_cityscapes.py | cityscapes | mIoU | 77.8 | 77.8 | 77.8 | 77.8 |
+| deeplabv3 | deeplabv3_r50-d8_512x1024_40k_cityscapes.py | cityscapes | mIoU | 79.0 | 79.0 | 79.0 | 79.0 |
+| deeplabv3+ | deeplabv3plus_r50-d8_512x1024_40k_cityscapes.py | cityscapes | mIoU | 79.6 | 79.5 | 79.5 | 79.5 |
+| PSPNet | pspnet_r50-d8_769x769_40k_cityscapes.py | cityscapes | mIoU | 78.2 | 78.1 | | |
+| deeplabv3 | deeplabv3_r50-d8_769x769_40k_cityscapes.py | cityscapes | mIoU | 78.5 | 78.3 | | |
+| deeplabv3+ | deeplabv3plus_r50-d8_769x769_40k_cityscapes.py | cityscapes | mIoU | 78.9 | 78.7 | | |
+
+**注意**: TensorRT 仅在使用 `whole mode` 测试模式时的配置文件里可用。
+
+### 导出 TorchScript (试验性)
+
+我们同样提供一个脚本去把模型导出成 [TorchScript](https://pytorch.org/docs/stable/jit.html) 格式。您可以使用 pytorch C++ API [LibTorch](https://pytorch.org/docs/stable/cpp_index.html) 去推理训练好的模型。
+被转换的模型能被像 [Netron](https://github.com/lutzroeder/netron) 的工具来可视化。此外，我们还支持 PyTorch 和 TorchScript 模型的输出结果的比较。
+
+```shell
+python tools/pytorch2torchscript.py \
+ ${CONFIG_FILE} \
+ --checkpoint ${CHECKPOINT_FILE} \
+ --output-file ${ONNX_FILE}
+ --shape ${INPUT_SHAPE}
+ --verify \
+ --show
+```
+
+各个参数的描述:
+
+- `config` : pytorch 模型的配置文件的路径
+- `--checkpoint` : pytorch 模型的检查点文件的路径
+- `--output-file`: TorchScript 模型输出的路径，如果没有被专门指定，它将被设置成 `tmp.pt`
+- `--input-img` : 用来转换和可视化的输入图像的路径
+- `--shape`: 模型的输入张量的宽和高。如果没有被专门指定，它将被设置成 `512 512`
+- `--show`: 是否打印输出模型的追踪图 (traced graph)，如果没有被专门指定，它将被设置成 `False`
+- `--verify`: 是否验证一个输出模型的正确性 (correctness)，如果没有被专门指定，它将被设置成 `False`
+
+**注意**: 目前仅支持 PyTorch>=1.8.0 版本
+
+**注意**: 这个工具仍然是试验性的，一些自定义操作符目前还不被支持
+
+例子:
+
+- 导出 PSPNet 在 cityscapes 数据集上的 pytorch 模型
+
+ ```shell
+ python tools/pytorch2torchscript.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+ --checkpoint checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
+ --output-file checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pt \
+ --shape 512 1024
+ ```
+
+### 导出 TensorRT (试验性)
+
+一个导出 [ONNX](https://github.com/onnx/onnx) 模型成 [TensorRT](https://developer.nvidia.com/tensorrt) 格式的脚本
+
+先决条件
+
+- 按照 [ONNXRuntime in mmcv](https://mmcv.readthedocs.io/en/latest/deployment/onnxruntime_op.html) 和 [TensorRT plugin in mmcv](https://github.com/open-mmlab/mmcv/blob/master/docs/en/deployment/tensorrt_plugin.md) ，用 ONNXRuntime 自定义运算 (custom ops) 和 TensorRT 插件安装 `mmcv-full`
+- 使用 [pytorch2onnx](#convert-to-onnx-experimental) 将模型从 PyTorch 转成 ONNX
+
+使用方法
+
+```bash
+python ${MMSEG_PATH}/tools/onnx2tensorrt.py \
+ ${CFG_PATH} \
+ ${ONNX_PATH} \
+ --trt-file ${OUTPUT_TRT_PATH} \
+ --min-shape ${MIN_SHAPE} \
+ --max-shape ${MAX_SHAPE} \
+ --input-img ${INPUT_IMG} \
+ --show \
+ --verify
+```
+
+各个参数的描述:
+
+- `config` : 模型的配置文件
+- `model` : 输入的 ONNX 模型的路径
+- `--trt-file` : 输出的 TensorRT 引擎的路径
+- `--max-shape` : 模型的输入的最大形状
+- `--min-shape` : 模型的输入的最小形状
+- `--fp16` : 做 fp16 模型转换
+- `--workspace-size` : 在 GiB 里的最大工作空间大小 (Max workspace size)
+- `--input-img` : 用来可视化的图像
+- `--show` : 做结果的可视化
+- `--dataset` : Palette provider, 默认为 `CityscapesDataset`
+- `--verify` : 验证 ONNXRuntime 和 TensorRT 的输出
+- `--verbose` : 当创建 TensorRT 引擎时，是否详细做信息日志。默认为 False
+
+**注意**: 仅在全图测试模式 (whole mode) 下测试过
+
+## 其他内容
+
+### 打印完整的配置文件
+
+`tools/print_config.py` 会逐字逐句的打印整个配置文件，展开所有的导入。
+
+```shell
+python tools/print_config.py \
+ ${CONFIG} \
+ --graph \
+ --cfg-options ${OPTIONS [OPTIONS...]} \
+```
+
+各个参数的描述:
+
+- `config` : pytorch 模型的配置文件的路径
+- `--graph` : 是否打印模型的图 (models graph)
+- `--cfg-options`: 自定义替换配置文件的选项
+
+### 对训练日志 (training logs) 画图
+
+`tools/analyze_logs.py` 会画出给定的训练日志文件的 loss/mIoU 曲线，首先需要 `pip install seaborn` 安装依赖包。
+
+```shell
+python tools/analyze_logs.py xxx.log.json [--keys ${KEYS}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+示例:
+
+- 对 mIoU, mAcc, aAcc 指标画图
+
+ ```shell
+ python tools/analyze_logs.py log.json --keys mIoU mAcc aAcc --legend mIoU mAcc aAcc
+ ```
+
+- 对 loss 指标画图
+
+ ```shell
+ python tools/analyze_logs.py log.json --keys loss --legend loss
+ ```
+
+### 转换其他仓库的权重
+
+`tools/model_converters/` 提供了若干个预训练权重转换脚本，支持将其他仓库的预训练权重的 key 转换为与 MMSegmentation 相匹配的 key。
+
+#### ViT Swin MiT Transformer 模型
+
+- ViT
+
+`tools/model_converters/vit2mmseg.py` 将 timm 预训练模型转换到 MMSegmentation。
+
+```shell
+python tools/model_converters/vit2mmseg.py ${SRC} ${DST}
+```
+
+- Swin
+
+ `tools/model_converters/swin2mmseg.py` 将官方预训练模型转换到 MMSegmentation。
+
+ ```shell
+ python tools/model_converters/swin2mmseg.py ${SRC} ${DST}
+ ```
+
+- SegFormer
+
+ `tools/model_converters/mit2mmseg.py` 将官方预训练模型转换到 MMSegmentation。
+
+ ```shell
+ python tools/model_converters/mit2mmseg.py ${SRC} ${DST}
+ ```
+
+## 模型服务
+
+为了用 [`TorchServe`](https://pytorch.org/serve/) 服务 `MMSegmentation` 的模型 ， 您可以遵循如下流程:
+
+### 1. 将 model 从 MMSegmentation 转换到 TorchServe
+
+```shell
+python tools/mmseg2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+**注意**: ${MODEL_STORE} 需要设置为某个文件夹的绝对路径
+
+### 2. 构建 `mmseg-serve` 容器镜像 (docker image)
+
+```shell
+docker build -t mmseg-serve:latest docker/serve/
+```
+
+### 3. 运行 `mmseg-serve`
+
+请查阅官方文档: [使用容器运行 TorchServe](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment)
+
+为了在 GPU 环境下使用, 您需要安装 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html). 若在 CPU 环境下使用，您可以忽略添加 `--gpus` 参数。
+
+示例:
+
+```shell
+docker run --rm \
+--cpus 8 \
+--gpus device=0 \
+-p8080:8080 -p8081:8081 -p8082:8082 \
+--mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
+mmseg-serve:latest
+```
+
+阅读关于推理 (8080), 管理 (8081) 和指标 (8082) APIs 的 [文档](https://github.com/pytorch/serve/blob/072f5d088cce9bb64b2a18af065886c9b01b317b/docs/rest_api.md) 。
+
+### 4. 测试部署
+
+```shell
+curl -O https://raw.githubusercontent.com/open-mmlab/mmsegmentation/master/resources/3dogs.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg -o 3dogs_mask.png
+```
+
+得到的响应将是一个 ".png" 的分割掩码.
+
+您可以按照如下方法可视化输出:
+
+```python
+import matplotlib.pyplot as plt
+import mmcv
+plt.imshow(mmcv.imread("3dogs_mask.png", "grayscale"))
+plt.show()
+```
+
+看到的东西将会和下图类似:
+
+
+
+然后您可以使用 `test_torchserve.py` 比较 torchserve 和 pytorch 的结果，并将它们可视化。
+
+```shell
+python tools/torchserve/test_torchserve.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--result-image ${RESULT_IMAGE}] [--device ${DEVICE}]
+```
+
+示例：
+
+```shell
+python tools/torchserve/test_torchserve.py \
+demo/demo.png \
+configs/fcn/fcn_r50-d8_512x1024_40k_cityscapes.py \
+checkpoint/fcn_r50-d8_512x1024_40k_cityscapes_20200604_192608-efe53f0d.pth \
+fcn
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/visualization.md b/internlm_langchain/knowledge_base/MMSegmentation/content/visualization.md
new file mode 100644
index 00000000..2ef020ba
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/visualization.md
@@ -0,0 +1,173 @@
+# 可视化
+
+MMSegmentation 1.x 提供了简便的方式监控训练时的状态以及可视化在模型预测时的数据。
+
+## 训练状态监控
+
+MMSegmentation 1.x 使用 TensorBoard 来监控训练时候的状态。
+
+### TensorBoard 的配置
+
+安装 TensorBoard 的过程可以按照 [官方安装指南](https://www.tensorflow.org/install) ，具体的步骤如下：
+
+```shell
+pip install tensorboardX
+pip install future tensorboard
+```
+
+在配置文件 `default_runtime.py` 的 `vis_backend` 中添加 `TensorboardVisBackend`。
+
+```python
+vis_backends = [dict(type='LocalVisBackend'),
+ dict(type='TensorboardVisBackend')]
+visualizer = dict(
+ type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
+
+### 检查 TensorBoard 中的标量
+
+启动训练实验的命令如下
+
+```shell
+python tools/train.py configs/pspnet/pspnet_r50-d8_4xb4-80k_ade20k-512x512.py --work-dir work_dir/test_visual
+```
+
+开始训练后找到 `work_dir` 中的 `vis_data` 路径，例如：本次特定测试的 vis_data 路径如下所示：
+
+```shell
+work_dirs/test_visual/20220810_115248/vis_data
+```
+
+vis_data 路径中的标量文件包括了学习率、损失函数和 data_time 等，还记录了指标结果，您可以参考 MMEngine 中的 [记录日志教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/logging.html) 中的日志教程来帮助记录自己定义的数据。 Tensorboard 的可视化结果使用下面的命令执行：
+
+```shell
+tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
+```
+
+## 数据和结果的可视化
+
+### 模型测试或验证期间的可视化数据样本
+
+MMSegmentation 提供了 `SegVisualizationHook` ，它是一个可以用于可视化 ground truth 和在模型测试和验证期间的预测分割结果的[钩子](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html) 。 它的配置在 `default_hooks` 中，更多详细信息请参见 [执行器教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)。
+
+例如，在 `_base_/schedules/schedule_20k.py` 中，修改 `SegVisualizationHook` 配置，将 `draw` 设置为 `True` 以启用网络推理结果的存储，`interval` 表示预测结果的采样间隔， 设置为 1 时，将保存网络的每个推理结果。 `interval` 默认设置为 50：
+
+```python
+default_hooks = dict(
+ timer=dict(type='IterTimerHook'),
+ logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+ param_scheduler=dict(type='ParamSchedulerHook'),
+ checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+ sampler_seed=dict(type='DistSamplerSeedHook'),
+ visualization=dict(type='SegVisualizationHook', draw=True, interval=1))
+
+```
+
+启动训练实验后，可视化结果将在 validation loop 存储到本地文件夹中，或者在一个数据集上启动评估模型时，预测结果将存储在本地。本地的可视化的存储结果保存在 `$WORK_DIRS/vis_data` 下的 `vis_image` 中，例如：
+
+```shell
+work_dirs/test_visual/20220810_115248/vis_data/vis_image
+```
+
+另外，如果在 `vis_backends` 中添加 `TensorboardVisBackend` ，如 [TensorBoard 的配置](###TensorBoard的配置)，我们还可以运行下面的命令在 TensorBoard 中查看它们：
+
+```shell
+tensorboard --logdir work_dirs/test_visual/20220810_115248/vis_data
+```
+
+### 可视化单个数据样本
+
+如果你想可视化单个样本数据，我们建议使用 `SegLocalVisualizer` 。
+
+`SegLocalVisualizer`是继承自 MMEngine 中`Visualizer` 类的子类，适用于 MMSegmentation 可视化，有关`Visualizer`的详细信息请参考在 MMEngine 中的[可视化教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html) 。
+
+以下是一个关于 `SegLocalVisualizer` 的示例，首先你可以使用下面的命令下载这个案例中的数据：
+
+
+ dataset:
+ type:
+ data_path: ./data
+ #more arguments for processor function...
+
+argparse_cfg:
+ data:
+ bind_to: processor_cfg.dataset.data_path
+ help: the path of data
+ #more option arguments for command line...
+```
+
+The `processor_cfg` specifies a processor function and its dataset module
+In adittion, the `data_path` argument of the dataset is "./data".
+The `argparse_cfg` create a option argument `data` which is bound to `data_path`.
+
+Note that, mmskeleton will import processor function or modules according to the given path by the priority of `local directory > system python path > mmskeleton`.
+
+
+
+With this configuration, the application can be started by:
+```shell
+mmskl $CONFIG_FILE [--data $DATA_PATH]
+```
+
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMSkeleton/content/CUSTOM_DATASET.md b/internlm_langchain/knowledge_base/MMSkeleton/content/CUSTOM_DATASET.md
new file mode 100644
index 00000000..ab3f2363
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSkeleton/content/CUSTOM_DATASET.md
@@ -0,0 +1,99 @@
+## Custom Skeleton-based Dataset
+mmskeleton accepts two formats of skeleton data, `.npy` and `.json`.
+We recommend users to store their dataset as `.json` files.
+Please follow the below example to build a custom dataset.
+
+### Build dataset from videos
+
+We have prepared a mini video set including three 10-seconds clips in the `resource/data_example` with the structure:
+
+ resource/dataset_example
+ ├── skateboarding.mp4
+ ├── clean_and_jerk.mp4
+ └── ta_chi.mp4
+
+
+Run this command for building skeleton-based dataset for them:
+```
+mmskl configs/utils/build_dataset_example.yaml [--gpus $GPUS]
+```
+mmskeleton extracts skeleton sequences for each video via performing **person detection** and **pose estimation** on all frames.
+A few `.json` files will be stored under `data/dataset_example` if you did not change default arguments. The directory layout is shown here:
+
+ data/dataset_example
+ ├── skateboarding.json
+ ├── clean_and_jerk.json
+ └── ta_chi.json
+
+All annotations share the same basic data structure like below:
+```javascript
+{
+ "info":
+ {
+ "video_name": "skateboarding.mp4",
+ "resolution": [340, 256],
+ "num_frame": 300,
+ "num_keypoints": 17,
+ "keypoint_channels": ["x", "y", "score"],
+ "version": "1.0"
+ },
+ "annotations":
+ [
+ {
+ "frame_index": 0,
+ "id": 0,
+ "person_id": null,
+ "keypoints": [[x, y, score], [x, y, score], ...]
+ },
+ ...
+ ],
+ "category_id": 0,
+}
+```
+
+After that, train the st-gcn model by:
+```
+mmskl configs/recognition/st_gcn/dataset_example/train.yaml
+```
+and test the model by:
+```
+mmskl configs/recognition/st_gcn/dataset_example/test.yaml --checkpoint $CHECKPOINT_PATH
+```
+
+### Build your own dataset
+
+If you want to use mmskeleton on your own **skeleton-based data**, the simplest method is reformatting
+your data format to `.json` files with the basic structure we mentioned above.
+Or you can design another data feeder to replace [our data feeder](../mmskeleton/datasets/recognition.py),
+and specify it by changing `processor_cfg.dataset_cfg.name` in your training configuration file.
+
+If you want to use mmskeleton on your own **video dataset**,
+just follow the above tutorial to build the skeleton-based dataset for videos.
+Note that, in the above example, the groundtruth of `category_id` is from [another annotation file](../resource/category_annotation_example.json) with the structure:
+```javascript
+{
+ "categories": [
+ "skateboarding",
+ "clean_and_jerk",
+ "ta_chi"
+ ],
+ "annotations": {
+ "clean_and_jerk.mp4": {
+ "category_id": 1
+ },
+ "skateboarding.mp4": {
+ "category_id": 0
+ },
+ "ta_chi.mp4": {
+ "category_id": 2
+ }
+ }
+}
+```
+The `category_id` will be set to `-1` if the category annotations miss.
+
+You can build dataset by:
+```
+mmskl configs/utils/build_dataset_example.yaml --video_dir $VIDEO_DIR --category_annotation $VIDEO_ANNOTATION --out_dir $OUT_DIR [--gpus $GPUS]
+```
+To change the person detector, pose estimator or other arguments, modify the `build_dataset_example.yaml`.
diff --git a/internlm_langchain/knowledge_base/MMSkeleton/content/GETTING_STARTED.md b/internlm_langchain/knowledge_base/MMSkeleton/content/GETTING_STARTED.md
new file mode 100644
index 00000000..6e9248af
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSkeleton/content/GETTING_STARTED.md
@@ -0,0 +1,87 @@
+## Getting Started
+
+### Installation
+
+a. [Optional] Create a [conda](www.anaconda.com/distribution/) virtual environment and activate it:
+
+``` shell
+conda create -n open-mmlab python=3.7 -y
+conda activate open-mmlab
+```
+
+b. Install PyTorch and torchvision (CUDA is required):
+``` shell
+# CUDA 9.2
+conda install pytorch==1.2.0 torchvision==0.4.0 cudatoolkit=9.2 -c pytorch
+
+# CUDA 10.0
+conda install pytorch==1.2.0 torchvision==0.4.0 cudatoolkit=10.0 -c pytorch
+```
+The higher versions are not covered by tests.
+
+c. Clone mmskeleton from github:
+
+``` shell
+git clone https://github.com/open-mmlab/mmskeleton.git
+cd mmskeleton
+```
+
+d. Install mmskeleton:
+
+``` shell
+python setup.py develop
+```
+
+e. Install nms for person estimation:
+``` shell
+cd mmskeleton/ops/nms/
+python setup_linux.py develop
+cd ../../../
+```
+
+f. [Optional] Install mmdetection for person detection:
+
+``` shell
+python setup.py develop --mmdet
+```
+In the event of a failure installation, please install [mmdetection](https://github.com/open-mmlab/mmdetection/blob/master/docs/INSTALL.md) manually.
+
+g. To verify that mmskeleton and mmdetection installed correctly, use:
+```shell
+python mmskl.py pose_demo [--gpus $GPUS]
+# or "python mmskl.py pose_demo_HD [--gpus $GPUS]" for a higher accuracy
+```
+An generated video as below will be saved under the prompted path.
+
+
+```
+
+#### NTU RGB+D
+NTU RGB+D can be downloaded from [their website](http://rose1.ntu.edu.sg/datasets/actionrecognition.asp).
+Only the **3D skeletons**(5.8GB) modality is required in our experiments. After that, this command should be used to build the database for training or evaluation on mmskeleton:
+```
+python deprecated/tools/data_processing/ntu_gendata.py --data_path
+```
+where the `````` is the directory path of 3D skeletons annotations of the NTU RGB+D dataset you download.
diff --git a/internlm_langchain/knowledge_base/MMSkeleton/content/START_POSE_ESTIMATION.md b/internlm_langchain/knowledge_base/MMSkeleton/content/START_POSE_ESTIMATION.md
new file mode 100644
index 00000000..bbf16eec
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSkeleton/content/START_POSE_ESTIMATION.md
@@ -0,0 +1,64 @@
+## Start Pose Estimation
+
+We provide a demo for video-based pose estimation:
+```shell
+mmskl pose_demo [--video $VIDEO_PATH] [--gpus $GPUS] [--$MORE_OPTIONS]
+```
+This demo predict pose sequences via sequentially feeding frames into the image-based human detector and the pose estimator. By default, they are **cascade-rcnn** [1] and **hrnet** [2] respectively.
+We test our demo on 8 gpus of TITAN X and get a realtime speed (27.1fps). To check the full usage, please run `mmskl pose_demo -h`. You can also refer to [pose_demo.yaml](../configs/pose_estimation/hrnet/pose_demo.yaml) for detailed configurations.
+
+We also provide another demo `pose_demo_HD` with a slower but more powerful detector **htc** [3]. Similarly, run:
+```shell
+mmskl pose_demo_HD [--video $VIDEO_PATH] [--gpus $GPUS] [--$MORE_OPTIONS]
+```
+
+
+### High-level APIs for testing images
+
+Here is an example of building the pose estimator and test given images.
+```python
+import mmcv
+from mmskeleton.apis import init_pose_estimator, inference_pose_estimator
+
+cfg = mmcv.Config.fromfile('configs/apis/pose_estimator.cascade_rcnn+hrnet.yaml')
+video = mmcv.VideoReader('resource/data_example/skateboarding.mp4')
+
+model = init_pose_estimator(**cfg, device=0)
+for i, frame in enumerate(video):
+ result = inference_pose_estimator(model, frame)
+ print('Process the frame {}'.format(i))
+
+ # process the result here
+
+```
+
+### Training and Test a Pose Estimator
+Comming soon...
+
+
+
+### Reference
+```
+@inproceedings{cai2018cascade,
+ title={Cascade r-cnn: Delving into high quality object detection},
+ author={Cai, Zhaowei and Vasconcelos, Nuno},
+ booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
+ pages={6154--6162},
+ year={2018}
+}
+
+@article{sun2019deep,
+ title={Deep high-resolution representation learning for human pose estimation},
+ author={Sun, Ke and Xiao, Bin and Liu, Dong and Wang, Jingdong},
+ journal={arXiv preprint arXiv:1902.09212},
+ year={2019}
+}
+
+@inproceedings{chen2019hybrid,
+ title={Hybrid task cascade for instance segmentation},
+ author={Chen, Kai and Pang, Jiangmiao and Wang, Jiaqi and Xiong, Yu and Li, Xiaoxiao and Sun, Shuyang and Feng, Wansen and Liu, Ziwei and Shi, Jianping and Ouyang, Wanli and others},
+ booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
+ pages={4974--4983},
+ year={2019}
+}
+```
\ No newline at end of file
diff --git a/internlm_langchain/knowledge_base/MMSkeleton/content/START_RECOGNITION.md b/internlm_langchain/knowledge_base/MMSkeleton/content/START_RECOGNITION.md
new file mode 100644
index 00000000..4bbdce4d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSkeleton/content/START_RECOGNITION.md
@@ -0,0 +1,62 @@
+## Start Action Recognition Using ST-GCN
+
+This repository holds the codebase for the paper:
+
+**Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition** Sijie Yan, Yuanjun Xiong and Dahua Lin, AAAI 2018. [[Arxiv Preprint]](https://arxiv.org/abs/1801.07455)
+
+
| textdet |
+ _base_ | +datasets | +icdar_datasets.py ctw1500.py ... |
+ 数据集配置 | +
| schedules | +schedule_adam_600e.py ... |
+ 训练策略配置 | +||
| default_runtime.py |
+ - | +环境配置 默认hook配置 日志配置 权重加载配置 评测配置 可视化配置 |
+ ||
| dbnet | +_base_dbnet_resnet18_fpnc.py | +- | +网络配置 数据流水线 |
+ |
| dbnet_resnet18_fpnc_1200e_icdar2015.py | +- | +Dataloader 配置 数据流水线(Optional) |
+
+
+
+
+
+
+在本教程中，我们将介绍 Dataset 类的一些常见接口，以及 MMOCR 中 Dataset 实现的使用以及它们支持的注释类型。
+
+```{tip}
+Dataset 类支持一些高级功能，例如懒加载、数据序列化、利用各种数据集包装器执行数据连接、重复和类别平衡。这些内容将不在本教程中介绍，但您可以阅读 {external+mmengine:doc}`MMEngine: BaseDataset `pred_scores`
`gt_polygons` | `recall`
`precision`
`hmean` | +| [WordMetric](#wordmetric) | 文本识别 | `pred_text`
`gt_text` | `word_acc`
`word_acc_ignore_case`
`word_acc_ignore_case_symbol` | +| [CharMetric](#charmetric) | 文本识别 | `pred_text`
`gt_text` | `char_recall`
`char_precision` | +| [OneMinusNEDMetric](#oneminusnedmetric) | 文本识别 | `pred_text`
`gt_text` | `1-N.E.D` | +| [F1Metric](#f1metric) | 关键信息抽取 | `pred_labels`
`gt_labels` | `macro_f1`
`micro_f1` | + +通常来说，每一类任务所采用的评测标准是约定俗成的，用户一般无须深入了解或手动修改评测方法的内部实现。然而，为了方便用户实现更加定制化的需求，本文档将进一步介绍了 MMOCR 内置评测算法的具体实现策略，以及可配置参数。 + +### HmeanIOUMetric + +[HmeanIOUMetric](mmocr.evaluation.metrics.hmean_iou_metric.HmeanIOUMetric) 是文本检测任务中应用最广泛的评测指标之一，因其计算了检测精度（Precision）与召回率（Recall）之间的调和平均数（Harmonic mean, H-mean），故得名 `HmeanIOUMetric`。记精度为 *P*，召回率为 *R*，则 `HmeanIOUMetric` 可由下式计算得到： + +```{math} +H = \frac{2}{\frac{1}{P} + \frac{1}{R}} = \frac{2PR}{P+R} +``` + +另外，由于其等价于 {math}`\beta = 1` 时的 F-score (又称 F-measure 或 F-metric)，`HmeanIOUMetric` 有时也被写作 `F1Metric` 或 `f1-score` 等： + +```{math} +F_1=(1+\beta^2)\cdot\frac{PR}{\beta^2\cdot P+R} = \frac{2PR}{P+R} +``` + +在 MMOCR 的设计中，`HmeanIOUMetric` 的计算可以概括为以下几个步骤： + +1. 过滤无效的预测边界盒 + + - 依据置信度阈值 `pred_score_thrs` 过滤掉得分较低的预测边界盒 + - 依据 `ignore_precision_thr` 阈值过滤掉与 `ignored` 样本重合度过高的预测边界盒 + + 值得注意的是，`pred_score_thrs` 默认将**自动搜索**一定范围内的**最佳阈值**，用户也可以通过手动修改配置文件来自定义搜索范围： + + ```python + # HmeanIOUMetric 默认以 0.1 为步长搜索 [0.3, 0.9] 范围内的最佳得分阈值 + val_evaluator = dict(type='HmeanIOUMetric', pred_score_thrs=dict(start=0.3, stop=0.9, step=0.1)) + ``` + +2. 计算 IoU 矩阵 + + - 在数据处理阶段，`HmeanIOUMetric` 会计算并维护一个 {math}`M \times N` 的 IoU 矩阵 `iou_metric`，以方便后续的边界盒配对步骤。其中，M 和 N 分别为标签边界盒与过滤后预测边界盒的数量。由此，该矩阵的每个元素都存放了第 m 个标签边界盒与第 n 个预测边界盒之间的交并比（IoU）。 + +3. 基于相应的配对策略统计能被准确匹配的 GT 样本数 + + 尽管 `HmeanIOUMetric` 可以由固定的公式计算取得，不同的任务或算法库内部的具体实现仍可能存在一些细微差别。这些差异主要体现在采用不同的策略来匹配真实与预测边界盒，从而导致最终得分的差距。目前，MMOCR 内部的 `HmeanIOUMetric` 共支持两种不同的匹配策略，即 `vanilla` 与 `max_matching`。如下所示，用户可以通过修改配置文件来指定不同的匹配策略。 + + - `vanilla` 匹配策略 + + `HmeanIOUMetric` 默认采用 `vanilla` 匹配策略，该实现与 MMOCR 0.x 版本中的 `hmean-iou` 及 ICDAR 系列**官方文本检测竞赛的评测标准保持一致**，采用先到先得的匹配方式对标签边界盒（Ground-truth bbox）与预测边界盒（Predicted bbox）进行配对。 + + ```python + # 不指定 strategy 时，HmeanIOUMetric 默认采用 'vanilla' 匹配策略 + val_evaluator = dict(type='HmeanIOUMetric') + ``` + + - `max_matching` 匹配策略 + + 针对现有匹配机制中的不完善之处，MMOCR 算法库实现了一套更高效的匹配策略，用以最大化匹配数目。 + + ```python + # 指定采用 'max_matching' 匹配策略 + val_evaluator = dict(type='HmeanIOUMetric', strategy='max_matching') + ``` + + ```{note} + 我们建议面向学术研究的开发用户采用默认的 `vanilla` 匹配策略，以保证与其他论文的对比结果保持一致。而面向工业应用的开发用户则可以采用 `max_matching` 匹配策略，以获得精准的结果。 + ``` + +4. 根据上文介绍的 `HmeanIOUMetric` 公式计算最终的评测得分 + +### WordMetric + +[WordMetric](mmocr.evaluation.metrics.recog_metric.WordMetric) 实现了**单词级别**的文本识别评测指标，并内置了 `exact`，`ignore_case`，及 `ignore_case_symbol` 三种文本匹配模式，用户可以在配置文件中修改 `mode` 字段来自由组合输出一种或多种文本匹配模式下的 `WordMetric` 得分。 + +```python +# 在文本识别任务中使用 WordMetric 评测 +val_evaluator = [ + dict(type='WordMetric', mode=['exact', 'ignore_case', 'ignore_case_symbol']) +] +``` + +- `exact`：全匹配模式，即，预测与标签完全一致才能被记录为正确样本。 +- `ignore_case`：忽略大小写的匹配模式。 +- `ignore_case_symbol`：忽略大小写及符号的匹配模式，这也是大部分学术论文中报告的文本识别准确率；MMOCR 报告的识别模型性能默认采用该匹配模式。 + +假设真实标签为 `MMOCR!`，模型的输出结果为 `mmocr`，则三种匹配模式下的 `WordMetric` 得分分别为：`{'exact': 0, 'ignore_case': 0, 'ignore_case_symbol': 1}`。 + +### CharMetric + +[CharMetric](mmocr.evaluation.metrics.recog_metric.CharMetric) 实现了**不区分大小写**的**字符级别**的文本识别评测指标。 + +```python +# 在文本识别任务中使用 CharMetric 评测 +val_evaluator = [dict(type='CharMetric')] +``` + +具体而言，`CharMetric` 会输出两个评测评测指标，即字符精度 `char_precision` 和字符召回率 `char_recall`。设正确预测的字符（True Positive）数量为 {math}`\sigma_{tp}`，则精度 *P* 和召回率 *R* 可由下式计算取得： + +```{math} +P=\frac{\sigma_{tp}}{\sigma_{pred}}, R = \frac{\sigma_{tp}}{\sigma_{gt}} +``` + +其中，{math}`\sigma_{gt}` 与 {math}`\sigma_{pred}` 分别为标签文本与预测文本所包含的字符总数。 + +例如，假设标签文本为 "MM**O**CR"，预测文本为 "mm**0**cR**1**"，则使用 `CharMetric` 评测指标的得分为： + +```{math} +P=\frac{4}{6}, R=\frac{4}{5} +``` + +### OneMinusNEDMetric + +[`OneMinusNEDMetric(1-N.E.D)`](mmocr.evaluation.metrics.recog_metric.OneMinusNEDMetric) 常用于中文或英文**文本行级别**标注的文本识别评测，不同于全匹配的评测标准要求预测与真实样本完全一致，该评测指标使用归一化的[编辑距离](https://en.wikipedia.org/wiki/Edit_distance)（Edit Distance，又名莱温斯坦距离 Levenshtein Distance）来测量预测文本与真实文本之间的差异性，从而在评测长文本样本时能够更好地区分出模型的性能差异。假设真实和预测文本分别为 {math}`s_i` 和 {math}`\hat{s_i}`，其长度分别为 {math}`l_{i}` 和 {math}`\hat{l_i}`，则 `OneMinusNEDMetric` 得分可由下式计算得到： + +```{math} +score = 1 - \frac{1}{N}\sum_{i=1}^{N}\frac{D(s_i, \hat{s_{i}})}{max(l_{i},\hat{l_{i}})} +``` + +其中，*N* 是样本总数，{math}`D(s_1, s_2)` 为两个字符串之间的编辑距离。 + +例如，假设真实标签为 "OpenMMLabMMOCR"，模型 A 的预测结果为 "0penMMLabMMOCR", 模型 B 的预测结果为 "uvwxyz"，则采用全匹配和 `OneMinusNEDMetric` 评测指标的结果分别为: + +| | | | +| ------ | ------ | ---------- | +| | 全匹配 | 1 - N.E.D. | +| 模型 A | 0 | 0.92857 | +| 模型 B | 0 | 0 | + +由上表可以发现，尽管模型 A 仅预测错了一个字母，而模型 B 全部预测错误，在使用全匹配的评测指标时，这两个模型的得分都为0；而使用 `OneMinuesNEDMetric` 的评测指标则能够更好地区分模型在**长文本**上的性能差异。 + +### F1Metric + +[F1Metric](mmocr.evaluation.metrics.f_metric.F1Metric) 实现了针对 KIE 任务的 F1-Metric 评测指标，并提供了 `micro` 和 `macro` 两种评测模式。 + +```python +val_evaluator = [ + dict(type='F1Metric', mode=['micro', 'macro'], +] +``` + +- `micro` 模式：依据 True Positive，False Negative，及 False Positive 总数来计算全局 F1-Metric 得分。 + +- `macro` 模式：依据类别标签计算每一类的 F1-Metric，并求平均值。 + +### 自定义评测指标 + +对于追求更高定制化功能的用户，MMOCR 也支持自定义实现不同类型的评测指标。一般来说，用户只需要新建自定义评测指标类 `CustomizedMetric` 并继承 {external+mmengine:doc}`MMEngine: BaseMetric
+ 
+
+
+```{note}
+如果你在没有 GUI 的服务器上运行 MMOCR，或者是通过禁用 X11 转发的 SSH 隧道运行该指令，`show` 选项将不起作用。然而，你仍然可以通过设置 `out_dir` 和 `save_vis=True` 参数将可视化数据保存到文件。阅读 [储存结果](#储存结果) 了解详情。
+```
+
+根据初始化参数，`MMOCRInferencer`可以在不同模式下运行。例如，如果初始化时指定了 `det`、`rec` 和 `kie`，它可以在 KIE 模式下运行。
+
+::::{tabs}
+
+:::{code-tab} python
+>>> kie = MMOCRInferencer(det='DBNet', rec='SAR', kie='SDMGR')
+>>> kie('demo/demo_kie.jpeg', show=True)
+:::
+
+:::{code-tab} bash 命令行
+python tools/infer.py demo/demo_kie.jpeg --det DBNet --rec SAR --kie SDMGR --show
+:::
+
+::::
+
+可视化结果如下：
+
+
+
+ 
+
+
++ +可以见到，MMOCRInferencer 的 Python 接口与命令行接口的使用方法非常相似。下文将以 Python 接口为例，介绍 MMOCRInferencer 的具体用法。关于命令行接口的更多信息，请参考 [命令行接口](#命令行接口)。 + + +```` + +````{group-tab} 标准推理器 + +通常，OpenMMLab 中的所有标准推理器都具有非常相似的接口。下面的例子展示了如何使用 `TextDetInferencer` 对单个图像进行推理。 + +```python +>>> from mmocr.apis import TextDetInferencer +>>> # 读取模型 +>>> inferencer = TextDetInferencer(model='DBNet') +>>> # 推理 +>>> inferencer('demo/demo_text_ocr.jpg', show=True) +``` + +可视化结果如图： + +
+ 
+
+
+````
+
+`````
+
+## 初始化
+
+每个推理器必须使用一个模型进行初始化。初始化时，可以手动选择推理设备。
+
+### 模型初始化
+
+`````{tabs}
+
+````{group-tab} MMOCRInferencer
+
+对于每个任务，`MMOCRInferencer` 需要两个参数 `xxx` 和 `xxx_weights` （例如 `det` 和 `det_weights`）以对模型进行初始化。此处将以`det`和`det_weights`为例来说明一些典型的初始化模型的方法。
+
+- 要用 MMOCR 的预训练模型进行推理，只需要把它的名字传给参数 `det`，权重将自动从 OpenMMLab 的模型库中下载和加载。[此处](../modelzoo.md#权重)记录了 MMOCR 中可以通过该方法初始化的所有模型。
+
+ ```python
+ >>> MMOCRInferencer(det='DBNet')
+ ```
+
+- 要加载自定义的配置和权重，你可以把配置文件的路径传给 `det`，把权重的路径传给 `det_weights`。
+
+ ```python
+ >>> MMOCRInferencer(det='path/to/dbnet_config.py', det_weights='path/to/dbnet.pth')
+ ```
+
+如果需要查看更多的初始化方法，请点击“标准推理器”选项卡。
+
+````
+
+````{group-tab} 标准推理器
+
+每个标准的 `Inferencer` 都接受两个参数，`model` 和 `weights` 。在 MMOCRInferencer 中，这两个参数分别对应 `xxx` 和 `xxx_weights` （例如 `det` 和 `det_weights`）。
+
+- `model` 接受模型的名称或配置文件的路径作为输入。模型的名称从 [model-index.yml](https://github.com/open-mmlab/mmocr/blob/1.x/model-index.yml) 中的模型的元文件（[示例](https://github.com/open-mmlab/mmocr/blob/1.x/configs/textdet/dbnet/metafile.yml) ）中获取。你可以在[此处](../modelzoo.md#权重)找到可用权重的列表。
+
+- `weights` 接受权重文件的路径。
+
+
++ +此处列举了一些常见的初始化模型的方法。 + +- 你可以通过传递模型的名称给 `model` 来推理 MMOCR 的预训练模型。权重将会自动从 OpenMMLab 的模型库中下载并加载。 + + ```python + >>> from mmocr.apis import TextDetInferencer + >>> inferencer = TextDetInferencer(model='DBNet') + ``` + + ```{note} + 模型与推理器的任务种类必须匹配。 + ``` + + 你可以通过将权重的路径或 URL 传递给 `weights` 来让推理器加载自定义的权重。 + + ```python + >>> inferencer = TextDetInferencer(model='DBNet', weights='path/to/dbnet.pth') + ``` + +- 如果有自定义的配置和权重，你可以将配置文件的路径传递给 `model`，将权重的路径传递给 `weights`。 + + ```python + >>> inferencer = TextDetInferencer(model='path/to/dbnet_config.py', weights='path/to/dbnet.pth') + ``` + +- 默认情况下，[MMEngine](https://github.com/open-mmlab/mmengine/) 会在训练模型时自动将配置文件转储到权重文件中。如果你有一个在 MMEngine 上训练的权重，你也可以将权重文件的路径传递给 `weights`，而不需要指定 `model`： + + ```python + >>> # 如果无法在权重中找到配置文件，则会引发错误 + >>> inferencer = TextDetInferencer(weights='path/to/dbnet.pth') + ``` + +- 传递配置文件到 `model` 而不指定 `weight` 则会产生一个随机初始化的模型。 + +```` +````` + +### 推理设备 + +每个推理器实例都会跟一个设备绑定。默认情况下，最佳设备是由 [MMEngine](https://github.com/open-mmlab/mmengine/) 自动决定的。你也可以通过指定 `device` 参数来改变设备。例如，你可以使用以下代码在 GPU 1上创建一个推理器。 + +`````{tabs} + +````{group-tab} MMOCRInferencer + +```python +>>> inferencer = MMOCRInferencer(det='DBNet', device='cuda:1') +``` + +```` + +````{group-tab} 标准推理器 + +```python +>>> inferencer = TextDetInferencer(model='DBNet', device='cuda:1') +``` + +```` + +````` + +如要在 CPU 上创建一个推理器： + +`````{tabs} + +````{group-tab} MMOCRInferencer + +```python +>>> inferencer = MMOCRInferencer(det='DBNet', device='cpu') +``` + +```` + +````{group-tab} 标准推理器 + +```python +>>> inferencer = TextDetInferencer(model='DBNet', device='cpu') +``` + +```` + +````` + +请参考 [torch.device](torch.device) 了解 `device` 参数支持的所有形式。 + +## 推理 + +当推理器初始化后，你可以直接传入要推理的原始数据，从返回值中获取推理结果。 + +### 输入 + +`````{tabs} + +````{tab} MMOCRInferencer / TextDetInferencer / TextRecInferencer / TextSpottingInferencer + +输入可以是以下任意一种格式： + +- str: 图像的路径/URL。 + + ```python + >>> inferencer('demo/demo_text_ocr.jpg') + ``` + +- array: 图像的 numpy 数组。它应该是 BGR 格式。 + + ```python + >>> import mmcv + >>> array = mmcv.imread('demo/demo_text_ocr.jpg') + >>> inferencer(array) + ``` + +- list: 基本类型的列表。列表中的每个元素都将单独处理。 + + ```python + >>> inferencer(['img_1.jpg', 'img_2.jpg]) + >>> # 列表内混合类型也是允许的 + >>> inferencer(['img_1.jpg', array]) + ``` + +- str: 目录的路径。目录中的所有图像都将被处理。 + + ```python + >>> inferencer('tests/data/det_toy_dataset/imgs/test/') + ``` + +```` + +````{tab} KIEInferencer + +输入可以是一个字典或者一个字典列表，其中每个字典包含以下键： + +- `img` (str 或者 ndarray): 图像的路径或图像本身。如果 KIE 推理器在无可视模式下使用，则不需要此键。如果它是一个 numpy 数组，则应该是 BGR 顺序编码的图片。 +- `img_shape` (tuple(int, int)): 图像的形状 (H, W)。仅在 KIE 推理器在无可视模式下使用且没有提供 `img` 时才需要。 +- `instances` (list[dict]): 实例列表。 + +每个 `instance` 都应该包含以下键： + +```python +{ + # 一个嵌套列表，其中包含 4 个数字，表示实例的边界框，顺序为 (x1, y1, x2, y2) + "bbox": np.array([[x1, y1, x2, y2], [x1, y1, x2, y2], ...], + dtype=np.int32), + + # 文本列表 + "texts": ['text1', 'text2', ...], +} +``` + +```` +````` + +### 输出 + +默认情况下，每个推理器都以字典格式返回预测结果。 + +- `visualization` 包含可视化的预测结果。但默认情况下，它是一个空列表，除非 `return_vis=True`。 + +- `predictions` 包含以 json-可序列化格式返回的预测结果。如下所示，内容因任务类型而异。 + + `````{tabs} + + :::{group-tab} MMOCRInferencer + + ```python + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'det_polygons': [...], # 2d 列表，长度为 (N,)，格式为 [x1, y1, x2, y2, ...] + 'det_scores': [...], # 浮点列表，长度为（N, ） + 'det_bboxes': [...], # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y] + 'rec_texts': [...], # 字符串列表，长度为（N, ） + 'rec_scores': [...], # 浮点列表，长度为（N, ） + 'kie_labels': [...], # 节点标签，长度为 (N, ) + 'kie_scores': [...], # 节点置信度，长度为 (N, ) + 'kie_edge_scores': [...], # 边预测置信度, 形状为 (N, N) + 'kie_edge_labels': [...] # 边标签, 形状为 (N, N) + }, + ... + ], + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ``` + + ::: + + ````{group-tab} 标准推理器 + + ::::{tabs} + :::{code-tab} python TextDetInferencer + + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'polygons': [...], # 2d 列表，长度为 (N,)，格式为 [x1, y1, x2, y2, ...] + 'bboxes': [...], # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y] + 'scores': [...] # 浮点列表，长度为（N, ） + }, + ... + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + + :::{code-tab} python TextRecInferencer + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'text': '...', # 字符串 + 'scores': 0.1, # 浮点 + }, + ... + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + + :::{code-tab} python TextSpottingInferencer + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'polygons': [...], # 2d 列表，长度为 (N,)，格式为 [x1, y1, x2, y2, ...] + 'bboxes': [...], # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y] + 'scores': [...] # 浮点列表，长度为（N, ） + 'texts': ['...',] # 字符串列表，长度为（N, ） + }, + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + + :::{code-tab} python KIEInferencer + { + 'predictions' : [ + # 每个实例都对应于一个输入图像 + { + 'labels': [...], # 节点标签，长度为 (N, ) + 'scores': [...], # 节点置信度，长度为 (N, ) + 'edge_scores': [...], # 边预测置信度, 形状为 (N, N) + 'edge_labels': [...], # 边标签, 形状为 (N, N) + }, + ] + 'visualization' : [ + array(..., dtype=uint8), + ] + } + ::: + :::: + ```` + + ````` + +如果你想要从模型中获取原始输出，可以将 `return_datasamples` 设置为 `True` 来获取原始的 [DataSample](structures.md)，它将存储在 `predictions` 中。 + +### 储存结果 + +除了从返回值中获取预测结果，你还可以通过设置 `out_dir` 和 `save_pred`/`save_vis` 参数将预测结果和可视化结果导出到文件中。 + +```python +>>> inferencer('img_1.jpg', out_dir='outputs/', save_pred=True, save_vis=True) +``` + +结果目录结构如下： + +```text +outputs +├── preds +│ └── img_1.json +└── vis + └── img_1.jpg +``` + +文件名与对应的输入图像文件名相同。 如果输入图像是数组，则文件名将是从0开始的数字。 + +### 批量推理 + +你可以通过设置 `batch_size` 来自定义批量推理的批大小。 默认批大小为 1。 + +## API + +这里列出了推理器详尽的参数列表。 + +````{tabs} + +```{group-tab} MMOCRInferencer + +**MMOCRInferencer.\_\_init\_\_():** + +| 参数 | 类型 | 默认值 | 描述 | +| ------------- | ----------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------ | +| `det` | str 或 [权重](../modelzoo.html#id2), 可选 | None | 预训练的文本检测算法。它是配置文件的路径或者是 metafile 中定义的模型名称。 | +| `det_weights` | str, 可选 | None | det 模型的权重文件的路径。 | +| `rec` | str 或 [权重](../modelzoo.html#id2), 可选 | None | 预训练的文本识别算法。它是配置文件的路径或者是 metafile 中定义的模型名称。 | +| `rec_weights` | str, 可选 | None | rec 模型的权重文件的路径。 | +| `kie` \[1\] | str 或 [权重](../modelzoo.html#id2), 可选 | None | 预训练的关键信息提取算法。它是配置文件的路径或者是 metafile 中定义的模型名称。 | +| `kie_weights` | str, 可选 | None | kie 模型的权重文件的路径。 | +| `device` | str, 可选 | None | 推理使用的设备，接受 `torch.device` 允许的所有字符串。例如，'cuda:0' 或 'cpu'。如果为 None，将自动使用可用设备。 默认为 None。 | + +\[1\]: 当同时指定了文本检测和识别模型时，`kie` 才会生效。 + +**MMOCRInferencer.\_\_call\_\_()** + +| 参数 | 类型 | 默认值 | 描述 | +| -------------------- | ----------------------- | ---------- | ---------------------------------------------------------------------------------------------- | +| `inputs` | str/list/tuple/np.array | **必需** | 它可以是一个图片/文件夹的路径，一个 numpy 数组，或者是一个包含图片路径或 numpy 数组的列表/元组 | +| `return_datasamples` | bool | False | 是否将结果作为 DataSample 返回。如果为 False，结果将被打包成一个字典。 | +| `batch_size` | int | 1 | 推理的批大小。 | +| `det_batch_size` | int, 可选 | None | 推理的批大小 (文本检测模型)。如果不为 None，则覆盖 batch_size。 | +| `rec_batch_size` | int, 可选 | None | 推理的批大小 (文本识别模型)。如果不为 None，则覆盖 batch_size。 | +| `kie_batch_size` | int, 可选 | None | 推理的批大小 (关键信息提取模型)。如果不为 None，则覆盖 batch_size。 | +| `return_vis` | bool | False | 是否返回可视化结果。 | +| `print_result` | bool | False | 是否将推理结果打印到控制台。 | +| `show` | bool | False | 是否在弹出窗口中显示可视化结果。 | +| `wait_time` | float | 0 | 弹窗展示可视化结果的时间间隔。 | +| `out_dir` | str | `results/` | 结果的输出目录。 | +| `save_vis` | bool | False | 是否将可视化结果保存到 `out_dir`。 | +| `save_pred` | bool | False | 是否将推理结果保存到 `out_dir`。 | + +``` + +```{group-tab} 标准推理器 + +**Inferencer.\_\_init\_\_():** + +| 参数 | 类型 | 默认值 | 描述 | +| --------- | ----------------------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------- | +| `model` | str 或 [权重](../modelzoo.html#id2), 可选 | None | 路径到配置文件或者在 metafile 中定义的模型名称。 | +| `weights` | str, 可选 | None | 权重文件的路径。 | +| `device` | str, 可选 | None | 推理使用的设备，接受 `torch.device` 允许的所有字符串。 例如，'cuda:0' 或 'cpu'。 如果为 None，则将自动使用可用设备。 默认为 None。 | + +**Inferencer.\_\_call\_\_()** + +| 参数 | 类型 | 默认值 | 描述 | +| -------------------- | ----------------------- | ---------- | ----------------------------------------------------------------------------------- | +| `inputs` | str/list/tuple/np.array | **必需** | 可以是图像的路径/文件夹，np 数组或列表/元组（带有图像路径或 np 数组） | +| `return_datasamples` | bool | False | 是否将结果作为 DataSamples 返回。 如果为 False，则结果将被打包到一个 dict 中。 | +| `batch_size` | int | 1 | 推理批大小。 | +| `progress_bar` | bool | True | 是否显示进度条。 | +| `return_vis` | bool | False | 是否返回可视化结果。 | +| `print_result` | bool | False | 是否将推理结果打印到控制台。 | +| `show` | bool | False | 是否在弹出窗口中显示可视化结果。 | +| `wait_time` | float | 0 | 弹窗展示可视化结果的时间间隔。 | +| `draw_pred` | bool | True | 是否绘制预测的边界框。 *仅适用于 `TextDetInferencer` 和 `TextSpottingInferencer`。* | +| `out_dir` | str | `results/` | 结果的输出目录。 | +| `save_vis` | bool | False | 是否将可视化结果保存到 `out_dir`。 | +| `save_pred` | bool | False | 是否将推理结果保存到 `out_dir`。 | + +``` +```` + +## 命令行接口 + +```{note} +该节仅适用于 `MMOCRInferencer`. +``` + +`MMOCRInferencer` 的命令行形式可以通过 `tools/infer.py` 调用，大致形式如下： + +```bash +python tools/infer.py INPUT_PATH [--det DET] [--det-weights ...] ... +``` + +其中，`INPUT_PATH` 为必须字段，内容应当为指向图片或文件目录的路径。其他参数与 Python 接口遵循的映射关系如下： + +- 在命令行中调用参数时，需要在 Python 接口的参数前面加上两个`-`，然后把下划线`_`替换成连字符`-`。例如， `out_dir` 会变成 `--out-dir`。 +- 对于布尔类型的参数，将参数放在命令中就相当于将其指定为 True。例如， `--show` 会将 `show` 参数指定为 True。 + +此外，命令行中默认不会回显推理结果，你可以通过 `--print-result` 参数来查看推理结果。 + +下面是一个例子： + +```bash +python tools/infer.py demo/demo_text_ocr.jpg --det DBNet --rec SAR --show --print-result +``` + +运行该命令，可以得到如下结果： + +```bash +{'predictions': [{'rec_texts': ['CBank', 'Docbcba', 'GROUP', 'MAUN', 'CROBINSONS', 'AOCOC', '916M3', 'BOO9', 'Oven', 'BRANDS', 'ARETAIL', '14', '70
+ 
+
+
++ +```bash +# 识别结果 +{'predictions': [{'rec_texts': ['cbanks', 'docecea', 'grouf', 'pwate', 'chobnsonsg', 'soxee', 'oeioh', 'c', 'sones', 'lbrandec', 'sretalg', '11', 'to8', 'round', 'sale', 'year', +'ally', 'sie', 'sall'], 'rec_scores': [...], 'det_polygons': [...], 'det_scores': +[...]}]} +``` + +```{note} +如果你在没有 GUI 的服务器上运行 MMOCR，或者通过没有开启 X11 转发的 SSH 隧道运行 MMOCR，你可能无法看到弹出的窗口。 +``` + +## 自定义安装 + +### CUDA 版本 + +安装 PyTorch 时，需要指定 CUDA 版本。如果您不清楚选择哪个，请遵循我们的建议： + +- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 series 以及 NVIDIA A100，CUDA 11 是必需的。 +- 对于更早的 NVIDIA GPU，CUDA 11 是向前兼容的，但 CUDA 10.2 能够提供更好的兼容性，也更加轻量。 + +请确保你的 GPU 驱动版本满足最低的版本需求，参阅[这张表](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。 + +```{note} +如果按照我们的最佳实践进行安装，CUDA 运行时库就足够了，因为我们提供相关 CUDA 代码的预编译，你不需要进行本地编译。 +但如果你希望从源码进行 MMCV 的编译，或是进行其他 CUDA 算子的开发，那么就必须安装完整的 CUDA 工具链，参见 +[NVIDIA 官网](https://developer.nvidia.com/cuda-downloads)，另外还需要确保该 CUDA 工具链的版本与 PyTorch 安装时 +的配置相匹配（如用 `conda install` 安装 PyTorch 时指定的 cudatoolkit 版本）。 +``` + +### 不使用 MIM 安装 MMCV + +MMCV 包含 C++ 和 CUDA 扩展，因此其对 PyTorch 的依赖比较复杂。MIM 会自动解析这些 +依赖，选择合适的 MMCV 预编译包，使安装更简单，但它并不是必需的。 + +要使用 pip 而不是 MIM 来安装 MMCV，请遵照 [MMCV 安装指南](https://mmcv.readthedocs.io/zh_CN/latest/get_started/installation.html)。 +它需要你用指定 url 的形式手动指定对应的 PyTorch 和 CUDA 版本。 + +举个例子，如下命令将会安装基于 PyTorch 1.10.x 和 CUDA 11.3 编译的 mmcv-full。 + +```shell +pip install 'mmcv>=2.0.0rc1' -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html +``` + +### 在 CPU 环境中安装 + +MMOCR 可以仅在 CPU 环境中安装，在 CPU 模式下，你可以完成训练（需要 MMCV 版本 >= 1.4.4）、测试和模型推理等所有操作。 + +在 CPU 模式下，MMCV 中的以下算子将不可用： + +- Deformable Convolution +- Modulated Deformable Convolution +- ROI pooling +- SyncBatchNorm + +如果你尝试使用用到了以上算子的模型进行训练、测试或推理，程序将会报错。以下为可能受到影响的模型列表： + +| 算子 | 模型 | +| :-----------------------------------------------------: | :-----------------------------------------------------: | +| Deformable Convolution/Modulated Deformable Convolution | DBNet (r50dcnv2), DBNet++ (r50dcnv2), FCENet (r50dcnv2) | +| SyncBatchNorm | PANet, PSENet | + +### 通过 Docker 使用 MMOCR + +我们提供了一个 [Dockerfile](https://github.com/open-mmlab/mmocr/blob/master/docker/Dockerfile) 文件以建立 docker 镜像 。 + +```shell +# build an image with PyTorch 1.6, CUDA 10.1 +docker build -t mmocr docker/ +``` + +使用以下命令运行。 + +```shell +docker run --gpus all --shm-size=8g -it -v {实际数据目录}:/mmocr/data mmocr +``` + +## 对 MMEngine、MMCV 和 MMDetection 的版本依赖 + +为了确保代码实现的正确性，MMOCR 每个版本都有可能改变对 MMEngine、MMCV 和 MMDetection 版本的依赖。请根据以下表格确保版本之间的相互匹配。 + +| MMOCR | MMEngine | MMCV | MMDetection | +| -------------- | --------------------------- | -------------------------- | --------------------------- | +| dev-1.x | 0.7.1 \<= mmengine \< 1.1.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.2.0 | +| 1.0.1 | 0.7.1 \<= mmengine \< 1.1.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.2.0 | +| 1.0.0 | 0.7.1 \<= mmengine \< 1.0.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.1.0 | +| 1.0.0rc6 | 0.6.0 \<= mmengine \< 1.0.0 | 2.0.0rc4 \<= mmcv \< 2.1.0 | 3.0.0rc5 \<= mmdet \< 3.1.0 | +| 1.0.0rc\[4-5\] | 0.1.0 \<= mmengine \< 1.0.0 | 2.0.0rc1 \<= mmcv \< 2.1.0 | 3.0.0rc0 \<= mmdet \< 3.1.0 | +| 1.0.0rc\[0-3\] | 0.0.0 \<= mmengine \< 0.2.0 | 2.0.0rc1 \<= mmcv \< 2.1.0 | 3.0.0rc0 \<= mmdet \< 3.1.0 | diff --git a/internlm_langchain/knowledge_base/MMOCR/content/kie.md b/internlm_langchain/knowledge_base/MMOCR/content/kie.md new file mode 100644 index 00000000..ce8d1462 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/kie.md @@ -0,0 +1,40 @@ +# 关键信息提取 + +```{note} +我们正努力往 [Dataset Preparer](./dataset_preparer.md) 中增加更多数据集。对于 [Dataset Preparer](./dataset_preparer.md) 暂未能完整支持的数据集，本页提供了一系列手动下载的步骤，供有需要的用户使用。 +``` + +## 概览 + +关键信息提取任务的数据集，文件目录应按如下配置： + +```text +└── wildreceipt + ├── class_list.txt + ├── dict.txt + ├── image_files + ├── test.txt + └── train.txt +``` + +## 准备步骤 + +### WildReceipt + +- 下载并解压 [wildreceipt.tar](https://download.openmmlab.com/mmocr/data/wildreceipt.tar) + +### WildReceiptOpenset + +- 准备好 [WildReceipt](#WildReceipt)。 +- 转换 WildReceipt 成 OpenSet 格式: + +```bash +# 你可以运行以下命令以获取更多可用参数： +# python tools/data/kie/closeset_to_openset.py -h +python tools/data/kie/closeset_to_openset.py data/wildreceipt/train.txt data/wildreceipt/openset_train.txt +python tools/data/kie/closeset_to_openset.py data/wildreceipt/test.txt data/wildreceipt/openset_test.txt +``` + +```{note} +[这篇教程](../tutorials/kie_closeset_openset.md)里讲述了更多 CloseSet 和 OpenSet 数据格式之间的区别。 +``` diff --git a/internlm_langchain/knowledge_base/MMOCR/content/model.md b/internlm_langchain/knowledge_base/MMOCR/content/model.md new file mode 100644 index 00000000..0e276513 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/model.md @@ -0,0 +1,5 @@ +# 预训练模型迁移指南 + +由于在新版本中我们对模型的结构进行了大量的重构和修复，MMOCR 1.x 并不能直接读入旧版的预训练权重。我们在网站上同步更新了所有模型的预训练权重和log，供有需要的用户使用。 + +此外，我们正在进行针对文本检测任务的权重迁移工具的开发，并计划于近期版本内发布。由于文本识别和关键信息提取模型改动过大，且迁移是有损的，我们暂时不计划作相应支持。如果您有具体的需求，欢迎通过 [Issue](https://github.com/open-mmlab/mmocr/issues) 向我们提问。 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/models.md b/internlm_langchain/knowledge_base/MMOCR/content/models.md new file mode 100644 index 00000000..7ec449d5 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/models.md @@ -0,0 +1,3 @@ +# 模型\[待更新\] + +待更新 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/news.md b/internlm_langchain/knowledge_base/MMOCR/content/news.md new file mode 100644 index 00000000..e1ca6f91 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/news.md @@ -0,0 +1,19 @@ +# MMOCR 1.x 更新汇总 + +此处列出了 MMOCR 1.x 相对于 0.x 版本的重大更新。 + +1. 架构升级：MMOCR 1.x 是基于 [MMEngine](https://github.com/open-mmlab/mmengine)，提供了一个通用的、强大的执行器，允许更灵活的定制，提供了统一的训练和测试入口。 + +2. 统一接口：MMOCR 1.x 统一了数据集、模型、评估和可视化的接口和内部逻辑。支持更强的扩展性。 + +3. 跨项目调用：受益于统一的设计，你可以使用其他OpenMMLab项目中实现的模型，如MMDet。 我们提供了一个例子，说明如何通过MMDetWrapper使用MMDetection的Mask R-CNN。查看我们的文档以了解更多细节。更多的包装器将在未来发布。 + +4. 更强的可视化：我们提供了一系列可视化工具， 用户现在可以更方便可视化数据。 + +5. 更多的文档和教程：我们增加了更多的教程，降低用户的学习门槛。 + +6. 一站式数据准备：准备数据集已经不再是难事。使用我们的 [Dataset Preparer](https://mmocr.readthedocs.io/zh_CN/dev-1.x/user_guides/data_prepare/dataset_preparer.html)，一行命令即可让多个数据集准备就绪。 + +7. 拥抱更多 `projects/`: 我们推出了 `projects/` 文件夹，用于存放一些实验性的新特性、框架和模型。我们对这个文件夹下的代码规范不作过多要求，力求让社区的所有想法第一时间得到实现和展示。请查看我们的[样例 project](https://github.com/open-mmlab/mmocr/blob/dev-1.x/projects/example_project/) 以了解更多。 + +8. 更多新模型：MMOCR 1.0 支持了更多模型和模型种类。 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/overview.md b/internlm_langchain/knowledge_base/MMOCR/content/overview.md new file mode 100644 index 00000000..bbd72139 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/overview.md @@ -0,0 +1,3 @@ +# 设计理念与特性\[待更新\] + +待更新 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/quick_run.md b/internlm_langchain/knowledge_base/MMOCR/content/quick_run.md new file mode 100644 index 00000000..bcca7370 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/quick_run.md @@ -0,0 +1,201 @@ +# 快速运行 + +这个章节会介绍 MMOCR 的一些基本功能。我们假设你已经[从源码安装了 MMOCR](install.md#best-practices)。此外，你也可以通过[教程 Notebook](https://colab.research.google.com/github/open-mmlab/mmocr/blob/dev-1.x/demo/tutorial.ipynb)来了解如何在交互式环境下实现推理、训练和测试。 + +## 推理 + +在 MMOCR 的根目录下运行以下命令： + +```shell +python tools/infer.py demo/demo_text_ocr.jpg --det DBNet --rec CRNN --show --print-result +``` + +你可以看到弹出的预测结果，以及在控制台中打印出的推理结果。 + +
+
+
+
++ +```bash +# 识别结果 +{'predictions': [{'rec_texts': ['cbanks', 'docecea', 'grouf', 'pwate', 'chobnsonsg', 'soxee', 'oeioh', 'c', 'sones', 'lbrandec', 'sretalg', '11', 'to8', 'round', 'sale', 'year', +'ally', 'sie', 'sall'], 'rec_scores': [...], 'det_polygons': [...], 'det_scores': +[...]}]} +``` + +```{note} +如果你在没有 GUI 的服务器上运行 MMOCR，或者通过没有开启 X11 转发的 SSH 隧道运行 MMOCR，你可能无法看到弹出的窗口。 +``` + +对 MMOCR 中推理接口更为详细的说明，可以在[这里](../user_guides/inference.md)找到。 + +除了使用我们提供好的预训练模型，用户也可以在自己的数据集上训练流行模型。接下来我们以在迷你的 [ICDAR 2015](https://rrc.cvc.uab.es/?ch=4&com=downloads) 数据集上训练 DBNet 为例，带大家熟悉 MMOCR 的基本功能。 + +## 准备数据集 + +由于 OCR 任务的数据集种类多样，格式不一，不利于多数据集的切换和联合训练，因此 MMOCR 约定了一种[统一的数据格式](../user_guides/dataset_prepare.md)，并针对常用的 OCR 数据集提供了[一键式数据准备脚本](../user_guides/data_prepare/dataset_preparer.md)。通常，要在 MMOCR 中使用数据集，你只需要按照对应步骤运行指令即可。 + +```{note} +但我们亦深知，效率就是生命——尤其对想要快速上手 MMOCR 的你来说。 +``` + +在这里，我们准备了一个用于演示的精简版 ICDAR 2015 数据集。下载我们预先准备好的[压缩包](https://download.openmmlab.com/mmocr/data/icdar2015/mini_icdar2015.tar.gz)，解压到 mmocr 的 `data/` 目录下，就能得到我们准备好的图片和标注文件。 + +```Bash +wget https://download.openmmlab.com/mmocr/data/icdar2015/mini_icdar2015.tar.gz +mkdir -p data/ +tar xzvf mini_icdar2015.tar.gz -C data/ +``` + +## 修改配置 + +准备好数据集后，我们接下来就需要通过修改配置的方式指定训练集的位置和训练参数。 + +在这个例子中，我们将会训练一个以 resnet18 作为骨干网络（backbone）的 DBNet。由于 MMOCR 已经有针对完整 ICDAR 2015 数据集的配置 （`configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py`），我们只需要在它的基础上作出一点修改。 + +我们首先需要修改数据集的路径。在这个配置中，大部分关键的配置文件都在 `_base_` 中被导入，如数据库的配置就来自 `configs/textdet/_base_/datasets/icdar2015.py`。打开该文件，把第一行 `icdar2015_textdet_data_root` 指向的路径替换： + +```Python +icdar2015_textdet_data_root = 'data/mini_icdar2015' +``` + +另外，因为数据集尺寸缩小了，我们也要相应地减少训练的轮次到 400，缩短验证和储存权重的间隔到10轮，并放弃学习率衰减策略。直接把以下几行配置放入 `configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py`即可生效： + +```Python +# 每 10 个 epoch 储存一次权重，且只保留最后一个权重 +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=10, + max_keep_ckpts=1, + )) +# 设置最大 epoch 数为 400，每 10 个 epoch 运行一次验证 +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=400, val_interval=10) +# 令学习率为常量，即不进行学习率衰减 +param_scheduler = [dict(type='ConstantLR', factor=1.0),] +``` + +这里，我们通过配置的继承 ({external+mmengine:doc}`MMEngine: Config
+
+ 
+
+
+```{note}
+有关更多可视化功能的介绍，请参阅[这里](../user_guides/visualization.md)。
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/structures.md b/internlm_langchain/knowledge_base/MMOCR/content/structures.md
new file mode 100644
index 00000000..857a356f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/structures.md
@@ -0,0 +1,219 @@
+# 数据元素与数据结构
+
+MMOCR 基于 {external+mmengine:doc}`MMEngine: 抽象数据接口 +
+
+
+
+(绿色框为真实标注，红色框为预测结果)
+
+
+
+
+
+
+
+（绿色字体为真实标注，红色字体为预测结果）
+
+
+
+
+
+
+
+（从左至右分别为：原图，文本检测和识别结果，文本分类结果，关系图）
+
+
+
+```bash
+# 示例1：每间隔 2 秒绘制出
+python tools/test.py configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth --show --wait-time 2
+
+# 示例2：对于不支持图形化界面的系统（如计算集群等），可以将可视化结果存入指定路径
+python tools/test.py configs/textdet/dbnet/dbnet_r50dcnv2_fpnc_1200e_icdar2015.py dbnet_r50.pth --show-dir ./vis_results
+```
+
+`tools/test.py` 中可视化相关参数说明：
+
+| 参数 | 类型 | 说明 |
+| ----------- | ----- | -------------------------------- |
+| --show | bool | 是否绘制可视化结果。 |
+| --show-dir | str | 可视化图片存储路径。 |
+| --wait-time | float | 可视化间隔时间（秒），默认为 2。 |
+
+### 测试时数据增强
+
+测试时增强，指的是在推理（预测）阶段，将原始图片进行水平翻转、垂直翻转、对角线翻转、旋转角度等数据增强操作，得到多张图，分别进行推理，再对多个结果进行综合分析，得到最终输出结果。
+为此，MMOCR 提供了一键式测试时数据增强，仅需在测试时添加 `--tta` 参数即可。
+
+```{note}
+TTA 仅支持文本识别模型。
+```
+
+```bash
+python tools/test.py configs/textrecog/crnn/crnn_mini-vgg_5e_mj.py checkpoints/crnn_mini-vgg_5e_mj.pth --tta
+```
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/transforms.md b/internlm_langchain/knowledge_base/MMOCR/content/transforms.md
new file mode 100644
index 00000000..cc07c986
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/transforms.md
@@ -0,0 +1,227 @@
+# 数据变换与流水线
+
+在 MMOCR 的设计中，数据集的构建与数据准备是相互解耦的。也就是说，[`OCRDataset`](mmocr.datasets.ocr_dataset.OCRDataset) 等数据集构建类负责完成标注文件的读取与解析功能；而数据变换方法（Data Transforms）则进一步实现了数据预处理、数据增强、数据格式化等相关功能。目前，如下表所示，MMOCR 中共实现了 5 类数据变换方法：
+
+| | | |
+| -------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| 数据变换类型 | 对应文件 | 功能说明 |
+| 数据读取 | loading.py | 实现了不同格式数据的读取功能。 |
+| 数据格式化 | formatting.py | 完成不同任务所需数据的格式化功能。 |
+| 跨库数据适配器 | adapters.py | 负责 OpenMMLab 项目内跨库调用的数据格式转换功能。 |
+| 数据增强 | ocr_transforms.pytextdet_transforms.py
textrecog_transforms.py | 实现了不同任务下的各类数据增强方法。 | +| 包装类 | wrappers.py | 实现了对 ImgAug 等常用算法库的包装，使其适配 MMOCR 的内部数据格式。 | + +由于每一个数据变换类之间都是相互独立的，因此，在约定好固定的数据存储字段后，我们可以便捷地采用任意的数据变换组合来构建数据流水线（Pipeline）。如下图所示，在 MMOCR 中，一个典型的训练数据流水线主要由**数据读取**、**图像增强**以及**数据格式化**三部分构成，用户只需要在配置文件中定义相关的数据流水线列表，并指定具体所需的数据变换类及其参数即可： + +
+
+
+
+
+
+```python
+train_pipeline_r18 = [
+ # 数据读取（图像）
+ dict(
+ type='LoadImageFromFile',
+ color_type='color_ignore_orientation'),
+ # 数据读取（标注）
+ dict(
+ type='LoadOCRAnnotations',
+ with_polygon=True,
+ with_bbox=True,
+ with_label=True,
+ ),
+ # 使用 ImgAug 作数据增强
+ dict(
+ type='ImgAugWrapper',
+ args=[['Fliplr', 0.5],
+ dict(cls='Affine', rotate=[-10, 10]), ['Resize', [0.5, 3.0]]]),
+ # 使用 MMOCR 内置的图像增强
+ dict(type='RandomCrop', min_side_ratio=0.1),
+ dict(type='Resize', scale=(640, 640), keep_ratio=True),
+ dict(type='Pad', size=(640, 640)),
+ # 数据格式化
+ dict(
+ type='PackTextDetInputs',
+ meta_keys=('img_path', 'ori_shape', 'img_shape'))
+]
+```
+
+```{tip}
+更多有关数据流水线配置的教程可见[配置文档](../user_guides/config.md#数据流水线配置)。下面，我们将简单介绍 MMOCR 中已支持的数据变换类型。
+```
+
+对于每一个数据变换方法，MMOCR 都严格按照文档字符串（docstring）规范在源码中提供了详细的代码注释。例如，每一个数据转换类的头部我们都注释了 “需求字段”（`Required keys`）， “修改字段”（`Modified Keys`）与 “添加字段”（`Added Keys`）。其中，“需求字段”代表该数据转换方法对于输入数据所需包含字段的强制需求，而“修改字段”与“添加字段”则表明该方法可能会在原有数据基础之上修改或添加的字段。例如，`LoadImageFromFile` 实现了图片的读取功能，其需求字段为图像的存储路径 `img_path`，而修改字段则包括了读入的图像信息 `img`，以及图片当前尺寸 `img_shape`，图片原始尺寸 `ori_shape` 等图片属性。
+
+```python
+@TRANSFORMS.register_module()
+class LoadImageFromFile(MMCV_LoadImageFromFile):
+ # 在每一个数据变换方法的头部，我们都提供了详细的代码注释。
+ """Load an image from file.
+
+ Required Keys:
+
+ - img_path
+
+ Modified Keys:
+
+ - img
+ - img_shape
+ - ori_shape
+ """
+```
+
+```{note}
+在 MMOCR 的数据流水线中，图像及标签等信息被统一保存在字典中。通过统一的字段名，我们可以在不同的数据变换方法间灵活地传递数据。因此，了解 MMOCR 中常用的约定字段名是非常重要的。
+```
+
+为方便用户查询，下表列出了 MMOCR 中各数据转换（Data Transform）类常用的字段约定和说明。
+
+| | | |
+| ---------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| 字段 | 类型 | 说明 |
+| img | `np.array(dtype=np.uint8)` | 图像信息，形状为 `(h, w, c)`。 |
+| img_shape | `tuple(int, int)` | 当前图像尺寸 `(h, w)`。 |
+| ori_shape | `tuple(int, int)` | 图像在初始化时的尺寸 `(h, w)`。 |
+| scale | `tuple(int, int)` | 存放用户在 Resize 系列数据变换（Transform）中指定的目标图像尺寸 `(h, w)`。注意：该值未必与变换后的实际图像尺寸相符。 |
+| scale_factor | `tuple(float, float)` | 存放用户在 Resize 系列数据变换（Transform）中指定的目标图像缩放因子 `(w_scale, h_scale)`。注意：该值未必与变换后的实际图像尺寸相符。 |
+| keep_ratio | `bool` | 是否按等比例对图像进行缩放。 |
+| flip | `bool` | 图像是否被翻转。 |
+| flip_direction | `str` | 翻转方向。可选项为 `horizontal`, `vertical`, `diagonal`。 |
+| gt_bboxes | `np.array(dtype=np.float32)` | 文本实例边界框的真实标签。 |
+| gt_polygons | `list[np.array(dtype=np.float32)` | 文本实例边界多边形的真实标签。 |
+| gt_bboxes_labels | `np.array(dtype=np.int64)` | 文本实例对应的类别标签。在 MMOCR 中通常为 0，代指 "text" 类别。 |
+| gt_texts | `list[str]` | 与文本实例对应的字符串标注。 |
+| gt_ignored | `np.array(dtype=np.bool_)` | 是否要在计算目标时忽略该实例（用于检测任务中）。 |
+
+## 数据读取 - loading.py
+
+数据读取类主要实现了不同文件格式、后端读取图片及加载标注信息的功能。目前，MMOCR 内部共实现了以下数据读取类的 Data Transforms：
+
+| | | | |
+| ------------------ | --------------------------------------------------------- | -------------------------------------------------------------- | --------------------------------------------------------------- |
+| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 |
+| LoadImageFromFile | `img_path` | `img``img_shape`
`ori_shape` | 从图片路径读取图片，支持多种文件存储后端（如 `disk`, `http`, `petrel` 等）及图片解码后端（如 `cv2`, `turbojpeg`, `pillow`, `tifffile`等）。 | +| LoadOCRAnnotations | `bbox`
`bbox_label`
`polygon`
`ignore`
`text` | `gt_bboxes`
`gt_bboxes_labels`
`gt_polygons`
`gt_ignored`
`gt_texts` | 解析 OCR 任务所需的标注信息。 | +| LoadKIEAnnotations | `bboxes` `bbox_labels` `edge_labels`
`texts` | `gt_bboxes`
`gt_bboxes_labels`
`gt_edge_labels`
`gt_texts`
`ori_shape` | 解析 KIE 任务所需的标注信息。 | + +## 数据增强 - xxx_transforms.py + +数据增强是文本检测、识别等任务中必不可少的流程之一。目前，MMOCR 中共实现了数十种文本领域内常用的数据增强模块，依据其任务类型，分别为通用 OCR 数据增强模块 [ocr_transforms.py](/mmocr/datasets/transforms/ocr_transforms.py)，文本检测数据增强模块 [textdet_transforms.py](/mmocr/datasets/transforms/textdet_transforms.py)，以及文本识别数据增强模块 [textrecog_transforms.py](/mmocr/datasets/transforms/textrecog_transforms.py)。 + +具体而言，`ocr_transforms.py` 中实现了随机剪裁、随机旋转等各任务通用的数据增强模块： + +| | | | | +| -------------- | -------------------------------------------------------------- | -------------------------------------------------------------- | -------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| RandomCrop | `img`
`gt_bboxes`
`gt_bboxes_labels`
`gt_polygons`
`gt_ignored`
`gt_texts` (optional) | `img`
`img_shape`
`gt_bboxes`
`gt_bboxes_labels`
`gt_polygons`
`gt_ignored`
`gt_texts` (optional) | 随机裁剪，并确保裁剪后的图片至少包含一个文本实例。可选参数为 `min_side_ratio`，用以控制裁剪图片的短边占原始图片的比例，默认值为 `0.4`。 | +| RandomRotate | `img`
`img_shape`
`gt_bboxes` (optional)
`gt_polygons` (optional) | `img`
`img_shape`
`gt_bboxes` (optional)
`gt_polygons` (optional)
`rotated_angle` | 随机旋转，并可选择对旋转后图像的黑边进行填充。 | +| | | | | + +`textdet_transforms.py` 则实现了文本检测任务中常用的数据增强模块： + +| | | | | +| ----------------- | ------------------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| RandomFlip | `img`
`gt_bboxes`
`gt_polygons` | `img`
`gt_bboxes`
`gt_polygons`
`flip`
`flip_direction` | 随机翻转，支持水平、垂直和对角三种方向的图像翻转。默认使用水平翻转。 | +| FixInvalidPolygon | `gt_polygons`
`gt_ignored` | `gt_polygons`
`gt_ignored` | 自动修复或忽略非法多边形标注。 | + +`textrecog_transforms.py` 中实现了文本识别任务中常用的数据增强模块： + +| | | | | +| --------------- | -------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| RescaleToHeight | `img` | `img`
`img_shape`
`scale`
`scale_factor`
`keep_ratio` | 缩放图像至指定高度，并尽可能保持长宽比不变。当 `min_width` 及 `max_width` 被指定时，长宽比则可能会被改变。 | +| | | | | + +```{warning} +以上表格仅选择性地对部分数据增强方法作简要介绍，更多数据增强方法介绍请参考[API 文档](../api.rst)或阅读代码内的文档注释。 +``` + +## 数据格式化 - formatting.py + +数据格式化负责将图像、真实标签以及其它常用信息等打包成一个字典。不同的任务通常依赖于不同的数据格式化数据变换类。例如： + +| | | | | +| ------------------- | -------- | ------------- | ------------------------------------------ | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| PackTextDetInputs | - | - | 用于打包文本检测任务所需要的输入信息。 | +| PackTextRecogInputs | - | - | 用于打包文本识别任务所需要的输入信息。 | +| PackKIEInputs | - | - | 用于打包关键信息抽取任务所需要的输入信息。 | + +## 跨库数据适配器 - adapters.py + +跨库数据适配器打通了 MMOCR 与其他 OpenMMLab 系列算法库如 [MMDetection](https://github.com/open-mmlab/mmdetection) 之间的数据格式，使得跨项目调用其它开源算法库的配置文件及算法成为了可能。目前，MMOCR 实现了 `MMDet2MMOCR` 以及 `MMOCR2MMDet`，使得数据可以在 MMDetection 与 MMOCR 的格式之间自由转换；借助这些适配转换器，用户可以在 MMOCR 算法库内部轻松调用任何 MMDetection 已支持的检测算法，并在 OCR 相关数据集上进行训练。例如，我们以 Mask R-CNN 为例提供了[教程](#todo)，展示了如何在 MMOCR 中使用 MMDetection 的检测算法训练文本检测器。 + +| | | | | +| -------------- | -------------------------------------------- | ----------------------------- | ---------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| MMDet2MMOCR | `gt_masks` `gt_ignore_flags` | `gt_polygons`
`gt_ignored` | 将 MMDet 中采用的字段转换为对应的 MMOCR 字段。 | +| MMOCR2MMDet | `img_shape`
`gt_polygons`
`gt_ignored` | `gt_masks` `gt_ignore_flags` | 将 MMOCR 中采用的字段转换为对应的 MMDet 字段。 | + +## 包装类 - wrappers.py + +为了方便用户在 MMOCR 内部无缝调用常用的 CV 算法库，我们在 wrappers.py 中提供了相应的包装类。其主要打通了 MMOCR 与其它第三方算法库之间的数据格式和转换标准，使得用户可以在 MMOCR 的配置文件内直接配置使用这些第三方库提供的数据变换方法。目前支持的包装类有： + +| | | | | +| ------------------ | ------------------------------------------------------------ | ------------------------------------------------------------- | ------------------------------------------------------------- | +| 数据转换类名称 | 需求字段 | 修改/添加字段 | 说明 | +| ImgAugWrapper | `img`
`gt_polygons` (optional for text recognition)
`gt_bboxes` (optional for text recognition)
`gt_bboxes_labels` (optional for text recognition)
`gt_ignored` (optional for text recognition)
`gt_texts` (optional) | `img`
`gt_polygons` (optional for text recognition)
`gt_bboxes` (optional for text recognition)
`gt_bboxes_labels` (optional for text recognition)
`gt_ignored` (optional for text recognition)
`img_shape` (optional)
`gt_texts` (optional) | [ImgAug](https://github.com/aleju/imgaug) 包装类，用于打通 ImgAug 与 MMOCR 的数据格式及配置，方便用户调用 ImgAug 实现的一系列数据增强方法。 | +| TorchVisionWrapper | `img` | `img`
`img_shape` | [TorchVision](https://github.com/pytorch/vision) 包装类，用于打通 TorchVision 与 MMOCR 的数据格式及配置，方便用户调用 `torchvision.transforms` 中实现的一系列数据变换方法。 | + +### `ImgAugWrapper` 示例 + +例如，在原生的 ImgAug 中，我们可以按照如下代码定义一个 `Sequential` 类型的数据增强流程，对图像分别进行随机翻转、随机旋转和随机缩放： + +```python +import imgaug.augmenters as iaa + +aug = iaa.Sequential( + iaa.Fliplr(0.5), # 以概率 0.5 进行水平翻转 + iaa.Affine(rotate=(-10, 10)), # 随机旋转 -10 到 10 度 + iaa.Resize((0.5, 3.0)) # 随机缩放到 50% 到 300% 的尺寸 +) +``` + +而在 MMOCR 中，我们可以通过 `ImgAugWrapper` 包装类，将上述数据增强流程直接配置到 `train_pipeline` 中： + +```python +dict( + type='ImgAugWrapper', + args=[ + ['Fliplr', 0.5], + dict(cls='Affine', rotate=[-10, 10]), + ['Resize', [0.5, 3.0]], + ] +) +``` + +其中，`args` 参数接收一个列表，列表中的每个元素可以是一个列表，也可以是一个字典。如果是列表，则列表的第一个元素为 `imgaug.augmenters` 中的类名，后面的元素为该类的初始化参数；如果是字典，则字典的 `cls` 键对应 `imgaug.augmenters` 中的类名，其他键值对则对应该类的初始化参数。 + +### `TorchVisionWrapper` 示例 + +例如，在原生的 TorchVision 中，我们可以按照如下代码定义一个 `Compose` 类型的数据变换流程，对图像进行色彩抖动： + +```python +import torchvision.transforms as transforms + +aug = transforms.Compose([ + transforms.ColorJitter( + brightness=32.0 / 255, # 亮度抖动范围 + saturation=0.5) # 饱和度抖动范围 +]) +``` + +而在 MMOCR 中，我们可以通过 `TorchVisionWrapper` 包装类，将上述数据变换流程直接配置到 `train_pipeline` 中： + +```python +dict( + type='TorchVisionWrapper', + op='ColorJitter', + brightness=32.0 / 255, + saturation=0.5 +) +``` + +其中，`op` 参数为 `torchvision.transforms` 中的类名，后面的参数则对应该类的初始化参数。 diff --git a/internlm_langchain/knowledge_base/MMOCR/content/useful_tools.md b/internlm_langchain/knowledge_base/MMOCR/content/useful_tools.md new file mode 100644 index 00000000..2a607245 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMOCR/content/useful_tools.md @@ -0,0 +1,241 @@ +# 常用工具 + +## 可视化工具 + +### 数据集可视化工具 + +MMOCR 提供了数据集可视化工具 `tools/visualizations/browse_datasets.py` 以辅助用户排查可能遇到的数据集相关的问题。用户只需要指定所使用的训练配置文件（通常存放在如 `configs/textdet/dbnet/xxx.py` 文件中）或数据集配置（通常存放在 `configs/textdet/_base_/datasets/xxx.py` 文件中）路径。该工具将依据输入的配置文件类型自动将经过数据流水线（data pipeline）处理过的图像及其对应的标签，或原始图片及其对应的标签绘制出来。 + +#### 支持参数 + +```bash +python tools/visualizations/browse_dataset.py \ + ${CONFIG_FILE} \ + [-o, --output-dir ${OUTPUT_DIR}] \ + [-p, --phase ${DATASET_PHASE}] \ + [-m, --mode ${DISPLAY_MODE}] \ + [-t, --task ${DATASET_TASK}] \ + [-n, --show-number ${NUMBER_IMAGES_DISPLAY}] \ + [-i, --show-interval ${SHOW_INTERRVAL}] \ + [--cfg-options ${CFG_OPTIONS}] +``` + +| 参数名 | 类型 | 描述 | +| ------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | +| config | str | (必须) 配置文件路径。 | +| -o, --output-dir | str | 如果图形化界面不可用，请指定一个输出路径来保存可视化结果。 | +| -p, --phase | str | 用于指定需要可视化的数据集切片，如 "train", "test", "val"。当数据集存在多个变种时，也可以通过该参数来指定待可视化的切片。 | +| -m, --mode | `original`, `transformed`, `pipeline` | 用于指定数据可视化的模式。`original`：原始模式，仅可视化数据集的原始标注；`transformed`：变换模式，展示经过所有数据变换步骤的最终图像；`pipeline`：流水线模式，展示数据变换过程中每一个中间步骤的变换图像。默认使用 `transformed` 变换模式。 | +| -t, --task | `auto`, `textdet`, `textrecog` | 用于指定可视化数据集的任务类型。`auto`：自动模式，将依据给定的配置文件自动选择合适的任务类型，如果无法自动获取任务类型，则需要用户手动指定为 `textdet` 文本检测任务 或 `textrecog` 文本识别任务。默认采用 `auto` 自动模式。 | +| -n, --show-number | int | 指定需要可视化的样本数量。若该参数缺省则默认将可视化全部图片。 | +| -i, --show-interval | float | 可视化图像间隔时间，默认为 2 秒。 | +| --cfg-options | float | 用于覆盖配置文件中的参数，详见[示例](./config.md#command-line-modification)。 | + +#### 用法示例 + +以下示例演示了如何使用该工具可视化 "DBNet_R50_icdar2015" 模型使用的训练数据。 + +```Bash +# 使用默认参数可视化 "dbnet_r50dcn_v2_fpnc_1200e_icadr2015" 模型的训练数据 +python tools/visualizations/browse_dataset.py configs/textdet/dbnet/dbnet_resnet50-dcnv2_fpnc_1200e_icdar2015.py +``` + +默认情况下，可视化模式为 "transformed"，您将看到经由数据流水线变换过后的图像和标注： + +
+
+
+
+
+如果只想查看预测结果信息可以只让`draw_pred=True`
+
+```Python
+visualization = _base_.default_hooks.visualization
+visualization.update(
+ dict(enable=True, show=True, draw_gt=False, draw_pred=True))
+```
+
+
+
+
+
+
+在 `test.py` 过程中进一步简化，提供了 `--show` 和 `--show-dir`两个参数，无需修改配置即可视化测试过程中绘制标注和预测结果。
+
+```Shell
+# 展示test 结果
+python tools/test.py configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py dbnet_r18_fpnc_1200e_icdar2015/epoch_400.pth --show
+
+# 指定预测结果的存储位置
+python tools/test.py configs/textdet/dbnet/dbnet_resnet18_fpnc_1200e_icdar2015.py dbnet_r18_fpnc_1200e_icdar2015/epoch_400.pth --show-dir imgs/
+```
+
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMOCR/content/visualizers.md b/internlm_langchain/knowledge_base/MMOCR/content/visualizers.md
new file mode 100644
index 00000000..323dc0a2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMOCR/content/visualizers.md
@@ -0,0 +1,3 @@
+# 可视化组件\[待更新\]
+
+待更新
diff --git a/internlm_langchain/knowledge_base/MMOCR/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMOCR/vector_store/index.faiss
new file mode 100644
index 00000000..3e74d49d
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMOCR/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMPose/content/2d_animal_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/2d_animal_keypoint.md
new file mode 100644
index 00000000..28b0b726
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/2d_animal_keypoint.md
@@ -0,0 +1,545 @@
+# 2D Animal Keypoint Dataset
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- [Animal-Pose](#animal-pose) \[ [Homepage](https://sites.google.com/view/animal-pose/) \]
+- [AP-10K](#ap-10k) \[ [Homepage](https://github.com/AlexTheBad/AP-10K/) \]
+- [Horse-10](#horse-10) \[ [Homepage](http://www.mackenziemathislab.org/horse10) \]
+- [MacaquePose](#macaquepose) \[ [Homepage](http://www.pri.kyoto-u.ac.jp/datasets/macaquepose/index.html) \]
+- [Vinegar Fly](#vinegar-fly) \[ [Homepage](https://github.com/jgraving/DeepPoseKit-Data) \]
+- [Desert Locust](#desert-locust) \[ [Homepage](https://github.com/jgraving/DeepPoseKit-Data) \]
+- [Grévy’s Zebra](#grvys-zebra) \[ [Homepage](https://github.com/jgraving/DeepPoseKit-Data) \]
+- [ATRW](#atrw) \[ [Homepage](https://cvwc2019.github.io/challenge.html) \]
+- [Animal Kingdom](#Animal-Kindom) \[ [Homepage](https://openaccess.thecvf.com/content/CVPR2022/html/Ng_Animal_Kingdom_A_Large_and_Diverse_Dataset_for_Animal_Behavior_CVPR_2022_paper.html) \]
+
+## Animal-Pose
+
+
+
+
+
+
+
+Animal-Pose (ICCV'2019)
+ +```bibtex +@InProceedings{Cao_2019_ICCV, + author = {Cao, Jinkun and Tang, Hongyang and Fang, Hao-Shu and Shen, Xiaoyong and Lu, Cewu and Tai, Yu-Wing}, + title = {Cross-Domain Adaptation for Animal Pose Estimation}, + booktitle = {The IEEE International Conference on Computer Vision (ICCV)}, + month = {October}, + year = {2019} +} +``` + +
+ 
+
+
+For [Animal-Pose](https://sites.google.com/view/animal-pose/) dataset, we prepare the dataset as follows:
+
+1. Download the images of [PASCAL VOC2012](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/#data), especially the five categories (dog, cat, sheep, cow, horse), which we use as trainval dataset.
+2. Download the [test-set](https://drive.google.com/drive/folders/1DwhQobZlGntOXxdm7vQsE4bqbFmN3b9y?usp=sharing) images with raw annotations (1000 images, 5 categories).
+3. We have pre-processed the annotations to make it compatible with MMPose. Please download the annotation files from [annotations](https://download.openmmlab.com/mmpose/datasets/animalpose_annotations.tar). If you would like to generate the annotations by yourself, please check our dataset parsing [codes](/tools/dataset_converters/parse_animalpose_dataset.py).
+
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── animalpose
+ │
+ │-- VOC2012
+ │ │-- Annotations
+ │ │-- ImageSets
+ │ │-- JPEGImages
+ │ │-- SegmentationClass
+ │ │-- SegmentationObject
+ │
+ │-- animalpose_image_part2
+ │ │-- cat
+ │ │-- cow
+ │ │-- dog
+ │ │-- horse
+ │ │-- sheep
+ │
+ │-- annotations
+ │ │-- animalpose_train.json
+ │ |-- animalpose_val.json
+ │ |-- animalpose_trainval.json
+ │ │-- animalpose_test.json
+ │
+ │-- PASCAL2011_animal_annotation
+ │ │-- cat
+ │ │ |-- 2007_000528_1.xml
+ │ │ |-- 2007_000549_1.xml
+ │ │ │-- ...
+ │ │-- cow
+ │ │-- dog
+ │ │-- horse
+ │ │-- sheep
+ │
+ │-- annimalpose_anno2
+ │ │-- cat
+ │ │ |-- ca1.xml
+ │ │ |-- ca2.xml
+ │ │ │-- ...
+ │ │-- cow
+ │ │-- dog
+ │ │-- horse
+ │ │-- sheep
+
+```
+
+The official dataset does not provide the official train/val/test set split.
+We choose the images from PascalVOC for train & val. In total, we have 3608 images and 5117 annotations for train+val, where
+2798 images with 4000 annotations are used for training, and 810 images with 1117 annotations are used for validation.
+Those images from other sources (1000 images with 1000 annotations) are used for testing.
+
+## AP-10K
+
+
+
+
+
+
+
+AP-10K (NeurIPS'2021)
+ +```bibtex +@misc{yu2021ap10k, + title={AP-10K: A Benchmark for Animal Pose Estimation in the Wild}, + author={Hang Yu and Yufei Xu and Jing Zhang and Wei Zhao and Ziyu Guan and Dacheng Tao}, + year={2021}, + eprint={2108.12617}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` + +
+ 
+
+
+For [AP-10K](https://github.com/AlexTheBad/AP-10K/) dataset, images and annotations can be downloaded from [download](https://drive.google.com/file/d/1-FNNGcdtAQRehYYkGY1y4wzFNg4iWNad/view?usp=sharing).
+Note, this data and annotation data is for non-commercial use only.
+
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── ap10k
+ │-- annotations
+ │ │-- ap10k-train-split1.json
+ │ |-- ap10k-train-split2.json
+ │ |-- ap10k-train-split3.json
+ │ │-- ap10k-val-split1.json
+ │ |-- ap10k-val-split2.json
+ │ |-- ap10k-val-split3.json
+ │ |-- ap10k-test-split1.json
+ │ |-- ap10k-test-split2.json
+ │ |-- ap10k-test-split3.json
+ │-- data
+ │ │-- 000000000001.jpg
+ │ │-- 000000000002.jpg
+ │ │-- ...
+
+```
+
+The annotation files in 'annotation' folder contains 50 labeled animal species. There are total 10,015 labeled images with 13,028 instances in the AP-10K dataset. We randonly split them into train, val, and test set following the ratio of 7:1:2.
+
+## Horse-10
+
+
+
+
+
+
+
+Horse-10 (WACV'2021)
+ +```bibtex +@inproceedings{mathis2021pretraining, + title={Pretraining boosts out-of-domain robustness for pose estimation}, + author={Mathis, Alexander and Biasi, Thomas and Schneider, Steffen and Yuksekgonul, Mert and Rogers, Byron and Bethge, Matthias and Mathis, Mackenzie W}, + booktitle={Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision}, + pages={1859--1868}, + year={2021} +} +``` + +
+ 
+
+
+For [Horse-10](http://www.mackenziemathislab.org/horse10) dataset, images can be downloaded from [download](http://www.mackenziemathislab.org/horse10).
+Please download the annotation files from [horse10_annotations](https://download.openmmlab.com/mmpose/datasets/horse10_annotations.tar). Note, this data and annotation data is for non-commercial use only, per the authors (see http://horse10.deeplabcut.org for more information).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── horse10
+ │-- annotations
+ │ │-- horse10-train-split1.json
+ │ |-- horse10-train-split2.json
+ │ |-- horse10-train-split3.json
+ │ │-- horse10-test-split1.json
+ │ |-- horse10-test-split2.json
+ │ |-- horse10-test-split3.json
+ │-- labeled-data
+ │ │-- BrownHorseinShadow
+ │ │-- BrownHorseintoshadow
+ │ │-- ...
+
+```
+
+## MacaquePose
+
+
+
+
+
+
+
+MacaquePose (bioRxiv'2020)
+ +```bibtex +@article{labuguen2020macaquepose, + title={MacaquePose: A novel ‘in the wild’macaque monkey pose dataset for markerless motion capture}, + author={Labuguen, Rollyn and Matsumoto, Jumpei and Negrete, Salvador and Nishimaru, Hiroshi and Nishijo, Hisao and Takada, Masahiko and Go, Yasuhiro and Inoue, Ken-ichi and Shibata, Tomohiro}, + journal={bioRxiv}, + year={2020}, + publisher={Cold Spring Harbor Laboratory} +} +``` + +
+ 
+
+
+For [MacaquePose](http://www.pri.kyoto-u.ac.jp/datasets/macaquepose/index.html) dataset, images can be downloaded from [download](http://www.pri.kyoto-u.ac.jp/datasets/macaquepose/index.html).
+Please download the annotation files from [macaque_annotations](https://download.openmmlab.com/mmpose/datasets/macaque_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── macaque
+ │-- annotations
+ │ │-- macaque_train.json
+ │ |-- macaque_test.json
+ │-- images
+ │ │-- 01418849d54b3005.jpg
+ │ │-- 0142d1d1a6904a70.jpg
+ │ │-- 01ef2c4c260321b7.jpg
+ │ │-- 020a1c75c8c85238.jpg
+ │ │-- 020b1506eef2557d.jpg
+ │ │-- ...
+
+```
+
+Since the official dataset does not provide the test set, we randomly select 12500 images for training, and the rest for evaluation (see [code](/tools/dataset/parse_macaquepose_dataset.py)).
+
+## Vinegar Fly
+
+
+
+
+
+
+
+Vinegar Fly (Nature Methods'2019)
+ +```bibtex +@article{pereira2019fast, + title={Fast animal pose estimation using deep neural networks}, + author={Pereira, Talmo D and Aldarondo, Diego E and Willmore, Lindsay and Kislin, Mikhail and Wang, Samuel S-H and Murthy, Mala and Shaevitz, Joshua W}, + journal={Nature methods}, + volume={16}, + number={1}, + pages={117--125}, + year={2019}, + publisher={Nature Publishing Group} +} +``` + +
+ 
+
+
+For [Vinegar Fly](https://github.com/jgraving/DeepPoseKit-Data) dataset, images can be downloaded from [vinegar_fly_images](https://download.openmmlab.com/mmpose/datasets/vinegar_fly_images.tar).
+Please download the annotation files from [vinegar_fly_annotations](https://download.openmmlab.com/mmpose/datasets/vinegar_fly_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── fly
+ │-- annotations
+ │ │-- fly_train.json
+ │ |-- fly_test.json
+ │-- images
+ │ │-- 0.jpg
+ │ │-- 1.jpg
+ │ │-- 2.jpg
+ │ │-- 3.jpg
+ │ │-- ...
+
+```
+
+Since the official dataset does not provide the test set, we randomly select 90% images for training, and the rest (10%) for evaluation (see [code](/tools/dataset_converters/parse_deepposekit_dataset.py)).
+
+## Desert Locust
+
+
+
+
+
+
+
+Desert Locust (Elife'2019)
+ +```bibtex +@article{graving2019deepposekit, + title={DeepPoseKit, a software toolkit for fast and robust animal pose estimation using deep learning}, + author={Graving, Jacob M and Chae, Daniel and Naik, Hemal and Li, Liang and Koger, Benjamin and Costelloe, Blair R and Couzin, Iain D}, + journal={Elife}, + volume={8}, + pages={e47994}, + year={2019}, + publisher={eLife Sciences Publications Limited} +} +``` + +
+ 
+
+
+For [Desert Locust](https://github.com/jgraving/DeepPoseKit-Data) dataset, images can be downloaded from [locust_images](https://download.openmmlab.com/mmpose/datasets/locust_images.tar).
+Please download the annotation files from [locust_annotations](https://download.openmmlab.com/mmpose/datasets/locust_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── locust
+ │-- annotations
+ │ │-- locust_train.json
+ │ |-- locust_test.json
+ │-- images
+ │ │-- 0.jpg
+ │ │-- 1.jpg
+ │ │-- 2.jpg
+ │ │-- 3.jpg
+ │ │-- ...
+
+```
+
+Since the official dataset does not provide the test set, we randomly select 90% images for training, and the rest (10%) for evaluation (see [code](/tools/dataset_converters/parse_deepposekit_dataset.py)).
+
+## Grévy’s Zebra
+
+
+
+
+
+
+
+Grévy’s Zebra (Elife'2019)
+ +```bibtex +@article{graving2019deepposekit, + title={DeepPoseKit, a software toolkit for fast and robust animal pose estimation using deep learning}, + author={Graving, Jacob M and Chae, Daniel and Naik, Hemal and Li, Liang and Koger, Benjamin and Costelloe, Blair R and Couzin, Iain D}, + journal={Elife}, + volume={8}, + pages={e47994}, + year={2019}, + publisher={eLife Sciences Publications Limited} +} +``` + +
+ 
+
+
+For [Grévy’s Zebra](https://github.com/jgraving/DeepPoseKit-Data) dataset, images can be downloaded from [zebra_images](https://download.openmmlab.com/mmpose/datasets/zebra_images.tar).
+Please download the annotation files from [zebra_annotations](https://download.openmmlab.com/mmpose/datasets/zebra_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── zebra
+ │-- annotations
+ │ │-- zebra_train.json
+ │ |-- zebra_test.json
+ │-- images
+ │ │-- 0.jpg
+ │ │-- 1.jpg
+ │ │-- 2.jpg
+ │ │-- 3.jpg
+ │ │-- ...
+
+```
+
+Since the official dataset does not provide the test set, we randomly select 90% images for training, and the rest (10%) for evaluation (see [code](/tools/dataset_converters/parse_deepposekit_dataset.py)).
+
+## ATRW
+
+
+
+
+
+
+
+ATRW (ACM MM'2020)
+ +```bibtex +@inproceedings{li2020atrw, + title={ATRW: A Benchmark for Amur Tiger Re-identification in the Wild}, + author={Li, Shuyuan and Li, Jianguo and Tang, Hanlin and Qian, Rui and Lin, Weiyao}, + booktitle={Proceedings of the 28th ACM International Conference on Multimedia}, + pages={2590--2598}, + year={2020} +} +``` + +
+ 
+
+
+ATRW captures images of the Amur tiger (also known as Siberian tiger, Northeast-China tiger) in the wild.
+For [ATRW](https://cvwc2019.github.io/challenge.html) dataset, please download images from
+[Pose_train](https://lilablobssc.blob.core.windows.net/cvwc2019/train/atrw_pose_train.tar.gz),
+[Pose_val](https://lilablobssc.blob.core.windows.net/cvwc2019/train/atrw_pose_val.tar.gz), and
+[Pose_test](https://lilablobssc.blob.core.windows.net/cvwc2019/test/atrw_pose_test.tar.gz).
+Note that in the ATRW official annotation files, the key "file_name" is written as "filename". To make it compatible with
+other coco-type json files, we have modified this key.
+Please download the modified annotation files from [atrw_annotations](https://download.openmmlab.com/mmpose/datasets/atrw_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── atrw
+ │-- annotations
+ │ │-- keypoint_train.json
+ │ │-- keypoint_val.json
+ │ │-- keypoint_trainval.json
+ │-- images
+ │ │-- train
+ │ │ │-- 000002.jpg
+ │ │ │-- 000003.jpg
+ │ │ │-- ...
+ │ │-- val
+ │ │ │-- 000001.jpg
+ │ │ │-- 000013.jpg
+ │ │ │-- ...
+ │ │-- test
+ │ │ │-- 000000.jpg
+ │ │ │-- 000004.jpg
+ │ │ │-- ...
+
+```
+
+## Animal Kingdom
+
+
+
+
+ 
+
+
+```bibtex
+@inproceedings{Ng_2022_CVPR,
+ author = {Ng, Xun Long and Ong, Kian Eng and Zheng, Qichen and Ni, Yun and Yeo, Si Yong and Liu, Jun},
+ title = {Animal Kingdom: A Large and Diverse Dataset for Animal Behavior Understanding},
+ booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+ month = {June},
+ year = {2022},
+ pages = {19023-19034}
+ }
+```
+
+For [Animal Kingdom](https://github.com/sutdcv/Animal-Kingdom) dataset, images can be downloaded from [here](https://forms.office.com/pages/responsepage.aspx?id=drd2NJDpck-5UGJImDFiPVRYpnTEMixKqPJ1FxwK6VZUQkNTSkRISTNORUI2TDBWMUpZTlQ5WUlaSyQlQCN0PWcu).
+Please Extract dataset under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── ak
+ |--annotations
+ │ │-- ak_P1
+ │ │ │-- train.json
+ │ │ │-- test.json
+ │ │-- ak_P2
+ │ │ │-- train.json
+ │ │ │-- test.json
+ │ │-- ak_P3_amphibian
+ │ │ │-- train.json
+ │ │ │-- test.json
+ │ │-- ak_P3_bird
+ │ │ │-- train.json
+ │ │ │-- test.json
+ │ │-- ak_P3_fish
+ │ │ │-- train.json
+ │ │ │-- test.json
+ │ │-- ak_P3_mammal
+ │ │ │-- train.json
+ │ │ │-- test.json
+ │ │-- ak_P3_reptile
+ │ │-- train.json
+ │ │-- test.json
+ │-- images
+ │ │-- AAACXZTV
+ │ │ │--AAACXZTV_f000059.jpg
+ │ │ │--...
+ │ │-- AAAUILHH
+ │ │ │--AAAUILHH_f000098.jpg
+ │ │ │--...
+ │ │-- ...
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/2d_body_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/2d_body_keypoint.md
new file mode 100644
index 00000000..4448ebe8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/2d_body_keypoint.md
@@ -0,0 +1,588 @@
+# 2D Body Keypoint Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- Images
+ - [COCO](#coco) \[ [Homepage](http://cocodataset.org/) \]
+ - [MPII](#mpii) \[ [Homepage](http://human-pose.mpi-inf.mpg.de/) \]
+ - [MPII-TRB](#mpii-trb) \[ [Homepage](https://github.com/kennymckormick/Triplet-Representation-of-human-Body) \]
+ - [AI Challenger](#aic) \[ [Homepage](https://github.com/AIChallenger/AI_Challenger_2017) \]
+ - [CrowdPose](#crowdpose) \[ [Homepage](https://github.com/Jeff-sjtu/CrowdPose) \]
+ - [OCHuman](#ochuman) \[ [Homepage](https://github.com/liruilong940607/OCHumanApi) \]
+ - [MHP](#mhp) \[ [Homepage](https://lv-mhp.github.io/dataset) \]
+ - [Human-Art](#humanart) \[ [Homepage](https://idea-research.github.io/HumanArt/) \]
+- Videos
+ - [PoseTrack18](#posetrack18) \[ [Homepage](https://posetrack.net/users/download.php) \]
+ - [sub-JHMDB](#sub-jhmdb-dataset) \[ [Homepage](http://jhmdb.is.tue.mpg.de/dataset) \]
+
+## COCO
+
+
+
+
+
+
+COCO (ECCV'2014)
+ +```bibtex +@inproceedings{lin2014microsoft, + title={Microsoft coco: Common objects in context}, + author={Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C Lawrence}, + booktitle={European conference on computer vision}, + pages={740--755}, + year={2014}, + organization={Springer} +} +``` + +
+ 
+
+
+For [COCO](http://cocodataset.org/) data, please download from [COCO download](http://cocodataset.org/#download), 2017 Train/Val is needed for COCO keypoints training and validation.
+[HRNet-Human-Pose-Estimation](https://github.com/HRNet/HRNet-Human-Pose-Estimation) provides person detection result of COCO val2017 to reproduce our multi-person pose estimation results.
+Please download from [OneDrive](https://1drv.ms/f/s!AhIXJn_J-blWzzDXoz5BeFl8sWM-) or [GoogleDrive](https://drive.google.com/drive/folders/1fRUDNUDxe9fjqcRZ2bnF_TKMlO0nB_dk?usp=sharing).
+Optionally, to evaluate on COCO'2017 test-dev, please download the [image-info](https://download.openmmlab.com/mmpose/datasets/person_keypoints_test-dev-2017.json).
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── coco
+ │-- annotations
+ │ │-- person_keypoints_train2017.json
+ │ |-- person_keypoints_val2017.json
+ │ |-- person_keypoints_test-dev-2017.json
+ |-- person_detection_results
+ | |-- COCO_val2017_detections_AP_H_56_person.json
+ | |-- COCO_test-dev2017_detections_AP_H_609_person.json
+ │-- train2017
+ │ │-- 000000000009.jpg
+ │ │-- 000000000025.jpg
+ │ │-- 000000000030.jpg
+ │ │-- ...
+ `-- val2017
+ │-- 000000000139.jpg
+ │-- 000000000285.jpg
+ │-- 000000000632.jpg
+ │-- ...
+
+```
+
+## MPII
+
+
+
+
+
+
+
+MPII (CVPR'2014)
+ +```bibtex +@inproceedings{andriluka14cvpr, + author = {Mykhaylo Andriluka and Leonid Pishchulin and Peter Gehler and Schiele, Bernt}, + title = {2D Human Pose Estimation: New Benchmark and State of the Art Analysis}, + booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2014}, + month = {June} +} +``` + +
+ 
+
+
+For [MPII](http://human-pose.mpi-inf.mpg.de/) data, please download from [MPII Human Pose Dataset](http://human-pose.mpi-inf.mpg.de/).
+We have converted the original annotation files into json format, please download them from [mpii_annotations](https://download.openmmlab.com/mmpose/datasets/mpii_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── mpii
+ |── annotations
+ | |── mpii_gt_val.mat
+ | |── mpii_test.json
+ | |── mpii_train.json
+ | |── mpii_trainval.json
+ | `── mpii_val.json
+ `── images
+ |── 000001163.jpg
+ |── 000003072.jpg
+
+```
+
+During training and inference, the prediction result will be saved as '.mat' format by default. We also provide a tool to convert this '.mat' to more readable '.json' format.
+
+```shell
+python tools/dataset/mat2json ${PRED_MAT_FILE} ${GT_JSON_FILE} ${OUTPUT_PRED_JSON_FILE}
+```
+
+For example,
+
+```shell
+python tools/dataset/mat2json work_dirs/res50_mpii_256x256/pred.mat data/mpii/annotations/mpii_val.json pred.json
+```
+
+## MPII-TRB
+
+
+
+
+
+
+
+MPII-TRB (ICCV'2019)
+ +```bibtex +@inproceedings{duan2019trb, + title={TRB: A Novel Triplet Representation for Understanding 2D Human Body}, + author={Duan, Haodong and Lin, Kwan-Yee and Jin, Sheng and Liu, Wentao and Qian, Chen and Ouyang, Wanli}, + booktitle={Proceedings of the IEEE International Conference on Computer Vision}, + pages={9479--9488}, + year={2019} +} +``` + +
+ 
+
+
+For [MPII-TRB](https://github.com/kennymckormick/Triplet-Representation-of-human-Body) data, please download from [MPII Human Pose Dataset](http://human-pose.mpi-inf.mpg.de/).
+Please download the annotation files from [mpii_trb_annotations](https://download.openmmlab.com/mmpose/datasets/mpii_trb_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── mpii
+ |── annotations
+ | |── mpii_trb_train.json
+ | |── mpii_trb_val.json
+ `── images
+ |── 000001163.jpg
+ |── 000003072.jpg
+
+```
+
+## AIC
+
+
+
+
+
+
+
+AI Challenger (ArXiv'2017)
+ +```bibtex +@article{wu2017ai, + title={Ai challenger: A large-scale dataset for going deeper in image understanding}, + author={Wu, Jiahong and Zheng, He and Zhao, Bo and Li, Yixin and Yan, Baoming and Liang, Rui and Wang, Wenjia and Zhou, Shipei and Lin, Guosen and Fu, Yanwei and others}, + journal={arXiv preprint arXiv:1711.06475}, + year={2017} +} +``` + +
+ 
+
+
+For [AIC](https://github.com/AIChallenger/AI_Challenger_2017) data, please download from [AI Challenger 2017](https://github.com/AIChallenger/AI_Challenger_2017), 2017 Train/Val is needed for keypoints training and validation.
+Please download the annotation files from [aic_annotations](https://download.openmmlab.com/mmpose/datasets/aic_annotations.tar).
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── aic
+ │-- annotations
+ │ │-- aic_train.json
+ │ |-- aic_val.json
+ │-- ai_challenger_keypoint_train_20170902
+ │ │-- keypoint_train_images_20170902
+ │ │ │-- 0000252aea98840a550dac9a78c476ecb9f47ffa.jpg
+ │ │ │-- 000050f770985ac9653198495ef9b5c82435d49c.jpg
+ │ │ │-- ...
+ `-- ai_challenger_keypoint_validation_20170911
+ │-- keypoint_validation_images_20170911
+ │-- 0002605c53fb92109a3f2de4fc3ce06425c3b61f.jpg
+ │-- 0003b55a2c991223e6d8b4b820045bd49507bf6d.jpg
+ │-- ...
+```
+
+## CrowdPose
+
+
+
+
+
+
+
+CrowdPose (CVPR'2019)
+ +```bibtex +@article{li2018crowdpose, + title={CrowdPose: Efficient Crowded Scenes Pose Estimation and A New Benchmark}, + author={Li, Jiefeng and Wang, Can and Zhu, Hao and Mao, Yihuan and Fang, Hao-Shu and Lu, Cewu}, + journal={arXiv preprint arXiv:1812.00324}, + year={2018} +} +``` + +
+ 
+
+
+For [CrowdPose](https://github.com/Jeff-sjtu/CrowdPose) data, please download from [CrowdPose](https://github.com/Jeff-sjtu/CrowdPose).
+Please download the annotation files and human detection results from [crowdpose_annotations](https://download.openmmlab.com/mmpose/datasets/crowdpose_annotations.tar).
+For top-down approaches, we follow [CrowdPose](https://arxiv.org/abs/1812.00324) to use the [pre-trained weights](https://pjreddie.com/media/files/yolov3.weights) of [YOLOv3](https://github.com/eriklindernoren/PyTorch-YOLOv3) to generate the detected human bounding boxes.
+For model training, we follow [HigherHRNet](https://github.com/HRNet/HigherHRNet-Human-Pose-Estimation) to train models on CrowdPose train/val dataset, and evaluate models on CrowdPose test dataset.
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── crowdpose
+ │-- annotations
+ │ │-- mmpose_crowdpose_train.json
+ │ │-- mmpose_crowdpose_val.json
+ │ │-- mmpose_crowdpose_trainval.json
+ │ │-- mmpose_crowdpose_test.json
+ │ │-- det_for_crowd_test_0.1_0.5.json
+ │-- images
+ │-- 100000.jpg
+ │-- 100001.jpg
+ │-- 100002.jpg
+ │-- ...
+```
+
+## OCHuman
+
+
+
+
+
+
+
+OCHuman (CVPR'2019)
+ +```bibtex +@inproceedings{zhang2019pose2seg, + title={Pose2seg: Detection free human instance segmentation}, + author={Zhang, Song-Hai and Li, Ruilong and Dong, Xin and Rosin, Paul and Cai, Zixi and Han, Xi and Yang, Dingcheng and Huang, Haozhi and Hu, Shi-Min}, + booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition}, + pages={889--898}, + year={2019} +} +``` + +
+
+
+
+For [OCHuman](https://github.com/liruilong940607/OCHumanApi) data, please download the images and annotations from [OCHuman](https://github.com/liruilong940607/OCHumanApi),
+Move them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── ochuman
+ │-- annotations
+ │ │-- ochuman_coco_format_val_range_0.00_1.00.json
+ │ |-- ochuman_coco_format_test_range_0.00_1.00.json
+ |-- images
+ │-- 000001.jpg
+ │-- 000002.jpg
+ │-- 000003.jpg
+ │-- ...
+
+```
+
+## MHP
+
+
+
+
+
+
+
+MHP (ACM MM'2018)
+ +```bibtex +@inproceedings{zhao2018understanding, + title={Understanding humans in crowded scenes: Deep nested adversarial learning and a new benchmark for multi-human parsing}, + author={Zhao, Jian and Li, Jianshu and Cheng, Yu and Sim, Terence and Yan, Shuicheng and Feng, Jiashi}, + booktitle={Proceedings of the 26th ACM international conference on Multimedia}, + pages={792--800}, + year={2018} +} +``` + +
+ 
+
+
+For [MHP](https://lv-mhp.github.io/dataset) data, please download from [MHP](https://lv-mhp.github.io/dataset).
+Please download the annotation files from [mhp_annotations](https://download.openmmlab.com/mmpose/datasets/mhp_annotations.tar.gz).
+Please download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── mhp
+ │-- annotations
+ │ │-- mhp_train.json
+ │ │-- mhp_val.json
+ │
+ `-- train
+ │ │-- images
+ │ │ │-- 1004.jpg
+ │ │ │-- 10050.jpg
+ │ │ │-- ...
+ │
+ `-- val
+ │ │-- images
+ │ │ │-- 10059.jpg
+ │ │ │-- 10068.jpg
+ │ │ │-- ...
+ │
+ `-- test
+ │ │-- images
+ │ │ │-- 1005.jpg
+ │ │ │-- 10052.jpg
+ │ │ │-- ...~~~~
+```
+
+## Human-Art dataset
+
+
+
+
+
+
+
+Human-Art (CVPR'2023)
+ +```bibtex +@inproceedings{ju2023humanart, + title={Human-Art: A Versatile Human-Centric Dataset Bridging Natural and Artificial Scenes}, + author={Ju, Xuan and Zeng, Ailing and Jianan, Wang and Qiang, Xu and Lei, Zhang}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), + year={2023}} +``` + +
+
+
+
+For [Human-Art](https://idea-research.github.io/HumanArt/) data, please download the images and annotation files from [its website](https://idea-research.github.io/HumanArt/). You need to fill in the [data form](https://docs.google.com/forms/d/e/1FAIpQLScroT_jvw6B9U2Qca1_cl5Kmmu1ceKtlh6DJNmWLte8xNEhEw/viewform) to get access to the data.
+Move them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+|── data
+ │── HumanArt
+ │-- images
+ │ │-- 2D_virtual_human
+ │ │ |-- cartoon
+ │ │ | |-- 000000000000.jpg
+ │ │ | |-- ...
+ │ │ |-- digital_art
+ │ │ |-- ...
+ │ |-- 3D_virtual_human
+ │ |-- real_human
+ |-- annotations
+ │ │-- validation_humanart.json
+ │ │-- training_humanart_coco.json
+ |-- person_detection_results
+ │ │-- HumanArt_validation_detections_AP_H_56_person.json
+```
+
+You can choose whether to download other annotation files in Human-Art. If you want to use additional annotation files (e.g. validation set of cartoon), you need to edit the corresponding code in config file.
+
+## PoseTrack18
+
+
+
+
+
+
+
+PoseTrack18 (CVPR'2018)
+ +```bibtex +@inproceedings{andriluka2018posetrack, + title={Posetrack: A benchmark for human pose estimation and tracking}, + author={Andriluka, Mykhaylo and Iqbal, Umar and Insafutdinov, Eldar and Pishchulin, Leonid and Milan, Anton and Gall, Juergen and Schiele, Bernt}, + booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, + pages={5167--5176}, + year={2018} +} +``` + +
+ 
+
+
+For [PoseTrack18](https://posetrack.net/users/download.php) data, please download from [PoseTrack18](https://posetrack.net/users/download.php).
+Please download the annotation files from [posetrack18_annotations](https://download.openmmlab.com/mmpose/datasets/posetrack18_annotations.tar).
+We have merged the video-wise separated official annotation files into two json files (posetrack18_train & posetrack18_val.json). We also generate the [mask files](https://download.openmmlab.com/mmpose/datasets/posetrack18_mask.tar) to speed up training.
+For top-down approaches, we use [MMDetection](https://github.com/open-mmlab/mmdetection) pre-trained [Cascade R-CNN](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco/cascade_rcnn_x101_64x4d_fpn_20e_coco_20200509_224357-051557b1.pth) (X-101-64x4d-FPN) to generate the detected human bounding boxes.
+Please download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── posetrack18
+ │-- annotations
+ │ │-- posetrack18_train.json
+ │ │-- posetrack18_val.json
+ │ │-- posetrack18_val_human_detections.json
+ │ │-- train
+ │ │ │-- 000001_bonn_train.json
+ │ │ │-- 000002_bonn_train.json
+ │ │ │-- ...
+ │ │-- val
+ │ │ │-- 000342_mpii_test.json
+ │ │ │-- 000522_mpii_test.json
+ │ │ │-- ...
+ │ `-- test
+ │ │-- 000001_mpiinew_test.json
+ │ │-- 000002_mpiinew_test.json
+ │ │-- ...
+ │
+ `-- images
+ │ │-- train
+ │ │ │-- 000001_bonn_train
+ │ │ │ │-- 000000.jpg
+ │ │ │ │-- 000001.jpg
+ │ │ │ │-- ...
+ │ │ │-- ...
+ │ │-- val
+ │ │ │-- 000342_mpii_test
+ │ │ │ │-- 000000.jpg
+ │ │ │ │-- 000001.jpg
+ │ │ │ │-- ...
+ │ │ │-- ...
+ │ `-- test
+ │ │-- 000001_mpiinew_test
+ │ │ │-- 000000.jpg
+ │ │ │-- 000001.jpg
+ │ │ │-- ...
+ │ │-- ...
+ `-- mask
+ │-- train
+ │ │-- 000002_bonn_train
+ │ │ │-- 000000.jpg
+ │ │ │-- 000001.jpg
+ │ │ │-- ...
+ │ │-- ...
+ `-- val
+ │-- 000522_mpii_test
+ │ │-- 000000.jpg
+ │ │-- 000001.jpg
+ │ │-- ...
+ │-- ...
+```
+
+The official evaluation tool for PoseTrack should be installed from GitHub.
+
+```shell
+pip install git+https://github.com/svenkreiss/poseval.git
+```
+
+## sub-JHMDB dataset
+
+
+
+
+
+
+
+RSN (ECCV'2020)
+ +```bibtex +@misc{cai2020learning, + title={Learning Delicate Local Representations for Multi-Person Pose Estimation}, + author={Yuanhao Cai and Zhicheng Wang and Zhengxiong Luo and Binyi Yin and Angang Du and Haoqian Wang and Xinyu Zhou and Erjin Zhou and Xiangyu Zhang and Jian Sun}, + year={2020}, + eprint={2003.04030}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` + +
+ 
+
+
+For [sub-JHMDB](http://jhmdb.is.tue.mpg.de/dataset) data, please download the [images](<(http://files.is.tue.mpg.de/jhmdb/Rename_Images.tar.gz)>) from [JHMDB](http://jhmdb.is.tue.mpg.de/dataset),
+Please download the annotation files from [jhmdb_annotations](https://download.openmmlab.com/mmpose/datasets/jhmdb_annotations.tar).
+Move them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── jhmdb
+ │-- annotations
+ │ │-- Sub1_train.json
+ │ |-- Sub1_test.json
+ │ │-- Sub2_train.json
+ │ |-- Sub2_test.json
+ │ │-- Sub3_train.json
+ │ |-- Sub3_test.json
+ |-- Rename_Images
+ │-- brush_hair
+ │ │--April_09_brush_hair_u_nm_np1_ba_goo_0
+ | │ │--00001.png
+ | │ │--00002.png
+ │-- catch
+ │-- ...
+
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/2d_face_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/2d_face_keypoint.md
new file mode 100644
index 00000000..62f66bd8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/2d_face_keypoint.md
@@ -0,0 +1,384 @@
+# 2D Face Keypoint Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- [300W](#300w-dataset) \[ [Homepage](https://ibug.doc.ic.ac.uk/resources/300-W/) \]
+- [WFLW](#wflw-dataset) \[ [Homepage](https://wywu.github.io/projects/LAB/WFLW.html) \]
+- [AFLW](#aflw-dataset) \[ [Homepage](https://www.tugraz.at/institute/icg/research/team-bischof/lrs/downloads/aflw/) \]
+- [COFW](#cofw-dataset) \[ [Homepage](http://www.vision.caltech.edu/xpburgos/ICCV13/) \]
+- [COCO-WholeBody-Face](#coco-wholebody-face) \[ [Homepage](https://github.com/jin-s13/COCO-WholeBody/) \]
+- [LaPa](#lapa-dataset) \[ [Homepage](https://github.com/JDAI-CV/lapa-dataset) \]
+
+## 300W Dataset
+
+
+
+
+
+
+
+300W (IMAVIS'2016)
+ +```bibtex +@article{sagonas2016300, + title={300 faces in-the-wild challenge: Database and results}, + author={Sagonas, Christos and Antonakos, Epameinondas and Tzimiropoulos, Georgios and Zafeiriou, Stefanos and Pantic, Maja}, + journal={Image and vision computing}, + volume={47}, + pages={3--18}, + year={2016}, + publisher={Elsevier} +} +``` + +
+ 
+
+
+For 300W data, please download images from [300W Dataset](https://ibug.doc.ic.ac.uk/resources/300-W/).
+Please download the annotation files from [300w_annotations](https://download.openmmlab.com/mmpose/datasets/300w_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── 300w
+ |── annotations
+ | |── face_landmarks_300w_train.json
+ | |── face_landmarks_300w_valid.json
+ | |── face_landmarks_300w_valid_common.json
+ | |── face_landmarks_300w_valid_challenge.json
+ | |── face_landmarks_300w_test.json
+ `── images
+ |── afw
+ | |── 1051618982_1.jpg
+ | |── 111076519_1.jpg
+ | ...
+ |── helen
+ | |── trainset
+ | | |── 100032540_1.jpg
+ | | |── 100040721_1.jpg
+ | | ...
+ | |── testset
+ | | |── 296814969_3.jpg
+ | | |── 2968560214_1.jpg
+ | | ...
+ |── ibug
+ | |── image_003_1.jpg
+ | |── image_004_1.jpg
+ | ...
+ |── lfpw
+ | |── trainset
+ | | |── image_0001.png
+ | | |── image_0002.png
+ | | ...
+ | |── testset
+ | | |── image_0001.png
+ | | |── image_0002.png
+ | | ...
+ `── Test
+ |── 01_Indoor
+ | |── indoor_001.png
+ | |── indoor_002.png
+ | ...
+ `── 02_Outdoor
+ |── outdoor_001.png
+ |── outdoor_002.png
+ ...
+```
+
+## WFLW Dataset
+
+
+
+
+
+
+
+WFLW (CVPR'2018)
+ +```bibtex +@inproceedings{wu2018look, + title={Look at boundary: A boundary-aware face alignment algorithm}, + author={Wu, Wayne and Qian, Chen and Yang, Shuo and Wang, Quan and Cai, Yici and Zhou, Qiang}, + booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition}, + pages={2129--2138}, + year={2018} +} +``` + +
+ 
+
+
+For WFLW data, please download images from [WFLW Dataset](https://wywu.github.io/projects/LAB/WFLW.html).
+Please download the annotation files from [wflw_annotations](https://download.openmmlab.com/mmpose/datasets/wflw_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── wflw
+ |── annotations
+ | |── face_landmarks_wflw_train.json
+ | |── face_landmarks_wflw_test.json
+ | |── face_landmarks_wflw_test_blur.json
+ | |── face_landmarks_wflw_test_occlusion.json
+ | |── face_landmarks_wflw_test_expression.json
+ | |── face_landmarks_wflw_test_largepose.json
+ | |── face_landmarks_wflw_test_illumination.json
+ | |── face_landmarks_wflw_test_makeup.json
+ |
+ `── images
+ |── 0--Parade
+ | |── 0_Parade_marchingband_1_1015.jpg
+ | |── 0_Parade_marchingband_1_1031.jpg
+ | ...
+ |── 1--Handshaking
+ | |── 1_Handshaking_Handshaking_1_105.jpg
+ | |── 1_Handshaking_Handshaking_1_107.jpg
+ | ...
+ ...
+```
+
+## AFLW Dataset
+
+
+
+
+
+
+
+For AFLW data, please download images from [AFLW Dataset](https://www.tugraz.at/institute/icg/research/team-bischof/lrs/downloads/aflw/).
+Please download the annotation files from [aflw_annotations](https://download.openmmlab.com/mmpose/datasets/aflw_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── aflw
+ |── annotations
+ | |── face_landmarks_aflw_train.json
+ | |── face_landmarks_aflw_test_frontal.json
+ | |── face_landmarks_aflw_test.json
+ `── images
+ |── flickr
+ |── 0
+ | |── image00002.jpg
+ | |── image00013.jpg
+ | ...
+ |── 2
+ | |── image00004.jpg
+ | |── image00006.jpg
+ | ...
+ `── 3
+ |── image00032.jpg
+ |── image00035.jpg
+ ...
+```
+
+## COFW Dataset
+
+
+
+AFLW (ICCVW'2011)
+ +```bibtex +@inproceedings{koestinger2011annotated, + title={Annotated facial landmarks in the wild: A large-scale, real-world database for facial landmark localization}, + author={Koestinger, Martin and Wohlhart, Paul and Roth, Peter M and Bischof, Horst}, + booktitle={2011 IEEE international conference on computer vision workshops (ICCV workshops)}, + pages={2144--2151}, + year={2011}, + organization={IEEE} +} +``` + +
+
+
+COFW (ICCV'2013)
+ +```bibtex +@inproceedings{burgos2013robust, + title={Robust face landmark estimation under occlusion}, + author={Burgos-Artizzu, Xavier P and Perona, Pietro and Doll{\'a}r, Piotr}, + booktitle={Proceedings of the IEEE international conference on computer vision}, + pages={1513--1520}, + year={2013} +} +``` + +
+ 
+
+
+For COFW data, please download from [COFW Dataset (Color Images)](http://www.vision.caltech.edu/xpburgos/ICCV13/Data/COFW_color.zip).
+Move `COFW_train_color.mat` and `COFW_test_color.mat` to `data/cofw/` and make them look like:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── cofw
+ |── COFW_train_color.mat
+ |── COFW_test_color.mat
+```
+
+Run the following script under `{MMPose}/data`
+
+`python tools/dataset_converters/parse_cofw_dataset.py`
+
+And you will get
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── cofw
+ |── COFW_train_color.mat
+ |── COFW_test_color.mat
+ |── annotations
+ | |── cofw_train.json
+ | |── cofw_test.json
+ |── images
+ |── 000001.jpg
+ |── 000002.jpg
+```
+
+## COCO-WholeBody (Face)
+
+
+
+
+
+
+
+COCO-WholeBody-Face (ECCV'2020)
+ +```bibtex +@inproceedings{jin2020whole, + title={Whole-Body Human Pose Estimation in the Wild}, + author={Jin, Sheng and Xu, Lumin and Xu, Jin and Wang, Can and Liu, Wentao and Qian, Chen and Ouyang, Wanli and Luo, Ping}, + booktitle={Proceedings of the European Conference on Computer Vision (ECCV)}, + year={2020} +} +``` + +
+ 
+
+
+For [COCO-WholeBody](https://github.com/jin-s13/COCO-WholeBody/) dataset, images can be downloaded from [COCO download](http://cocodataset.org/#download), 2017 Train/Val is needed for COCO keypoints training and validation.
+Download COCO-WholeBody annotations for COCO-WholeBody annotations for [Train](https://drive.google.com/file/d/1thErEToRbmM9uLNi1JXXfOsaS5VK2FXf/view?usp=sharing) / [Validation](https://drive.google.com/file/d/1N6VgwKnj8DeyGXCvp1eYgNbRmw6jdfrb/view?usp=sharing) (Google Drive).
+Download person detection result of COCO val2017 from [OneDrive](https://1drv.ms/f/s!AhIXJn_J-blWzzDXoz5BeFl8sWM-) or [GoogleDrive](https://drive.google.com/drive/folders/1fRUDNUDxe9fjqcRZ2bnF_TKMlO0nB_dk?usp=sharing).
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── coco
+ │-- annotations
+ │ │-- coco_wholebody_train_v1.0.json
+ │ |-- coco_wholebody_val_v1.0.json
+ |-- person_detection_results
+ | |-- COCO_val2017_detections_AP_H_56_person.json
+ │-- train2017
+ │ │-- 000000000009.jpg
+ │ │-- 000000000025.jpg
+ │ │-- 000000000030.jpg
+ │ │-- ...
+ `-- val2017
+ │-- 000000000139.jpg
+ │-- 000000000285.jpg
+ │-- 000000000632.jpg
+ │-- ...
+
+```
+
+Please also install the latest version of [Extended COCO API](https://github.com/jin-s13/xtcocoapi) to support COCO-WholeBody evaluation:
+
+`pip install xtcocotools`
+
+## LaPa
+
+
+
+
+
+
+
+LaPa (AAAI'2020)
+ +```bibtex +@inproceedings{liu2020new, + title={A New Dataset and Boundary-Attention Semantic Segmentation for Face Parsing.}, + author={Liu, Yinglu and Shi, Hailin and Shen, Hao and Si, Yue and Wang, Xiaobo and Mei, Tao}, + booktitle={AAAI}, + pages={11637--11644}, + year={2020} +} +``` + +
+ 
+
+
+For [LaPa](https://github.com/JDAI-CV/lapa-dataset) dataset, images can be downloaded from [their github page](https://github.com/JDAI-CV/lapa-dataset).
+
+Download and extract them under $MMPOSE/data, and use our `tools/dataset_converters/lapa2coco.py` to make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── LaPa
+ │-- annotations
+ │ │-- lapa_train.json
+ │ |-- lapa_val.json
+ │ |-- lapa_test.json
+ | |-- lapa_trainval.json
+ │-- train
+ │ │-- images
+ │ │-- labels
+ │ │-- landmarks
+ │-- val
+ │ │-- images
+ │ │-- labels
+ │ │-- landmarks
+ `-- test
+ │ │-- images
+ │ │-- labels
+ │ │-- landmarks
+
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/2d_fashion_landmark.md b/internlm_langchain/knowledge_base/MMPose/content/2d_fashion_landmark.md
new file mode 100644
index 00000000..25b7fd7c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/2d_fashion_landmark.md
@@ -0,0 +1,3 @@
+# 2D服装关键点数据集
+
+内容建设中……
diff --git a/internlm_langchain/knowledge_base/MMPose/content/2d_hand_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/2d_hand_keypoint.md
new file mode 100644
index 00000000..aade3585
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/2d_hand_keypoint.md
@@ -0,0 +1,348 @@
+# 2D Hand Keypoint Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- [OneHand10K](#onehand10k) \[ [Homepage](https://www.yangangwang.com/papers/WANG-MCC-2018-10.html) \]
+- [FreiHand](#freihand-dataset) \[ [Homepage](https://lmb.informatik.uni-freiburg.de/projects/freihand/) \]
+- [CMU Panoptic HandDB](#cmu-panoptic-handdb) \[ [Homepage](http://domedb.perception.cs.cmu.edu/handdb.html) \]
+- [InterHand2.6M](#interhand26m) \[ [Homepage](https://mks0601.github.io/InterHand2.6M/) \]
+- [RHD](#rhd-dataset) \[ [Homepage](https://lmb.informatik.uni-freiburg.de/resources/datasets/RenderedHandposeDataset.en.html) \]
+- [COCO-WholeBody-Hand](#coco-wholebody-hand) \[ [Homepage](https://github.com/jin-s13/COCO-WholeBody/) \]
+
+## OneHand10K
+
+
+
+
+
+
+
+OneHand10K (TCSVT'2019)
+ +```bibtex +@article{wang2018mask, + title={Mask-pose cascaded cnn for 2d hand pose estimation from single color image}, + author={Wang, Yangang and Peng, Cong and Liu, Yebin}, + journal={IEEE Transactions on Circuits and Systems for Video Technology}, + volume={29}, + number={11}, + pages={3258--3268}, + year={2018}, + publisher={IEEE} +} +``` + +
+ 
+
+
+For [OneHand10K](https://www.yangangwang.com/papers/WANG-MCC-2018-10.html) data, please download from [OneHand10K Dataset](https://www.yangangwang.com/papers/WANG-MCC-2018-10.html).
+Please download the annotation files from [onehand10k_annotations](https://download.openmmlab.com/mmpose/datasets/onehand10k_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── onehand10k
+ |── annotations
+ | |── onehand10k_train.json
+ | |── onehand10k_test.json
+ `── Train
+ | |── source
+ | |── 0.jpg
+ | |── 1.jpg
+ | ...
+ `── Test
+ |── source
+ |── 0.jpg
+ |── 1.jpg
+
+```
+
+## FreiHAND Dataset
+
+
+
+
+
+
+
+FreiHand (ICCV'2019)
+ +```bibtex +@inproceedings{zimmermann2019freihand, + title={Freihand: A dataset for markerless capture of hand pose and shape from single rgb images}, + author={Zimmermann, Christian and Ceylan, Duygu and Yang, Jimei and Russell, Bryan and Argus, Max and Brox, Thomas}, + booktitle={Proceedings of the IEEE International Conference on Computer Vision}, + pages={813--822}, + year={2019} +} +``` + +
+
+
+
+For [FreiHAND](https://lmb.informatik.uni-freiburg.de/projects/freihand/) data, please download from [FreiHand Dataset](https://lmb.informatik.uni-freiburg.de/resources/datasets/FreihandDataset.en.html).
+Since the official dataset does not provide validation set, we randomly split the training data into 8:1:1 for train/val/test.
+Please download the annotation files from [freihand_annotations](https://download.openmmlab.com/mmpose/datasets/frei_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── freihand
+ |── annotations
+ | |── freihand_train.json
+ | |── freihand_val.json
+ | |── freihand_test.json
+ `── training
+ |── rgb
+ | |── 00000000.jpg
+ | |── 00000001.jpg
+ | ...
+ |── mask
+ |── 00000000.jpg
+ |── 00000001.jpg
+ ...
+```
+
+## CMU Panoptic HandDB
+
+
+
+
+
+
+
+CMU Panoptic HandDB (CVPR'2017)
+ +```bibtex +@inproceedings{simon2017hand, + title={Hand keypoint detection in single images using multiview bootstrapping}, + author={Simon, Tomas and Joo, Hanbyul and Matthews, Iain and Sheikh, Yaser}, + booktitle={Proceedings of the IEEE conference on Computer Vision and Pattern Recognition}, + pages={1145--1153}, + year={2017} +} +``` + +
+
+
+
+For [CMU Panoptic HandDB](http://domedb.perception.cs.cmu.edu/handdb.html), please download from [CMU Panoptic HandDB](http://domedb.perception.cs.cmu.edu/handdb.html).
+Following [Simon et al](https://arxiv.org/abs/1704.07809), panoptic images (hand143_panopticdb) and MPII & NZSL training sets (manual_train) are used for training, while MPII & NZSL test set (manual_test) for testing.
+Please download the annotation files from [panoptic_annotations](https://download.openmmlab.com/mmpose/datasets/panoptic_annotations.tar).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── panoptic
+ |── annotations
+ | |── panoptic_train.json
+ | |── panoptic_test.json
+ |
+ `── hand143_panopticdb
+ | |── imgs
+ | | |── 00000000.jpg
+ | | |── 00000001.jpg
+ | | ...
+ |
+ `── hand_labels
+ |── manual_train
+ | |── 000015774_01_l.jpg
+ | |── 000015774_01_r.jpg
+ | ...
+ |
+ `── manual_test
+ |── 000648952_02_l.jpg
+ |── 000835470_01_l.jpg
+ ...
+```
+
+## InterHand2.6M
+
+
+
+
+
+
+
+InterHand2.6M (ECCV'2020)
+ +```bibtex +@InProceedings{Moon_2020_ECCV_InterHand2.6M, +author = {Moon, Gyeongsik and Yu, Shoou-I and Wen, He and Shiratori, Takaaki and Lee, Kyoung Mu}, +title = {InterHand2.6M: A Dataset and Baseline for 3D Interacting Hand Pose Estimation from a Single RGB Image}, +booktitle = {European Conference on Computer Vision (ECCV)}, +year = {2020} +} +``` + +
+ 
+
+
+For [InterHand2.6M](https://mks0601.github.io/InterHand2.6M/), please download from [InterHand2.6M](https://mks0601.github.io/InterHand2.6M/).
+Please download the annotation files from [annotations](https://drive.google.com/drive/folders/1pWXhdfaka-J0fSAze0MsajN0VpZ8e8tO).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── interhand2.6m
+ |── annotations
+ | |── all
+ | |── human_annot
+ | |── machine_annot
+ | |── skeleton.txt
+ | |── subject.txt
+ |
+ `── images
+ | |── train
+ | | |-- Capture0 ~ Capture26
+ | |── val
+ | | |-- Capture0
+ | |── test
+ | | |-- Capture0 ~ Capture7
+```
+
+## RHD Dataset
+
+
+
+
+
+
+
+RHD (ICCV'2017)
+ +```bibtex +@TechReport{zb2017hand, + author={Christian Zimmermann and Thomas Brox}, + title={Learning to Estimate 3D Hand Pose from Single RGB Images}, + institution={arXiv:1705.01389}, + year={2017}, + note="https://arxiv.org/abs/1705.01389", + url="https://lmb.informatik.uni-freiburg.de/projects/hand3d/" +} +``` + +
+ 
+
+
+For [RHD Dataset](https://lmb.informatik.uni-freiburg.de/resources/datasets/RenderedHandposeDataset.en.html), please download from [RHD Dataset](https://lmb.informatik.uni-freiburg.de/resources/datasets/RenderedHandposeDataset.en.html).
+Please download the annotation files from [rhd_annotations](https://download.openmmlab.com/mmpose/datasets/rhd_annotations.zip).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── rhd
+ |── annotations
+ | |── rhd_train.json
+ | |── rhd_test.json
+ `── training
+ | |── color
+ | | |── 00000.jpg
+ | | |── 00001.jpg
+ | |── depth
+ | | |── 00000.jpg
+ | | |── 00001.jpg
+ | |── mask
+ | | |── 00000.jpg
+ | | |── 00001.jpg
+ `── evaluation
+ | |── color
+ | | |── 00000.jpg
+ | | |── 00001.jpg
+ | |── depth
+ | | |── 00000.jpg
+ | | |── 00001.jpg
+ | |── mask
+ | | |── 00000.jpg
+ | | |── 00001.jpg
+```
+
+## COCO-WholeBody (Hand)
+
+
+
+
+
+
+
+COCO-WholeBody-Hand (ECCV'2020)
+ +```bibtex +@inproceedings{jin2020whole, + title={Whole-Body Human Pose Estimation in the Wild}, + author={Jin, Sheng and Xu, Lumin and Xu, Jin and Wang, Can and Liu, Wentao and Qian, Chen and Ouyang, Wanli and Luo, Ping}, + booktitle={Proceedings of the European Conference on Computer Vision (ECCV)}, + year={2020} +} +``` + +
+
+
+
+For [COCO-WholeBody](https://github.com/jin-s13/COCO-WholeBody/) dataset, images can be downloaded from [COCO download](http://cocodataset.org/#download), 2017 Train/Val is needed for COCO keypoints training and validation.
+Download COCO-WholeBody annotations for COCO-WholeBody annotations for [Train](https://drive.google.com/file/d/1thErEToRbmM9uLNi1JXXfOsaS5VK2FXf/view?usp=sharing) / [Validation](https://drive.google.com/file/d/1N6VgwKnj8DeyGXCvp1eYgNbRmw6jdfrb/view?usp=sharing) (Google Drive).
+Download person detection result of COCO val2017 from [OneDrive](https://1drv.ms/f/s!AhIXJn_J-blWzzDXoz5BeFl8sWM-) or [GoogleDrive](https://drive.google.com/drive/folders/1fRUDNUDxe9fjqcRZ2bnF_TKMlO0nB_dk?usp=sharing).
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── coco
+ │-- annotations
+ │ │-- coco_wholebody_train_v1.0.json
+ │ |-- coco_wholebody_val_v1.0.json
+ |-- person_detection_results
+ | |-- COCO_val2017_detections_AP_H_56_person.json
+ │-- train2017
+ │ │-- 000000000009.jpg
+ │ │-- 000000000025.jpg
+ │ │-- 000000000030.jpg
+ │ │-- ...
+ `-- val2017
+ │-- 000000000139.jpg
+ │-- 000000000285.jpg
+ │-- 000000000632.jpg
+ │-- ...
+```
+
+Please also install the latest version of [Extended COCO API](https://github.com/jin-s13/xtcocoapi) to support COCO-WholeBody evaluation:
+
+`pip install xtcocotools`
diff --git a/internlm_langchain/knowledge_base/MMPose/content/2d_wholebody_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/2d_wholebody_keypoint.md
new file mode 100644
index 00000000..a082c657
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/2d_wholebody_keypoint.md
@@ -0,0 +1,133 @@
+# 2D Wholebody Keypoint Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- [COCO-WholeBody](#coco-wholebody) \[ [Homepage](https://github.com/jin-s13/COCO-WholeBody/) \]
+- [Halpe](#halpe) \[ [Homepage](https://github.com/Fang-Haoshu/Halpe-FullBody/) \]
+
+## COCO-WholeBody
+
+
+
+
+
+
+
+COCO-WholeBody (ECCV'2020)
+ +```bibtex +@inproceedings{jin2020whole, + title={Whole-Body Human Pose Estimation in the Wild}, + author={Jin, Sheng and Xu, Lumin and Xu, Jin and Wang, Can and Liu, Wentao and Qian, Chen and Ouyang, Wanli and Luo, Ping}, + booktitle={Proceedings of the European Conference on Computer Vision (ECCV)}, + year={2020} +} +``` + +
+ 
+
+
+For [COCO-WholeBody](https://github.com/jin-s13/COCO-WholeBody/) dataset, images can be downloaded from [COCO download](http://cocodataset.org/#download), 2017 Train/Val is needed for COCO keypoints training and validation.
+Download COCO-WholeBody annotations for COCO-WholeBody annotations for [Train](https://drive.google.com/file/d/1thErEToRbmM9uLNi1JXXfOsaS5VK2FXf/view?usp=sharing) / [Validation](https://drive.google.com/file/d/1N6VgwKnj8DeyGXCvp1eYgNbRmw6jdfrb/view?usp=sharing) (Google Drive).
+Download person detection result of COCO val2017 from [OneDrive](https://1drv.ms/f/s!AhIXJn_J-blWzzDXoz5BeFl8sWM-) or [GoogleDrive](https://drive.google.com/drive/folders/1fRUDNUDxe9fjqcRZ2bnF_TKMlO0nB_dk?usp=sharing).
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── coco
+ │-- annotations
+ │ │-- coco_wholebody_train_v1.0.json
+ │ |-- coco_wholebody_val_v1.0.json
+ |-- person_detection_results
+ | |-- COCO_val2017_detections_AP_H_56_person.json
+ │-- train2017
+ │ │-- 000000000009.jpg
+ │ │-- 000000000025.jpg
+ │ │-- 000000000030.jpg
+ │ │-- ...
+ `-- val2017
+ │-- 000000000139.jpg
+ │-- 000000000285.jpg
+ │-- 000000000632.jpg
+ │-- ...
+
+```
+
+Please also install the latest version of [Extended COCO API](https://github.com/jin-s13/xtcocoapi) (version>=1.5) to support COCO-WholeBody evaluation:
+
+`pip install xtcocotools`
+
+## Halpe
+
+
+
+
+
+
+
+Halpe (CVPR'2020)
+ +```bibtex +@inproceedings{li2020pastanet, + title={PaStaNet: Toward Human Activity Knowledge Engine}, + author={Li, Yong-Lu and Xu, Liang and Liu, Xinpeng and Huang, Xijie and Xu, Yue and Wang, Shiyi and Fang, Hao-Shu and Ma, Ze and Chen, Mingyang and Lu, Cewu}, + booktitle={CVPR}, + year={2020} +} +``` + +
+ 
+
+
+For [Halpe](https://github.com/Fang-Haoshu/Halpe-FullBody/) dataset, please download images and annotations from [Halpe download](https://github.com/Fang-Haoshu/Halpe-FullBody).
+The images of the training set are from [HICO-Det](https://drive.google.com/open?id=1QZcJmGVlF9f4h-XLWe9Gkmnmj2z1gSnk) and those of the validation set are from [COCO](http://images.cocodataset.org/zips/val2017.zip).
+Download person detection result of COCO val2017 from [OneDrive](https://1drv.ms/f/s!AhIXJn_J-blWzzDXoz5BeFl8sWM-) or [GoogleDrive](https://drive.google.com/drive/folders/1fRUDNUDxe9fjqcRZ2bnF_TKMlO0nB_dk?usp=sharing).
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── halpe
+ │-- annotations
+ │ │-- halpe_train_v1.json
+ │ |-- halpe_val_v1.json
+ |-- person_detection_results
+ | |-- COCO_val2017_detections_AP_H_56_person.json
+ │-- hico_20160224_det
+ │ │-- anno_bbox.mat
+ │ │-- anno.mat
+ │ │-- README
+ │ │-- images
+ │ │ │-- train2015
+ │ │ │ │-- HICO_train2015_00000001.jpg
+ │ │ │ │-- HICO_train2015_00000002.jpg
+ │ │ │ │-- HICO_train2015_00000003.jpg
+ │ │ │ │-- ...
+ │ │ │-- test2015
+ │ │-- tools
+ │ │-- ...
+ `-- val2017
+ │-- 000000000139.jpg
+ │-- 000000000285.jpg
+ │-- 000000000632.jpg
+ │-- ...
+
+```
+
+Please also install the latest version of [Extended COCO API](https://github.com/jin-s13/xtcocoapi) (version>=1.5) to support Halpe evaluation:
+
+`pip install xtcocotools`
diff --git a/internlm_langchain/knowledge_base/MMPose/content/3d_body_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/3d_body_keypoint.md
new file mode 100644
index 00000000..82e21010
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/3d_body_keypoint.md
@@ -0,0 +1,199 @@
+# 3D Body Keypoint Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- [Human3.6M](#human36m) \[ [Homepage](http://vision.imar.ro/human3.6m/description.php) \]
+- [CMU Panoptic](#cmu-panoptic) \[ [Homepage](http://domedb.perception.cs.cmu.edu/) \]
+- [Campus/Shelf](#campus-and-shelf) \[ [Homepage](http://campar.in.tum.de/Chair/MultiHumanPose) \]
+
+## Human3.6M
+
+
+
+
+
+
+
+Human3.6M (TPAMI'2014)
+ +```bibtex +@article{h36m_pami, + author = {Ionescu, Catalin and Papava, Dragos and Olaru, Vlad and Sminchisescu, Cristian}, + title = {Human3.6M: Large Scale Datasets and Predictive Methods for 3D Human Sensing in Natural Environments}, + journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher = {IEEE Computer Society}, + volume = {36}, + number = {7}, + pages = {1325-1339}, + month = {jul}, + year = {2014} +} +``` + +
+ 
+
+
+For [Human3.6M](http://vision.imar.ro/human3.6m/description.php), please download from the official website and run the [preprocessing script](/tools/dataset_converters/preprocess_h36m.py), which will extract camera parameters and pose annotations at full framerate (50 FPS) and downsampled framerate (10 FPS). The processed data should have the following structure:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ ├── h36m
+ ├── annotation_body3d
+ | ├── cameras.pkl
+ | ├── fps50
+ | | ├── h36m_test.npz
+ | | ├── h36m_train.npz
+ | | ├── joint2d_rel_stats.pkl
+ | | ├── joint2d_stats.pkl
+ | | ├── joint3d_rel_stats.pkl
+ | | `── joint3d_stats.pkl
+ | `── fps10
+ | ├── h36m_test.npz
+ | ├── h36m_train.npz
+ | ├── joint2d_rel_stats.pkl
+ | ├── joint2d_stats.pkl
+ | ├── joint3d_rel_stats.pkl
+ | `── joint3d_stats.pkl
+ `── images
+ ├── S1
+ | ├── S1_Directions_1.54138969
+ | | ├── S1_Directions_1.54138969_00001.jpg
+ | | ├── S1_Directions_1.54138969_00002.jpg
+ | | ├── ...
+ | ├── ...
+ ├── S5
+ ├── S6
+ ├── S7
+ ├── S8
+ ├── S9
+ `── S11
+```
+
+## CMU Panoptic
+
+
+
+
+
+CMU Panoptic (ICCV'2015)
+ +```bibtex +@Article = {joo_iccv_2015, +author = {Hanbyul Joo, Hao Liu, Lei Tan, Lin Gui, Bart Nabbe, Iain Matthews, Takeo Kanade, Shohei Nobuhara, and Yaser Sheikh}, +title = {Panoptic Studio: A Massively Multiview System for Social Motion Capture}, +booktitle = {ICCV}, +year = {2015} +} +``` + +
+ 
+
+
+Please follow [voxelpose-pytorch](https://github.com/microsoft/voxelpose-pytorch) to prepare this dataset.
+
+1. Download the dataset by following the instructions in [panoptic-toolbox](https://github.com/CMU-Perceptual-Computing-Lab/panoptic-toolbox) and extract them under `$MMPOSE/data/panoptic`.
+
+2. Only download those sequences that are needed. You can also just download a subset of camera views by specifying the number of views (HD_Video_Number) and changing the camera order in `./scripts/getData.sh`. The used sequences and camera views can be found in [VoxelPose](https://arxiv.org/abs/2004.06239). Note that the sequence "160906_band3" might not be available due to errors on the server of CMU Panoptic.
+
+3. Note that we only use HD videos, calibration data, and 3D Body Keypoint in the codes. You can comment out other irrelevant codes such as downloading 3D Face data in `./scripts/getData.sh`.
+
+The directory tree should be like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ ├── panoptic
+ ├── 16060224_haggling1
+ | | ├── hdImgs
+ | | ├── hdvideos
+ | | ├── hdPose3d_stage1_coco19
+ | | ├── calibration_160224_haggling1.json
+ ├── 160226_haggling1
+ ├── ...
+```
+
+## Campus and Shelf
+
+
+
+
+
+Campus and Shelf (CVPR'2014)
+ +```bibtex +@inproceedings {belagian14multi, + title = {{3D} Pictorial Structures for Multiple Human Pose Estimation}, + author = {Belagiannis, Vasileios and Amin, Sikandar and Andriluka, Mykhaylo and Schiele, Bernt and Navab + Nassir and Ilic, Slobo + booktitle = {IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2014}, + month = {June}, + organization={IEEE} +} +``` + +
+ 
+
+
+Please follow [voxelpose-pytorch](https://github.com/microsoft/voxelpose-pytorch) to prepare these two datasets.
+
+1. Please download the datasets from the [official website](http://campar.in.tum.de/Chair/MultiHumanPose) and extract them under `$MMPOSE/data/campus` and `$MMPOSE/data/shelf`, respectively. The original data include images as well as the ground truth pose file `actorsGT.mat`.
+
+2. We directly use the processed camera parameters from [voxelpose-pytorch](https://github.com/microsoft/voxelpose-pytorch). You can download them from this repository and place in under `$MMPOSE/data/campus/calibration_campus.json` and `$MMPOSE/data/shelf/calibration_shelf.json`, respectively.
+
+3. Like [Voxelpose](https://github.com/microsoft/voxelpose-pytorch), due to the limited and incomplete annotations of the two datasets, we don't train the model using this dataset. Instead, we directly use the 2D pose estimator trained on COCO, and use independent 3D human poses from the CMU Panoptic dataset to train our 3D model. It lies in `${MMPOSE}/data/panoptic_training_pose.pkl`.
+
+4. Like [Voxelpose](https://github.com/microsoft/voxelpose-pytorch), for testing, we first estimate 2D poses and generate 2D heatmaps for these two datasets. You can download the predicted poses from [voxelpose-pytorch](https://github.com/microsoft/voxelpose-pytorch) and place them in `$MMPOSE/data/campus/pred_campus_maskrcnn_hrnet_coco.pkl` and `$MMPOSE/data/shelf/pred_shelf_maskrcnn_hrnet_coco.pkl`, respectively. You can also use the models trained on COCO dataset (like HigherHRNet) to generate 2D heatmaps directly.
+
+The directory tree should be like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ ├── panoptic_training_pose.pkl
+ ├── campus
+ | ├── Camera0
+ | | | ├── campus4-c0-00000.png
+ | | | ├── ...
+ | | | ├── campus4-c0-01999.png
+ | ...
+ | ├── Camera2
+ | | | ├── campus4-c2-00000.png
+ | | | ├── ...
+ | | | ├── campus4-c2-01999.png
+ | ├── calibration_campus.json
+ | ├── pred_campus_maskrcnn_hrnet_coco.pkl
+ | ├── actorsGT.mat
+ ├── shelf
+ | ├── Camera0
+ | | | ├── img_000000.png
+ | | | ├── ...
+ | | | ├── img_003199.png
+ | ...
+ | ├── Camera4
+ | | | ├── img_000000.png
+ | | | ├── ...
+ | | | ├── img_003199.png
+ | ├── calibration_shelf.json
+ | ├── pred_shelf_maskrcnn_hrnet_coco.pkl
+ | ├── actorsGT.mat
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/3d_body_mesh.md b/internlm_langchain/knowledge_base/MMPose/content/3d_body_mesh.md
new file mode 100644
index 00000000..aced63c8
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/3d_body_mesh.md
@@ -0,0 +1,342 @@
+# 3D Body Mesh Recovery Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+To achieve high-quality human mesh estimation, we use multiple datasets for training.
+The following items should be prepared for human mesh training:
+
+
+
+- [3D Body Mesh Recovery Datasets](#3d-body-mesh-recovery-datasets)
+ - [Notes](#notes)
+ - [Annotation Files for Human Mesh Estimation](#annotation-files-for-human-mesh-estimation)
+ - [SMPL Model](#smpl-model)
+ - [COCO](#coco)
+ - [Human3.6M](#human36m)
+ - [MPI-INF-3DHP](#mpi-inf-3dhp)
+ - [LSP](#lsp)
+ - [LSPET](#lspet)
+ - [CMU MoShed Data](#cmu-moshed-data)
+
+
+
+## Notes
+
+### Annotation Files for Human Mesh Estimation
+
+For human mesh estimation, we use multiple datasets for training.
+The annotation of different datasets are preprocessed to the same format. Please
+follow the [preprocess procedure](https://github.com/nkolot/SPIN/tree/master/datasets/preprocess)
+of SPIN to generate the annotation files or download the processed files from
+[here](https://download.openmmlab.com/mmpose/datasets/mesh_annotation_files.zip),
+and make it look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── mesh_annotation_files
+ ├── coco_2014_train.npz
+ ├── h36m_valid_protocol1.npz
+ ├── h36m_valid_protocol2.npz
+ ├── hr-lspet_train.npz
+ ├── lsp_dataset_original_train.npz
+ ├── mpi_inf_3dhp_train.npz
+ └── mpii_train.npz
+```
+
+### SMPL Model
+
+```bibtex
+@article{loper2015smpl,
+ title={SMPL: A skinned multi-person linear model},
+ author={Loper, Matthew and Mahmood, Naureen and Romero, Javier and Pons-Moll, Gerard and Black, Michael J},
+ journal={ACM transactions on graphics (TOG)},
+ volume={34},
+ number={6},
+ pages={1--16},
+ year={2015},
+ publisher={ACM New York, NY, USA}
+}
+```
+
+For human mesh estimation, SMPL model is used to generate the human mesh.
+Please download the [gender neutral SMPL model](http://smplify.is.tue.mpg.de/),
+[joints regressor](https://download.openmmlab.com/mmpose/datasets/joints_regressor_cmr.npy)
+and [mean parameters](https://download.openmmlab.com/mmpose/datasets/smpl_mean_params.npz)
+under `$MMPOSE/models/smpl`, and make it look like this:
+
+```text
+mmpose
+├── mmpose
+├── ...
+├── models
+ │── smpl
+ ├── joints_regressor_cmr.npy
+ ├── smpl_mean_params.npz
+ └── SMPL_NEUTRAL.pkl
+```
+
+## COCO
+
+
+
+
+
+
+
+For [COCO](http://cocodataset.org/) data, please download from [COCO download](http://cocodataset.org/#download). COCO'2014 Train is needed for human mesh estimation training.
+Download and extract them under $MMPOSE/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── coco
+ │-- train2014
+ │ ├── COCO_train2014_000000000009.jpg
+ │ ├── COCO_train2014_000000000025.jpg
+ │ ├── COCO_train2014_000000000030.jpg
+ | │-- ...
+
+```
+
+## Human3.6M
+
+
+
+COCO (ECCV'2014)
+ +```bibtex +@inproceedings{lin2014microsoft, + title={Microsoft coco: Common objects in context}, + author={Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C Lawrence}, + booktitle={European conference on computer vision}, + pages={740--755}, + year={2014}, + organization={Springer} +} +``` + +
+
+
+For [Human3.6M](http://vision.imar.ro/human3.6m/description.php), we use the MoShed data provided in [HMR](https://github.com/akanazawa/hmr) for training.
+However, due to license limitations, we are not allowed to redistribute the MoShed data.
+
+For the evaluation on Human3.6M dataset, please follow the
+[preprocess procedure](https://github.com/nkolot/SPIN/tree/master/datasets/preprocess)
+of SPIN to extract test images from
+[Human3.6M](http://vision.imar.ro/human3.6m/description.php) original videos,
+and make it look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── Human3.6M
+ ├── images
+ ├── S11_Directions_1.54138969_000001.jpg
+ ├── S11_Directions_1.54138969_000006.jpg
+ ├── S11_Directions_1.54138969_000011.jpg
+ ├── ...
+```
+
+The download of Human3.6M dataset is quite difficult, you can also download the
+[zip file](https://drive.google.com/file/d/1WnRJD9FS3NUf7MllwgLRJJC-JgYFr8oi/view?usp=sharing)
+of the test images. However, due to the license limitations, we are not allowed to
+redistribute the images either. So the users need to download the original video and
+extract the images by themselves.
+
+## MPI-INF-3DHP
+
+
+
+```bibtex
+@inproceedings{mono-3dhp2017,
+ author = {Mehta, Dushyant and Rhodin, Helge and Casas, Dan and Fua, Pascal and Sotnychenko, Oleksandr and Xu, Weipeng and Theobalt, Christian},
+ title = {Monocular 3D Human Pose Estimation In The Wild Using Improved CNN Supervision},
+ booktitle = {3D Vision (3DV), 2017 Fifth International Conference on},
+ url = {http://gvv.mpi-inf.mpg.de/3dhp_dataset},
+ year = {2017},
+ organization={IEEE},
+ doi={10.1109/3dv.2017.00064},
+}
+```
+
+For [MPI-INF-3DHP](http://gvv.mpi-inf.mpg.de/3dhp-dataset/), please follow the
+[preprocess procedure](https://github.com/nkolot/SPIN/tree/master/datasets/preprocess)
+of SPIN to sample images, and make them like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ ├── mpi_inf_3dhp_test_set
+ │ ├── TS1
+ │ ├── TS2
+ │ ├── TS3
+ │ ├── TS4
+ │ ├── TS5
+ │ └── TS6
+ ├── S1
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S2
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S3
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S4
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S5
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S6
+ │ ├── Seq1
+ │ └── Seq2
+ ├── S7
+ │ ├── Seq1
+ │ └── Seq2
+ └── S8
+ ├── Seq1
+ └── Seq2
+```
+
+## LSP
+
+
+
+```bibtex
+@inproceedings{johnson2010clustered,
+ title={Clustered Pose and Nonlinear Appearance Models for Human Pose Estimation.},
+ author={Johnson, Sam and Everingham, Mark},
+ booktitle={bmvc},
+ volume={2},
+ number={4},
+ pages={5},
+ year={2010},
+ organization={Citeseer}
+}
+```
+
+For [LSP](https://sam.johnson.io/research/lsp.html), please download the high resolution version
+[LSP dataset original](http://sam.johnson.io/research/lsp_dataset_original.zip).
+Extract them under `$MMPOSE/data`, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── lsp_dataset_original
+ ├── images
+ ├── im0001.jpg
+ ├── im0002.jpg
+ └── ...
+```
+
+## LSPET
+
+
+
+```bibtex
+@inproceedings{johnson2011learning,
+ title={Learning effective human pose estimation from inaccurate annotation},
+ author={Johnson, Sam and Everingham, Mark},
+ booktitle={CVPR 2011},
+ pages={1465--1472},
+ year={2011},
+ organization={IEEE}
+}
+```
+
+For [LSPET](https://sam.johnson.io/research/lspet.html), please download its high resolution form
+[HR-LSPET](http://datasets.d2.mpi-inf.mpg.de/hr-lspet/hr-lspet.zip).
+Extract them under `$MMPOSE/data`, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── lspet_dataset
+ ├── images
+ │ ├── im00001.jpg
+ │ ├── im00002.jpg
+ │ ├── im00003.jpg
+ │ └── ...
+ └── joints.mat
+```
+
+## CMU MoShed Data
+
+
+
+```bibtex
+@inproceedings{kanazawa2018end,
+ title={End-to-end recovery of human shape and pose},
+ author={Kanazawa, Angjoo and Black, Michael J and Jacobs, David W and Malik, Jitendra},
+ booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
+ pages={7122--7131},
+ year={2018}
+}
+```
+
+Real-world SMPL parameters are used for the adversarial training in human mesh estimation.
+The MoShed data provided in [HMR](https://github.com/akanazawa/hmr) is included in this
+[zip file](https://download.openmmlab.com/mmpose/datasets/mesh_annotation_files.zip).
+Please download and extract it under `$MMPOSE/data`, and make it look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── mesh_annotation_files
+ ├── CMU_mosh.npz
+ └── ...
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/3d_hand_keypoint.md b/internlm_langchain/knowledge_base/MMPose/content/3d_hand_keypoint.md
new file mode 100644
index 00000000..2b1f4d39
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/3d_hand_keypoint.md
@@ -0,0 +1,59 @@
+# 3D Hand Keypoint Datasets
+
+It is recommended to symlink the dataset root to `$MMPOSE/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+MMPose supported datasets:
+
+- [InterHand2.6M](#interhand26m) \[ [Homepage](https://mks0601.github.io/InterHand2.6M/) \]
+
+## InterHand2.6M
+
+
+
+Human3.6M (TPAMI'2014)
+ +```bibtex +@article{h36m_pami, + author = {Ionescu, Catalin and Papava, Dragos and Olaru, Vlad and Sminchisescu, Cristian}, + title = {Human3.6M: Large Scale Datasets and Predictive Methods for 3D Human Sensing in Natural Environments}, + journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher = {IEEE Computer Society}, + volume = {36}, + number = {7}, + pages = {1325-1339}, + month = {jul}, + year = {2014} +} +``` + +
+
+
+InterHand2.6M (ECCV'2020)
+ +```bibtex +@InProceedings{Moon_2020_ECCV_InterHand2.6M, +author = {Moon, Gyeongsik and Yu, Shoou-I and Wen, He and Shiratori, Takaaki and Lee, Kyoung Mu}, +title = {InterHand2.6M: A Dataset and Baseline for 3D Interacting Hand Pose Estimation from a Single RGB Image}, +booktitle = {European Conference on Computer Vision (ECCV)}, +year = {2020} +} +``` + +
+ 
+
+
+For [InterHand2.6M](https://mks0601.github.io/InterHand2.6M/), please download from [InterHand2.6M](https://mks0601.github.io/InterHand2.6M/).
+Please download the annotation files from [annotations](https://drive.google.com/drive/folders/1pWXhdfaka-J0fSAze0MsajN0VpZ8e8tO).
+Extract them under {MMPose}/data, and make them look like this:
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── interhand2.6m
+ |── annotations
+ | |── all
+ | |── human_annot
+ | |── machine_annot
+ | |── skeleton.txt
+ | |── subject.txt
+ |
+ `── images
+ | |── train
+ | | |-- Capture0 ~ Capture26
+ | |── val
+ | | |-- Capture0
+ | |── test
+ | | |-- Capture0 ~ Capture7
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/advanced_training.md b/internlm_langchain/knowledge_base/MMPose/content/advanced_training.md
new file mode 100644
index 00000000..dd02a766
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/advanced_training.md
@@ -0,0 +1,104 @@
+# 高级训练设置
+
+## 恢复训练
+
+恢复训练是指从之前某次训练保存下来的状态开始继续训练，这里的状态包括模型的权重、优化器和优化器参数调整策略的状态。
+
+### 自动恢复训练
+
+用户可以在训练命令最后加上 `--resume` 恢复训练，程序会自动从 `work_dirs` 中加载最新的权重文件恢复训练。如果 `work_dir` 中有最新的 `checkpoint`（例如该训练在上一次训练时被中断），则会从该 `checkpoint` 恢复训练，否则（例如上一次训练还没来得及保存 `checkpoint` 或者启动了新的训练任务）会重新开始训练。
+
+下面是一个恢复训练的示例:
+
+```shell
+python tools/train.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_res50_8xb64-210e_coco-256x192.py --resume
+```
+
+### 指定 Checkpoint 恢复训练
+
+你也可以对 `--resume` 指定 `checkpoint` 路径，MMPose 会自动读取该 `checkpoint` 并从中恢复训练，命令如下：
+
+```shell
+python tools/train.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_res50_8xb64-210e_coco-256x192.py \
+ --resume work_dirs/td-hm_res50_8xb64-210e_coco-256x192/latest.pth
+```
+
+如果你希望手动在配置文件中指定 `checkpoint` 路径，除了设置 `resume=True`，还需要设置 `load_from` 参数。需要注意的是，如果只设置了 `load_from` 而没有设置 `resume=True`，则只会加载 `checkpoint` 中的权重并重新开始训练，而不是接着之前的状态继续训练。
+
+下面的例子与上面指定 `--resume` 参数的例子等价：
+
+```python
+resume = True
+load_from = 'work_dirs/td-hm_res50_8xb64-210e_coco-256x192/latest.pth'
+# model settings
+model = dict(
+ ## 内容省略 ##
+ )
+```
+
+## 自动混合精度（AMP）训练
+
+混合精度训练在不改变模型、不降低模型训练精度的前提下，可以缩短训练时间，降低存储需求，因而能支持更大的 batch size、更大模型和尺寸更大的输入的训练。
+
+如果要开启自动混合精度（AMP）训练，在训练命令最后加上 --amp 即可， 命令如下：
+
+```shell
+python tools/train.py ${CONFIG_FILE} --amp
+```
+
+具体例子如下：
+
+```shell
+python tools/train.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_res50_8xb64-210e_coco-256x192.py --amp
+```
+
+## 设置随机种子
+
+如果想要在训练时指定随机种子，可以使用以下命令：
+
+```shell
+python ./tools/train.py \
+ ${CONFIG} \ # 配置文件路径
+ --cfg-options randomness.seed=2023 \ # 设置随机种子为 2023
+ [randomness.diff_rank_seed=True] \ # 根据 rank 来设置不同的种子。
+ [randomness.deterministic=True] # 把 cuDNN 后端确定性选项设置为 True
+# [] 代表可选参数，实际输入命令行时，不用输入 []
+```
+
+randomness 有三个参数可设置，具体含义如下：
+
+- `randomness.seed=2023` ，设置随机种子为 `2023`。
+
+- `randomness.diff_rank_seed=True`，根据 `rank` 来设置不同的种子，`diff_rank_seed` 默认为 `False`。
+
+- `randomness.deterministic=True`，把 `cuDNN` 后端确定性选项设置为 `True`，即把 `torch.backends.cudnn.deterministic` 设为 `True`，把 `torch.backends.cudnn.benchmark` 设为 `False`。`deterministic` 默认为 `False`。更多细节见 [Pytorch Randomness](https://pytorch.org/docs/stable/notes/randomness.html)。
+
+如果你希望手动在配置文件中指定随机种子，可以在配置文件中设置 `random_seed` 参数，具体如下：
+
+```python
+randomness = dict(seed=2023)
+# model settings
+model = dict(
+ ## 内容省略 ##
+ )
+```
+
+## 使用 Tensorboard 可视化训练过程
+
+安装 Tensorboard 环境
+
+```shell
+pip install tensorboard
+```
+
+在 config 文件中添加 tensorboard 配置
+
+```python
+visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')])
+```
+
+运行训练命令后，tensorboard 文件会生成在可视化文件夹 `work_dir/${CONFIG}/${TIMESTAMP}/vis_data` 下，运行下面的命令就可以在网页链接使用 tensorboard 查看 loss、学习率和精度等信息。
+
+```shell
+tensorboard --logdir work_dir/${CONFIG}/${TIMESTAMP}/vis_data
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/changelog.md b/internlm_langchain/knowledge_base/MMPose/content/changelog.md
new file mode 100644
index 00000000..68beeeb0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/changelog.md
@@ -0,0 +1,1316 @@
+# Changelog
+
+## **v1.0.0rc1 (14/10/2022)**
+
+**Highlights**
+
+- Release RTMPose, a high-performance real-time pose estimation algorithm with cross-platform deployment and inference support. See details at the [project page](/projects/rtmpose/)
+- Support several new algorithms: ViTPose (arXiv'2022), CID (CVPR'2022), DEKR (CVPR'2021)
+- Add Inferencer, a convenient inference interface that perform pose estimation and visualization on images, videos and webcam streams with only one line of code
+- Introduce *Project*, a new form for rapid and easy implementation of new algorithms and features in MMPose, which is more handy for community contributors
+
+**New Features**
+
+- Support RTMPose ([#1971](https://github.com/open-mmlab/mmpose/pull/1971), [#2024](https://github.com/open-mmlab/mmpose/pull/2024), [#2028](https://github.com/open-mmlab/mmpose/pull/2028), [#2030](https://github.com/open-mmlab/mmpose/pull/2030), [#2040](https://github.com/open-mmlab/mmpose/pull/2040), [#2057](https://github.com/open-mmlab/mmpose/pull/2057))
+- Support Inferencer ([#1969](https://github.com/open-mmlab/mmpose/pull/1969))
+- Support ViTPose ([#1876](https://github.com/open-mmlab/mmpose/pull/1876), [#2056](https://github.com/open-mmlab/mmpose/pull/2056), [#2058](https://github.com/open-mmlab/mmpose/pull/2058)， [#2065](https://github.com/open-mmlab/mmpose/pull/2065))
+- Support CID ([#1907](https://github.com/open-mmlab/mmpose/pull/1907))
+- Support DEKR ([#1834](https://github.com/open-mmlab/mmpose/pull/1834), [#1901](https://github.com/open-mmlab/mmpose/pull/1901))
+- Support training with multiple datasets ([#1767](https://github.com/open-mmlab/mmpose/pull/1767), [#1930](https://github.com/open-mmlab/mmpose/pull/1930), [#1938](https://github.com/open-mmlab/mmpose/pull/1938), [#2025](https://github.com/open-mmlab/mmpose/pull/2025))
+- Add *project* to allow rapid and easy implementation of new models and features ([#1914](https://github.com/open-mmlab/mmpose/pull/1914))
+
+**Improvements**
+
+- Improve documentation quality ([#1846](https://github.com/open-mmlab/mmpose/pull/1846), [#1858](https://github.com/open-mmlab/mmpose/pull/1858), [#1872](https://github.com/open-mmlab/mmpose/pull/1872), [#1899](https://github.com/open-mmlab/mmpose/pull/1899), [#1925](https://github.com/open-mmlab/mmpose/pull/1925), [#1945](https://github.com/open-mmlab/mmpose/pull/1945), [#1952](https://github.com/open-mmlab/mmpose/pull/1952), [#1990](https://github.com/open-mmlab/mmpose/pull/1990), [#2023](https://github.com/open-mmlab/mmpose/pull/2023), [#2042](https://github.com/open-mmlab/mmpose/pull/2042))
+- Support visualizing keypoint indices ([#2051](https://github.com/open-mmlab/mmpose/pull/2051))
+- Support OpenPose style visualization ([#2055](https://github.com/open-mmlab/mmpose/pull/2055))
+- Accelerate image transpose in data pipelines with tensor operation ([#1976](https://github.com/open-mmlab/mmpose/pull/1976))
+- Support auto-import modules from registry ([#1961](https://github.com/open-mmlab/mmpose/pull/1961))
+- Support keypoint partition metric ([#1944](https://github.com/open-mmlab/mmpose/pull/1944))
+- Support SimCC 1D-heatmap visualization ([#1912](https://github.com/open-mmlab/mmpose/pull/1912))
+- Support saving predictions and data metainfo in demos ([#1814](https://github.com/open-mmlab/mmpose/pull/1814), [#1879](https://github.com/open-mmlab/mmpose/pull/1879))
+- Support SimCC with DARK ([#1870](https://github.com/open-mmlab/mmpose/pull/1870))
+- Remove Gaussian blur for offset maps in UDP-regress ([#1815](https://github.com/open-mmlab/mmpose/pull/1815))
+- Refactor encoding interface of Codec for better extendibility and easier configuration ([#1781](https://github.com/open-mmlab/mmpose/pull/1781))
+- Support evaluating CocoMetric without annotation file ([#1722](https://github.com/open-mmlab/mmpose/pull/1722))
+- Improve unit tests ([#1765](https://github.com/open-mmlab/mmpose/pull/1765))
+
+**Bug Fixes**
+
+- Fix repeated warnings from different ranks ([#2053](https://github.com/open-mmlab/mmpose/pull/2053))
+- Avoid frequent scope switching when using mmdet inference api ([#2039](https://github.com/open-mmlab/mmpose/pull/2039))
+- Remove EMA parameters and message hub data when publishing model checkpoints ([#2036](https://github.com/open-mmlab/mmpose/pull/2036))
+- Fix metainfo copying in dataset class ([#2017](https://github.com/open-mmlab/mmpose/pull/2017))
+- Fix top-down demo bug when there is no object detected ([#2007](https://github.com/open-mmlab/mmpose/pull/2007))
+- Fix config errors ([#1882](https://github.com/open-mmlab/mmpose/pull/1882), [#1906](https://github.com/open-mmlab/mmpose/pull/1906), [#1995](https://github.com/open-mmlab/mmpose/pull/1995))
+- Fix image demo failure when GUI is unavailable ([#1968](https://github.com/open-mmlab/mmpose/pull/1968))
+- Fix bug in AdaptiveWingLoss ([#1953](https://github.com/open-mmlab/mmpose/pull/1953))
+- Fix incorrect importing of RepeatDataset which is deprecated ([#1943](https://github.com/open-mmlab/mmpose/pull/1943))
+- Fix bug in bottom-up datasets that ignores images without instances ([#1752](https://github.com/open-mmlab/mmpose/pull/1752), [#1936](https://github.com/open-mmlab/mmpose/pull/1936))
+- Fix upstream dependency issues ([#1867](https://github.com/open-mmlab/mmpose/pull/1867), [#1921](https://github.com/open-mmlab/mmpose/pull/1921))
+- Fix evaluation issues and update results ([#1763](https://github.com/open-mmlab/mmpose/pull/1763), [#1773](https://github.com/open-mmlab/mmpose/pull/1773), [#1780](https://github.com/open-mmlab/mmpose/pull/1780), [#1850](https://github.com/open-mmlab/mmpose/pull/1850), [#1868](https://github.com/open-mmlab/mmpose/pull/1868))
+- Fix local registry missing warnings ([#1849](https://github.com/open-mmlab/mmpose/pull/1849))
+- Remove deprecated scripts for model deployment ([#1845](https://github.com/open-mmlab/mmpose/pull/1845))
+- Fix a bug in input transformation in BaseHead ([#1843](https://github.com/open-mmlab/mmpose/pull/1843))
+- Fix an interface mismatch with MMDetection in webcam demo ([#1813](https://github.com/open-mmlab/mmpose/pull/1813))
+- Fix a bug in heatmap visualization that causes incorrect scale ([#1800](https://github.com/open-mmlab/mmpose/pull/1800))
+- Add model metafiles ([#1768](https://github.com/open-mmlab/mmpose/pull/1768))
+
+## **v1.0.0rc0 (14/10/2022)**
+
+**New Features**
+
+- Support 4 light-weight pose estimation algorithms: [SimCC](https://doi.org/10.48550/arxiv.2107.03332) (ECCV'2022), [Debias-IPR](https://openaccess.thecvf.com/content/ICCV2021/papers/Gu_Removing_the_Bias_of_Integral_Pose_Regression_ICCV_2021_paper.pdf) (ICCV'2021), [IPR](https://arxiv.org/abs/1711.08229) (ECCV'2018), and [DSNT](https://arxiv.org/abs/1801.07372v2) (ArXiv'2018) ([#1628](https://github.com/open-mmlab/mmpose/pull/1628))
+
+**Migrations**
+
+- Add Webcam API in MMPose 1.0 ([#1638](https://github.com/open-mmlab/mmpose/pull/1638), [#1662](https://github.com/open-mmlab/mmpose/pull/1662)) @Ben-Louis
+- Add codec for Associative Embedding (beta) ([#1603](https://github.com/open-mmlab/mmpose/pull/1603)) @ly015
+
+**Improvements**
+
+- Add a colab tutorial for MMPose 1.0 ([#1660](https://github.com/open-mmlab/mmpose/pull/1660)) @Tau-J
+- Add model index in config folder ([#1710](https://github.com/open-mmlab/mmpose/pull/1710), [#1709](https://github.com/open-mmlab/mmpose/pull/1709), [#1627](https://github.com/open-mmlab/mmpose/pull/1627)) @ly015, @Tau-J, @Ben-Louis
+- Update and improve documentation ([#1692](https://github.com/open-mmlab/mmpose/pull/1692), [#1656](https://github.com/open-mmlab/mmpose/pull/1656), [#1681](https://github.com/open-mmlab/mmpose/pull/1681), [#1677](https://github.com/open-mmlab/mmpose/pull/1677), [#1664](https://github.com/open-mmlab/mmpose/pull/1664), [#1659](https://github.com/open-mmlab/mmpose/pull/1659)) @Tau-J, @Ben-Louis, @liqikai9
+- Improve config structures and formats ([#1651](https://github.com/open-mmlab/mmpose/pull/1651)) @liqikai9
+
+**Bug Fixes**
+
+- Update mmengine version requirements ([#1715](https://github.com/open-mmlab/mmpose/pull/1715)) @Ben-Louis
+- Update dependencies of pre-commit hooks ([#1705](https://github.com/open-mmlab/mmpose/pull/1705)) @Ben-Louis
+- Fix mmcv version in DockerFile ([#1704](https://github.com/open-mmlab/mmpose/pull/1704))
+- Fix a bug in setting dataset metainfo in configs ([#1684](https://github.com/open-mmlab/mmpose/pull/1684)) @ly015
+- Fix a bug in UDP training ([#1682](https://github.com/open-mmlab/mmpose/pull/1682)) @liqikai9
+- Fix a bug in Dark decoding ([#1676](https://github.com/open-mmlab/mmpose/pull/1676)) @liqikai9
+- Fix bugs in visualization ([#1671](https://github.com/open-mmlab/mmpose/pull/1671), [#1668](https://github.com/open-mmlab/mmpose/pull/1668), [#1657](https://github.com/open-mmlab/mmpose/pull/1657)) @liqikai9, @Ben-Louis
+- Fix incorrect flops calculation ([#1669](https://github.com/open-mmlab/mmpose/pull/1669)) @liqikai9
+- Fix `tensor.tile` compatibility issue for pytorch 1.6 ([#1658](https://github.com/open-mmlab/mmpose/pull/1658)) @ly015
+- Fix compatibility with `MultilevelPixelData` ([#1647](https://github.com/open-mmlab/mmpose/pull/1647)) @liqikai9
+
+## **v1.0.0beta (1/09/2022)**
+
+We are excited to announce the release of MMPose 1.0.0beta.
+MMPose 1.0.0beta is the first version of MMPose 1.x, a part of the OpenMMLab 2.0 projects.
+Built upon the new [training engine](https://github.com/open-mmlab/mmengine),
+MMPose 1.x unifies the interfaces of dataset, models, evaluation, and visualization with faster training and testing speed.
+It also provide a general semi-supervised object detection framework, and more strong baselines.
+
+**Highlights**
+
+- **New engines**. MMPose 1.x is based on [MMEngine](https://github.com/open-mmlab/mmengine), which provides a general and powerful runner that allows more flexible customizations and significantly simplifies the entrypoints of high-level interfaces.
+
+- **Unified interfaces**. As a part of the OpenMMLab 2.0 projects, MMPose 1.x unifies and refactors the interfaces and internal logics of train, testing, datasets, models, evaluation, and visualization. All the OpenMMLab 2.0 projects share the same design in those interfaces and logics to allow the emergence of multi-task/modality algorithms.
+
+- **More documentation and tutorials**. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmpose.readthedocs.io/en/latest/).
+
+**Breaking Changes**
+
+In this release, we made lots of major refactoring and modifications. Please refer to the [migration guide](../migration.md) for details and migration instructions.
+
+## **v0.28.1 (28/07/2022)**
+
+This release is meant to fix the compatibility with the latest mmcv v1.6.1
+
+## **v0.28.0 (06/07/2022)**
+
+**Highlights**
+
+- Support [TCFormer](https://openaccess.thecvf.com/content/CVPR2022/html/Zeng_Not_All_Tokens_Are_Equal_Human-Centric_Visual_Analysis_via_Token_CVPR_2022_paper.html) backbone, CVPR'2022 ([#1447](https://github.com/open-mmlab/mmpose/pull/1447), [#1452](https://github.com/open-mmlab/mmpose/pull/1452)) @zengwang430521
+
+- Add [RLE](https://arxiv.org/abs/2107.11291) models on COCO dataset ([#1424](https://github.com/open-mmlab/mmpose/pull/1424)) @Indigo6, @Ben-Louis, @ly015
+
+- Update swin models with better performance ([#1467](https://github.com/open-mmlab/mmpose/pull/1434)) @jin-s13
+
+**New Features**
+
+- Support [TCFormer](https://openaccess.thecvf.com/content/CVPR2022/html/Zeng_Not_All_Tokens_Are_Equal_Human-Centric_Visual_Analysis_via_Token_CVPR_2022_paper.html) backbone, CVPR'2022 ([#1447](https://github.com/open-mmlab/mmpose/pull/1447), [#1452](https://github.com/open-mmlab/mmpose/pull/1452)) @zengwang430521
+
+- Add [RLE](https://arxiv.org/abs/2107.11291) models on COCO dataset ([#1424](https://github.com/open-mmlab/mmpose/pull/1424)) @Indigo6, @Ben-Louis, @ly015
+
+- Support layer decay optimizer constructor and learning rate decay optimizer constructor ([#1423](https://github.com/open-mmlab/mmpose/pull/1423)) @jin-s13
+
+**Improvements**
+
+- Improve documentation quality ([#1416](https://github.com/open-mmlab/mmpose/pull/1416), [#1421](https://github.com/open-mmlab/mmpose/pull/1421), [#1423](https://github.com/open-mmlab/mmpose/pull/1423), [#1426](https://github.com/open-mmlab/mmpose/pull/1426), [#1458](https://github.com/open-mmlab/mmpose/pull/1458), [#1463](https://github.com/open-mmlab/mmpose/pull/1463)) @ly015, @liqikai9
+
+- Support installation by [mim](https://github.com/open-mmlab/mim) ([#1425](https://github.com/open-mmlab/mmpose/pull/1425)) @liqikai9
+
+- Support PAVI logger ([#1434](https://github.com/open-mmlab/mmpose/pull/1434)) @EvelynWang-0423
+
+- Add progress bar for some demos ([#1454](https://github.com/open-mmlab/mmpose/pull/1454)) @liqikai9
+
+- Webcam API supports quick device setting in terminal commands ([#1466](https://github.com/open-mmlab/mmpose/pull/1466)) @ly015
+
+- Update swin models with better performance ([#1467](https://github.com/open-mmlab/mmpose/pull/1434)) @jin-s13
+
+**Bug Fixes**
+
+- Rename `custom_hooks_config` to `custom_hooks` in configs to align with the documentation ([#1427](https://github.com/open-mmlab/mmpose/pull/1427)) @ly015
+
+- Fix deadlock issue in Webcam API ([#1430](https://github.com/open-mmlab/mmpose/pull/1430)) @ly015
+
+- Fix smoother configs in video 3D demo ([#1457](https://github.com/open-mmlab/mmpose/pull/1457)) @ly015
+
+## **v0.27.0 (07/06/2022)**
+
+**Highlights**
+
+- Support hand gesture recognition
+
+ - Try the demo for gesture recognition
+ - Learn more about the algorithm, dataset and experiment results
+
+- Major upgrade to the Webcam API
+
+ - Tutorials (EN|zh_CN)
+ - [API Reference](https://mmpose.readthedocs.io/en/latest/api.html#mmpose-apis-webcam)
+ - Demo
+
+**New Features**
+
+- Support gesture recognition algorithm [MTUT](https://openaccess.thecvf.com/content_CVPR_2019/html/Abavisani_Improving_the_Performance_of_Unimodal_Dynamic_Hand-Gesture_Recognition_With_Multimodal_CVPR_2019_paper.html) CVPR'2019 and dataset [NVGesture](https://openaccess.thecvf.com/content_cvpr_2016/html/Molchanov_Online_Detection_and_CVPR_2016_paper.html) CVPR'2016 ([#1380](https://github.com/open-mmlab/mmpose/pull/1380)) @Ben-Louis
+
+**Improvements**
+
+- Upgrade Webcam API and related documents ([#1393](https://github.com/open-mmlab/mmpose/pull/1393), [#1404](https://github.com/open-mmlab/mmpose/pull/1404), [#1413](https://github.com/open-mmlab/mmpose/pull/1413)) @ly015
+
+- Support exporting COCO inference result without the annotation file ([#1368](https://github.com/open-mmlab/mmpose/pull/1368)) @liqikai9
+
+- Replace markdownlint with mdformat in CI to avoid the dependence on ruby [#1382](https://github.com/open-mmlab/mmpose/pull/1382) @ly015
+
+- Improve documentation quality ([#1385](https://github.com/open-mmlab/mmpose/pull/1385), [#1394](https://github.com/open-mmlab/mmpose/pull/1394), [#1395](https://github.com/open-mmlab/mmpose/pull/1395), [#1408](https://github.com/open-mmlab/mmpose/pull/1408)) @chubei-oppen, @ly015, @liqikai9
+
+**Bug Fixes**
+
+- Fix xywh->xyxy bbox conversion in dataset sanity check ([#1367](https://github.com/open-mmlab/mmpose/pull/1367)) @jin-s13
+
+- Fix a bug in two-stage 3D keypoint demo ([#1373](https://github.com/open-mmlab/mmpose/pull/1373)) @ly015
+
+- Fix out-dated settings in PVT configs ([#1376](https://github.com/open-mmlab/mmpose/pull/1376)) @ly015
+
+- Fix myst settings for document compiling ([#1381](https://github.com/open-mmlab/mmpose/pull/1381)) @ly015
+
+- Fix a bug in bbox transform ([#1384](https://github.com/open-mmlab/mmpose/pull/1384)) @ly015
+
+- Fix inaccurate description of `min_keypoints` in tracking apis ([#1398](https://github.com/open-mmlab/mmpose/pull/1398)) @pallgeuer
+
+- Fix warning with `torch.meshgrid` ([#1402](https://github.com/open-mmlab/mmpose/pull/1402)) @pallgeuer
+
+- Remove redundant transformer modules from `mmpose.datasets.backbones.utils` ([#1405](https://github.com/open-mmlab/mmpose/pull/1405)) @ly015
+
+## **v0.26.0 (05/05/2022)**
+
+**Highlights**
+
+- Support [RLE (Residual Log-likelihood Estimation)](https://arxiv.org/abs/2107.11291), ICCV'2021 ([#1259](https://github.com/open-mmlab/mmpose/pull/1259)) @Indigo6, @ly015
+
+- Support [Swin Transformer](https://arxiv.org/abs/2103.14030), ICCV'2021 ([#1300](https://github.com/open-mmlab/mmpose/pull/1300)) @yumendecc, @ly015
+
+- Support [PVT](https://arxiv.org/abs/2102.12122), ICCV'2021 and [PVTv2](https://arxiv.org/abs/2106.13797), CVMJ'2022 ([#1343](https://github.com/open-mmlab/mmpose/pull/1343)) @zengwang430521
+
+- Speed up inference and reduce CPU usage by optimizing the pre-processing pipeline ([#1320](https://github.com/open-mmlab/mmpose/pull/1320)) @chenxinfeng4, @liqikai9
+
+**New Features**
+
+- Support [RLE (Residual Log-likelihood Estimation)](https://arxiv.org/abs/2107.11291), ICCV'2021 ([#1259](https://github.com/open-mmlab/mmpose/pull/1259)) @Indigo6, @ly015
+
+- Support [Swin Transformer](https://arxiv.org/abs/2103.14030), ICCV'2021 ([#1300](https://github.com/open-mmlab/mmpose/pull/1300)) @yumendecc, @ly015
+
+- Support [PVT](https://arxiv.org/abs/2102.12122), ICCV'2021 and [PVTv2](https://arxiv.org/abs/2106.13797), CVMJ'2022 ([#1343](https://github.com/open-mmlab/mmpose/pull/1343)) @zengwang430521
+
+- Support [FPN](https://openaccess.thecvf.com/content_cvpr_2017/html/Lin_Feature_Pyramid_Networks_CVPR_2017_paper.html), CVPR'2017 ([#1300](https://github.com/open-mmlab/mmpose/pull/1300)) @yumendecc, @ly015
+
+**Improvements**
+
+- Speed up inference and reduce CPU usage by optimizing the pre-processing pipeline ([#1320](https://github.com/open-mmlab/mmpose/pull/1320)) @chenxinfeng4, @liqikai9
+
+- Video demo supports models that requires multi-frame inputs ([#1300](https://github.com/open-mmlab/mmpose/pull/1300)) @liqikai9, @jin-s13
+
+- Update benchmark regression list ([#1328](https://github.com/open-mmlab/mmpose/pull/1328)) @ly015, @liqikai9
+
+- Remove unnecessary warnings in `TopDownPoseTrack18VideoDataset` ([#1335](https://github.com/open-mmlab/mmpose/pull/1335)) @liqikai9
+
+- Improve documentation quality ([#1313](https://github.com/open-mmlab/mmpose/pull/1313), [#1305](https://github.com/open-mmlab/mmpose/pull/1305)) @Ben-Louis, @ly015
+
+- Update deprecating settings in configs ([#1317](https://github.com/open-mmlab/mmpose/pull/1317)) @ly015
+
+**Bug Fixes**
+
+- Fix a bug in human skeleton grouping that may skip the matching process unexpectedly when `ignore_to_much` is True ([#1341](https://github.com/open-mmlab/mmpose/pull/1341)) @daixinghome
+
+- Fix a GPG key error that leads to CI failure ([#1354](https://github.com/open-mmlab/mmpose/pull/1354)) @ly015
+
+- Fix bugs in distributed training script ([#1338](https://github.com/open-mmlab/mmpose/pull/1338), [#1298](https://github.com/open-mmlab/mmpose/pull/1298)) @ly015
+
+- Fix an upstream bug in xtoccotools that causes incorrect AP(M) results ([#1308](https://github.com/open-mmlab/mmpose/pull/1308)) @jin-s13, @ly015
+
+- Fix indentiation errors in the colab tutorial ([#1298](https://github.com/open-mmlab/mmpose/pull/1298)) @YuanZi1501040205
+
+- Fix incompatible model weight initialization with other OpenMMLab codebases ([#1329](https://github.com/open-mmlab/mmpose/pull/1329)) @274869388
+
+- Fix HRNet FP16 checkpoints download URL ([#1309](https://github.com/open-mmlab/mmpose/pull/1309)) @YinAoXiong
+
+- Fix typos in `body3d_two_stage_video_demo.py` ([#1295](https://github.com/open-mmlab/mmpose/pull/1295)) @mucozcan
+
+**Breaking Changes**
+
+- Refactor bbox processing in datasets and pipelines ([#1311](https://github.com/open-mmlab/mmpose/pull/1311)) @ly015, @Ben-Louis
+
+- The bbox format conversion (xywh to center-scale) and random translation are moved from the dataset to the pipeline. The comparison between new and old version is as below:
+
+v0.26.0v0.25.0Dataset
+(e.g. [TopDownCOCODataset](https://github.com/open-mmlab/mmpose/blob/master/mmpose/datasets/datasets/top_down/topdown_coco_dataset.py))
+
+... # Data sample only contains bbox rec.append({ 'bbox': obj\['clean_bbox\]\[:4\], ... })
+
+
+
+
+
+
+
+对于 [Animal-Pose](https://sites.google.com/view/animal-pose/)，可以从[官方网站](https://sites.google.com/view/animal-pose/)下载图像和标注。脚本 `tools/dataset_converters/parse_animalpose_dataset.py` 将原始标注转换为 MMPose 兼容的格式。预处理的[标注文件](https://download.openmmlab.com/mmpose/datasets/animalpose_annotations.tar)可用。如果您想自己生成标注，请按照以下步骤操作：
+
+1. 下载图片与标注信息并解压到 `$MMPOSE/data`，按照以下格式组织：
+
+ ```text
+ mmpose
+ ├── mmpose
+ ├── docs
+ ├── tests
+ ├── tools
+ ├── configs
+ `── data
+ │── animalpose
+ │
+ │-- VOC2012
+ │ │-- Annotations
+ │ │-- ImageSets
+ │ │-- JPEGImages
+ │ │-- SegmentationClass
+ │ │-- SegmentationObject
+ │
+ │-- animalpose_image_part2
+ │ │-- cat
+ │ │-- cow
+ │ │-- dog
+ │ │-- horse
+ │ │-- sheep
+ │
+ │-- PASCAL2011_animal_annotation
+ │ │-- cat
+ │ │ |-- 2007_000528_1.xml
+ │ │ |-- 2007_000549_1.xml
+ │ │ │-- ...
+ │ │-- cow
+ │ │-- dog
+ │ │-- horse
+ │ │-- sheep
+ │
+ │-- annimalpose_anno2
+ │ │-- cat
+ │ │ |-- ca1.xml
+ │ │ |-- ca2.xml
+ │ │ │-- ...
+ │ │-- cow
+ │ │-- dog
+ │ │-- horse
+ │ │-- sheep
+ ```
+
+2. 运行脚本
+
+ ```bash
+ python tools/dataset_converters/parse_animalpose_dataset.py
+ ```
+
+ 生成的标注文件将保存在 `$MMPOSE/data/animalpose/annotations` 中。
+
+开源作者没有提供官方的 train/val/test 划分，我们选择来自 PascalVOC 的图片作为 train & val，train+val 一共 3600 张图片，5117 个标注。其中 2798 张图片，4000 个标注用于训练，810 张图片，1117 个标注用于验证。测试集包含 1000 张图片，1000 个标注用于评估。
+
+## COFW 数据集
+
+Animal-Pose (ICCV'2019)
+ +```bibtex +@InProceedings{Cao_2019_ICCV, + author = {Cao, Jinkun and Tang, Hongyang and Fang, Hao-Shu and Shen, Xiaoyong and Lu, Cewu and Tai, Yu-Wing}, + title = {Cross-Domain Adaptation for Animal Pose Estimation}, + booktitle = {The IEEE International Conference on Computer Vision (ICCV)}, + month = {October}, + year = {2019} +} +``` + +
+
+
+对于 COFW 数据集，请从 [COFW Dataset (Color Images)](https://data.caltech.edu/records/20099) 进行下载。
+
+将 `COFW_train_color.mat` 和 `COFW_test_color.mat` 移动到 `$MMPOSE/data/cofw/`，确保它们按照以下格式组织：
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── cofw
+ |── COFW_train_color.mat
+ |── COFW_test_color.mat
+```
+
+运行 `pip install h5py` 安装依赖，然后在 `$MMPOSE` 下运行脚本：
+
+```bash
+python tools/dataset_converters/parse_cofw_dataset.py
+```
+
+最终结果为：
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ │── cofw
+ |── COFW_train_color.mat
+ |── COFW_test_color.mat
+ |── annotations
+ | |── cofw_train.json
+ | |── cofw_test.json
+ |── images
+ |── 000001.jpg
+ |── 000002.jpg
+```
+
+## DeepposeKit 数据集
+
+COFW (ICCV'2013)
+ +```bibtex +@inproceedings{burgos2013robust, + title={Robust face landmark estimation under occlusion}, + author={Burgos-Artizzu, Xavier P and Perona, Pietro and Doll{\'a}r, Piotr}, + booktitle={Proceedings of the IEEE international conference on computer vision}, + pages={1513--1520}, + year={2013} +} +``` + +
+
+
+对于 [Vinegar Fly](https://github.com/jgraving/DeepPoseKit-Data)，[Desert Locust](https://github.com/jgraving/DeepPoseKit-Data), 和 [Grévy’s Zebra](https://github.com/jgraving/DeepPoseKit-Data) 数据集，请从 [DeepPoseKit-Data](https://github.com/jgraving/DeepPoseKit-Data) 下载数据。
+
+`tools/dataset_converters/parse_deepposekit_dataset.py` 脚本可以将原始标注转换为 MMPose 支持的格式。我们已经转换好的标注文件可以在这里下载：
+
+- [vinegar_fly_annotations](https://download.openmmlab.com/mmpose/datasets/vinegar_fly_annotations.tar)
+- [locust_annotations](https://download.openmmlab.com/mmpose/datasets/locust_annotations.tar)
+- [zebra_annotations](https://download.openmmlab.com/mmpose/datasets/zebra_annotations.tar)
+
+如果你希望自己转换数据，请按照以下步骤操作：
+
+1. 下载原始图片和标注，并解压到 `$MMPOSE/data`，将它们按照以下格式组织：
+
+ ```text
+ mmpose
+ ├── mmpose
+ ├── docs
+ ├── tests
+ ├── tools
+ ├── configs
+ `── data
+ |
+ |── DeepPoseKit-Data
+ | `── datasets
+ | |── fly
+ | | |── annotation_data_release.h5
+ | | |── skeleton.csv
+ | | |── ...
+ | |
+ | |── locust
+ | | |── annotation_data_release.h5
+ | | |── skeleton.csv
+ | | |── ...
+ | |
+ | `── zebra
+ | |── annotation_data_release.h5
+ | |── skeleton.csv
+ | |── ...
+ |
+ │── fly
+ `-- images
+ │-- 0.jpg
+ │-- 1.jpg
+ │-- ...
+ ```
+
+ 图片也可以在 [vinegar_fly_images](https://download.openmmlab.com/mmpose/datasets/vinegar_fly_images.tar)，[locust_images](https://download.openmmlab.com/mmpose/datasets/locust_images.tar) 和[zebra_images](https://download.openmmlab.com/mmpose/datasets/zebra_images.tar) 下载。
+
+2. 运行脚本：
+
+ ```bash
+ python tools/dataset_converters/parse_deepposekit_dataset.py
+ ```
+
+ 生成的标注文件将保存在 $MMPOSE/data/fly/annotations`，`$MMPOSE/data/locust/annotations`和`$MMPOSE/data/zebra/annotations\` 中。
+
+由于官方数据集中没有提供测试集，我们随机选择了 90% 的图片用于训练，剩下的 10% 用于测试。
+
+## Macaque 数据集
+
+Desert Locust (Elife'2019)
+ +```bibtex +@article{graving2019deepposekit, + title={DeepPoseKit, a software toolkit for fast and robust animal pose estimation using deep learning}, + author={Graving, Jacob M and Chae, Daniel and Naik, Hemal and Li, Liang and Koger, Benjamin and Costelloe, Blair R and Couzin, Iain D}, + journal={Elife}, + volume={8}, + pages={e47994}, + year={2019}, + publisher={eLife Sciences Publications Limited} +} +``` + +
+
+
+对于 [MacaquePose](http://www2.ehub.kyoto-u.ac.jp/datasets/macaquepose/index.html) 数据集，请从 [这里](http://www2.ehub.kyoto-u.ac.jp/datasets/macaquepose/index.html) 下载数据。
+
+`tools/dataset_converters/parse_macaquepose_dataset.py` 脚本可以将原始标注转换为 MMPose 支持的格式。我们已经转换好的标注文件可以在 [这里](https://download.openmmlab.com/mmpose/datasets/macaque_annotations.tar) 下载。
+
+如果你希望自己转换数据，请按照以下步骤操作：
+
+1. 下载原始图片和标注，并解压到 `$MMPOSE/data`，将它们按照以下格式组织：
+
+ ```text
+ mmpose
+ ├── mmpose
+ ├── docs
+ ├── tests
+ ├── tools
+ ├── configs
+ `── data
+ │── macaque
+ │-- annotations.csv
+ │-- images
+ │ │-- 01418849d54b3005.jpg
+ │ │-- 0142d1d1a6904a70.jpg
+ │ │-- 01ef2c4c260321b7.jpg
+ │ │-- 020a1c75c8c85238.jpg
+ │ │-- 020b1506eef2557d.jpg
+ │ │-- ...
+ ```
+
+2. 运行脚本：
+
+ ```bash
+ python tools/dataset_converters/parse_macaquepose_dataset.py
+ ```
+
+ 生成的标注文件将保存在 `$MMPOSE/data/macaque/annotations` 中。
+
+由于官方数据集中没有提供测试集，我们随机选择了 90% 的图片用于训练，剩下的 10% 用于测试。
+
+## Human3.6M 数据集
+
+MacaquePose (bioRxiv'2020)
+ +```bibtex +@article{labuguen2020macaquepose, + title={MacaquePose: A novel ‘in the wild’macaque monkey pose dataset for markerless motion capture}, + author={Labuguen, Rollyn and Matsumoto, Jumpei and Negrete, Salvador and Nishimaru, Hiroshi and Nishijo, Hisao and Takada, Masahiko and Go, Yasuhiro and Inoue, Ken-ichi and Shibata, Tomohiro}, + journal={bioRxiv}, + year={2020}, + publisher={Cold Spring Harbor Laboratory} +} +``` + +
+
+
+对于 [Human3.6M](http://vision.imar.ro/human3.6m/description.php) 数据集，请从官网下载数据，放置到 `$MMPOSE/data/h36m` 下。
+
+然后执行 [预处理脚本](/tools/dataset_converters/preprocess_h36m.py)。
+
+```bash
+python tools/dataset_converters/preprocess_h36m.py --metadata {path to metadata.xml} --original data/h36m
+```
+
+这将在全帧率（50 FPS）和降频帧率（10 FPS）下提取相机参数和姿势注释。处理后的数据应具有以下结构：
+
+```text
+mmpose
+├── mmpose
+├── docs
+├── tests
+├── tools
+├── configs
+`── data
+ ├── h36m
+ ├── annotation_body3d
+ | ├── cameras.pkl
+ | ├── fps50
+ | | ├── h36m_test.npz
+ | | ├── h36m_train.npz
+ | | ├── joint2d_rel_stats.pkl
+ | | ├── joint2d_stats.pkl
+ | | ├── joint3d_rel_stats.pkl
+ | | `── joint3d_stats.pkl
+ | `── fps10
+ | ├── h36m_test.npz
+ | ├── h36m_train.npz
+ | ├── joint2d_rel_stats.pkl
+ | ├── joint2d_stats.pkl
+ | ├── joint3d_rel_stats.pkl
+ | `── joint3d_stats.pkl
+ `── images
+ ├── S1
+ | ├── S1_Directions_1.54138969
+ | | ├── S1_Directions_1.54138969_00001.jpg
+ | | ├── S1_Directions_1.54138969_00002.jpg
+ | | ├── ...
+ | ├── ...
+ ├── S5
+ ├── S6
+ ├── S7
+ ├── S8
+ ├── S9
+ `── S11
+```
+
+然后，标注信息需要转换为 MMPose 支持的 COCO 格式。这可以通过运行以下命令完成：
+
+```bash
+python tools/dataset_converters/h36m_to_coco.py
+```
+
+## MPII 数据集
+
+Human3.6M (TPAMI'2014)
+ +```bibtex +@article{h36m_pami, + author = {Ionescu, Catalin and Papava, Dragos and Olaru, Vlad and Sminchisescu, Cristian}, + title = {Human3.6M: Large Scale Datasets and Predictive Methods for 3D Human Sensing in Natural Environments}, + journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher = {IEEE Computer Society}, + volume = {36}, + number = {7}, + pages = {1325-1339}, + month = {jul}, + year = {2014} +} +``` + +
+
+
+对于 [MPII](http://human-pose.mpi-inf.mpg.de/) 数据集，请从官网下载数据，放置到 `$MMPOSE/data/mpii` 下。
+
+我们提供了一个脚本来将 `.mat` 格式的标注文件转换为 `.json` 格式。这可以通过运行以下命令完成：
+
+```shell
+python tools/dataset_converters/mat2json ${PRED_MAT_FILE} ${GT_JSON_FILE} ${OUTPUT_PRED_JSON_FILE}
+```
+
+例如：
+
+```shell
+python tools/dataset/mat2json work_dirs/res50_mpii_256x256/pred.mat data/mpii/annotations/mpii_val.json pred.json
+```
+
+## Label Studio 数据集
+
+MPII (CVPR'2014)
+ +```bibtex +@inproceedings{andriluka14cvpr, + author = {Mykhaylo Andriluka and Leonid Pishchulin and Peter Gehler and Schiele, Bernt}, + title = {2D Human Pose Estimation: New Benchmark and State of the Art Analysis}, + booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2014}, + month = {June} +} +``` + +
+
+
+对于 [Label Studio](https://github.com/heartexlabs/label-studio/) 用户，请依照 [Label Studio 转换工具文档](./label_studio.md) 中的方法进行标注，并将结果导出为 Label Studio 标准的 `.json` 文件，将 `Labeling Interface` 中的 `Code` 保存为 `.xml` 文件。
+
+我们提供了一个脚本来将 Label Studio 标准的 `.json` 格式标注文件转换为 COCO 标准的 `.json` 格式。这可以通过运行以下命令完成：
+
+```shell
+python tools/dataset_converters/labelstudio2coco.py ${LS_JSON_FILE} ${LS_XML_FILE} ${OUTPUT_COCO_JSON_FILE}
+```
+
+例如：
+
+```shell
+python tools/dataset_converters/labelstudio2coco.py config.xml project-1-at-2023-05-13-09-22-91b53efa.json output/result.json
+```
diff --git a/internlm_langchain/knowledge_base/MMPose/content/ecosystem.md b/internlm_langchain/knowledge_base/MMPose/content/ecosystem.md
new file mode 100644
index 00000000..b0027cfa
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/ecosystem.md
@@ -0,0 +1,3 @@
+# Ecosystem
+
+Coming soon.
diff --git a/internlm_langchain/knowledge_base/MMPose/content/faq.md b/internlm_langchain/knowledge_base/MMPose/content/faq.md
new file mode 100644
index 00000000..b1e69983
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/faq.md
@@ -0,0 +1,148 @@
+# FAQ
+
+We list some common issues faced by many users and their corresponding solutions here.
+Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them.
+If the contents here do not cover your issue, please create an issue using the [provided templates](/.github/ISSUE_TEMPLATE/error-report.md) and make sure you fill in all required information in the template.
+
+## Installation
+
+Compatibility issue between MMCV and MMPose; "AssertionError: MMCV==xxx is used but incompatible. Please install mmcv>=xxx, \<=xxx."
+
+Here are the version correspondences between `mmdet`, `mmcv` and `mmpose`:
+
+- mmdet 2.x \<=> mmpose 0.x \<=> mmcv 1.x
+- mmdet 3.x \<=> mmpose 1.x \<=> mmcv 2.x
+
+Detailed compatible MMPose and MMCV versions are shown as below. Please choose the correct version of MMCV to avoid installation issues.
+
+### MMPose 1.x
+
+| MMPose version | MMCV/MMEngine version |
+| :------------: | :-----------------------------: |
+| 1.1.0 | mmcv>=2.0.1, mmengine>=0.8.0 |
+| 1.0.0 | mmcv>=2.0.0, mmengine>=0.7.0 |
+| 1.0.0rc1 | mmcv>=2.0.0rc4, mmengine>=0.6.0 |
+| 1.0.0rc0 | mmcv>=2.0.0rc0, mmengine>=0.0.1 |
+| 1.0.0b0 | mmcv>=2.0.0rc0, mmengine>=0.0.1 |
+
+### MMPose 0.x
+
+| MMPose version | MMCV version |
+| :------------: | :-----------------------: |
+| 0.x | mmcv-full>=1.3.8, \<1.8.0 |
+| 0.29.0 | mmcv-full>=1.3.8, \<1.7.0 |
+| 0.28.1 | mmcv-full>=1.3.8, \<1.7.0 |
+| 0.28.0 | mmcv-full>=1.3.8, \<1.6.0 |
+| 0.27.0 | mmcv-full>=1.3.8, \<1.6.0 |
+| 0.26.0 | mmcv-full>=1.3.8, \<1.6.0 |
+| 0.25.1 | mmcv-full>=1.3.8, \<1.6.0 |
+| 0.25.0 | mmcv-full>=1.3.8, \<1.5.0 |
+| 0.24.0 | mmcv-full>=1.3.8, \<1.5.0 |
+| 0.23.0 | mmcv-full>=1.3.8, \<1.5.0 |
+| 0.22.0 | mmcv-full>=1.3.8, \<1.5.0 |
+| 0.21.0 | mmcv-full>=1.3.8, \<1.5.0 |
+| 0.20.0 | mmcv-full>=1.3.8, \<1.4.0 |
+| 0.19.0 | mmcv-full>=1.3.8, \<1.4.0 |
+| 0.18.0 | mmcv-full>=1.3.8, \<1.4.0 |
+| 0.17.0 | mmcv-full>=1.3.8, \<1.4.0 |
+| 0.16.0 | mmcv-full>=1.3.8, \<1.4.0 |
+| 0.14.0 | mmcv-full>=1.1.3, \<1.4.0 |
+| 0.13.0 | mmcv-full>=1.1.3, \<1.4.0 |
+| 0.12.0 | mmcv-full>=1.1.3, \<1.3 |
+| 0.11.0 | mmcv-full>=1.1.3, \<1.3 |
+| 0.10.0 | mmcv-full>=1.1.3, \<1.3 |
+| 0.9.0 | mmcv-full>=1.1.3, \<1.3 |
+| 0.8.0 | mmcv-full>=1.1.1, \<1.2 |
+| 0.7.0 | mmcv-full>=1.1.1, \<1.2 |
+
+- **Unable to install xtcocotools**
+
+ 1. Try to install it using pypi manually `pip install xtcocotools`.
+ 2. If step1 does not work. Try to install it from [source](https://github.com/jin-s13/xtcocoapi).
+
+ ```
+ git clone https://github.com/jin-s13/xtcocoapi
+ cd xtcocoapi
+ python setup.py install
+ ```
+
+- **No matching distribution found for xtcocotools>=1.6**
+
+ 1. Install cython by `pip install cython`.
+ 2. Install xtcocotools from [source](https://github.com/jin-s13/xtcocoapi).
+
+ ```
+ git clone https://github.com/jin-s13/xtcocoapi
+ cd xtcocoapi
+ python setup.py install
+ ```
+
+- **"No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'"**
+
+ 1. Uninstall existing mmcv in the environment using `pip uninstall mmcv`.
+ 2. Install mmcv-full following the [installation instruction](https://mmcv.readthedocs.io/en/latest/#installation).
+
+## Data
+
+- **What if my custom dataset does not have bounding box label?**
+
+ We can estimate the bounding box of a person as the minimal box that tightly bounds all the keypoints.
+
+- **What is `COCO_val2017_detections_AP_H_56_person.json`? Can I train pose models without it?**
+
+ "COCO_val2017_detections_AP_H_56_person.json" contains the "detected" human bounding boxes for COCO validation set, which are generated by FasterRCNN.
+ One can choose to use gt bounding boxes to evaluate models, by setting `bbox_file=None''` in `val_dataloader.dataset` in config. Or one can use detected boxes to evaluate
+ the generalizability of models, by setting `bbox_file='COCO_val2017_detections_AP_H_56_person.json'`.
+
+## Training
+
+- **RuntimeError: Address already in use**
+
+ Set the environment variables `MASTER_PORT=XXX`. For example,
+ `MASTER_PORT=29517 GPUS=16 GPUS_PER_NODE=8 CPUS_PER_TASK=2 ./tools/slurm_train.sh Test res50 configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_8xb64-210e_coco-256x192.py work_dirs/res50_coco_256x192`
+
+- **"Unexpected keys in source state dict" when loading pre-trained weights**
+
+ It's normal that some layers in the pretrained model are not used in the pose model. ImageNet-pretrained classification network and the pose network may have different architectures (e.g. no classification head). So some unexpected keys in source state dict is actually expected.
+
+- **How to use trained models for backbone pre-training ?**
+
+ Refer to [Migration - Step3: Model - Backbone](../migration.md).
+
+ When training, the unexpected keys will be ignored.
+
+- **How to visualize the training accuracy/loss curves in real-time ?**
+
+ Use `TensorboardLoggerHook` in `log_config` like
+
+ ```python
+ log_config=dict(interval=20, hooks=[dict(type='TensorboardLoggerHook')])
+ ```
+
+ You can refer to [user_guides/visualization.md](../user_guides/visualization.md).
+
+- **Log info is NOT printed**
+
+ Use smaller log interval. For example, change `interval=50` to `interval=1` in the config.
+
+## Evaluation
+
+- **How to evaluate on MPII test dataset?**
+ Since we do not have the ground-truth for test dataset, we cannot evaluate it 'locally'.
+ If you would like to evaluate the performance on test set, you have to upload the pred.mat (which is generated during testing) to the official server via email, according to [the MPII guideline](http://human-pose.mpi-inf.mpg.de/#evaluation).
+
+- **For top-down 2d pose estimation, why predicted joint coordinates can be out of the bounding box (bbox)?**
+ We do not directly use the bbox to crop the image. bbox will be first transformed to center & scale, and the scale will be multiplied by a factor (1.25) to include some context. If the ratio of width/height is different from that of model input (possibly 192/256), we will adjust the bbox.
+
+## Inference
+
+- **How to run mmpose on CPU?**
+
+ Run demos with `--device=cpu`.
+
+- **How to speed up inference?**
+
+ For top-down models, try to edit the config file. For example,
+
+ 1. set `flip_test=False` in `init_cfg` in the config file.
+ 2. use faster human bounding box detector, see [MMDetection](https://mmdetection.readthedocs.io/zh_CN/3.x/model_zoo.html).
diff --git a/internlm_langchain/knowledge_base/MMPose/content/guide_to_framework.md b/internlm_langchain/knowledge_base/MMPose/content/guide_to_framework.md
new file mode 100644
index 00000000..349abf23
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPose/content/guide_to_framework.md
@@ -0,0 +1,682 @@
+# 20 分钟了解 MMPose 架构设计
+
+MMPose 1.0 与之前的版本有较大改动，对部分模块进行了重新设计和组织，降低代码冗余度，提升运行效率，降低学习难度。
+
+MMPose 1.0 采用了全新的模块结构设计以精简代码，提升运行效率，降低学习难度。对于有一定深度学习基础的用户，本章节提供了对 MMPose 架构设计的总体介绍。不论你是**旧版 MMPose 的用户**，还是**希望直接从 MMPose 1.0 上手的新用户**，都可以通过本教程了解如何构建一个基于 MMPose 1.0 的项目。
+
+```{note}
+本教程包含了使用 MMPose 1.0 时开发者会关心的内容：
+
+- 整体代码架构与设计逻辑
+
+- 如何用config文件管理模块
+
+- 如何使用自定义数据集
+
+- 如何添加新的模块（骨干网络、模型头部、损失函数等）
+```
+
+以下是这篇教程的目录：
+
+- [20 分钟了解 MMPose 架构设计](#20-分钟了解-mmpose-架构设计)
+ - [总览](#总览)
+ - [Step1：配置文件](#step1配置文件)
+ - [Step2：数据](#step2数据)
+ - [数据集元信息](#数据集元信息)
+ - [数据集](#数据集)
+ - [数据流水线](#数据流水线)
+ - [i. 数据增强](#i-数据增强)
+ - [ii. 数据变换](#ii-数据变换)
+ - [iii. 数据编码](#iii-数据编码)
+ - [iv. 数据打包](#iv-数据打包)
+ - [Step3: 模型](#step3-模型)
+ - [前处理器（DataPreprocessor）](#前处理器datapreprocessor)
+ - [主干网络（Backbone）](#主干网络backbone)
+ - [颈部模块（Neck）](#颈部模块neck)
+ - [预测头（Head）](#预测头head)
+
+## 总览
+
+
+
+一般来说，开发者在项目开发过程中经常接触内容的主要有**五个**方面：
+
+- **通用**：环境、钩子（Hook）、模型权重存取（Checkpoint）、日志（Logger）等
+
+- **数据**：数据集、数据读取（Dataloader）、数据增强等
+
+- **训练**：优化器、学习率调整等
+
+- **模型**：主干网络、颈部模块（Neck）、预测头模块（Head）、损失函数等
+
+- **评测**：评测指标（Metric）、评测器（Evaluator）等
+
+其中**通用**、**训练**和**评测**相关的模块往往由训练框架提供，开发者只需要调用和调整参数，不需要自行实现，开发者主要实现的是**数据**和**模型**部分。
+
+## Step1：配置文件
+
+在MMPose中，我们通常 python 格式的配置文件，用于整个项目的定义、参数管理，因此我们强烈建议第一次接触 MMPose 的开发者，查阅 [配置文件](./user_guides/configs.md) 学习配置文件的定义。
+
+需要注意的是，所有新增的模块都需要使用注册器（Registry）进行注册，并在对应目录的 `__init__.py` 中进行 `import`，以便能够使用配置文件构建其实例。
+
+## Step2：数据
+
+MMPose 数据的组织主要包含三个方面：
+
+- 数据集元信息
+
+- 数据集
+
+- 数据流水线
+
+### 数据集元信息
+
+元信息指具体标注之外的数据集信息。姿态估计数据集的元信息通常包括：关键点和骨骼连接的定义、对称性、关键点性质（如关键点权重、标注标准差、所属上下半身）等。这些信息在数据在数据处理、模型训练和测试中有重要作用。在 MMPose 中，数据集的元信息使用 python 格式的配置文件保存，位于 `$MMPOSE/configs/_base_/datasets` 目录下。
+
+在 MMPose 中使用自定义数据集时，你需要增加对应的元信息配置文件。以 MPII 数据集（`$MMPOSE/configs/_base_/datasets/mpii.py`）为例：
+
+```Python
+dataset_info = dict(
+ dataset_name='mpii',
+ paper_info=dict(
+ author='Mykhaylo Andriluka and Leonid Pishchulin and '
+ 'Peter Gehler and Schiele, Bernt',
+ title='2D Human Pose Estimation: New Benchmark and '
+ 'State of the Art Analysis',
+ container='IEEE Conference on Computer Vision and '
+ 'Pattern Recognition (CVPR)',
+ year='2014',
+ homepage='http://human-pose.mpi-inf.mpg.de/',
+ ),
+ keypoint_info={
+ 0:
+ dict(
+ name='right_ankle',
+ id=0,
+ color=[255, 128, 0],
+ type='lower',
+ swap='left_ankle'),
+ ## 内容省略
+ },
+ skeleton_info={
+ 0:
+ dict(link=('right_ankle', 'right_knee'), id=0, color=[255, 128, 0]),
+ ## 内容省略
+ },
+ joint_weights=[
+ 1.5, 1.2, 1., 1., 1.2, 1.5, 1., 1., 1., 1., 1.5, 1.2, 1., 1., 1.2, 1.5
+ ],
+ # 使用 COCO 数据集中提供的 sigmas 值
+ sigmas=[
+ 0.089, 0.083, 0.107, 0.107, 0.083, 0.089, 0.026, 0.026, 0.026, 0.026,
+ 0.062, 0.072, 0.179, 0.179, 0.072, 0.062
+ ])
+```
+
+在模型配置文件中，你需要为自定义数据集指定对应的元信息配置文件。假如该元信息配置文件路径为 `$MMPOSE/configs/_base_/datasets/custom.py`，指定方式如下：
+
+```python
+# dataset and dataloader settings
+dataset_type = 'MyCustomDataset' # or 'CocoDataset'
+train_dataloader = dict(
+ batch_size=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root='root/of/your/train/data',
+ ann_file='path/to/your/train/json',
+ data_prefix=dict(img='path/to/your/train/img'),
+ # 指定对应的元信息配置文件
+ metainfo=dict(from_file='configs/_base_/datasets/custom.py'),
+ ...),
+ )
+val_dataloader = dict(
+ batch_size=2,
+ dataset=dict(
+ type=dataset_type,
+ data_root='root/of/your/val/data',
+ ann_file='path/to/your/val/json',
+ data_prefix=dict(img='path/to/your/val/img'),
+ # 指定对应的元信息配置文件
+ metainfo=dict(from_file='configs/_base_/datasets/custom.py'),
+ ...),
+ )
+test_dataloader = val_dataloader
+```
+
+### 数据集
+
+在 MMPose 中使用自定义数据集时，我们推荐将数据转化为已支持的格式（如 COCO 或 MPII），并直接使用我们提供的对应数据集实现。如果这种方式不可行，则用户需要实现自己的数据集类。
+
+MMPose 中的大部分 2D 关键点数据集**以 COCO 形式组织**，为此我们提供了基类 [BaseCocoStyleDataset](/mmpose/datasets/datasets/base/base_coco_style_dataset.py)。我们推荐用户继承该基类，并按需重写它的方法（通常是 `__init__()` 和 `_load_annotations()` 方法），以扩展到新的 2D 关键点数据集。
+
+```{note}
+关于COCO数据格式的详细说明请参考 [COCO](./dataset_zoo/2d_body_keypoint.md) 。
+```
+
+```{note}
+在 MMPose 中 bbox 的数据格式采用 `xyxy`，而不是 `xywh`，这与 [MMDetection](https://github.com/open-mmlab/mmdetection) 等其他 OpenMMLab 成员保持一致。为了实现不同 bbox 格式之间的转换，我们提供了丰富的函数：`bbox_xyxy2xywh`、`bbox_xywh2xyxy`、`bbox_xyxy2cs`等。这些函数定义在`$MMPOSE/mmpose/structures/bbox/transforms.py`。
+```
+
+下面我们以MPII数据集的实现（`$MMPOSE/mmpose/datasets/datasets/body/mpii_dataset.py`）为例：
+
+```Python
+@DATASETS.register_module()
+class MpiiDataset(BaseCocoStyleDataset):
+ METAINFO: dict = dict(from_file='configs/_base_/datasets/mpii.py')
+
+ def __init__(self,
+ ## 内容省略
+ headbox_file: Optional[str] = None,
+ ## 内容省略):
+
+ if headbox_file:
+ if data_mode != 'topdown':
+ raise ValueError(
+ f'{self.__class__.__name__} is set to {data_mode}: '
+ 'mode, while "headbox_file" is only '
+ 'supported in topdown mode.')
+
+ if not test_mode:
+ raise ValueError(
+ f'{self.__class__.__name__} has `test_mode==False` '
+ 'while "headbox_file" is only '
+ 'supported when `test_mode==True`.')
+
+ headbox_file_type = headbox_file[-3:]
+ allow_headbox_file_type = ['mat']
+ if headbox_file_type not in allow_headbox_file_type:
+ raise KeyError(
+ f'The head boxes file type {headbox_file_type} is not '
+ f'supported. Should be `mat` but got {headbox_file_type}.')
+ self.headbox_file = headbox_file
+
+ super().__init__(
+ ## 内容省略
+ )
+
+ def _load_annotations(self) -> List[dict]:
+ """Load data from annotations in MPII format."""
+ check_file_exist(self.ann_file)
+ with open(self.ann_file) as anno_file:
+ anns = json.load(anno_file)
+
+ if self.headbox_file:
+ check_file_exist(self.headbox_file)
+ headbox_dict = loadmat(self.headbox_file)
+ headboxes_src = np.transpose(headbox_dict['headboxes_src'],
+ [2, 0, 1])
+ SC_BIAS = 0.6
+
+ data_list = []
+ ann_id = 0
+
+ # mpii bbox scales are normalized with factor 200.
+ pixel_std = 200.
+
+ for idx, ann in enumerate(anns):
+ center = np.array(ann['center'], dtype=np.float32)
+ scale = np.array([ann['scale'], ann['scale']],
+ dtype=np.float32) * pixel_std
+
+ # Adjust center/scale slightly to avoid cropping limbs
+ if center[0] != -1:
+ center[1] = center[1] + 15. / pixel_std * scale[1]
+
+ # MPII uses matlab format, index is 1-based,
+ # we should first convert to 0-based index
+ center = center - 1
+
+ # unify shape with coco datasets
+ center = center.reshape(1, -1)
+ scale = scale.reshape(1, -1)
+ bbox = bbox_cs2xyxy(center, scale)
+
+ # load keypoints in shape [1, K, 2] and keypoints_visible in [1, K]
+ keypoints = np.array(ann['joints']).reshape(1, -1, 2)
+ keypoints_visible = np.array(ann['joints_vis']).reshape(1, -1)
+
+ data_info = {
+ 'id': ann_id,
+ 'img_id': int(ann['image'].split('.')[0]),
+ 'img_path': osp.join(self.data_prefix['img'], ann['image']),
+ 'bbox_center': center,
+ 'bbox_scale': scale,
+ 'bbox': bbox,
+ 'bbox_score': np.ones(1, dtype=np.float32),
+ 'keypoints': keypoints,
+ 'keypoints_visible': keypoints_visible,
+ }
+
+ if self.headbox_file:
+ # calculate the diagonal length of head box as norm_factor
+ headbox = headboxes_src[idx]
+ head_size = np.linalg.norm(headbox[1] - headbox[0], axis=0)
+ head_size *= SC_BIAS
+ data_info['head_size'] = head_size.reshape(1, -1)
+
+ data_list.append(data_info)
+ ann_id = ann_id + 1
+
+ return data_list
+```
+
+在对MPII数据集进行支持时，由于MPII需要读入 `head_size` 信息来计算 `PCKh`，因此我们在`__init__()`中增加了 `headbox_file`，并重载了 `_load_annotations()` 来完成数据组织。
+
+如果自定义数据集无法被 `BaseCocoStyleDataset` 支持，你需要直接继承 [MMEngine](https://github.com/open-mmlab/mmengine) 中提供的 `BaseDataset` 基类。具体方法请参考相关[文档](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html)。
+
+### 数据流水线
+
+一个典型的数据流水线配置如下：
+
+```Python
+# pipelines
+train_pipeline = [
+ dict(type='LoadImage'),
+ dict(type='GetBBoxCenterScale'),
+ dict(type='RandomFlip', direction='horizontal'),
+ dict(type='RandomHalfBody'),
+ dict(type='RandomBBoxTransform'),
+ dict(type='TopdownAffine', input_size=codec['input_size']),
+ dict(type='GenerateTarget', encoder=codec),
+ dict(type='PackPoseInputs')
+]
+test_pipeline = [
+ dict(type='LoadImage'),
+ dict(type='GetBBoxCenterScale'),
+ dict(type='TopdownAffine', input_size=codec['input_size']),
+ dict(type='PackPoseInputs')
+]
+```
+
+在关键点检测任务中，数据一般会在三个尺度空间中变换：
+
+- **原始图片空间**：图片存储时的原始空间，不同图片的尺寸不一定相同
+
+- **输入图片空间**：模型输入的图片尺度空间，所有**图片**和**标注**被缩放到输入尺度，如 `256x256`，`256x192` 等
+
+- **输出尺度空间**：模型输出和训练监督信息所在的尺度空间，如`64x64(热力图)`，`1x1(回归坐标值)`等
+
+数据在三个空间中变换的流程如图所示：
+
+
+
+在MMPose中，数据变换所需要的模块在`$MMPOSE/mmpose/datasets/transforms`目录下，它们的工作流程如图所示：
+
+
+
+#### i. 数据增强
+
+数据增强中常用的变换存放在 `$MMPOSE/mmpose/datasets/transforms/common_transforms.py` 中，如 `RandomFlip`、`RandomHalfBody` 等。
+
+对于 top-down 方法，`Shift`、`Rotate`、`Resize` 操作由 `RandomBBoxTransform`来实现；对于 bottom-up 方法，这些则是由 `BottomupRandomAffine` 实现。
+
+```{note}
+值得注意的是，大部分数据变换都依赖于 `bbox_center` 和 `bbox_scale`，它们可以通过 `GetBBoxCenterScale` 来得到。
+```
+
+#### ii. 数据变换
+
+我们使用仿射变换，将图像和坐标标注从原始图片空间变换到输入图片空间。这一操作在 top-down 方法中由 `TopdownAffine` 完成，在 bottom-up 方法中则由 `BottomupRandomAffine` 完成。
+
+#### iii. 数据编码
+
+在模型训练时，数据从原始空间变换到输入图片空间后，需要使用 `GenerateTarget` 来生成训练所需的监督目标（比如用坐标值生成高斯热图），我们将这一过程称为编码（Encode），反之，通过高斯热图得到对应坐标值的过程称为解码（Decode）。
+
+在 MMPose 中，我们将编码和解码过程集合成一个编解码器（Codec），在其中实现 `encode()` 和 `decode()`。
+
+目前 MMPose 支持生成以下类型的监督目标：
+
+- `heatmap`: 高斯热图
+
+- `keypoint_label`: 关键点标签（如归一化的坐标值）
+
+- `keypoint_xy_label`: 单个坐标轴关键点标签
+
+- `heatmap+keypoint_label`: 同时生成高斯热图和关键点标签
+
+- `multiscale_heatmap`: 多尺度高斯热图
+
+生成的监督目标会按以下关键字进行封装：
+
+- `heatmaps`：高斯热图
+
+- `keypoint_labels`：关键点标签（如归一化的坐标值）
+
+- `keypoint_x_labels`：x 轴关键点标签
+
+- `keypoint_y_labels`：y 轴关键点标签
+
+- `keypoint_weights`：关键点权重
+
+```Python
+@TRANSFORMS.register_module()
+class GenerateTarget(BaseTransform):
+ """Encode keypoints into Target.
+
+ Added Keys (depends on the args):
+ - heatmaps
+ - keypoint_labels
+ - keypoint_x_labels
+ - keypoint_y_labels
+ - keypoint_weights
+ """
+```
+
+值得注意的是，我们对 top-down 和 bottom-up 的数据格式进行了统一，这意味着标注信息中会新增一个维度来代表同一张图里的不同目标（如人），格式为：
+
+```Python
+[batch_size, num_instances, num_keypoints, dim_coordinates]
+```
+
+- top-down：`[B, 1, K, D]`
+
+- Bottom-up: `[B, N, K, D]`
+
+当前已经支持的编解码器定义在 `$MMPOSE/mmpose/codecs` 目录下，如果你需要自定新的编解码器，可以前往[编解码器](./user_guides/codecs.md)了解更多详情。
+
+#### iv. 数据打包
+
+数据经过前处理变换后，最终需要通过 `PackPoseInputs` 打包成数据样本。该操作定义在 `$MMPOSE/mmpose/datasets/transforms/formatting.py` 中。
+
+打包过程会将数据流水线中用字典 `results` 存储的数据转换成用 MMPose 所需的标准数据结构， 如 `InstanceData`，`PixelData`，`PoseDataSample` 等。
+
+具体而言，我们将数据样本内容分为 `gt`（标注真值） 和 `pred`（模型预测）两部分，它们都包含以下数据项：
+
+- **instances**(numpy.array)：实例级别的原始标注或预测结果，属于原始尺度空间
+
+- **instance_labels**(torch.tensor)：实例级别的训练标签（如归一化的坐标值、关键点可见性），属于输出尺度空间
+
+- **fields**(torch.tensor)：像素级别的训练标签（如高斯热图）或预测结果，属于输出尺度空间
+
+下面是 `PoseDataSample` 底层实现的例子：
+
+```Python
+def get_pose_data_sample(self):
+ # meta
+ pose_meta = dict(
+ img_shape=(600, 900), # [h, w, c]
+ crop_size=(256, 192), # [h, w]
+ heatmap_size=(64, 48), # [h, w]
+ )
+
+ # gt_instances
+ gt_instances = InstanceData()
+ gt_instances.bboxes = np.random.rand(1, 4)
+ gt_instances.keypoints = np.random.rand(1, 17, 2)
+
+ # gt_instance_labels
+ gt_instance_labels = InstanceData()
+ gt_instance_labels.keypoint_labels = torch.rand(1, 17, 2)
+ gt_instance_labels.keypoint_weights = torch.rand(1, 17)
+
+ # pred_instances
+ pred_instances = InstanceData()
+ pred_instances.keypoints = np.random.rand(1, 17, 2)
+ pred_instances.keypoint_scores = np.random.rand(1, 17)
+
+ # gt_fields
+ gt_fields = PixelData()
+ gt_fields.heatmaps = torch.rand(17, 64, 48)
+
+ # pred_fields
+ pred_fields = PixelData()
+ pred_fields.heatmaps = torch.rand(17, 64, 48)
+ data_sample = PoseDataSample(
+ gt_instances=gt_instances,
+ pred_instances=pred_instances,
+ gt_fields=gt_fields,
+ pred_fields=pred_fields,
+ metainfo=pose_meta)
+
+ return data_sample
+```
+
+## Step3: 模型
+
+在 MMPose 1.0中，模型由以下几部分构成：
+
+- **预处理器（DataPreprocessor）**：完成图像归一化和通道转换等前处理
+
+- **主干网络 （Backbone）**：用于特征提取
+
+- **颈部模块（Neck）**：GAP，FPN 等可选项
+
+- **预测头（Head）**：用于实现核心算法功能和损失函数定义
+
+我们在 `$MMPOSE/models/pose_estimators/base.py` 下为姿态估计模型定义了一个基类 `BasePoseEstimator`，所有的模型（如 `TopdownPoseEstimator`）都需要继承这个基类，并重载对应的方法。
+
+在模型的 `forward()` 方法中提供了三种不同的模式：
+
+- `mode == 'loss'`：返回损失函数计算的结果，用于模型训练
+
+- `mode == 'predict'`：返回输入尺度下的预测结果，用于模型推理
+
+- `mode == 'tensor'`：返回输出尺度下的模型输出，即只进行模型前向传播，用于模型导出
+
+开发者需要在 `PoseEstimator` 中按照模型结构调用对应的 `Registry` ，对模块进行实例化。以 top-down 模型为例：
+
+```Python
+@MODELS.register_module()
+class TopdownPoseEstimator(BasePoseEstimator):
+ def __init__(self,
+ backbone: ConfigType,
+ neck: OptConfigType = None,
+ head: OptConfigType = None,
+ train_cfg: OptConfigType = None,
+ test_cfg: OptConfigType = None,
+ data_preprocessor: OptConfigType = None,
+ init_cfg: OptMultiConfig = None):
+ super().__init__(data_preprocessor, init_cfg)
+
+ self.backbone = MODELS.build(backbone)
+
+ if neck is not None:
+ self.neck = MODELS.build(neck)
+
+ if head is not None:
+ self.head = MODELS.build(head)
+```
+
+### 前处理器（DataPreprocessor）
+
+从 MMPose 1.0 开始，我们在模型中添加了新的前处理器模块，用以完成图像归一化、通道顺序变换等操作。这样做的好处是可以利用 GPU 等设备的计算能力加快计算，并使模型在导出和部署时更具完整性。
+
+在配置文件中，一个常见的 `data_preprocessor` 如下：
+
+```Python
+data_preprocessor=dict(
+ type='PoseDataPreprocessor',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ bgr_to_rgb=True),
+```
+
+它会将输入图片的通道顺序从 `bgr` 转换为 `rgb`，并根据 `mean` 和 `std` 进行数据归一化。
+
+### 主干网络（Backbone）
+
+MMPose 实现的主干网络存放在 `$MMPOSE/mmpose/models/backbones` 目录下。
+
+在实际开发中，开发者经常会使用预训练的网络权重进行迁移学习，这能有效提升模型在小数据集上的性能。 在 MMPose 中，只需要在配置文件 `backbone` 的 `init_cfg` 中设置：
+
+```Python
+init_cfg=dict(
+ type='Pretrained',
+ checkpoint='PATH/TO/YOUR_MODEL_WEIGHTS.pth'),
+```
+
+如果你想只加载一个训练好的 checkpoint 的 backbone 部分，你需要指明一下前缀 `prefix`:
+
+```Python
+init_cfg=dict(
+ type='Pretrained',
+ prefix='backbone.',
+ checkpoint='PATH/TO/YOUR_CHECKPOINT.pth'),
+```
+
+其中 `checkpoint` 既可以是本地路径，也可以是下载链接。因此，如果你想使用 Torchvision 提供的预训练模型（比如ResNet50），可以使用：
+
+```Python
+init_cfg=dict(
+ type='Pretrained',
+ checkpoint='torchvision://resnet50')
+```
+
+除了这些常用的主干网络以外，你还可以从 MMClassification 等其他 OpenMMLab 项目中方便地迁移主干网络，它们都遵循同一套配置文件格式，并提供了预训练权重可供使用。
+
+需要强调的是，如果你加入了新的主干网络，需要在模型定义时进行注册：
+
+```Python
+@MODELS.register_module()
+class YourBackbone(BaseBackbone):
+```
+
+同时在 `$MMPOSE/mmpose/models/backbones/__init__.py` 下进行 `import`，并加入到 `__all__` 中，才能被配置文件正确地调用。
+
+### 颈部模块（Neck）
+
+颈部模块通常是介于主干网络和预测头之间的模块，在部分模型算法中会用到，常见的颈部模块有：
+
+- Global Average Pooling (GAP)
+
+- Feature Pyramid Networks (FPN)
+
+- Feature Map Processor (FMP)
+
+ `FeatureMapProcessor` 是一个通用的 PyTorch 模块，旨在通过选择、拼接和缩放等非参数变换将主干网络输出的特征图转换成适合预测头的格式。以下是一些操作的配置方式及效果示意图:
+
+ - 选择操作
+
+ ```python
+ neck=dict(type='FeatureMapProcessor', select_index=0)
+ ```
+
+ Label Studio
+ +```bibtex +@misc{Label Studio, + title={{Label Studio}: Data labeling software}, + url={https://github.com/heartexlabs/label-studio}, + note={Open source software available from https://github.com/heartexlabs/label-studio}, + author={ + Maxim Tkachenko and + Mikhail Malyuk and + Andrey Holmanyuk and + Nikolai Liubimov}, + year={2020-2022}, +} +``` + ++ + - 拼接操作 + + ```python + neck=dict(type='FeatureMapProcessor', concat=True) + ``` + +
+ + 拼接之前，其它特征图会被缩放到和序号为 0 的特征图相同的尺寸。 + + - 缩放操作 + + ```python + neck=dict(type='FeatureMapProcessor', scale_factor=2.0) + ``` + +
+ +### 预测头（Head） + +通常来说，预测头是模型算法实现的核心，用于控制模型的输出，并进行损失函数计算。 + +MMPose 中 Head 相关的模块定义在 `$MMPOSE/mmpose/models/heads` 目录下，开发者在自定义预测头时需要继承我们提供的基类 `BaseHead`，并重载以下三个方法对应模型推理的三种模式： + +- forward() + +- predict() + +- loss() + +具体而言，`predict()` 返回的应是输入图片尺度下的结果，因此需要调用 `self.decode()` 对网络输出进行解码，这一过程实现在 `BaseHead` 中已经实现，它会调用编解码器提供的 `decode()` 方法来完成解码。 + +另一方面，我们会在 `predict()` 中进行测试时增强。在进行预测时，一个常见的测试时增强技巧是进行翻转集成。即，将一张图片先进行一次推理，再将图片水平翻转进行一次推理，推理的结果再次水平翻转回去，对两次推理的结果进行平均。这个技巧能有效提升模型的预测稳定性。 + +下面是在 `RegressionHead` 中定义 `predict()` 的例子： + +```Python +def predict(self, + feats: Tuple[Tensor], + batch_data_samples: OptSampleList, + test_cfg: ConfigType = {}) -> Predictions: + """Predict results from outputs.""" + + if test_cfg.get('flip_test', False): + # TTA: flip test -> feats = [orig, flipped] + assert isinstance(feats, list) and len(feats) == 2 + flip_indices = batch_data_samples[0].metainfo['flip_indices'] + input_size = batch_data_samples[0].metainfo['input_size'] + _feats, _feats_flip = feats + _batch_coords = self.forward(_feats) + _batch_coords_flip = flip_coordinates( + self.forward(_feats_flip), + flip_indices=flip_indices, + shift_coords=test_cfg.get('shift_coords', True), + input_size=input_size) + batch_coords = (_batch_coords + _batch_coords_flip) * 0.5 + else: + batch_coords = self.forward(feats) # (B, K, D) + + batch_coords.unsqueeze_(dim=1) # (B, N, K, D) + preds = self.decode(batch_coords) +``` + +`loss()`除了进行损失函数的计算，还会进行 accuracy 等训练时指标的计算，并通过一个字典 `losses` 来传递: + +```Python + # calculate accuracy +_, avg_acc, _ = keypoint_pck_accuracy( + pred=to_numpy(pred_coords), + gt=to_numpy(keypoint_labels), + mask=to_numpy(keypoint_weights) > 0, + thr=0.05, + norm_factor=np.ones((pred_coords.size(0), 2), dtype=np.float32)) + +acc_pose = torch.tensor(avg_acc, device=keypoint_labels.device) +losses.update(acc_pose=acc_pose) +``` + +每个 batch 的数据都打包成了 `batch_data_samples`。以 Regression-based 方法为例，训练所需的归一化的坐标值和关键点权重可以用如下方式获取： + +```Python +keypoint_labels = torch.cat( + [d.gt_instance_labels.keypoint_labels for d in batch_data_samples]) +keypoint_weights = torch.cat([ + d.gt_instance_labels.keypoint_weights for d in batch_data_samples +]) +``` + +以下为 `RegressionHead` 中完整的 `loss()` 实现： + +```Python +def loss(self, + inputs: Tuple[Tensor], + batch_data_samples: OptSampleList, + train_cfg: ConfigType = {}) -> dict: + """Calculate losses from a batch of inputs and data samples.""" + + pred_outputs = self.forward(inputs) + + keypoint_labels = torch.cat( + [d.gt_instance_labels.keypoint_labels for d in batch_data_samples]) + keypoint_weights = torch.cat([ + d.gt_instance_labels.keypoint_weights for d in batch_data_samples + ]) + + # calculate losses + losses = dict() + loss = self.loss_module(pred_outputs, keypoint_labels, + keypoint_weights.unsqueeze(-1)) + + if isinstance(loss, dict): + losses.update(loss) + else: + losses.update(loss_kpt=loss) + + # calculate accuracy + _, avg_acc, _ = keypoint_pck_accuracy( + pred=to_numpy(pred_outputs), + gt=to_numpy(keypoint_labels), + mask=to_numpy(keypoint_weights) > 0, + thr=0.05, + norm_factor=np.ones((pred_outputs.size(0), 2), dtype=np.float32)) + acc_pose = torch.tensor(avg_acc, device=keypoint_labels.device) + losses.update(acc_pose=acc_pose) + + return losses +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/how_to_deploy.md b/internlm_langchain/knowledge_base/MMPose/content/how_to_deploy.md new file mode 100644 index 00000000..b4fead87 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/how_to_deploy.md @@ -0,0 +1,3 @@ +# How to Deploy MMPose Models + +Coming soon. diff --git a/internlm_langchain/knowledge_base/MMPose/content/implement_new_models.md b/internlm_langchain/knowledge_base/MMPose/content/implement_new_models.md new file mode 100644 index 00000000..4a10b0c3 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/implement_new_models.md @@ -0,0 +1,3 @@ +# Implement New Models + +Coming soon. diff --git a/internlm_langchain/knowledge_base/MMPose/content/inference.md b/internlm_langchain/knowledge_base/MMPose/content/inference.md new file mode 100644 index 00000000..0844bc61 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/inference.md @@ -0,0 +1,267 @@ +# 使用现有模型进行推理 + +MMPose为姿态估计提供了大量可以从[模型库](https://mmpose.readthedocs.io/en/latest/model_zoo.html)中找到的预测训练模型。本指南将演示**如何执行推理**，或使用训练过的模型对提供的图像或视频运行姿态估计。 + +有关在标准数据集上测试现有模型的说明，请参阅本指南。 + +在MMPose，模型由配置文件定义，而其已计算好的参数存储在权重文件（checkpoint file）中。您可以在[模型库](https://mmpose.readthedocs.io/en/latest/model_zoo.html)中找到模型配置文件和相应的权重文件的URL。我们建议从使用HRNet模型的[配置文件](https://github.com/open-mmlab/mmpose/blob/main/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py)和[权重文件](https://download.openmmlab.com/mmpose/v1/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192-81c58e40_20220909.pth)开始。 + +## 推理器：统一的推理接口 + +MMPose提供了一个被称为`MMPoseInferencer`的、全面的推理API。这个API使得用户得以使用所有MMPose支持的模型来对图像和视频进行模型推理。此外，该API可以完成推理结果自动化，并方便用户保存预测结果。 + +### 基本用法 + +`MMPoseInferencer`可以在任何Python程序中被用来执行姿态估计任务。以下是在一个在Python Shell中使用预训练的人体姿态模型对给定图像进行推理的示例。 + +```python +from mmpose.apis import MMPoseInferencer + +img_path = 'tests/data/coco/000000000785.jpg' # 将img_path替换给你自己的路径 + +# 使用模型别名创建推断器 +inferencer = MMPoseInferencer('human') + +# MMPoseInferencer采用了惰性推断方法，在给定输入时创建一个预测生成器 +result_generator = inferencer(img_path, show=True) +result = next(result_generator) +``` + +如果一切正常，你将在一个新窗口中看到下图： + + + +`result` 变量是一个包含两个键值 `'visualization'` 和 `'predictions'` 的字典。 + +- `'visualization'` 键对应的值是一个列表，该列表： + - 包含可视化结果，例如输入图像、估计姿态的标记，以及可选的预测热图。 + - 如果没有指定 `return_vis` 参数，该列表将保持为空。 +- `'predictions'` 键对应的值是： + - 一个包含每个检测实例的预估关键点的列表。 + +`result` 字典的结构如下所示： + +```python +result = { + 'visualization': [ + # 元素数量：batch_size（默认为1） + vis_image_1, + ... + ], + 'predictions': [ + # 每张图像的姿态估计结果 + # 元素数量：batch_size（默认为1） + [ + # 每个检测到的实例的姿态信息 + # 元素数量：检测到的实例数 + {'keypoints': ..., # 实例 1 + 'keypoint_scores': ..., + ... + }, + {'keypoints': ..., # 实例 2 + 'keypoint_scores': ..., + ... + }, + ] + ... + ] +} +``` + +还可以使用用于用于推断的**命令行界面工具**（CLI, command-line interface）: `demo/inferencer_demo.py`。这个工具允许用户使用以下命令使用相同的模型和输入执行推理： + +```python +python demo/inferencer_demo.py 'tests/data/coco/000000000785.jpg' \ + --pose2d 'human' --show --pred-out-dir 'predictions' +``` + +预测结果将被保存在路径`predictions/000000000785.json`。作为一个API，`inferencer_demo.py`的输入参数与`MMPoseInferencer`的相同。前者能够处理一系列输入类型，包括以下内容： + +- 图像路径 + +- 视频路径 + +- 文件夹路径（这会导致该文件夹中的所有图像都被推断出来） + +- 表示图像的 numpy array (在命令行界面工具中未支持) + +- 表示图像的 numpy array 列表 (在命令行界面工具中未支持) + +- 摄像头（在这种情况下，输入参数应该设置为`webcam`或`webcam:{CAMERA_ID}`） + +当输入对应于多个图像时，例如输入为**视频**或**文件夹**路径时，推理生成器必须被遍历，以便推理器对视频/文件夹中的所有帧/图像进行推理。以下是一个示例： + +```python +folder_path = 'tests/data/coco' + +result_generator = inferencer(folder_path, show=True) +results = [result for result in result_generator] +``` + +在这个示例中，`inferencer` 接受 `folder_path` 作为输入，并返回一个生成器对象（`result_generator`），用于生成推理结果。通过遍历 `result_generator` 并将每个结果存储在 `results` 列表中，您可以获得视频/文件夹中所有帧/图像的推理结果。 + +### 自定义姿态估计模型 + +`MMPoseInferencer`提供了几种可用于自定义所使用的模型的方法： + +```python +# 使用模型别名构建推断器 +inferencer = MMPoseInferencer('human') + +# 使用模型配置名构建推断器 +inferencer = MMPoseInferencer('td-hm_hrnet-w32_8xb64-210e_coco-256x192') + +# 使用模型配置文件和权重文件的路径或 URL 构建推断器 +inferencer = MMPoseInferencer( + pose2d='configs/body_2d_keypoint/topdown_heatmap/coco/' \ + 'td-hm_hrnet-w32_8xb64-210e_coco-256x192.py', + pose2d_weights='https://download.openmmlab.com/mmpose/top_down/' \ + 'hrnet/hrnet_w32_coco_256x192-c78dce93_20200708.pth' +) +``` + +模型别名的完整列表可以在模型别名部分中找到。 + +此外，自顶向下的姿态估计器还需要一个对象检测模型。`MMPoseInferencer`能够推断用MMPose支持的数据集训练的模型的实例类型，然后构建必要的对象检测模型。用户也可以通过以下方式手动指定检测模型: + +```python +# 通过别名指定检测模型 +# 可用的别名包括“human”、“hand”、“face”、“animal”、 +# 以及mmdet中定义的任何其他别名 +inferencer = MMPoseInferencer( + # 假设姿态估计器是在自定义数据集上训练的 + pose2d='custom_human_pose_estimator.py', + pose2d_weights='custom_human_pose_estimator.pth', + det_model='human' +) + +# 使用模型配置名称指定检测模型 +inferencer = MMPoseInferencer( + pose2d='human', + det_model='yolox_l_8x8_300e_coco', + det_cat_ids=[0], # 指定'human'类的类别id +) + +# 使用模型配置文件和权重文件的路径或URL构建推断器 +inferencer = MMPoseInferencer( + pose2d='human', + det_model=f'{PATH_TO_MMDET}/configs/yolox/yolox_l_8x8_300e_coco.py', + det_weights='https://download.openmmlab.com/mmdetection/v2.0/' \ + 'yolox/yolox_l_8x8_300e_coco/' \ + 'yolox_l_8x8_300e_coco_20211126_140236-d3bd2b23.pth', + det_cat_ids=[0], # 指定'human'类的类别id +) +``` + +### 转储结果 + +在执行姿态估计推理任务之后，您可能希望保存结果以供进一步分析或处理。本节将指导您将预测的关键点和可视化结果保存到本地。 + +要将预测保存在JSON文件中，在运行`MMPoseInferencer`的实例`inferencer`时使用`pred_out_dir`参数: + +```python +result_generator = inferencer(img_path, pred_out_dir='predictions') +result = next(result_generator) +``` + +预测结果将以JSON格式保存在`predictions/`文件夹中，每个文件以相应的输入图像或视频的名称命名。 + +对于更高级的场景，还可以直接从`inferencer`返回的`result`字典中访问预测结果。其中，`predictions`包含输入图像或视频中每个单独实例的预测关键点列表。然后，您可以使用您喜欢的方法操作或存储这些结果。 + +请记住，如果你想将可视化图像和预测文件保存在一个文件夹中，你可以使用`out_dir`参数： + +```python +result_generator = inferencer(img_path, out_dir='output') +result = next(result_generator) +``` + +在这种情况下，可视化图像将保存在`output/visualization/`文件夹中，而预测将存储在`output/forecasts/`文件夹中。 + +### 可视化 + +推理器`inferencer`可以自动对输入的图像或视频进行预测。可视化结果可以显示在一个新的窗口中，并保存在本地。 + +要在新窗口中查看可视化结果，请使用以下代码： + +请注意： + +- 如果输入视频来自网络摄像头，默认情况下将在新窗口中显示可视化结果，以此让用户看到输入 + +- 如果平台上没有GUI，这个步骤可能会卡住 + +要将可视化结果保存在本地，可以像这样指定`vis_out_dir`参数: + +```python +result_generator = inferencer(img_path, vis_out_dir='vis_results') +result = next(result_generator) +``` + +输入图片或视频的可视化预测结果将保存在`vis_results/`文件夹中 + +在开头展示的滑雪图中，姿态的可视化估计结果由关键点（用实心圆描绘）和骨架（用线条表示）组成。这些视觉元素的默认大小可能不会产生令人满意的结果。用户可以使用`radius`和`thickness`参数来调整圆的大小和线的粗细，如下所示： + +```python +result_generator = inferencer(img_path, show=True, radius=4, thickness=2) +result = next(result_generator) +``` + +### 推理器参数 + +`MMPoseInferencer`提供了各种自定义姿态估计、可视化和保存预测结果的参数。下面是初始化推断器时可用的参数列表及对这些参数的描述： + +| Argument | Description | +| ---------------- | ------------------------------------------------------------ | +| `pose2d` | 指定 2D 姿态估计模型的模型别名、配置文件名称或配置文件路径。 | +| `pose2d_weights` | 指定 2D 姿态估计模型权重文件的URL或本地路径。 | +| `pose3d` | 指定 3D 姿态估计模型的模型别名、配置文件名称或配置文件路径。 | +| `pose3d_weights` | 指定 3D 姿态估计模型权重文件的URL或本地路径。 | +| `det_model` | 指定对象检测模型的模型别名、配置文件名或配置文件路径。 | +| `det_weights` | 指定对象检测模型权重文件的 URL 或本地路径。 | +| `det_cat_ids` | 指定与要检测的对象类对应的类别 id 列表。 | +| `device` | 执行推理的设备。如果为 `None`，推理器将选择最合适的一个。 | +| `scope` | 定义模型模块的名称空间 | + +推理器被设计用于可视化和保存预测。以下表格列出了在使用 `MMPoseInferencer` 进行推断时可用的参数列表，以及它们与 2D 和 3D 推理器的兼容性： + +| 参数 | 描述 | 2D | 3D | +| ------------------------ | -------------------------------------------------------------------------------------------------------------------------- | --- | --- | +| `show` | 控制是否在弹出窗口中显示图像或视频。 | ✔️ | ✔️ | +| `radius` | 设置可视化关键点的半径。 | ✔️ | ✔️ | +| `thickness` | 确定可视化链接的厚度。 | ✔️ | ✔️ | +| `kpt_thr` | 设置关键点分数阈值。分数超过此阈值的关键点将被显示。 | ✔️ | ✔️ | +| `draw_bbox` | 决定是否显示实例的边界框。 | ✔️ | ✔️ | +| `draw_heatmap` | 决定是否绘制预测的热图。 | ✔️ | ❌ | +| `black_background` | 决定是否在黑色背景上显示预估的姿势。 | ✔️ | ❌ | +| `skeleton_style` | 设置骨架样式。可选项包括 'mmpose'（默认）和 'openpose'。 | ✔️ | ❌ | +| `use_oks_tracking` | 决定是否在追踪中使用OKS作为相似度测量。 | ❌ | ✔️ | +| `tracking_thr` | 设置追踪的相似度阈值。 | ❌ | ✔️ | +| `norm_pose_2d` | 决定是否将边界框缩放至数据集的平均边界框尺寸，并将边界框移至数据集的平均边界框中心。 | ❌ | ✔️ | +| `rebase_keypoint_height` | 决定是否将最低关键点的高度置为 0。 | ❌ | ✔️ | +| `return_vis` | 决定是否在结果中包含可视化图像。 | ✔️ | ✔️ | +| `vis_out_dir` | 定义保存可视化图像的文件夹路径。如果未设置，将不保存可视化图像。 | ✔️ | ✔️ | +| `return_datasample` | 决定是否以 `PoseDataSample` 格式返回预测。 | ✔️ | ✔️ | +| `pred_out_dir` | 指定保存预测的文件夹路径。如果未设置，将不保存预测。 | ✔️ | ✔️ | +| `out_dir` | 如果 `vis_out_dir` 或 `pred_out_dir` 未设置，它们将分别设置为 `f'{out_dir}/visualization'` 或 `f'{out_dir}/predictions'`。 | ✔️ | ✔️ | + +### 模型别名 + +MMPose为常用模型提供了一组预定义的别名。在初始化 `MMPoseInferencer` 时，这些别名可以用作简略的表达方式，而不是指定完整的模型配置名称。下面是可用的模型别名及其对应的配置名称的列表： + +| 别名 | 配置文件名称 | 对应任务 | 姿态估计模型 | 检测模型 | +| --------- | -------------------------------------------------- | ------------------------------- | ------------- | ------------------- | +| animal | rtmpose-m_8xb64-210e_ap10k-256x256 | Animal pose estimation | RTMPose-m | RTMDet-m | +| human | rtmpose-m_8xb256-420e_aic-coco-256x192 | Human pose estimation | RTMPose-m | RTMDet-m | +| face | rtmpose-m_8xb64-60e_wflw-256x256 | Face keypoint detection | RTMPose-m | yolox-s | +| hand | rtmpose-m_8xb32-210e_coco-wholebody-hand-256x256 | Hand keypoint detection | RTMPose-m | ssdlite_mobilenetv2 | +| wholebody | rtmpose-m_8xb64-270e_coco-wholebody-256x192 | Human wholebody pose estimation | RTMPose-m | RTMDet-m | +| vitpose | td-hm_ViTPose-base-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-base | RTMDet-m | +| vitpose-s | td-hm_ViTPose-small-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-small | RTMDet-m | +| vitpose-b | td-hm_ViTPose-base-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-base | RTMDet-m | +| vitpose-l | td-hm_ViTPose-large-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-large | RTMDet-m | +| vitpose-h | td-hm_ViTPose-huge-simple_8xb64-210e_coco-256x192 | Human pose estimation | ViTPose-huge | RTMDet-m | + +此外，用户可以使用命令行界面工具显示所有可用的别名，使用以下命令: + +```shell +python demo/inferencer_demo.py --show-alias +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/installation.md b/internlm_langchain/knowledge_base/MMPose/content/installation.md new file mode 100644 index 00000000..ef515c80 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/installation.md @@ -0,0 +1,248 @@ +# 安装 + +我们推荐用户按照我们的最佳实践来安装 MMPose。但除此之外，如果您想根据 +您的习惯完成安装流程，也可以参见 [自定义安装](#自定义安装) 一节来获取更多信息。 + +- [安装](#安装) + - [依赖环境](#依赖环境) + - [最佳实践](#最佳实践) + - [从源码安装 MMPose](#从源码安装-mmpose) + - [作为 Python 包安装](#作为-python-包安装) + - [验证安装](#验证安装) + - [自定义安装](#自定义安装) + - [CUDA 版本](#cuda-版本) + - [不使用 MIM 安装 MMEngine](#不使用-mim-安装-mmengine) + - [在 CPU 环境中安装](#在-cpu-环境中安装) + - [在 Google Colab 中安装](#在-google-colab-中安装) + - [通过 Docker 使用 MMPose](#通过-docker-使用-mmpose) + - [故障解决](#故障解决) + +## 依赖环境 + +在本节中，我们将演示如何准备 PyTorch 相关的依赖环境。 + +MMPose 适用于 Linux、Windows 和 macOS。它需要 Python 3.7+、CUDA 9.2+ 和 PyTorch 1.8+。 + +如果您对配置 PyTorch 环境已经很熟悉，并且已经完成了配置，可以直接进入下一节：[安装](#安装-mmpose)。否则，请依照以下步骤完成配置。 + +**第 1 步** 从[官网](https://docs.conda.io/en/latest/miniconda.html) 下载并安装 Miniconda。 + +**第 2 步** 创建一个 conda 虚拟环境并激活它。 + +```shell +conda create --name openmmlab python=3.8 -y +conda activate openmmlab +``` + +**第 3 步** 按照[官方指南](https://pytorch.org/get-started/locally/) 安装 PyTorch。例如： + +在 GPU 平台： + +```shell +conda install pytorch torchvision -c pytorch +``` + +```{warning} +以上命令会自动安装最新版的 PyTorch 与对应的 cudatoolkit，请检查它们是否与您的环境匹配。 +``` + +在 CPU 平台： + +```shell +conda install pytorch torchvision cpuonly -c pytorch +``` + +**第 4 步** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine) 和 [MMCV](https://github.com/open-mmlab/mmcv/tree/2.x) + +```shell +pip install -U openmim +mim install mmengine +mim install "mmcv>=2.0.1" +``` + +请注意，MMPose 中的一些推理示例脚本需要使用 [MMDetection](https://github.com/open-mmlab/mmdetection) (mmdet) 检测人体。如果您想运行这些示例脚本，可以通过运行以下命令安装 mmdet: + +```shell +mim install "mmdet>=3.1.0" +``` + +## 最佳实践 + +根据具体需求，我们支持两种安装模式: 从源码安装（推荐）和作为 Python 包安装 + +### 从源码安装（推荐） + +如果基于 MMPose 框架开发自己的任务，需要添加新的功能，比如新的模型或是数据集，或者使用我们提供的各种工具。从源码按如下方式安装 mmpose： + +```shell +git clone https://github.com/open-mmlab/mmpose.git +cd mmpose +pip install -r requirements.txt +pip install -v -e . +# "-v" 表示输出更多安装相关的信息 +# "-e" 表示以可编辑形式安装，这样可以在不重新安装的情况下，让本地修改直接生效 +``` + +### 作为 Python 包安装 + +如果只是希望调用 MMPose 的接口，或者在自己的项目中导入 MMPose 中的模块。直接使用 mim 安装即可。 + +```shell +mim install "mmpose>=1.1.0" +``` + +## 验证安装 + +为了验证 MMPose 是否安装正确，您可以通过以下步骤运行模型推理。 + +**第 1 步** 我们需要下载配置文件和模型权重文件 + +```shell +mim download mmpose --config td-hm_hrnet-w48_8xb32-210e_coco-256x192 --dest . +``` + +下载过程往往需要几秒或更多的时间，这取决于您的网络环境。完成之后，您会在当前目录下找到这两个文件：`td-hm_hrnet-w48_8xb32-210e_coco-256x192.py` 和 `hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth`, 分别是配置文件和对应的模型权重文件。 + +**第 2 步** 验证推理示例 + +如果您是**从源码安装**的 mmpose，可以直接运行以下命令进行验证： + +```shell +python demo/image_demo.py \ + tests/data/coco/000000000785.jpg \ + td-hm_hrnet-w48_8xb32-210e_coco-256x192.py \ + hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth \ + --out-file vis_results.jpg \ + --draw-heatmap +``` + +如果一切顺利，您将会得到这样的可视化结果： + + + +代码会将预测的关键点和热图绘制在图像中的人体上，并保存到当前文件夹下的 `vis_results.jpg`。 + +如果您是**作为 Python 包安装**，可以打开您的 Python 解释器，复制并粘贴如下代码： + +```python +from mmpose.apis import inference_topdown, init_model +from mmpose.utils import register_all_modules + +register_all_modules() + +config_file = 'td-hm_hrnet-w48_8xb32-210e_coco-256x192.py' +checkpoint_file = 'hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth' +model = init_model(config_file, checkpoint_file, device='cpu') # or device='cuda:0' + +# 请准备好一张带有人体的图片 +results = inference_topdown(model, 'demo.jpg') +``` + +示例图片 `demo.jpg` 可以从 [Github](https://raw.githubusercontent.com/open-mmlab/mmpose/main/tests/data/coco/000000000785.jpg) 下载。 +推理结果是一个 `PoseDataSample` 列表，预测结果将会保存在 `pred_instances` 中，包括检测到的关键点位置和置信度。 + +## 自定义安装 + +### CUDA 版本 + +安装 PyTorch 时，需要指定 CUDA 版本。如果您不清楚选择哪个，请遵循我们的建议： + +- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 系列 以及 NVIDIA A100，CUDA 11 是必需的。 +- 对于更早的 NVIDIA GPU，CUDA 11 是向后兼容 (backward compatible) 的，但 CUDA 10.2 能够提供更好的兼容性，也更加轻量。 + +请确保您的 GPU 驱动版本满足最低的版本需求，参阅[这张表](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。 + +```{note} +如果按照我们的最佳实践进行安装，CUDA 运行时库就足够了，因为我们提供相关 CUDA 代码的预编译，您不需要进行本地编译。 +但如果您希望从源码进行 MMCV 的编译，或是进行其他 CUDA 算子的开发，那么就必须安装完整的 CUDA 工具链，参见 +[NVIDIA 官网](https://developer.nvidia.com/cuda-downloads)，另外还需要确保该 CUDA 工具链的版本与 PyTorch 安装时 +的配置相匹配（如用 `conda install` 安装 PyTorch 时指定的 cudatoolkit 版本）。 +``` + +### 不使用 MIM 安装 MMEngine + +若不使用 mim 安装 MMEngine，请遵循 [ MMEngine 安装指南](https://mmengine.readthedocs.io/zh_CN/latest/get_started/installation.html). + +例如，您可以通过以下命令安装 MMEngine: + +```shell +pip install mmengine +``` + +### 不使用 MIM 安装 MMCV + +MMCV 包含 C++ 和 CUDA 扩展，因此其对 PyTorch 的依赖比较复杂。MIM 会自动解析这些 +依赖，选择合适的 MMCV 预编译包，使安装更简单，但它并不是必需的。 + +若不使用 mim 来安装 MMCV，请遵照 [MMCV 安装指南](https://mmcv.readthedocs.io/zh_CN/2.x/get_started/installation.html)。 +它需要您用指定 url 的形式手动指定对应的 PyTorch 和 CUDA 版本。 + +举个例子，如下命令将会安装基于 PyTorch 1.10.x 和 CUDA 11.3 编译的 mmcv。 + +```shell +pip install 'mmcv>=2.0.1' -f https://download.openmmlab.com/mmcv/dist/cu113/torch1.10/index.html +``` + +### 在 CPU 环境中安装 + +MMPose 可以仅在 CPU 环境中安装，在 CPU 模式下，您可以完成训练、测试和模型推理等所有操作。 + +在 CPU 模式下，MMCV 的部分功能将不可用，通常是一些 GPU 编译的算子，如 `Deformable Convolution`。MMPose 中大部分的模型都不会依赖这些算子，但是如果您尝试使用包含这些算子的模型来运行训练、测试或推理，将会报错。 + +### 在 Google Colab 中安装 + +[Google Colab](https://colab.research.google.com/) 通常已经包含了 PyTorch 环境，因此我们只需要安装 MMEngine, MMCV 和 MMPose 即可，命令如下： + +**第 1 步** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine) 和 [MMCV](https://github.com/open-mmlab/mmcv/tree/2.x) + +```shell +!pip3 install openmim +!mim install mmengine +!mim install "mmcv>=2.0.1" +``` + +**第 2 步** 从源码安装 mmpose + +```shell +!git clone https://github.com/open-mmlab/mmpose.git +%cd mmpose +!pip install -e . +``` + +**第 3 步** 验证 + +```python +import mmpose +print(mmpose.__version__) +# 预期输出： 1.1.0 +``` + +```{note} +在 Jupyter 中，感叹号 `!` 用于执行外部命令，而 `%cd` 是一个[魔术命令](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd)，用于切换 Python 的工作路径。 +``` + +### 通过 Docker 使用 MMPose + +MMPose 提供 [Dockerfile](https://github.com/open-mmlab/mmpose/blob/master/docker/Dockerfile) +用于构建镜像。请确保您的 [Docker 版本](https://docs.docker.com/engine/install/) >=19.03。 + +```shell +# 构建默认的 PyTorch 1.8.0，CUDA 10.1 版本镜像 +# 如果您希望使用其他版本，请修改 Dockerfile +docker build -t mmpose docker/ +``` + +**注意**：请确保您已经安装了 [nvidia-container-toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker)。 + +用以下命令运行 Docker 镜像： + +```shell +docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmpose/data mmpose +``` + +`{DATA_DIR}` 是您本地存放用于 MMPose 训练、测试、推理等流程的数据目录。 + +## 故障解决 + +如果您在安装过程中遇到了什么问题，请先查阅[常见问题](faq.md)。如果没有找到解决方法，可以在 GitHub +上[提出 issue](https://github.com/open-mmlab/mmpose/issues/new/choose)。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/label_studio.md b/internlm_langchain/knowledge_base/MMPose/content/label_studio.md new file mode 100644 index 00000000..94cbd641 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/label_studio.md @@ -0,0 +1,76 @@ +# Label Studio 标注工具转COCO脚本 + +[Label Studio](https://labelstud.io/) 是一款广受欢迎的深度学习标注工具，可以对多种任务进行标注，然而对于关键点标注，Label Studio 无法直接导出成 MMPose 所需要的 COCO 格式。本文将介绍如何使用Label Studio 标注关键点数据，并利用 [labelstudio2coco.py](../../../tools/dataset_converters/labelstudio2coco.py) 工具将其转换为训练所需的格式。 + +## Label Studio 标注要求 + +根据 COCO 格式的要求，每个标注的实例中都需要包含关键点、分割和 bbox 的信息，然而 Label Studio 在标注时会将这些信息分散在不同的实例中，因此需要按一定规则进行标注，才能正常使用后续的脚本。 + +1. 标签接口设置 + +对于一个新建的 Label Studio 项目，首先要设置它的标签接口。这里需要有三种类型的标注：`KeyPointLabels`、`PolygonLabels`、`RectangleLabels`，分别对应 COCO 格式中的`keypoints`、`segmentation`、`bbox`。以下是一个标签接口的示例，可以在项目的`Settings`中找到`Labeling Interface`，点击`Code`，粘贴使用该示例。 + +```xml +
+ +有些关键点（例如“左手”）在两个数据集中都有定义，但它们具有不同的序号。具体来说，“左手”关键点在 COCO 数据集中的序号为 9，在AIC数据集中的序号为 5。此外，每个数据集都包含独特的关键点，另一个数据集中不存在。例如，面部关键点（序号为0〜4）仅在 COCO 数据集中定义，而“头顶”（序号为 12）和“颈部”（序号为 13）关键点仅在 AIC 数据集中存在。以下的维恩图显示了两个数据集中关键点之间的关系。 + +
+ +接下来，我们会介绍两种混合数据集的方式： + +- [将 AIC 合入 COCO 数据集](#将-aic-合入-coco-数据集) +- [合并 AIC 和 COCO 数据集](#合并-aic-和-coco-数据集) + +### 将 AIC 合入 COCO 数据集 + +如果用户想提高其模型在 COCO 或类似数据集上的性能，可以将 AIC 数据集作为辅助数据。此时应该仅选择 AIC 数据集中与 COCO 数据集共享的关键点，忽略其余关键点。此外，还需要将这些被选择的关键点在 AIC 数据集中的序号进行转换，以匹配在 COCO 数据集中对应关键点的序号。 + +
+ +在这种情况下，来自 COCO 的数据不需要进行转换。此时 COCO 数据集可通过如下方式配置： + +```python +dataset_coco = dict( + type='CocoDataset', + data_root='data/coco/', + ann_file='annotations/person_keypoints_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=[], # `pipeline` 应为空列表，因为 COCO 数据不需要转换 +) +``` + +对于 AIC 数据集，需要转换关键点的顺序。MMPose 提供了一个 `KeypointConverter` 转换器来实现这一点。以下是配置 AIC 子数据集的示例： + +```python +dataset_aic = dict( + type='AicDataset', + data_root='data/aic/', + ann_file='annotations/aic_train.json', + data_prefix=dict(img='ai_challenger_keypoint_train_20170902/' + 'keypoint_train_images_20170902/'), + pipeline=[ + dict( + type='KeypointConverter', + num_keypoints=17, # 与 COCO 数据集关键点数一致 + mapping=[ # 需要列出所有带转换关键点的序号 + (0, 6), # 0 (AIC 中的序号) -> 6 (COCO 中的序号) + (1, 8), + (2, 10), + (3, 5), + (4, 7), + (5, 9), + (6, 12), + (7, 14), + (8, 16), + (9, 11), + (10, 13), + (11, 15), + ]) + ], +) +``` + +`KeypointConverter` 会将原序号在 0 到 11 之间的关键点的序号转换为在 5 到 16 之间的对应序号。同时，在 AIC 中序号为为 12 和 13 的关键点将被删除。另外，目标序号在 0 到 4 之间的关键点在 `mapping` 参数中没有定义，这些点将被设为不可见，并且不会在训练中使用。 + +子数据集都完成配置后, 混合数据集 `CombinedDataset` 可以通过如下方式配置: + +```python +dataset = dict( + type='CombinedDataset', + # 混合数据集关键点顺序和 COCO 数据集相同， + # 所以使用 COCO 数据集的描述信息 + metainfo=dict(from_file='configs/_base_/datasets/coco.py'), + datasets=[dataset_coco, dataset_aic], + # `train_pipeline` 包含了常用的数据预处理， + # 比如图片读取、数据增广等 + pipeline=train_pipeline, +) +``` + +MMPose 提供了一份完整的 [配置文件](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-aic-256x192-merge.py) 来将 AIC 合入 COCO 数据集并用于训练网络。用户可以查阅这个文件以获取更多细节，或者参考这个文件来构建新的混合数据集。 + +### 合并 AIC 和 COCO 数据集 + +将 AIC 合入 COCO 数据集的过程中丢弃了部分 AIC 数据集中的标注信息。如果用户想要使用两个数据集中的所有信息，可以将两个数据集合并，即在两个数据集中取关键点的并集。 + +
+ +在这种情况下，COCO 和 AIC 数据集都需要使用 `KeypointConverter` 来调整它们关键点的顺序： + +```python +dataset_coco = dict( + type='CocoDataset', + data_root='data/coco/', + ann_file='annotations/person_keypoints_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=[ + dict( + type='KeypointConverter', + num_keypoints=19, # 并集中有 19 个关键点 + mapping=[ + (0, 0), + (1, 1), + # 省略 + (16, 16), + ]) + ]) + +dataset_aic = dict( + type='AicDataset', + data_root='data/aic/', + ann_file='annotations/aic_train.json', + data_prefix=dict(img='ai_challenger_keypoint_train_20170902/' + 'keypoint_train_images_20170902/'), + pipeline=[ + dict( + type='KeypointConverter', + num_keypoints=19, # 并集中有 19 个关键点 + mapping=[ + (0, 6), + # 省略 + (12, 17), + (13, 18), + ]) + ], +) +``` + +合并后的数据集有 19 个关键点，这与 COCO 或 AIC 数据集都不同，因此需要一个新的数据集描述信息文件。[coco_aic.py](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/_base_/datasets/coco_aic.py) 是一个描述信息文件的示例，它基于 [coco.py](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/_base_/datasets/coco.py) 并进行了以下几点修改: + +- 添加了 AIC 数据集的文章信息； +- 在 `keypoint_info` 中添加了“头顶”和“颈部”这两个只在 AIC 中定义的关键点； +- 在 `skeleton_info` 中添加了“头顶”和“颈部”间的连线； +- 拓展 `joint_weights` 和 `sigmas` 以添加新增关键点的信息。 + +完成以上步骤后，合并数据集 `CombinedDataset` 可以通过以下方式配置： + +```python +dataset = dict( + type='CombinedDataset', + # 使用新的描述信息文件 + metainfo=dict(from_file='configs/_base_/datasets/coco_aic.py'), + datasets=[dataset_coco, dataset_aic], + # `train_pipeline` 包含了常用的数据预处理， + # 比如图片读取、数据增广等 + pipeline=train_pipeline, +) +``` + +此外，在使用混合数据集时，由于关键点数量的变化，模型的输出通道数也要做相应调整。如果用户用混合数据集训练了模型，但是要在 COCO 数据集上评估模型，就需要从模型输出的关键点中取出一个子集来匹配 COCO 中的关键点格式。可以通过 `test_cfg` 中的 `output_keypoint_indices` 参数自定义此子集。这个 [配置文件](https://github.com/open-mmlab/mmpose/blob/dev-1.x/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-aic-256x192-combine.py) 展示了如何用 AIC 和 COCO 合并后的数据集训练模型并在 COCO 数据集上进行测试。用户可以查阅这个文件以获取更多细节，或者参考这个文件来构建新的混合数据集。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/model_analysis.md b/internlm_langchain/knowledge_base/MMPose/content/model_analysis.md new file mode 100644 index 00000000..234dc5be --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/model_analysis.md @@ -0,0 +1,100 @@ +# Model Analysis + +## 统计模型参数量与计算量 + +MMPose 提供了 `tools/analysis_tools/get_flops.py` 来统计模型的参数量与计算量。 + +```shell +python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}] [--cfg-options ${CFG_OPTIONS}] +``` + +参数说明： + +`CONFIG_FILE` : 模型配置文件的路径。 + +`--shape`: 模型的输入张量形状。 + +`--input-constructor`: 如果指定为 `batch`，将会生成一个 `batch tensor` 来计算 FLOPs。 + +`--batch-size`：如果 `--input-constructor` 指定为 `batch`，将会生成一个随机 `tensor`，形状为 `(batch_size, 3, **input_shape)` 来计算 FLOPs。 + +`--cfg-options`: 如果指定，可选的 `cfg` 的键值对将会被合并到配置文件中。 + +示例： + +```shell +python tools/analysis_tools/get_flops.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py +``` + +结果如下： + +```text +============================== +Input shape: (1, 3, 256, 192) +Flops: 7.7 GFLOPs +Params: 28.54 M +============================== +``` + +```{note} +目前该工具仍处于实验阶段，我们不能保证统计结果绝对正确，一些算子（比如 GN 或自定义算子）没有被统计到 FLOPs 中。 +``` + +## 分析训练日志 + +MMPose 提供了 `tools/analysis_tools/analyze_logs.py` 来对训练日志进行简单的分析，包括： + +- 将日志绘制成损失和精度曲线图 +- 统计训练速度 + +### 绘制损失和精度曲线图 + +该功能依赖于 `seaborn`，请先运行 `pip install seaborn` 安装依赖包。 + + + +```shell +python tools/analysis_tools/analyze_logs.py plot_curve ${JSON_LOGS} [--keys ${KEYS}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}] +``` + +示例： + +- 绘制损失曲线 + + ```shell + python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_kpt --legend loss_kpt + ``` + +- 绘制精度曲线并导出为 PDF 文件 + + ```shell + python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys acc_pose --out results.pdf + ``` + +- 将多个日志文件绘制在同一张图上 + + ```shell + python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys loss_kpt --legend run1 run2 --title loss_kpt --out loss_kpt.png + ``` + +### 统计训练速度 + +```shell +python tools/analysis_tools/analyze_logs.py cal_train_time ${JSON_LOGS} [--include-outliers] +``` + +示例： + +```shell +python tools/analysis_tools/analyze_logs.py cal_train_time log.json +``` + +结果如下： + +```text +-----Analyze train time of hrnet_w32_256x192.json----- +slowest epoch 56, average time is 0.6924 +fastest epoch 1, average time is 0.6502 +time std over epochs is 0.0085 +average iter time: 0.6688 s/iter +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/overview.md b/internlm_langchain/knowledge_base/MMPose/content/overview.md new file mode 100644 index 00000000..a790cd3b --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/overview.md @@ -0,0 +1,76 @@ +# 概述 + +本章将向你介绍 MMPose 的整体框架，并提供详细的教程链接。 + +## 什么是 MMPose + + + +MMPose 是一款基于 Pytorch 的姿态估计开源工具箱，是 OpenMMLab 项目的成员之一，包含了丰富的 2D 多人姿态估计、2D 手部姿态估计、2D 人脸关键点检测、133关键点全身人体姿态估计、动物关键点检测、服饰关键点检测等算法以及相关的组件和模块，下面是它的整体框架： + +MMPose 由 **8** 个主要部分组成，apis、structures、datasets、codecs、models、engine、evaluation 和 visualization。 + +- **apis** 提供用于模型推理的高级 API + +- **structures** 提供 bbox、keypoint 和 PoseDataSample 等数据结构 + +- **datasets** 支持用于姿态估计的各种数据集 + + - **transforms** 包含各种数据增强变换 + +- **codecs** 提供姿态编解码器：编码器用于将姿态信息（通常为关键点坐标）编码为模型学习目标（如热力图），解码器则用于将模型输出解码为姿态估计结果 + +- **models** 以模块化结构提供了姿态估计模型的各类组件 + + - **pose_estimators** 定义了所有姿态估计模型类 + - **data_preprocessors** 用于预处理模型的输入数据 + - **backbones** 包含各种骨干网络 + - **necks** 包含各种模型颈部组件 + - **heads** 包含各种模型头部 + - **losses** 包含各种损失函数 + +- **engine** 包含与姿态估计任务相关的运行时组件 + + - **hooks** 提供运行时的各种钩子 + +- **evaluation** 提供各种评估模型性能的指标 + +- **visualization** 用于可视化关键点骨架和热力图等信息 + +## 如何使用本指南 + +针对不同类型的用户，我们准备了详细的指南： + +1. 安装说明： + + - [安装](./installation.md) + +2. MMPose 的基本使用方法： + + - [20 分钟上手教程](./guide_to_framework.md) + - [Demos](./demos.md) + - [模型推理](./user_guides/inference.md) + - [配置文件](./user_guides/configs.md) + - [准备数据集](./user_guides/prepare_datasets.md) + - [训练与测试](./user_guides/train_and_test.md) + +3. 对于希望基于 MMPose 进行开发的研究者和开发者： + + - [编解码器](./advanced_guides/codecs.md) + - [数据流](./advanced_guides/dataflow.md) + - [实现新模型](./advanced_guides/implement_new_models.md) + - [自定义数据集](./advanced_guides/customize_datasets.md) + - [自定义数据变换](./advanced_guides/customize_transforms.md) + - [自定义优化器](./advanced_guides/customize_optimizer.md) + - [自定义日志](./advanced_guides/customize_logging.md) + - [模型部署](./advanced_guides/how_to_deploy.md) + - [模型分析工具](./advanced_guides/model_analysis.md) + - [迁移指南](./migration.md) + +4. 对于希望加入开源社区，向 MMPose 贡献代码的研究者和开发者： + + - [参与贡献代码](./contribution_guide.md) + +5. 对于使用过程中的常见问题： + + - [FAQ](./faq.md) diff --git a/internlm_langchain/knowledge_base/MMPose/content/prepare_datasets.md b/internlm_langchain/knowledge_base/MMPose/content/prepare_datasets.md new file mode 100644 index 00000000..8b7d651e --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/prepare_datasets.md @@ -0,0 +1,221 @@ +# 准备数据集 + +在这份文档将指导如何为 MMPose 准备数据集，包括使用内置数据集、创建自定义数据集、结合数据集进行训练、浏览和下载数据集。 + +## 使用内置数据集 + +**步骤一**: 准备数据 + +MMPose 支持多种任务和相应的数据集。你可以在 [数据集仓库](https://mmpose.readthedocs.io/en/latest/dataset_zoo.html) 中找到它们。为了正确准备你的数据，请按照你选择的数据集的指南进行操作。 + +**步骤二**: 在配置文件中进行数据集设置 + +在开始训练或评估模型之前，你必须配置数据集设置。以 [`td-hm_hrnet-w32_8xb64-210e_coco-256x192.py`](/configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py) 为例，它可以用于在 COCO 数据集上训练或评估 HRNet 姿态估计器。下面我们浏览一下数据集配置： + +- 基础数据集参数 + + ```python + # base dataset settings + dataset_type = 'CocoDataset' + data_mode = 'topdown' + data_root = 'data/coco/' + ``` + + - `dataset_type` 指定数据集的类名。用户可以参考 [数据集 API](https://mmpose.readthedocs.io/en/latest/api.html#datasets) 来找到他们想要的数据集的类名。 + - `data_mode` 决定了数据集的输出格式，有两个选项可用：`'topdown'` 和 `'bottomup'`。如果 `data_mode='topdown'`，数据元素表示一个实例及其姿态；否则，一个数据元素代表一张图像，包含多个实例和姿态。 + - `data_root` 指定数据集的根目录。 + +- 数据处理流程 + + ```python + # pipelines + train_pipeline = [ + dict(type='LoadImage'), + dict(type='GetBBoxCenterScale'), + dict(type='RandomFlip', direction='horizontal'), + dict(type='RandomHalfBody'), + dict(type='RandomBBoxTransform'), + dict(type='TopdownAffine', input_size=codec['input_size']), + dict(type='GenerateTarget', encoder=codec), + dict(type='PackPoseInputs') + ] + val_pipeline = [ + dict(type='LoadImage'), + dict(type='GetBBoxCenterScale'), + dict(type='TopdownAffine', input_size=codec['input_size']), + dict(type='PackPoseInputs') + ] + ``` + + `train_pipeline` 和 `val_pipeline` 分别定义了训练和评估阶段处理数据元素的步骤。除了加载图像和打包输入之外，`train_pipeline` 主要包含数据增强技术和目标生成器，而 `val_pipeline` 则专注于将数据元素转换为统一的格式。 + +- 数据加载器 + + ```python + # data loaders + train_dataloader = dict( + batch_size=64, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_mode=data_mode, + ann_file='annotations/person_keypoints_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=train_pipeline, + )) + val_dataloader = dict( + batch_size=32, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_mode=data_mode, + ann_file='annotations/person_keypoints_val2017.json', + bbox_file='data/coco/person_detection_results/' + 'COCO_val2017_detections_AP_H_56_person.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=val_pipeline, + )) + test_dataloader = val_dataloader + ``` + + 这个部分是配置数据集的关键。除了前面讨论过的基础数据集参数和数据处理流程之外，这里还定义了其他重要的参数。`batch_size` 决定了每个 GPU 的 batch size；`ann_file` 指定了数据集的注释文件；`data_prefix` 指定了图像文件夹。`bbox_file` 仅在 top-down 数据集的 val/test 数据加载器中使用，用于提供检测到的边界框信息。 + +我们推荐从使用相同数据集的配置文件中复制数据集配置，而不是从头开始编写，以最小化潜在的错误。通过这样做，用户可以根据需要进行必要的修改，从而确保更可靠和高效的设置过程。 + +## 使用自定义数据集 + +[自定义数据集](../advanced_guides/customize_datasets.md) 指南提供了如何构建自定义数据集的详细信息。在本节中，我们将强调一些使用和配置自定义数据集的关键技巧。 + +- 确定数据集类名。如果你将数据集重组为 COCO 格式，你可以简单地使用 `CocoDataset` 作为 `dataset_type` 的值。否则，你将需要使用你添加的自定义数据集类的名称。 + +- 指定元信息配置文件。MMPose 1.x 采用了与 MMPose 0.x 不同的策略来指定元信息。在 MMPose 1.x 中，用户可以按照以下方式指定元信息配置文件： + + ```python + train_dataloader = dict( + ... + dataset=dict( + type=dataset_type, + data_root='root/of/your/train/data', + ann_file='path/to/your/train/json', + data_prefix=dict(img='path/to/your/train/img'), + # specify dataset meta information + metainfo=dict(from_file='configs/_base_/datasets/custom.py'), + ...), + ) + ``` + + 注意，`metainfo` 参数必须在 val/test 数据加载器中指定。 + +## 使用混合数据集进行训练 + +MMPose 提供了一个方便且多功能的解决方案，用于训练混合数据集。请参考[混合数据集训练](./mixed_datasets.md)。 + +## 浏览数据集 + +`tools/analysis_tools/browse_dataset.py` 帮助用户可视化地浏览姿态数据集，或将图像保存到指定的目录。 + +```shell +python tools/misc/browse_dataset.py ${CONFIG} [-h] [--output-dir ${OUTPUT_DIR}] [--not-show] [--phase ${PHASE}] [--mode ${MODE}] [--show-interval ${SHOW_INTERVAL}] +``` + +| ARGS | Description | +| -------------------------------- | ---------------------------------------------------------------------------------------------------------- | +| `CONFIG` | 配置文件的路径 | +| `--output-dir OUTPUT_DIR` | 保存可视化结果的目标文件夹。如果不指定，可视化的结果将不会被保存 | +| `--not-show` | 不适用外部窗口显示可视化的结果 | +| `--phase {train, val, test}` | 数据集选项 | +| `--mode {original, transformed}` | 指定可视化图片类型。 `original` 为不使用数据增强的原始图片及标注可视化; `transformed` 为经过增强后的可视化 | +| `--show-interval SHOW_INTERVAL` | 显示图片的时间间隔 | + +例如，用户想要可视化 COCO 数据集中的图像和标注，可以使用： + +```shell +python tools/misc/browse_dataset.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-e210_coco-256x192.py --mode original +``` + +检测框和关键点将被绘制在原始图像上。下面是一个例子： + + +原始图像在被输入模型之前需要被处理。为了可视化预处理后的图像和标注，用户需要将参数 `mode` 修改为 `transformed`。例如： + +```shell +python tools/misc/browse_dataset.py configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-e210_coco-256x192.py --mode transformed +``` + +这是一个处理后的样本： + + + +热图目标将与之一起可视化，如果它是在 pipeline 中生成的。 + +## 用 MIM 下载数据集 + +通过使用 [OpenDataLab](https://opendatalab.com/)，您可以直接下载开源数据集。通过平台的搜索功能，您可以快速轻松地找到他们正在寻找的数据集。使用平台上的格式化数据集，您可以高效地跨数据集执行任务。 + +如果您使用 MIM 下载，请确保版本大于 v0.3.8。您可以使用以下命令进行更新、安装、登录和数据集下载： + +```shell +# upgrade your MIM +pip install -U openmim + +# install OpenDataLab CLI tools +pip install -U opendatalab +# log in OpenDataLab, registry +odl login + +# download coco2017 and preprocess by MIM +mim download mmpose --dataset coco2017 +``` + +### 已支持的数据集 + +下面是支持的数据集列表，更多数据集将在之后持续更新： + +#### 人体数据集 + +| Dataset name | Download command | +| ------------- | ----------------------------------------- | +| COCO 2017 | `mim download mmpose --dataset coco2017` | +| MPII | `mim download mmpose --dataset mpii` | +| AI Challenger | `mim download mmpose --dataset aic` | +| CrowdPose | `mim download mmpose --dataset crowdpose` | + +#### 人脸数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------ | +| LaPa | `mim download mmpose --dataset lapa` | +| 300W | `mim download mmpose --dataset 300w` | +| WFLW | `mim download mmpose --dataset wflw` | + +#### 手部数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------------ | +| OneHand10K | `mim download mmpose --dataset onehand10k` | +| FreiHand | `mim download mmpose --dataset freihand` | +| HaGRID | `mim download mmpose --dataset hagrid` | + +#### 全身数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------- | +| Halpe | `mim download mmpose --dataset halpe` | + +#### 动物数据集 + +| Dataset name | Download command | +| ------------ | ------------------------------------- | +| AP-10K | `mim download mmpose --dataset ap10k` | + +#### 服装数据集 + +Coming Soon diff --git a/internlm_langchain/knowledge_base/MMPose/content/projects.md b/internlm_langchain/knowledge_base/MMPose/content/projects.md new file mode 100644 index 00000000..460d8583 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/projects.md @@ -0,0 +1,20 @@ +# Projects based on MMPose + +There are many projects built upon MMPose. We list some of them as examples of how to extend MMPose for your own projects. As the page might not be completed, please feel free to create a PR to update this page. + +## Projects as an extension + +Some projects extend the boundary of MMPose for deployment or other research fields. They reveal the potential of what MMPose can do. We list several of them as below. + +- [Anime Face Detector](https://github.com/hysts/anime-face-detector): An anime face landmark detection toolbox. +- [PosePipeline](https://github.com/peabody124/PosePipeline): Open-Source Human Pose Estimation Pipeline for Clinical Research + +## Projects of papers + +There are also projects released with papers. Some of the papers are published in top-tier conferences (CVPR, ICCV, and ECCV), the others are also highly influential. We list some of these works as a reference for the community to develop and compare new pose estimation algorithms. Methods already supported and maintained by MMPose are not listed. + +- Pose for Everything: Towards Category-Agnostic Pose Estimation, ECCV 2022. [\[paper\]](https://arxiv.org/abs/2207.10387)[\[github\]](https://github.com/luminxu/Pose-for-Everything) +- UniFormer: Unified Transformer for Efficient Spatiotemporal Representation Learning, ICLR 2022. [\[paper\]](https://arxiv.org/abs/2201.04676)[\[github\]](https://github.com/Sense-X/UniFormer) +- Poseur:Direct Human Pose Regression with Transformers, ECCV 2022. [\[paper\]](https://arxiv.org/abs/2201.07412)[\[github\]](https://github.com/aim-uofa/Poseur) +- ViTAEv2: Vision Transformer Advanced by Exploring Inductive Bias for Image Recognition and Beyond, NeurIPS 2022. [\[paper\]](https://arxiv.org/abs/2106.03348)[\[github\]](https://github.com/ViTAE-Transformer/ViTAE-Transformer) +- Dite-HRNet:Dynamic Lightweight High-Resolution Network for Human Pose Estimation, IJCAI-ECAI 2021. [\[paper\]](https://arxiv.org/abs/2204.10762)[\[github\]](https://github.com/ZiyiZhang27/Dite-HRNet) diff --git a/internlm_langchain/knowledge_base/MMPose/content/pytorch_2.md b/internlm_langchain/knowledge_base/MMPose/content/pytorch_2.md new file mode 100644 index 00000000..4892e554 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/pytorch_2.md @@ -0,0 +1,14 @@ +# PyTorch 2.0 Compatibility and Benchmarks + +MMPose 1.0.0 is now compatible with PyTorch 2.0, ensuring that users can leverage the latest features and performance improvements offered by the PyTorch 2.0 framework when using MMPose. With the integration of inductor, users can expect faster model speeds. The table below shows several example models: + +| Model | Training Speed | Memory | +| :-------- | :---------------------: | :-----------: | +| ViTPose-B | 29.6% ↑ (0.931 → 0.655) | 10586 → 10663 | +| ViTPose-S | 33.7% ↑ (0.563 → 0.373) | 6091 → 6170 | +| HRNet-w32 | 12.8% ↑ (0.553 → 0.482) | 9849 → 10145 | +| HRNet-w48 | 37.1% ↑ (0.437 → 0.275) | 7319 → 7394 | +| RTMPose-t | 6.3% ↑ (1.533 → 1.437) | 6292 → 6489 | +| RTMPose-s | 13.1% ↑ (1.645 → 1.430) | 9013 → 9208 | + +- Pytorch 2.0 test, add projects doc and refactor by @LareinaM in [PR#2136](https://github.com/open-mmlab/mmpose/pull/2136) diff --git a/internlm_langchain/knowledge_base/MMPose/content/quick_run.md b/internlm_langchain/knowledge_base/MMPose/content/quick_run.md new file mode 100644 index 00000000..55c2d63b --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/quick_run.md @@ -0,0 +1,188 @@ +# 快速上手 + +在这一章里，我们将带领你走过MMPose工作流程中关键的七个步骤，帮助你快速上手： + +1. 使用预训练模型进行推理 +2. 准备数据集 +3. 准备配置文件 +4. 可视化训练图片 +5. 训练 +6. 测试 +7. 可视化 + +## 安装 + +请查看[安装指南](./installation.md)，以了解完整步骤。 + +## 快速开始 + +### 使用预训练模型进行推理 + +你可以通过以下命令来使用预训练模型对单张图片进行识别： + +```Bash +python demo/image_demo.py \ + tests/data/coco/000000000785.jpg \ + configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py\ + https://download.openmmlab.com/mmpose/top_down/deeppose/deeppose_res50_coco_256x192_rle-2ea9bb4a_20220616.pth +``` + +该命令中用到了测试图片、完整的配置文件、预训练模型，如果MMPose安装无误，将会弹出一个新窗口，对检测结果进行可视化显示： + + + +更多演示脚本的详细参数说明可以在 [模型推理](./user_guides/inference.md) 中找到。 + +### 准备数据集 + +MMPose支持各种不同的任务，我们提供了对应的数据集准备教程。 + +- [2D人体关键点](./dataset_zoo/2d_body_keypoint.md) + +- [3D人体关键点](./dataset_zoo/3d_body_keypoint.md) + +- [2D人手关键点](./dataset_zoo/2d_hand_keypoint.md) + +- [3D人手关键点](./dataset_zoo/3d_hand_keypoint.md) + +- [2D人脸关键点](./dataset_zoo/2d_face_keypoint.md) + +- [2D全身人体关键点](./dataset_zoo/2d_wholebody_keypoint.md) + +- [2D服饰关键点](./dataset_zoo/2d_fashion_landmark.md) + +- [2D动物关键点](./dataset_zoo/2d_animal_keypoint.md) + +你可以在【2D人体关键点数据集】>【COCO】下找到COCO数据集的准备教程，并按照教程完成数据集的下载和整理。 + +```{note} +在MMPose中，我们建议将COCO数据集存放到新建的 `$MMPOSE/data` 目录下。 +``` + +### 准备配置文件 + +MMPose拥有一套强大的配置系统，用于管理训练所需的一系列必要参数： + +- **通用**：环境、Hook、Checkpoint、Logger、Timer等 + +- **数据**：Dataset、Dataloader、数据增强等 + +- **训练**：优化器、学习率调整等 + +- **模型**：Backbone、Neck、Head、损失函数等 + +- **评测**：Metrics + +在`$MMPOSE/configs`目录下，我们提供了大量前沿论文方法的配置文件，可供直接使用和参考。 + +要在COCO数据集上训练基于ResNet50的RLE模型时，所需的配置文件为： + +```Bash +$MMPOSE/configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py +``` + +我们需要将配置文件中的 data_root 变量修改为COCO数据集存放路径： + +```Python +data_root = 'data/coco' +``` + +```{note} +感兴趣的读者也可以查阅 [配置文件](./user_guides/configs.md) 来进一步学习MMPose所使用的配置系统。 +``` + +### 可视化训练图片 + +在开始训练之前，我们还可以对训练图片进行可视化，检查训练图片是否正确进行了数据增强。 + +我们提供了相应的可视化脚本： + +```Bash +python tools/misc/browse_dastaset.py \ + configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py \ + --mode transformed +``` + + + +### 训练 + +确定数据无误后，运行以下命令启动训练： + +```Bash +python tools/train.py configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py +``` + +```{note} +MMPose中集成了大量实用训练trick和功能： + +- 学习率warmup和scheduling + +- ImageNet预训练权重 + +- 自动学习率缩放、自动batch size缩放 + +- CPU训练、多机多卡训练、集群训练 + +- HardDisk、LMDB、Petrel、HTTP等不同数据后端 + +- 混合精度浮点训练 + +- TensorBoard +``` + +### 测试 + +在不指定额外参数时，训练的权重和日志信息会默认存储到`$MMPOSE/work_dirs`目录下，最优的模型权重存放在`$MMPOSE/work_dir/best_coco`目录下。 + +我们可以通过如下指令测试模型在COCO验证集上的精度： + +```Bash +python tools/test.py \ + configs/body_2d_keypoint/topdown_regression/coco/td-reg_res50_rle-8xb64-210e_coco-256x192.py \ + work_dir/best_coco/AP_epoch_20.pth +``` + +在COCO验证集上评测结果样例如下： + +```Bash + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets= 20 ] = 0.704 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets= 20 ] = 0.883 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets= 20 ] = 0.777 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets= 20 ] = 0.667 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets= 20 ] = 0.769 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 20 ] = 0.751 + Average Recall (AR) @[ IoU=0.50 | area= all | maxDets= 20 ] = 0.920 + Average Recall (AR) @[ IoU=0.75 | area= all | maxDets= 20 ] = 0.815 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets= 20 ] = 0.709 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets= 20 ] = 0.811 +08/23 12:04:42 - mmengine - INFO - Epoch(test) [3254/3254] coco/AP: 0.704168 coco/AP .5: 0.883134 coco/AP .75: 0.777015 coco/AP (M): 0.667207 coco/AP (L): 0.768644 coco/AR: 0.750913 coco/AR .5: 0.919710 coco/AR .75: 0.815334 coco/AR (M): 0.709232 coco/AR (L): 0.811334 +``` + +```{note} +如果需要测试模型在其他数据集上的表现，可以前往 [训练与测试](./user_guides/train_and_test.md) 查看。 +``` + +### 可视化 + +除了对关键点骨架的可视化以外，我们还支持对热度图进行可视化，你只需要在配置文件中设置`output_heatmap=True`： + +```Python +model = dict( + ## 内容省略 + test_cfg = dict( + ## 内容省略 + output_heatmaps=True + ) +) +``` + +或在命令行中添加`--cfg-options='model.test_cfg.output_heatmaps=True'`。 + +可视化效果如下： + + + +```{note} +如果你希望深入地学习MMPose，将其应用到自己的项目当中，我们准备了一份详细的 [迁移指南](./migration.md) 。 +``` diff --git a/internlm_langchain/knowledge_base/MMPose/content/train_and_test.md b/internlm_langchain/knowledge_base/MMPose/content/train_and_test.md new file mode 100644 index 00000000..452eddc9 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/train_and_test.md @@ -0,0 +1,5 @@ +# 训练与测试 + +中文内容建设中，暂时请查阅[英文版文档](../../en/user_guides/train_and_test.md) + +如果您愿意参与中文文档的翻译与维护，我们团队将十分感谢您的贡献！欢迎加入我们的社区群与我们取得联系，或直接按照 [如何给 MMPose 贡献代码](../contribution_guide.md) 在 GitHub 上提交 Pull Request。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/useful_tools.md b/internlm_langchain/knowledge_base/MMPose/content/useful_tools.md new file mode 100644 index 00000000..f2ceb771 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/useful_tools.md @@ -0,0 +1,5 @@ +# 常用工具 + +中文内容建设中，暂时请查阅[英文版文档](../../en/user_guides/useful_tools.md) + +如果您愿意参与中文文档的翻译与维护，我们团队将十分感谢您的贡献！欢迎加入我们的社区群与我们取得联系，或直接按照 [如何给 MMPose 贡献代码](../contribution_guide.md) 在 GitHub 上提交 Pull Request。 diff --git a/internlm_langchain/knowledge_base/MMPose/content/visualization.md b/internlm_langchain/knowledge_base/MMPose/content/visualization.md new file mode 100644 index 00000000..a584eb45 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPose/content/visualization.md @@ -0,0 +1,5 @@ +# 可视化 + +中文内容建设中，暂时请查阅[英文版文档](../../en/user_guides/visualization.md) + +如果您愿意参与中文文档的翻译与维护，我们团队将十分感谢您的贡献！欢迎加入我们的社区群与我们取得联系，或直接按照 [如何给 MMPose 贡献代码](../contribution_guide.md) 在 GitHub 上提交 Pull Request。 diff --git a/internlm_langchain/knowledge_base/MMPose/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMPose/vector_store/index.faiss new file mode 100644 index 00000000..844a8a0b Binary files /dev/null and b/internlm_langchain/knowledge_base/MMPose/vector_store/index.faiss differ diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/cam_visualization.md b/internlm_langchain/knowledge_base/MMPreTrain/content/cam_visualization.md new file mode 100644 index 00000000..94d5ed17 --- /dev/null +++ b/internlm_langchain/knowledge_base/MMPreTrain/content/cam_visualization.md @@ -0,0 +1,164 @@ +# 类别激活图（CAM）可视化 + +## 类别激活图可视化工具介绍 + +MMPretrain 提供 `tools/visualization/vis_cam.py` 工具来可视化类别激活图。请使用 `pip install "grad-cam>=1.3.6"` 安装依赖的 [pytorch-grad-cam](https://github.com/jacobgil/pytorch-grad-cam)。 + +目前支持的方法有： + +| Method | What it does | +| :----------: | :-----------------------------------------------------------------------------------------------: | +| GradCAM | 使用平均梯度对 2D 激活进行加权 | +| GradCAM++ | 类似 GradCAM，但使用了二阶梯度 | +| XGradCAM | 类似 GradCAM，但通过归一化的激活对梯度进行了加权 | +| EigenCAM | 使用 2D 激活的第一主成分（无法区分类别，但效果似乎不错） | +| EigenGradCAM | 类似 EigenCAM，但支持类别区分，使用了激活 * 梯度的第一主成分，看起来和 GradCAM 差不多，但是更干净 | +| LayerCAM | 使用正梯度对激活进行空间加权，对于浅层有更好的效果 | + +也可以使用新版本 `pytorch-grad-cam` 支持的更多 CAM 方法，但我们尚未验证可用性。 + +**命令行**： + +```bash +python tools/visualization/vis_cam.py \ + ${IMG} \ + ${CONFIG_FILE} \ + ${CHECKPOINT} \ + [--target-layers ${TARGET-LAYERS}] \ + [--preview-model] \ + [--method ${METHOD}] \ + [--target-category ${TARGET-CATEGORY}] \ + [--save-path ${SAVE_PATH}] \ + [--vit-like] \ + [--num-extra-tokens ${NUM-EXTRA-TOKENS}] + [--aug_smooth] \ + [--eigen_smooth] \ + [--device ${DEVICE}] \ + [--cfg-options ${CFG-OPTIONS}] +``` + +**所有参数的说明**： + +- `img`：目标图片路径。 +- `config`：模型配置文件的路径。 +- `checkpoint`：权重路径。 +- `--target-layers`：所查看的网络层名称，可输入一个或者多个网络层，如果不设置，将使用最后一个`block`中的`norm`层。 +- `--preview-model`：是否查看模型所有网络层。 +- `--method`：类别激活图图可视化的方法，目前支持 `GradCAM`, `GradCAM++`, `XGradCAM`, `EigenCAM`, `EigenGradCAM`, `LayerCAM`，不区分大小写。如果不设置，默认为 `GradCAM`。 +- `--target-category`：查看的目标类别，如果不设置，使用模型检测出来的类别做为目标类别。 +- `--save-path`：保存的可视化图片的路径，默认不保存。 +- `--eigen-smooth`：是否使用主成分降低噪音，默认不开启。 +- `--vit-like`: 是否为 `ViT` 类似的 Transformer-based 网络 +- `--num-extra-tokens`: `ViT` 类网络的额外的 tokens 通道数，默认使用主干网络的 `num_extra_tokens`。 +- `--aug-smooth`：是否使用测试时增强 +- `--device`：使用的计算设备，如果不设置，默认为'cpu'。 +- `--cfg-options`：对配置文件的修改，参考[学习配置文件](../user_guides/config.md)。 + +```{note} +在指定 `--target-layers` 时，如果不知道模型有哪些网络层，可使用命令行添加 `--preview-model` 查看所有网络层名称； +``` + +## 如何可视化 CNN 网络的类别激活图（如 ResNet-50） + +`--target-layers` 在 `Resnet-50` 中的一些示例如下： + +- `'backbone.layer4'`，表示第四个 `ResLayer` 层的输出。 +- `'backbone.layer4.2'` 表示第四个 `ResLayer` 层中第三个 `BottleNeck` 块的输出。 +- `'backbone.layer4.2.conv1'` 表示上述 `BottleNeck` 块中 `conv1` 层的输出。 + +1. 使用不同方法可视化 `ResNet50`，默认 `target-category` 为模型检测的结果，使用默认推导的 `target-layers`。 + + ```shell + python tools/visualization/vis_cam.py \ + demo/bird.JPEG \ + configs/resnet/resnet50_8xb32_in1k.py \ + https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_batch256_imagenet_20200708-cfb998bf.pth \ + --method GradCAM + # GradCAM++, XGradCAM, EigenCAM, EigenGradCAM, LayerCAM + ``` + + | Image | GradCAM | GradCAM++ | EigenGradCAM | LayerCAM | + | ------------------------------------ | --------------------------------------- | ----------------------------------------- | -------------------------------------------- | ---------------------------------------- | + |
+
+## 从图像中提取特征
+
+与 `model.extract_feat` 相比，`FeatureExtractor` 用于直接从图像文件中提取特征，而不是从一批张量中提取特征。简单说，`model.extract_feat` 的输入是 `torch.Tensor`，`FeatureExtractor` 的输入是图像。
+
+```
+>>> from mmpretrain import FeatureExtractor, get_model
+>>> model = get_model('resnet50_8xb32_in1k', backbone=dict(out_indices=(0, 1, 2, 3)))
+>>> extractor = FeatureExtractor(model)
+>>> features = extractor('https://github.com/open-mmlab/mmpretrain/raw/main/demo/demo.JPEG')[0]
+>>> features[0].shape, features[1].shape, features[2].shape, features[3].shape
+(torch.Size([256]), torch.Size([512]), torch.Size([1024]), torch.Size([2048]))
+```
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/log_result_analysis.md b/internlm_langchain/knowledge_base/MMPreTrain/content/log_result_analysis.md
new file mode 100644
index 00000000..748a9076
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/log_result_analysis.md
@@ -0,0 +1,223 @@
+# 日志分析工具
+
+## 日志分析
+
+### 日志分析工具介绍
+
+`tools/analysis_tools/analyze_logs.py` 脚本绘制指定键值的变化曲线。
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMPreTrain/content/t-sne_visualization.md b/internlm_langchain/knowledge_base/MMPreTrain/content/t-sne_visualization.md
new file mode 100644
index 00000000..124e915e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMPreTrain/content/t-sne_visualization.md
@@ -0,0 +1,85 @@
+# t-分布随机邻域嵌入（t-SNE）可视化
+
+## t-分布随机邻域嵌入可视化工具介绍
+
+MMPretrain 提供 `tools/visualization/vis_tsne.py` 工具来用t-SNE可视化图像的特征嵌入。请使用 `pip install scikit-learn` 安装 `sklearn` 来计算t-SNE。
+
+**命令**：
+
+```bash
+python tools/visualization/vis_tsne.py \
+ CONFIG \
+ [--checkpoint CHECKPOINT] \
+ [--work-dir WORK_DIR] \
+ [--test-cfg TEST_CFG] \
+ [--vis-stage {backbone,neck,pre_logits}]
+ [--class-idx ${CLASS_IDX} [CLASS_IDX ...]]
+ [--max-num-class MAX_NUM_CLASS]
+ [--max-num-samples MAX_NUM_SAMPLES]
+ [--cfg-options CFG_OPTIONS [CFG_OPTIONS ...]]
+ [--device DEVICE]
+ [--legend]
+ [--show]
+ [--n-components N_COMPONENTS]
+ [--perplexity PERPLEXITY]
+ [--early-exaggeration EARLY_EXAGGERATION]
+ [--learning-rate LEARNING_RATE]
+ [--n-iter N_ITER]
+ [--n-iter-without-progress N_ITER_WITHOUT_PROGRESS]
+ [--init INIT]
+```
+
+**所有参数的说明**：
+
+- `CONFIG`: t-SNE 配置文件的路径。
+- `--checkpoint CHECKPOINT`: 模型权重文件的路径。
+- `--work-dir WORK_DIR`: 保存日志和可视化图像的目录。
+- `--test-cfg TEST_CFG`: 用来加载 test_dataloader 配置的 t-SNE 配置文件的路径。
+- `--vis-stage {backbone,neck,pre_logits}`: 模型可视化的阶段。
+- `--class-idx CLASS_IDX [CLASS_IDX ...]`: 用来计算 t-SNE 的类别。
+- `--max-num-class MAX_NUM_CLASS`: 前 N 个被应用 t-SNE 算法的类别，默认为20。
+- `--max-num-samples MAX_NUM_SAMPLES`: 每个类别中最大的样本数，值越高需要的计算时间越长，默认为100。
+- `--cfg-options CFG_OPTIONS [CFG_OPTIONS ...]`: 覆盖被使用的配置中的一些设定，形如 xxx=yyy 格式的关键字-值对会被合并到配置文件中。如果被覆盖的值是一个列表，它应该形如 key="[a,b]" 或者 key=a,b 。它还允许嵌套的列表/元组值，例如 key="[(a,b),(c,d)]" 。注意引号是必需的，而且不允许有空格。
+- `--device DEVICE`: 用于推理的设备。
+- `--legend`: 显示所有类别的图例。
+- `--show`: 在图形窗口中显示结果。
+- `--n-components N_COMPONENTS`: 结果的维数。
+- `--perplexity PERPLEXITY`: 复杂度与其他流形学习算法中使用的最近邻的数量有关。
+- `--early-exaggeration EARLY_EXAGGERATION`: 控制原空间中的自然聚类在嵌入空间中的紧密程度以及它们之间的空间大小。
+- `--learning-rate LEARNING_RATE`: t-SNE 的学习率通常在[10.0, 1000.0]的范围内。如果学习率太高，数据可能看起来像一个球，其中任何一点与它最近的邻居近似等距。如果学习率太低，大多数点可能看起来被压缩在一个几乎没有异常值的密集点云中。
+- `--n-iter N_ITER`: 优化的最大迭代次数。应该至少为250。
+- `--n-iter-without-progress N_ITER_WITHOUT_PROGRESS`: 在我们中止优化之前，最大的没有进展的迭代次数。
+- `--init INIT`: 初始化方法。
+
+## 如何可视化分类模型的t-SNE（如 ResNet）
+
+以下是在CIFAR-10数据集上训练的 ResNet-18 和 ResNet-50 模型上运行 t-SNE 可视化的两个样例：
+
+```shell
+python tools/visualization/vis_tsne.py \
+ configs/resnet/resnet18_8xb16_cifar10.py \
+ --checkpoint https://download.openmmlab.com/mmclassification/v0/resnet/resnet18_b16x8_cifar10_20210528-bd6371c8.pth
+
+python tools/visualization/vis_tsne.py \
+ configs/resnet/resnet50_8xb16_cifar10.py \
+ --checkpoint https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_b16x8_cifar10_20210528-f54bfad9.pth
+```
+
+| ResNet-18 | ResNet-50 |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| 
+ 
+
+ 
+
+
+
+可视化可以给深度学习的模型训练和测试过程提供直观解释。
+
+MMRazor 中，将使用 MMEngine 提供的 `Visualizer` 可视化器搭配 MMRazor 自带的 `Recorder`组件的数据记录功能，进行特征图可视化，其具备如下功能：
+
+- 支持基础绘图接口以及特征图可视化。
+- 支持选择模型中的任意位点来得到特征图，包含 `pixel_wise_max` ，`squeeze_mean` ， `select_max` ， `topk` 四种显示方式，用户还可以使用 `arrangement` 自定义特征图显示的布局方式。
+
+## 特征图绘制
+
+你可以调用 `tools/visualizations/vis_configs/feature_visualization.py` 来简单快捷地得到单张图片单个模型的可视化结果。
+
+为了方便理解，将其主要参数的功能梳理如下：
+
+- `img`：选择要用于特征图可视化的图片，支持单张图片或者图片路径列表。
+
+- `config`：选择算法的配置文件。
+
+- `vis_config`：可视化功能需借助可配置的 `Recorder` 组件获取模型中用户自定义位点的特征图，
+ 用户可以将 `Recorder` 相关配置文件放入 `vis_config` 中。 MMRazor提供了对backbone及neck
+ 输出进行可视化对应的config文件，详见 `configs/visualizations`
+
+- `checkpoint`：选择对应算法的权重文件。
+
+- `--out-file`：将得到的特征图保存到本地，并指定路径和文件名。若没有选定，则会直接显示特征图。
+
+- `--device`：指定用于推理图片的硬件，`--device cuda：0` 表示使用第 1 张 GPU 推理，`--device cpu` 表示用 CPU 推理。
+
+- `--repo`：模型对应的算法库。`--repo mmdet` 表示模型为检测模型。
+
+- `--use-norm`：是否将获取的特征图进行batch normalization后再显示。
+
+- `--overlaid`：是否将特征图覆盖在原图之上。若设为True，考虑到输入的特征图通常非常小，函数默认将特征图进行上采样后方便进行可视化。
+
+- `--channel-reduction`：输入的 Tensor 一般是包括多个通道的，`channel_reduction` 参数可以将多个通道压缩为单通道，然后和图片进行叠加显示，有以下三个参数可以设置：
+
+ - `pixel_wise_max`：将输入的 C 维度采用 max 函数压缩为一个通道，输出维度变为 (1, H, W)。
+ - `squeeze_mean`：将输入的 C 维度采用 mean 函数压缩为一个通道，输出维度变成 (1, H, W)。
+ - `select_max`：从输入的 C 维度中先在空间维度 sum，维度变成 (C, )，然后选择值最大的通道。
+ - `None`：表示不需要压缩，此时可以通过 `topk` 参数可选择激活度最高的 `topk` 个特征图显示。
+
+- `--topk`：只有在 `channel_reduction` 参数为 `None` 的情况下， `topk` 参数才会生效，其会按照激活度排序选择 `topk` 个通道，然后和图片进行叠加显示，并且此时会通过 `--arrangement` 参数指定显示的布局，该参数表示为一个数组，两个数字需要以空格分开，例如： `--topk 5 --arrangement 2 3` 表示以 `2行 3列` 显示激活度排序最高的 5 张特征图， `--topk 7 --arrangement 3 3` 表示以 `3行 3列` 显示激活度排序最高的 7 张特征图。
+
+ - 如果 topk 不是 -1，则会按照激活度排序选择 topk 个通道显示。
+ - 如果 topk = -1，此时通道 C 必须是 1 或者 3 表示输入数据是图片，否则报错提示用户应该设置 `channel_reduction` 来压缩通道。
+
+- `--arrangement`：特征图的排布。当 `channel_reduction` 不是None且topk > 0时才会有用。
+
+- `--resize-shape`：当`--overlaid`为True时，是否需要将原图和特征图resize为某一尺寸。
+
+- `--cfg-options`：由于不同算法库的visualizer拥有特例化的add_datasample方法，如mmdet的visualizer
+ 拥有 `pred_score_thr` 作为输入参数，可以在`--cfg-options`加入一些特例化的设置。
+
+类似的，用户可以通过调用 `tools/visualizations/vis_configs/feature_diff_visualization.py` 来得到
+单张图片两个模型的特征差异可视化结果，用法与上述类似，差异为：
+
+- `config1` / `config2`：选择算法1/2的配置文件。
+- `checkpoint1` / `checkpoint2`：选择对应算法1/2的权重文件。
+
+## 用法示例
+
+以预训练好的 RetinaNet-r101 与 RetinaNet-r50 模型为例:
+
+请提前下载 RetinaNet-r101 与 RetinaNet-r50 模型权重到本仓库根路径下：
+
+```shell
+cd mmrazor
+wget https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_2x_coco/retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth
+wget https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_2x_coco/retinanet_r50_fpn_2x_coco_20200131-fdb43119.pth
+```
+
+(1) 将多通道特征图采用 `pixel_wise_max` 参数压缩为单通道并显示, 通过提取 `neck` 层输出进行特征图可视化（这里只显示了前4个stage的特征图）：
+
+```shell
+python tools/visualizations/feature_visualization.py \
+ tools/visualizations/demo.jpg \
+ PATH/TO/THE/CONFIG \
+ tools/visualizations/vis_configs/fpn_feature_visualization.py \
+ retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth \
+ --repo mmdet --use-norm --overlaid
+ --channel-reduction pixel_wise_max
+```
+
+
+
+
+
+
+(2) 将多通道特征图采用 `select_max` 参数压缩为单通道并显示, 通过提取 `neck` 层输出进行特征图可视化（这里只显示了前4个stage的特征图）：
+
+```shell
+python tools/visualizations/feature_visualization.py \
+ tools/visualizations/demo.jpg \
+ PATH/TO/THE/CONFIG \
+ tools/visualizations/vis_configs/fpn_feature_visualization.py \
+ retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth \
+ --repo mmdet --overlaid
+ --channel-reduction select_max
+```
+
+
+
+
+
+
+(3) 将多通道特征图采用 `squeeze_mean` 参数压缩为单通道并显示, 通过提取 `neck` 层输出进行特征图可视化（这里只显示了前4个stage的特征图）：
+
+```shell
+python tools/visualizations/feature_visualization.py \
+ tools/visualizations/demo.jpg \
+ PATH/TO/THE/CONFIG \
+ tools/visualizations/vis_configs/fpn_feature_visualization.py \
+ retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth \
+ --repo mmdet --overlaid
+ --channel-reduction squeeze_mean
+```
+
+
+
+
+
+
+(4) 将多通道特征图采用 `squeeze_mean` 参数压缩为单通道并显示, 通过提取 `neck` 层输出进行特征图可视化（这里只显示了前4个stage的特征图）：
+
+```shell
+python tools/visualizations/feature_visualization.py \
+ tools/visualizations/demo.jpg \
+ PATH/TO/THE/CONFIG \
+ tools/visualizations/vis_configs/fpn_feature_visualization.py \
+ retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth \
+ --repo mmdet --overlaid
+ --channel-reduction squeeze_mean
+```
+
+
+
+
+
+
+(5) 将多通道的两个模型的特征图差异采用 `pixel_wise_max` 参数压缩为单通道并显示, 这里只显示了前4个stage的特征图差异：
+
+```shell
+python tools/visualizations/feature_diff_visualization.py \
+ tools/visualizations/demo.jpg \
+ PATH/TO/THE/CONFIG1 \
+ PATH/TO/THE/CONFIG2 \
+ tools/visualizations/vis_configs/fpn_feature_diff_visualization.py.py \
+ retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth \
+ retinanet_r50_fpn_2x_coco_20200131-fdb43119.pth \
+ --repo mmdet --use-norm --overlaid
+ --channel-reduction pixel_wise_max
+```
+
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMRazor/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMRazor/vector_store/index.faiss
new file mode 100644
index 00000000..e2dfe715
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMRazor/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/customize_config.md b/internlm_langchain/knowledge_base/MMRotate/content/customize_config.md
new file mode 100644
index 00000000..5b62f665
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/customize_config.md
@@ -0,0 +1,337 @@
+# 教程 1：学习配置文件
+
+我们在配置文件中支持了继承和模块化，这便于进行各种实验。
+如果需要检查配置文件，可以通过运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置。
+mmrotate 是建立在 [mmdet](https://github.com/open-mmlab/mmdetection) 之上的，
+因此强烈建议学习 [mmdet](https://mmdetection.readthedocs.io/en/latest/) 的基本知识。
+
+## 通过脚本参数修改配置
+
+当运行 `tools/train.py` 或者 `tools/test.py` 时，可以通过 `--cfg-options` 来修改配置。
+
+- 更新字典链的配置
+
+ 可以按照原始配置文件中的 dict 键顺序地指定配置预选项。
+ 例如，使用 `--cfg-options model.backbone.norm_eval=False` 将模型主干网络中的所有 BN 模块都改为 `train` 模式。
+
+- 更新配置列表中的键
+
+ 在配置文件里，一些字典型的配置被包含在列表中。例如，数据训练流程 `data.train.pipeline` 通常是一个列表，比如 `[dict(type='LoadImageFromFile'), ...]`。 如果需要将 `'LoadImageFromFile'` 改成 `'LoadImageFromWebcam'` ，需要写成下述形式： `--cfg-options data.train.pipeline.0.type=LoadImageFromWebcam`。
+
+- 更新列表或元组的值
+
+ 如果要更新的值是列表或元组。例如，配置文件通常设置 `workflow=[('train', 1)]`，如果需要改变这个键，可以通过 `--cfg-options workflow="[(train,1),(val,1)]"` 来重新设置。需要注意，引号 " 是支持列表或元组数据类型所必需的，并且在指定值的引号内**不允许**有空格。
+
+## 配置文件名称风格
+
+我们遵循以下样式来命名配置文件。建议贡献者遵循相同的风格。
+
+```text
+{model}_[model setting]_{backbone}_{neck}_[norm setting]_[misc]_[gpu x batch_per_gpu]_{dataset}_{data setting}_{angle version}
+```
+
+`{xxx}` 是被要求的文件 `[yyy]` 是可选的。
+
+- `{model}`： 模型种类，例如 `rotated_faster_rcnn`, `rotated_retinanet` 等。
+- `[model setting]`： 特定的模型，例如 `hbb` for `rotated_retinanet` 等。
+- `{backbone}`： 主干网络种类例如 `r50` (ResNet-50), `swin_tiny` (SWIN-tiny) 。
+- `{neck}`： Neck 模型的种类包括 `fpn`, `refpn`。
+- `[norm_setting]`： 默认使用 `bn` (Batch Normalization)，其他指定可以有 `gn` (Group Normalization)， `syncbn` (Synchronized Batch Normalization) 等。 `gn-head`/`gn-neck` 表示 GN 仅应用于网络的 Head 或 Neck， `gn-all` 表示 GN 用于整个模型， 例如主干网络、Neck 和 Head。
+- `[misc]`： 模型中各式各样的设置/插件，例如 `dconv`、 `gcb`、 `attention`、`albu`、 `mstrain` 等。
+- `[gpu x batch_per_gpu]`： GPU 数量和每个 GPU 的样本数，默认使用 `1xb2`。
+- `{dataset}`：数据集，例如 `dota`。
+- `{angle version}`：旋转定义方式，例如 `oc`, `le135` 或者 `le90`。
+
+## RotatedRetinaNet 配置文件示例
+
+为了帮助用户对 MMRotate 检测系统中的完整配置和模块有一个基本的了解
+我们对使用 ResNet50 和 FPN 的 RotatedRetinaNet 的配置文件进行简要注释说明。更详细的用法和各个模块对应的替代方案，请参考 API 文档。
+
+```python
+angle_version = 'oc' # 旋转定义方式
+model = dict(
+ type='RotatedRetinaNet', # 检测器(detector)名称
+ backbone=dict( # 主干网络的配置文件
+ type='ResNet', # # 主干网络的类别
+ depth=50, # 主干网络的深度
+ num_stages=4, # 主干网络阶段(stages)的数目
+ out_indices=(0, 1, 2, 3), # 每个阶段产生的特征图输出的索引
+ frozen_stages=1, # 第一个阶段的权重被冻结
+ zero_init_residual=False, # 是否对残差块(resblocks)中的最后一个归一化层使用零初始化(zero init)让它们表现为自身
+ norm_cfg=dict( # 归一化层(norm layer)的配置项
+ type='BN', # 归一化层的类别，通常是 BN 或 GN
+ requires_grad=True), # 是否训练归一化里的 gamma 和 beta
+ norm_eval=True, # 是否冻结 BN 里的统计项
+ style='pytorch', # 主干网络的风格，'pytorch' 意思是步长为2的层为 3x3 卷积， 'caffe' 意思是步长为2的层为 1x1 卷积。
+ init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), # 加载通过 ImageNet 预训练的模型
+ neck=dict(
+ type='FPN', # 检测器的 neck 是 FPN， 我们同样支持 'ReFPN'
+ in_channels=[256, 512, 1024, 2048], # 输入通道数，这与主干网络的输出通道一致
+ out_channels=256, # 金字塔特征图每一层的输出通道
+ start_level=1, # 用于构建特征金字塔的主干网络起始输入层索引值
+ add_extra_convs='on_input', # 决定是否在原始特征图之上添加卷积层
+ num_outs=5), # 决定输出多少个尺度的特征图(scales)
+ bbox_head=dict(
+ type='RotatedRetinaHead',# bbox_head 的类型是 'RRetinaHead'
+ num_classes=15, # 分类的类别数量
+ in_channels=256, # bbox head 输入通道数
+ stacked_convs=4, # head 卷积层的层数
+ feat_channels=256, # head 卷积层的特征通道
+ assign_by_circumhbbox='oc', # obb2hbb 的旋转定义方式
+ anchor_generator=dict( # 锚点(Anchor)生成器的配置
+ type='RotatedAnchorGenerator', # 锚点生成器类别
+ octave_base_scale=4, # RetinaNet 用于生成锚点的超参数，特征图 anchor 的基本尺度。值越大，所有 anchor 的尺度都会变大。
+ scales_per_octave=3, # RetinaNet 用于生成锚点的超参数，每个特征图有3个尺度
+ ratios=[1.0, 0.5, 2.0], # 高度和宽度之间的比率
+ strides=[8, 16, 32, 64, 128]), # 锚生成器的步幅。这与 FPN 特征步幅一致。如果未设置 base_sizes，则当前步幅值将被视为 base_sizes。
+ bbox_coder=dict( # 在训练和测试期间对框进行编码和解码
+ type='DeltaXYWHAOBBoxCoder', # 框编码器的类别
+ angle_range='oc', # 框编码器的旋转定义方式
+ norm_factor=None, # 框编码器的范数
+ edge_swap=False, # 设置是否启用框编码器的边缘交换
+ proj_xy=False, # 设置是否启用框编码器的投影
+ target_means=(0.0, 0.0, 0.0, 0.0, 0.0), # 用于编码和解码框的目标均值
+ target_stds=(1.0, 1.0, 1.0, 1.0, 1.0)), # 用于编码和解码框的标准差
+ loss_cls=dict( # 分类分支的损失函数配置
+ type='FocalLoss', # 分类分支的损失函数类型
+ use_sigmoid=True, # 是否使用 sigmoid
+ gamma=2.0, # Focal Loss 用于解决难易不均衡的参数 gamma
+ alpha=0.25, # Focal Loss 用于解决样本数量不均衡的参数 alpha
+ loss_weight=1.0), # 分类分支的损失权重
+ loss_bbox=dict( # 回归分支的损失函数配置
+ type='L1Loss', # 回归分支的损失类型
+ loss_weight=1.0)), # 回归分支的损失权重
+ train_cfg=dict( # 训练超参数的配置
+ assigner=dict( # 分配器(assigner)的配置
+ type='MaxIoUAssigner', # 分配器的类型
+ pos_iou_thr=0.5, # IoU >= 0.5(阈值) 被视为正样本
+ neg_iou_thr=0.4, # IoU < 0.4(阈值) 被视为负样本
+ min_pos_iou=0, # 将框作为正样本的最小 IoU 阈值
+ ignore_iof_thr=-1, # 忽略 bbox 的 IoF 阈值
+ iou_calculator=dict(type='RBboxOverlaps2D')), # IoU 的计算器类型
+ allowed_border=-1, # 填充有效锚点(anchor)后允许的边框
+ pos_weight=-1, # 训练期间正样本的权重
+ debug=False), # 是否设置调试(debug)模式
+ test_cfg=dict( # 测试超参数的配置
+ nms_pre=2000, # NMS 前的 box 数
+ min_bbox_size=0, # box 允许的最小尺寸
+ score_thr=0.05, # bbox 的分数阈值
+ nms=dict(iou_thr=0.1), # NMS 的阈值
+ max_per_img=2000)) # 每张图像的最大检测次数
+dataset_type = 'DOTADataset' # 数据集类型，这将被用来定义数据集
+data_root = '../datasets/split_1024_dota1_0/' # 数据的根路径
+img_norm_cfg = dict( # 图像归一化配置，用来归一化输入的图像
+ mean=[123.675, 116.28, 103.53], # 预训练里用于预训练主干网络模型的平均值
+ std=[58.395, 57.12, 57.375], # 预训练里用于预训练主干网络模型的标准差
+ to_rgb=True) # 预训练里用于预训练主干网络的图像的通道顺序
+train_pipeline = [ # 训练流程
+ dict(type='LoadImageFromFile'), # 第 1 个流程，从文件路径里加载图像
+ dict(type='LoadAnnotations', # 第 2 个流程，对于当前图像，加载它的注释信息
+ with_bbox=True), # 是否加载标注框(bounding box)， 目标检测需要设置为 True
+ dict(type='RResize', # 变化图像和其注释大小的数据增广的流程
+ img_scale=(1024, 1024)), # 图像的最大规模
+ dict(type='RRandomFlip', # 翻转图像和其注释大小的数据增广的流程
+ flip_ratio=0.5, # 翻转图像的概率
+ version='oc'), # 定义旋转的方式
+ dict(
+ type='Normalize', # 归一化当前图像的数据增广的流程
+ mean=[123.675, 116.28, 103.53], # 这些键与 img_norm_cfg 一致，
+ std=[58.395, 57.12, 57.375], # 因为 img_norm_cfg 被用作参数
+ to_rgb=True),
+ dict(type='Pad', # 填充当前图像到指定大小的数据增广的流程
+ size_divisor=32), # 填充图像可以被当前值整除
+ dict(type='DefaultFormatBundle'), # 流程里收集数据的默认格式包
+ dict(type='Collect', # 决定数据中哪些键应该传递给检测器的流程
+ keys=['img', 'gt_bboxes', 'gt_labels'])
+]
+test_pipeline = [ # 测试流程
+ dict(type='LoadImageFromFile'), # 第 1 个流程，从文件路径里加载图像
+ dict(
+ type='MultiScaleFlipAug', # 封装测试时数据增广(test time augmentations)
+ img_scale=(1024, 1024), # 决定测试时可改变图像的最大规模。用于改变图像大小的流程
+ flip=False, # 测试时是否翻转图像
+ transforms=[
+ dict(type='RResize'), # 使用改变图像大小的数据增广
+ dict(
+ type='Normalize', # 归一化配置项，值来自 img_norm_cfg
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ to_rgb=True),
+ dict(type='Pad', # 将配置传递给可被 32 整除的图像
+ size_divisor=32),
+ dict(type='DefaultFormatBundle'), # 用于在管道中收集数据的默认格式包
+ dict(type='Collect', # 收集测试时必须的键的收集流程
+ keys=['img'])
+ ])
+]
+data = dict(
+ samples_per_gpu=2, # 单个 GPU 的 Batch size
+ workers_per_gpu=2, # 单个 GPU 分配的数据加载线程数
+ train=dict( # 训练数据集配置
+ type='DOTADataset', # 数据集的类别
+ ann_file=
+ '../datasets/split_1024_dota1_0/trainval/annfiles/', # 注释文件路径
+ img_prefix=
+ '../datasets/split_1024_dota1_0/trainval/images/', # 图片路径前缀
+ pipeline=[ # 流程, 这是由之前创建的 train_pipeline 传递的
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations', with_bbox=True),
+ dict(type='RResize', img_scale=(1024, 1024)),
+ dict(type='RRandomFlip', flip_ratio=0.5, version='oc'),
+ dict(
+ type='Normalize',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ to_rgb=True),
+ dict(type='Pad', size_divisor=32),
+ dict(type='DefaultFormatBundle'),
+ dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
+ ],
+ version='oc'),
+ val=dict( # 验证数据集的配置
+ type='DOTADataset',
+ ann_file=
+ '../datasets/split_1024_dota1_0/trainval/annfiles/',
+ img_prefix=
+ '../datasets/split_1024_dota1_0/trainval/images/',
+ pipeline=[
+ dict(type='LoadImageFromFile'),
+ dict(
+ type='MultiScaleFlipAug',
+ img_scale=(1024, 1024),
+ flip=False,
+ transforms=[
+ dict(type='RResize'),
+ dict(
+ type='Normalize',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ to_rgb=True),
+ dict(type='Pad', size_divisor=32),
+ dict(type='DefaultFormatBundle'),
+ dict(type='Collect', keys=['img'])
+ ])
+ ],
+ version='oc'),
+ test=dict( # 测试数据集配置，修改测试开发/测试(test-dev/test)提交的 ann_file
+ type='DOTADataset',
+ ann_file=
+ '../datasets/split_1024_dota1_0/test/images/',
+ img_prefix=
+ '../datasets/split_1024_dota1_0/test/images/',
+ pipeline=[ # 由之前创建的 test_pipeline 传递的流程
+ dict(type='LoadImageFromFile'),
+ dict(
+ type='MultiScaleFlipAug',
+ img_scale=(1024, 1024),
+ flip=False,
+ transforms=[
+ dict(type='RResize'),
+ dict(
+ type='Normalize',
+ mean=[123.675, 116.28, 103.53],
+ std=[58.395, 57.12, 57.375],
+ to_rgb=True),
+ dict(type='Pad', size_divisor=32),
+ dict(type='DefaultFormatBundle'),
+ dict(type='Collect', keys=['img'])
+ ])
+ ],
+ version='oc'))
+evaluation = dict( # evaluation hook 的配置
+ interval=12, # 验证的间隔
+ metric='mAP') # 验证期间使用的指标
+optimizer = dict( # 用于构建优化器的配置文件
+ type='SGD', # 优化器类型
+ lr=0.0025, # 优化器的学习率
+ momentum=0.9, # 动量(Momentum)
+ weight_decay=0.0001) # SGD 的衰减权重(weight decay)
+optimizer_config = dict( # optimizer hook 的配置文件
+ grad_clip=dict(
+ max_norm=35,
+ norm_type=2))
+lr_config = dict( # 学习率调整配置，用于注册 LrUpdater hook
+ policy='step', # 调度流程(scheduler)的策略
+ warmup='linear', # 预热(warmup)策略，也支持 `exp` 和 `constant`
+ warmup_iters=500, # 预热的迭代次数
+ warmup_ratio=0.3333333333333333, # 用于预热的起始学习率的比率
+ step=[8, 11]) # 衰减学习率的起止回合数
+runner = dict(
+ type='EpochBasedRunner', # 将使用的 runner 的类别 (例如 IterBasedRunner 或 EpochBasedRunner)
+ max_epochs=12) # runner 总回合(epoch)数， 对于 IterBasedRunner 使用 `max_iters`
+checkpoint_config = dict( # checkpoint hook 的配置文件
+ interval=12) # 保存的间隔是 12
+log_config = dict( # register logger hook 的配置文件
+ interval=50, # 打印日志的间隔
+ hooks=[
+ # dict(type='TensorboardLoggerHook') # 同样支持 Tensorboard 日志
+ dict(type='TextLoggerHook')
+ ]) # 用于记录训练过程的记录器(logger)
+dist_params = dict(backend='nccl') # 用于设置分布式训练的参数，端口也同样可被设置
+log_level = 'INFO' # 日志的级别
+load_from = None # 从一个给定路径里加载模型作为预训练模型，它并不会消耗训练时间
+resume_from = None # 从给定路径里恢复检查点(checkpoints)，训练模式将从检查点保存的轮次开始恢复训练。
+workflow = [('train', 1)] # runner 的工作流程，[('train', 1)] 表示只有一个工作流且工作流仅执行一次。根据 total_epochs 工作流训练 12 个回合(epoch)。
+work_dir = './work_dirs/rotated_retinanet_hbb_r50_fpn_1x_dota_oc' # 用于保存当前实验的模型检查点(checkpoints)和日志的目录
+```
+
+## 常见问题 (FAQ)
+
+### 使用配置文件里的中间变量
+
+配置文件里会使用一些中间变量，例如数据集里的 `train_pipeline`/`test_pipeline`。
+值得注意的是，在修改子配置中的中间变量时，需要再次将中间变量传递到相应的字段中。
+例如，我们想使用离线多尺度策略 (multi scale strategy)来训练 RoI-Trans。 `train_pipeline` 是我们想要修改的中间变量。
+
+```python
+_base_ = ['./roi_trans_r50_fpn_1x_dota_le90.py']
+
+data_root = '../datasets/split_ms_dota1_0/'
+angle_version = 'le90'
+img_norm_cfg = dict(
+ mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations', with_bbox=True),
+ dict(type='RResize', img_scale=(1024, 1024)),
+ dict(
+ type='RRandomFlip',
+ flip_ratio=[0.25, 0.25, 0.25],
+ direction=['horizontal', 'vertical', 'diagonal'],
+ version=angle_version),
+ dict(
+ type='PolyRandomRotate',
+ rotate_ratio=0.5,
+ angles_range=180,
+ auto_bound=False,
+ version=angle_version),
+ dict(type='Normalize', **img_norm_cfg),
+ dict(type='Pad', size_divisor=32),
+ dict(type='DefaultFormatBundle'),
+ dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
+]
+data = dict(
+ train=dict(
+ pipeline=train_pipeline,
+ ann_file=data_root + 'trainval/annfiles/',
+ img_prefix=data_root + 'trainval/images/'),
+ val=dict(
+ ann_file=data_root + 'trainval/annfiles/',
+ img_prefix=data_root + 'trainval/images/'),
+ test=dict(
+ ann_file=data_root + 'test/images/',
+ img_prefix=data_root + 'test/images/'))
+```
+
+我们首先定义新的 `train_pipeline`/`test_pipeline` 然后传递到 `data` 里。
+
+同样的，如果我们想从 `SyncBN` 切换到 `BN` 或者 `MMSyncBN`，我们需要修改配置文件里的每一个 `norm_cfg`。
+
+```python
+_base_ = './roi_trans_r50_fpn_1x_dota_le90.py'
+norm_cfg = dict(type='BN', requires_grad=True)
+model = dict(
+ backbone=dict(norm_cfg=norm_cfg),
+ neck=dict(norm_cfg=norm_cfg),
+ ...)
+```
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/customize_dataset.md b/internlm_langchain/knowledge_base/MMRotate/content/customize_dataset.md
new file mode 100644
index 00000000..38fb294b
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/customize_dataset.md
@@ -0,0 +1,234 @@
+# 教程 2：自定义数据集
+
+## 支持新的数据格式
+
+要支持新的数据格式，您可以将它们转换为现有的格式（DOTA 格式）。您可以选择离线（在通过脚本训练之前）或在线（实施新数据集并在训练时进行转换）进行转换。
+在 MMRotate 中，我们建议将数据转换为 DOTA 格式并离线进行转换，如此您只需在数据转换后修改 config 的数据标注路径和类别即可。
+
+### 将新数据格式重构为现有格式
+
+最简单的方法是将数据集转换为现有数据集格式 (DOTA) 。
+
+DOTA 格式的注解 txt 文件：
+
+```text
+184 2875 193 2923 146 2932 137 2885 plane 0
+66 2095 75 2142 21 2154 11 2107 plane 0
+...
+```
+
+每行代表一个对象，并将其记录为一个 10 维数组 `A` 。
+
+- `A[0:8]`: 多边形的格式 `(x1, y1, x2, y2, x3, y3, x4, y4)` 。
+- `A[8]`: 类别
+- `A[9]`: 困难
+
+在数据预处理之后，用户可以通过两个步骤来训练具有现有格式（例如 DOTA 格式）的自定义新数据集：
+
+1. 修改配置文件以使用自定义数据集。
+2. 检查自定义数据集的标注。
+
+下面给出两个例子展示上述两个步骤，它使用一个自定义的 5 类 COCO 格式的数据集来训练一个现有的 Cascade Mask R-CNN R50-FPN 检测器。
+
+#### 1. 修改配置文件以使用自定义数据集
+
+配置文件的修改主要涉及两个方面:
+
+1. `data` 部分。具体来说，您需要在 `data.train`, `data.val` 和 `data.test` 中显式添加 classes 字段。
+
+2. `model` 部分中的 ` num_classes` 属性变量。特别是将所有 num_classes 的默认值（例如 COCO 中的 80）覆盖到您的类别编号中。
+
+在 `configs/my_custom_config.py` :
+
+```python
+
+# 新配置继承了基础配置用于突出显示必要的修改
+_base_ = './rotated_retinanet_hbb_r50_fpn_1x_dota_oc'
+
+# 1. 数据集的设置
+dataset_type = 'DOTADataset'
+classes = ('a', 'b', 'c', 'd', 'e')
+data = dict(
+ samples_per_gpu=2,
+ workers_per_gpu=2,
+ train=dict(
+ type=dataset_type,
+
+ # 注意将你的类名添加到字段 `classes`
+ classes=classes,
+ ann_file='path/to/your/train/annotation_data',
+ img_prefix='path/to/your/train/image_data'),
+ val=dict(
+ type=dataset_type,
+
+ # 注意将你的类名添加到字段 `classes`
+ classes=classes,
+ ann_file='path/to/your/val/annotation_data',
+ img_prefix='path/to/your/val/image_data'),
+ test=dict(
+ type=dataset_type,
+
+ # 注意将你的类名添加到字段 `classes`
+ classes=classes,
+ ann_file='path/to/your/test/annotation_data',
+ img_prefix='path/to/your/test/image_data'))
+
+# 2. 模型设置
+model = dict(
+ bbox_head=dict(
+ type='RotatedRetinaHead',
+ # 显式将所有 `num_classes` 字段从 15 重写为 5。。
+ num_classes=15))
+```
+
+#### 2. 查看自定义数据集的标注
+
+假设您的自定义数据集是 DOTA 格式，请确保您在自定义数据集中具有正确的标注：
+
+- 配置文件中的 `classes` 字段应该与 txt 标注的 `A[8]` 保持完全相同的元素和相同的顺序。
+ MMRotate 会自动的将 `categories` 中不连续的 `id` 映射到连续的标签索引中，所以在 `categories` 中 `name` 的字符串顺序会影响标签索引的顺序。同时，配置文件中 `classes` 的字符串顺序也会影响预测边界框可视化过程中的标签文本信息。
+
+## 通过封装器自定义数据集
+
+MMRotate 还支持许多数据集封装器对数据集进行混合或修改数据集的分布以进行训练。目前它支持三个数据集封装器，如下所示：
+
+- `RepeatDataset`: 简单地重复整个数据集。
+- `ClassBalancedDataset`: 以类平衡的方式重复数据集。
+- `ConcatDataset`: 拼接数据集。
+
+### 重复数据集
+
+我们使用 `RepeatDataset` 作为封装器来重复这个数据集。例如，假设原始数据集是 `Dataset_A`，我们就重复一遍这个数据集。配置信息如下所示：
+
+```python
+dataset_A_train = dict(
+ type='RepeatDataset',
+ times=N,
+ dataset=dict( # 这是 Dataset_A 的原始配置信息
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+ )
+```
+
+### 类别平衡数据集
+
+我们使用 `ClassBalancedDataset` 作为封装器，根据类别频率重复数据集。这个数据集的重复操作 `ClassBalancedDataset` 需要实例化函数 `self.get_cat_ids(idx)` 的支持。例如，`Dataset_A` 需要使用`oversample_thr=1e-3`，配置信息如下所示：
+
+```python
+dataset_A_train = dict(
+ type='ClassBalancedDataset',
+ oversample_thr=1e-3,
+ dataset=dict( # This is the original config of Dataset_A
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+ )
+```
+
+### 拼接数据集
+
+这里用三种方式对数据集进行拼接。
+
+1. 如果要拼接的数据集属于同一类型且具有不同的标注文件，则可以通过如下所示的配置信息来拼接数据集：
+
+ ````python
+ dataset_A_train = dict(
+ type='Dataset_A',
+ ann_file = ['anno_file_1', 'anno_file_2'],
+ pipeline=train_pipeline
+ )
+ ```如果拼接后的数据集用于测试或评估，我们这种方式是可以支持对每个数据集分别进行评估。如果要测试的整个拼接数据集，如下所示您可以直接通过设置 separate_eval=False 来实现。
+
+ ```python
+ dataset_A_train = dict(
+ type='Dataset_A',
+ ann_file = ['anno_file_1', 'anno_file_2'],
+ separate_eval=False,
+ pipeline=train_pipeline
+ )
+ ````
+
+2. 如果您要拼接不同的数据集，您可以通过如下所示的方法对拼接数据集配置信息进行设置。
+
+ ````python
+ dataset_A_train = dict()
+ dataset_B_train = dict()
+ data = dict(
+ imgs_per_gpu=2,
+ workers_per_gpu=2,
+ train = [
+ dataset_A_train,
+ dataset_B_train
+ ],
+ val = dataset_A_val,
+ test = dataset_A_test
+ )
+ ```如果拼接后的数据集用于测试或评估，这种方式还支持对每个数据集分别进行评估。
+
+ ````
+
+3. 我们也支持如下所示的方法对 `ConcatDataset` 进行明确的定义。
+
+ ````python
+ dataset_A_val = dict()
+ dataset_B_val = dict()
+ data = dict(
+ imgs_per_gpu=2,
+ workers_per_gpu=2,
+ train=dataset_A_train,
+ val=dict(
+ type='ConcatDataset',
+ datasets=[dataset_A_val, dataset_B_val],
+ separate_eval=False))
+ ```这种方式允许用户通过设置 `separate_eval=False` 将所有数据集转为单个数据集进行评估。
+
+ ````
+
+**笔记:**
+
+1. 假设数据集在评估期间使用 `self.data_infos`，就要把选项设置为 `separate_eval=False`。因为 COCO 数据集不完全依赖 `self.data_infos` 进行评估，所以 COCO 数据集并不支持这种设置操作。没有在组合不同类型的数据集并对其进行整体评估的场景进行测试，因此我们不建议使用这样的操作。
+2. 不支持评估 `ClassBalancedDataset` 和 `RepeatDataset`，所以也不支持评估这些类型的串联组合后的数据集。
+
+一个更复杂的例子，分别将 `Dataset_A` 和 `Dataset_B` 重复 N 次和 M 次，然后将重复的数据集连接起来，如下所示。
+
+```python
+dataset_A_train = dict(
+ type='RepeatDataset',
+ times=N,
+ dataset=dict(
+ type='Dataset_A',
+ ...
+ pipeline=train_pipeline
+ )
+)
+dataset_A_val = dict(
+ ...
+ pipeline=test_pipeline
+)
+dataset_A_test = dict(
+ ...
+ pipeline=test_pipeline
+)
+dataset_B_train = dict(
+ type='RepeatDataset',
+ times=M,
+ dataset=dict(
+ type='Dataset_B',
+ ...
+ pipeline=train_pipeline
+ )
+)
+data = dict(
+ imgs_per_gpu=2,
+ workers_per_gpu=2,
+ train = [
+ dataset_A_train,
+ dataset_B_train
+ ],
+ val = dataset_A_val,
+ test = dataset_A_test
+)
+```
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/customize_models.md b/internlm_langchain/knowledge_base/MMRotate/content/customize_models.md
new file mode 100644
index 00000000..407186ff
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/customize_models.md
@@ -0,0 +1,318 @@
+# 教程 3: 自定义模型
+
+我们大致将模型组件分为了 5 种类型。
+
+- 主干网络 (Backbone): 通常是一个全卷积网络 (FCN)，用来提取特征图，比如残差网络 (ResNet)。也可以是基于视觉 Transformer 的网络，比如 Swin Transformer 等。
+- Neck: 主干网络和任务头 (Head) 之间的连接组件，比如 FPN, ReFPN。
+- 任务头 (Head): 用于某种具体任务（比如边界框预测）的组件。
+- 区域特征提取器 (Roi Extractor): 用于从特征图上提取区域特征的组件，比如 RoI Align Rotated。
+- 损失 (loss): 任务头上用于计算损失函数的组件，比如 FocalLoss, GWDLoss, and KFIoULoss。
+
+## 开发新的组件
+
+### 添加新的主干网络
+
+这里，我们以 MobileNet 为例来展示如何开发新组件。
+
+#### 1. 定义一个新的主干网络（以 MobileNet 为例）
+
+新建文件 `mmrotate/models/backbones/mobilenet.py`。
+
+```python
+import torch.nn as nn
+
+from mmrotate.models.builder import ROTATED_BACKBONES
+
+
+@ROTATED_BACKBONES.register_module()
+class MobileNet(nn.Module):
+
+ def __init__(self, arg1, arg2):
+ pass
+
+ def forward(self, x): # should return a tuple
+ pass
+```
+
+#### 2. 导入模块
+
+你可以将下面的代码添加到 `mmrotate/models/backbones/__init__.py` 中：
+
+```python
+from .mobilenet import MobileNet
+```
+
+或者添加如下代码
+
+```python
+custom_imports = dict(
+ imports=['mmrotate.models.backbones.mobilenet'],
+ allow_failed_imports=False)
+```
+
+到配置文件中以避免修改原始代码。
+
+#### 3. 在你的配置文件中使用该主干网络
+
+```python
+model = dict(
+ ...
+ backbone=dict(
+ type='MobileNet',
+ arg1=xxx,
+ arg2=xxx),
+ ...
+```
+
+### 添加新的 Neck
+
+#### 1. 定义一个 Neck（以 PAFPN 为例）
+
+新建文件 `mmrotate/models/necks/pafpn.py`。
+
+```python
+from mmrotate.models.builder import ROTATED_NECKS
+
+@ROTATED_NECKS.register_module()
+class PAFPN(nn.Module):
+
+ def __init__(self,
+ in_channels,
+ out_channels,
+ num_outs,
+ start_level=0,
+ end_level=-1,
+ add_extra_convs=False):
+ pass
+
+ def forward(self, inputs):
+ # implementation is ignored
+ pass
+```
+
+#### 2. 导入该模块
+
+你可以添加下述代码到 `mmrotate/models/necks/__init__.py` 中
+
+```python
+from .pafpn import PAFPN
+```
+
+或者添加
+
+```python
+custom_imports = dict(
+ imports=['mmrotate.models.necks.pafpn.py'],
+ allow_failed_imports=False)
+```
+
+到配置文件中以避免修改原始代码。
+
+#### 3. 修改配置文件
+
+```python
+neck=dict(
+ type='PAFPN',
+ in_channels=[256, 512, 1024, 2048],
+ out_channels=256,
+ num_outs=5)
+```
+
+### 添加新的 Head
+
+这里，我们以 [Double Head R-CNN](https://arxiv.org/abs/1904.06493) 为例来展示如何添加一个新的 Head。
+
+首先，添加一个新的 bbox head 到 `mmrotate/models/roi_heads/bbox_heads/double_bbox_head.py`。
+Double Head R-CNN 在目标检测上实现了一个新的 bbox head。为了实现 bbox head，我们需要使用如下的新模块中三个函数。
+
+```python
+from mmrotate.models.builder import ROTATED_HEADS
+from mmrotate.models.roi_heads.bbox_heads.bbox_head import BBoxHead
+
+@ROTATED_HEADS.register_module()
+class DoubleConvFCBBoxHead(BBoxHead):
+ r"""Bbox head used in Double-Head R-CNN
+
+ /-> cls
+ /-> shared convs ->
+ \-> reg
+ roi features
+ /-> cls
+ \-> shared fc ->
+ \-> reg
+ """ # noqa: W605
+
+ def __init__(self,
+ num_convs=0,
+ num_fcs=0,
+ conv_out_channels=1024,
+ fc_out_channels=1024,
+ conv_cfg=None,
+ norm_cfg=dict(type='BN'),
+ **kwargs):
+ kwargs.setdefault('with_avg_pool', True)
+ super(DoubleConvFCBBoxHead, self).__init__(**kwargs)
+
+
+ def forward(self, x_cls, x_reg):
+
+```
+
+然后，如有必要，我们需要实现一个新的 RoI Head。我们打算从 `StandardRoIHead` 继承出新的 `DoubleHeadRoIHead`。我们发现 `StandardRoIHead` 已经实现了下述函数。
+
+```python
+import torch
+
+from mmdet.core import bbox2result, bbox2roi, build_assigner, build_sampler
+from mmrotate.models.builder import ROTATED_HEADS, build_head, build_roi_extractor
+from mmrotate.models.roi_heads.base_roi_head import BaseRoIHead
+from mmrotate.models.roi_heads.test_mixins import BBoxTestMixin, MaskTestMixin
+
+
+@ROTATED_HEADS.register_module()
+class StandardRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
+ """Simplest base roi head including one bbox head and one mask head.
+ """
+
+ def init_assigner_sampler(self):
+
+ def init_bbox_head(self, bbox_roi_extractor, bbox_head):
+
+ def forward_dummy(self, x, proposals):
+
+
+ def forward_train(self,
+ x,
+ img_metas,
+ proposal_list,
+ gt_bboxes,
+ gt_labels,
+ gt_bboxes_ignore=None,
+ gt_masks=None):
+
+ def _bbox_forward(self, x, rois):
+
+ def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
+ img_metas):
+
+ def simple_test(self,
+ x,
+ proposal_list,
+ img_metas,
+ proposals=None,
+ rescale=False):
+ """Test without augmentation."""
+
+```
+
+Double Head 的修改主要在 \_bbox_forward 的逻辑中，且它从 `StandardRoIHead` 中继承了其他逻辑。
+在 `mmrotate/models/roi_heads/double_roi_head.py` 中, 我们实现如下的新的 RoI Head:
+
+```python
+from mmrotate.models.builder import ROTATED_HEADS
+from mmrotate.models.roi_heads.standard_roi_head import StandardRoIHead
+
+
+@ROTATED_HEADS.register_module()
+class DoubleHeadRoIHead(StandardRoIHead):
+ """RoI head for Double Head RCNN
+
+ https://arxiv.org/abs/1904.06493
+ """
+
+ def __init__(self, reg_roi_scale_factor, **kwargs):
+ super(DoubleHeadRoIHead, self).__init__(**kwargs)
+ self.reg_roi_scale_factor = reg_roi_scale_factor
+
+ def _bbox_forward(self, x, rois):
+ bbox_cls_feats = self.bbox_roi_extractor(
+ x[:self.bbox_roi_extractor.num_inputs], rois)
+ bbox_reg_feats = self.bbox_roi_extractor(
+ x[:self.bbox_roi_extractor.num_inputs],
+ rois,
+ roi_scale_factor=self.reg_roi_scale_factor)
+ if self.with_shared_head:
+ bbox_cls_feats = self.shared_head(bbox_cls_feats)
+ bbox_reg_feats = self.shared_head(bbox_reg_feats)
+ cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats)
+
+ bbox_results = dict(
+ cls_score=cls_score,
+ bbox_pred=bbox_pred,
+ bbox_feats=bbox_cls_feats)
+ return bbox_results
+```
+
+最后，用户需要把这个新模块添加到 `mmrotate/models/bbox_heads/__init__.py` 以及 `mmrotate/models/roi_heads/__init__.py` 中。 这样，注册机制就能找到并加载它们。
+
+另外，用户也可以添加
+
+```python
+custom_imports=dict(
+ imports=['mmrotate.models.roi_heads.double_roi_head', 'mmrotate.models.bbox_heads.double_bbox_head'])
+```
+
+到配置文件中来实现同样的目的。
+
+### 添加新的损失
+
+假设你想添加一个新的损失 `MyLoss` 用于边界框回归。
+为了添加一个新的损失函数，用户需要在 `mmrotate/models/losses/my_loss.py` 中实现。
+装饰器 `weighted_loss` 可以使损失每个部分加权。
+
+```python
+import torch
+import torch.nn as nn
+
+from mmrotate.models.builder import ROTATED_LOSSES
+from mmdet.models.losses.utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+ assert pred.size() == target.size() and target.numel() > 0
+ loss = torch.abs(pred - target)
+ return loss
+
+@ROTATED_LOSSES.register_module()
+class MyLoss(nn.Module):
+
+ def __init__(self, reduction='mean', loss_weight=1.0):
+ super(MyLoss, self).__init__()
+ self.reduction = reduction
+ self.loss_weight = loss_weight
+
+ def forward(self,
+ pred,
+ target,
+ weight=None,
+ avg_factor=None,
+ reduction_override=None):
+ assert reduction_override in (None, 'none', 'mean', 'sum')
+ reduction = (
+ reduction_override if reduction_override else self.reduction)
+ loss_bbox = self.loss_weight * my_loss(
+ pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+ return loss_bbox
+```
+
+然后，用户需要把下面的代码加到 `mmrotate/models/losses/__init__.py` 中。
+
+```python
+from .my_loss import MyLoss, my_loss
+
+```
+
+或者，你可以添加：
+
+```python
+custom_imports=dict(
+ imports=['mmrotate.models.losses.my_loss'])
+```
+
+到配置文件来实现相同的目的。
+
+因为 MyLoss 是用于回归的，你需要在 Head 中修改 `loss_bbox` 字段：
+
+```python
+loss_bbox=dict(type='MyLoss', loss_weight=1.0))
+```
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/customize_runtime.md b/internlm_langchain/knowledge_base/MMRotate/content/customize_runtime.md
new file mode 100644
index 00000000..8099c09d
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/customize_runtime.md
@@ -0,0 +1,322 @@
+# 教程 4: 自定义训练设置
+
+## 自定义优化设置
+
+### 自定义 Pytorch 支持的优化器
+
+我们已经支持了全部 Pytorch 自带的优化器，唯一需要修改的就是配置文件中 `optimizer` 部分。
+例如，如果您想使用 `ADAM` (注意如下操作可能会让模型表现下降)，可以使用如下修改：
+
+```python
+optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
+```
+
+为了修改模型训练的学习率，使用者仅需修改配置文件里 `optimizer` 的 `lr` 即可。
+使用者可以参考 PyTorch 的 [API doc](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim) 直接设置参数。
+
+### 自定义用户自己实现的优化器
+
+#### 1. 定义一个新的优化器
+
+一个自定义的优化器可以这样定义：
+
+假如您想增加一个叫做 `MyOptimizer` 的优化器，它的参数分别有 `a`, `b`, 和 `c`。
+您需要创建一个名为 `mmrotate/core/optimizer` 的新文件夹；然后参考如下代码段在 `mmrotate/core/optimizer/my_optimizer.py` 文件中实现新的优化器:
+
+```python
+from mmdet.core.optimizer.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+ def __init__(self, a, b, c)
+
+```
+
+#### 2. 增加优化器到注册表 (registry)
+
+为了能够使得上述添加的模块被 `mmrotate` 发现，需要先将该模块添加到主命名空间（main namespace）。
+
+- 修改 `mmrotate/core/optimizer/__init__.py` 文件来导入该模块。
+
+ 新的被定义的模块应该被导入到 `mmrotate/core/optimizer/__init__.py` 中，这样注册表才会发现新的模块并添加它：
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- 在配置文件中使用 `custom_imports` 来手动添加该模块
+
+```python
+custom_imports = dict(imports=['mmrotate.core.optimizer.my_optimizer'], allow_failed_imports=False)
+```
+
+`mmrotate.core.optimizer.my_optimizer` 模块将会在程序开始被导入，并且 `MyOptimizer` 类将会自动注册。
+需要注意只有包含 `MyOptimizer` 类的包 (package) 应当被导入。
+而 `mmrotate.core.optimizer.my_optimizer.MyOptimizer` **不能** 被直接导入。
+
+事实上，在这种导入方式下用户可以用完全不同的文件夹结构，只要这一模块的根目录已经被添加到 `PYTHONPATH` 里面。
+
+#### 3. 在配置文件中指定优化器
+
+之后您可以在配置文件的 `optimizer` 部分里面使用 `MyOptimizer`。
+在配置文件里，优化器按照如下形式被定义在 `optimizer` 部分里：
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+要使用用户自定义的优化器，这部分应该改成：
+
+```python
+optimizer = dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value)
+```
+
+### 自定义优化器的构造函数 (constructor)
+
+有些模型的优化器可能有一些特别参数配置，例如批归一化层 (BatchNorm layers) 的权重衰减系数 (weight decay)。
+用户可以通过自定义优化器的构造函数去微调这些细粒度参数。
+
+```python
+from mmcv.utils import build_from_cfg
+
+from mmcv.runner.optimizer import OPTIMIZER_BUILDERS, OPTIMIZERS
+from mmrotate.utils import get_root_logger
+from .my_optimizer import MyOptimizer
+
+
+@OPTIMIZER_BUILDERS.register_module()
+class MyOptimizerConstructor(object):
+
+ def __init__(self, optimizer_cfg, paramwise_cfg=None):
+
+ def __call__(self, model):
+
+ return my_optimizer
+
+```
+
+`mmcv` 默认的优化器构造函数实现可以参考 [这里](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/optimizer/default_constructor.py#L11) ，这也可以作为新的优化器构造函数的模板。
+
+### 其他配置
+
+优化器未实现的技巧应该通过修改优化器构造函数（如设置基于参数的学习率）或者钩子（hooks）去实现。我们列出一些常见的设置，它们可以稳定或加速模型的训练。
+如果您有更多的设置，欢迎在 PR 和 issue 里面提出。
+
+- __使用梯度裁剪 (gradient clip) 来稳定训练__:
+ 一些模型需要梯度裁剪来稳定训练过程。使用方式如下：
+
+ ```python
+ optimizer_config = dict(
+ _delete_=True, grad_clip=dict(max_norm=35, norm_type=2))
+ ```
+
+ 如果您的配置继承了已经设置了 `optimizer_config` 的基础配置（base config），你可能需要设置 `_delete_=True` 来覆盖不必要的配置参数。请参考 [配置文档](https://mmdetection.readthedocs.io/en/latest/tutorials/config.html) 了解更多细节。
+
+- __使用动量调度加速模型收敛__:
+ 我们支持动量规划器（Momentum scheduler），以实现根据学习率调节模型优化过程中的动量设置，这可以使模型以更快速度收敛。
+ 动量规划器经常与学习率规划器（LR scheduler）一起使用，例如下面的配置经常被用于 3D 检测模型训练中以加速收敛。更多细节请参考 [CyclicLrUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L327) 和 [CyclicMomentumUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/momentum_updater.py#L130)。
+
+ ```python
+ lr_config = dict(
+ policy='cyclic',
+ target_ratio=(10, 1e-4),
+ cyclic_times=1,
+ step_ratio_up=0.4,
+ )
+ momentum_config = dict(
+ policy='cyclic',
+ target_ratio=(0.85 / 0.95, 1),
+ cyclic_times=1,
+ step_ratio_up=0.4,
+ )
+ ```
+
+## 自定义训练计划
+
+默认地，我们使用 1x 计划（1x schedule）的步进学习率（step learning rate），这在 MMCV 中被称为 [`StepLRHook`](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L153)。
+我们支持很多其他的学习率规划器，参考 [这里](https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/lr_updater.py) ，例如 `CosineAnnealing` 和 `Poly`。下面是一些例子：
+
+- `Poly` :
+
+ ```python
+ lr_config = dict(policy='poly', power=0.9, min_lr=1e-4, by_epoch=False)
+ ```
+
+- `ConsineAnnealing` :
+
+ ```python
+ lr_config = dict(
+ policy='CosineAnnealing',
+ warmup='linear',
+ warmup_iters=1000,
+ warmup_ratio=1.0 / 10,
+ min_lr_ratio=1e-5)
+ ```
+
+## 自定义工作流 (workflow)
+
+工作流是一个专门定义运行顺序和轮数（epochs）的列表。
+默认情况下它设置成：
+
+```python
+workflow = [('train', 1)]
+```
+
+这是指训练 1 个 epoch。
+有时候用户可能想检查一些模型在验证集上的指标，如损失函数值（Loss）和准确性（Accuracy）。
+在这种情况下，我们可以将工作流设置为：
+
+```python
+[('train', 1), ('val', 1)]
+```
+
+这样以来， 1 个 epoch 训练，1 个 epoch 验证将交替运行。
+
+**注意**:
+
+1. 模型参数在验证的阶段不会被自动更新。
+2. 配置文件里的键值 `total_epochs` 仅控制训练的 epochs 数目，而不会影响验证工作流。
+3. 工作流 `[('train', 1), ('val', 1)]` 和 `[('train', 1)]` 将不会改变 `EvalHook` 的行为，因为 `EvalHook` 被 `after_train_epoch`
+ 调用而且验证的工作流仅仅影响通过调用 `after_val_epoch` 的钩子 (hooks)。因此， `[('train', 1), ('val', 1)]` 和 `[('train', 1)]`
+ 的区别仅在于 runner 将在每次训练阶段（training epoch）结束后计算在验证集上的损失。
+
+## 自定义钩 (hooks)
+
+### 自定义用户自己实现的钩子（hooks）
+
+#### 1. 实现一个新的钩子（hook）
+
+在某些情况下，用户可能需要实现一个新的钩子。 MMRotate 支持训练中的自定义钩子。 因此，用户可以直接在 mmrotate 或其基于 mmdet 的代码库中实现钩子，并通过仅在训练中修改配置来使用钩子。
+这里我们举一个例子：在 mmrotate 中创建一个新的钩子并在训练中使用它。
+
+```python
+from mmcv.runner import HOOKS, Hook
+
+
+@HOOKS.register_module()
+class MyHook(Hook):
+
+ def __init__(self, a, b):
+ pass
+
+ def before_run(self, runner):
+ pass
+
+ def after_run(self, runner):
+ pass
+
+ def before_epoch(self, runner):
+ pass
+
+ def after_epoch(self, runner):
+ pass
+
+ def before_iter(self, runner):
+ pass
+
+ def after_iter(self, runner):
+ pass
+```
+
+用户需要根据钩子的功能指定钩子在训练各阶段中（ `before_run` , `after_run` , `before_epoch` , `after_epoch` , `before_iter` , `after_iter`）做什么。
+
+#### 2. 注册新的钩子（hook）
+
+接下来我们需要导入 `MyHook`。如果文件的路径是 `mmrotate/core/utils/my_hook.py` ，有两种方式导入：
+
+- 修改 `mmrotate/core/utils/__init__.py` 文件来导入
+
+ 新定义的模块需要在 `mmrotate/core/utils/__init__.py` 导入，注册表才会发现并添加该模块：
+
+```python
+from .my_hook import MyHook
+```
+
+- 在配置文件中使用 `custom_imports` 来手动导入
+
+```python
+custom_imports = dict(imports=['mmrotate.core.utils.my_hook'], allow_failed_imports=False)
+```
+
+#### 3. 修改配置
+
+```python
+custom_hooks = [
+ dict(type='MyHook', a=a_value, b=b_value)
+]
+```
+
+您也可以通过配置键值 `priority` 为 `'NORMAL'` 或 `'HIGHEST'` 来设置钩子的优先级：
+
+```python
+custom_hooks = [
+ dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+默认地，钩子的优先级在注册时被设置为 `NORMAL`。
+
+### 使用 MMCV 中实现的钩子 (hooks)
+
+如果钩子已经在 MMCV 里实现了，您可以直接修改配置文件来使用钩子。
+
+#### 4. 示例: `NumClassCheckHook`
+
+我们实现了一个自定义的钩子 [NumClassCheckHook](https://github.com/open-mmlab/mmdetection/blob/master/mmdet/datasets/utils.py) ，用来检验 head 中的 `num_classes` 是否与 `dataset` 中的 `CLASSSES` 长度匹配。
+
+我们在 [default_runtime.py](https://github.com/open-mmlab/mmdetection/blob/master/configs/_base_/default_runtime.py) 中对其进行设置。
+
+```python
+custom_hooks = [dict(type='NumClassCheckHook')]
+```
+
+### 修改默认运行挂钩
+
+有一些常见的钩子并不通过 `custom_hooks` 注册，这些钩子包括：
+
+- log_config
+- checkpoint_config
+- evaluation
+- lr_config
+- optimizer_config
+- momentum_config
+
+这些钩子中，只有记录器钩子（logger hook）是 `VERY_LOW` 优先级，其他钩子的优先级为 `NORMAL`。
+前面提到的教程已经介绍了如何修改 `optimizer_config` , `momentum_config` 以及 `lr_config`。
+这里我们介绍一下如何处理 `log_config` , `checkpoint_config` 以及 `evaluation`。
+
+#### Checkpoint config
+
+MMCV runner 将使用 `checkpoint_config` 来初始化 [`CheckpointHook`](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/hooks/checkpoint.py#L9)。
+
+```python
+checkpoint_config = dict(interval=1)
+```
+
+用户可以设置 `max_keep_ckpts` 来仅保存一小部分检查点（checkpoint）或者通过设置 `save_optimizer` 来决定是否保存优化器的状态字典 (state dict of optimizer)。更多使用参数的细节请参考 [这里](https://mmcv.readthedocs.io/en/latest/api.html#mmcv.runner.CheckpointHook)。
+
+#### Log config
+
+`log_config` 包裹了许多日志钩 (logger hooks) 而且能去设置间隔 (intervals)。现在 MMCV 支持 `WandbLoggerHook` ， `MlflowLoggerHook` 和 `TensorboardLoggerHook`。
+详细的使用请参照 [文档](https://mmcv.readthedocs.io/en/latest/api.html#mmcv.runner.LoggerHook)。
+
+```python
+log_config = dict(
+ interval=50,
+ hooks=[
+ dict(type='TextLoggerHook'),
+ dict(type='TensorboardLoggerHook')
+ ])
+```
+
+#### Evaluation config
+
+`evaluation` 的配置文件将被用来初始化 [`EvalHook`](https://github.com/open-mmlab/mmdetection/blob/7a404a2c000620d52156774a5025070d9e00d918/mmdet/core/evaluation/eval_hooks.py#L8)。
+除了 `interval` 键，其他的像 `metric` 这样的参数将被传递给 `dataset.evaluate()`。
+
+```python
+evaluation = dict(interval=1, metric='bbox')
+```
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/faq.md b/internlm_langchain/knowledge_base/MMRotate/content/faq.md
new file mode 100644
index 00000000..f16e46d0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/faq.md
@@ -0,0 +1,126 @@
+# 常见问题解答
+
+我们在这里列出了使用时的一些常见问题及其相应的解决方案。 如果您发现有一些问题被遗漏，请随时提 PR 丰富这个列表。如果您无法在此获得帮助，请使用 [issue模板](https://github.com/open-mmlab/mmdetection/blob/master/.github/ISSUE_TEMPLATE/error-report.md/) 创建问题，但是请在模板中填写所有必填信息，这有助于我们更快定位问题。
+
+## MMCV 安装相关
+
+- MMCV 与 MMDetection 的兼容问题: "ConvWS is already registered in conv layer"; "AssertionError: MMCV==xxx is used but incompatible. Please install mmcv>=xxx, \<=xxx."
+
+MMRotate 和 MMCV, MMDet 版本兼容性如下所示，需要安装正确的版本以避免安装出现问题。
+
+| MMRotate 版本 | MMCV 版本 | MMDetection 版本 |
+| :-----------: | :-----------------------: | :----------------------: |
+| main | mmcv-full>=1.5.3, \<1.8.0 | mmdet >= 2.25.1, \<3.0.0 |
+| 0.3.4 | mmcv-full>=1.5.3, \<1.8.0 | mmdet >= 2.25.1, \<3.0.0 |
+| 0.3.3 | mmcv-full>=1.5.3, \<1.7.0 | mmdet >= 2.25.1, \<3.0.0 |
+| 0.3.2 | mmcv-full>=1.5.3, \<1.7.0 | mmdet >= 2.25.1, \<3.0.0 |
+| 0.3.1 | mmcv-full>=1.4.5, \<1.6.0 | mmdet >= 2.22.0, \<3.0.0 |
+| 0.3.0 | mmcv-full>=1.4.5, \<1.6.0 | mmdet >= 2.22.0, \<3.0.0 |
+| 0.2.0 | mmcv-full>=1.4.5, \<1.5.0 | mmdet >= 2.19.0, \<3.0.0 |
+| 0.1.1 | mmcv-full>=1.4.5, \<1.5.0 | mmdet >= 2.19.0, \<3.0.0 |
+| 0.1.0 | mmcv-full>=1.4.5, \<1.5.0 | mmdet >= 2.19.0, \<3.0.0 |
+
+- "No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'".
+
+ 原因是安装了 `mmcv` 而不是 `mmcv-full`。
+
+ 1. 使用 `pip uninstall mmcv` 卸载。
+ 2. 根据 [安装说明](install#best-practices) 安装 `mmcv-full`。
+
+## PyTorch/CUDA 环境相关
+
+- "RTX 30 series card fails when building MMCV or MMDet"
+
+ 1. 常见报错信息为 `nvcc fatal: Unsupported gpu architecture 'compute_86'` 意思是你的编译器应该为 sm_86 进行优化，例如， 英伟达 30 系列的显卡，但这样的优化 CUDA toolkit 11.0 并不支持。
+ 此解决方案通过添加 `MMCV_WITH_OPS=1 MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80' pip install -e .` 来修改编译标志，这告诉编译器 `nvcc` 为 **sm_80** 进行优化，例如 Nvidia A100，尽管 A100 不同于 30 系列的显卡，但他们使用相似的图灵架构。这种解决方案可能会丧失一些性能但的确有效。
+ 2. PyTorch 开发者已经在 [pytorch/pytorch#47585](https://github.com/pytorch/pytorch/pull/47585) 更新了 PyTorch 默认的编译标志，所以使用 PyTorch-nightly 可能也能解决这个问题，但是我们对此并没有验证这种方式是否有效。
+
+- "invalid device function" or "no kernel image is available for execution".
+
+ 1. 检查您的 cuda 运行时版本(一般在 `/usr/local/`)、指令 `nvcc --version` 显示的版本以及 `conda list cudatoolkit` 指令显式的版本是否匹配。
+ 2. 通过运行 `python mmdet/utils/collect_env.py` 来检查是否为当前的GPU架构编译了正确的 PyTorch、torchvision 和 MMCV，你可能需要设置 `TORCH_CUDA_ARCH_LIST` 来重新安装 MMCV。可以参考 [GPU 架构表](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list)，即通过运行 `TORCH_CUDA_ARCH_LIST=7.0 pip install mmcv-full` 为 Volta GPU 编译 MMCV。这种架构不匹配的问题一般会出现在使用一些旧型号的 GPU 时候，例如，Tesla K80。
+ 3. 检查运行环境是否与 mmcv/mmdet 编译时相同，例如，您可能使用 CUDA 10.0 编译 MMCV，但在 CUDA 9.0 环境中运行它。
+
+- "undefined symbol" or "cannot open xxx.so".
+
+ 1. 如果这些 symbols 属于 CUDA/C++ (例如，libcudart.so 或者 GLIBCXX)，检查 CUDA/GCC 运行时环境是否与编译 MMCV 的一致。例如使用 `python mmdet/utils/collect_env.py` 检查 `"MMCV Compiler"`/`"MMCV CUDA Compiler"` 是否和 `"GCC"`/`"CUDA_HOME"` 一致。
+ 2. 如果这些 symbols 属于 PyTorch，(例如，symbols containing caffe、aten 和 TH)， 检查当前 PyTorch 版本是否与编译 MMCV 的版本一致。
+ 3. 运行 `python mmdet/utils/collect_env.py` 检查 PyTorch、torchvision、MMCV 等的编译环境与运行环境一致。
+
+- "setuptools.sandbox.UnpickleableException: DistutilsSetupError("each element of 'ext_modules' option must be an Extension instance or 2-tuple")"
+
+ 1. 如果你在使用 miniconda 而不是 anaconda，检查是否正确的安装了 Cython 如 [#3379](https://github.com/open-mmlab/mmdetection/issues/3379)。您需要先手动安装 Cpython 然后运命令 `pip install -r requirements.txt`。
+ 2. 检查环境中的 `setuptools`、`Cython` 和 `PyTorch` 相互之间版本是否匹配。
+
+- "Segmentation fault".
+
+ 1. 检查 GCC 的版本并使用 GCC 5.4，通常是因为 PyTorch 版本与 GCC 版本不匹配 （例如，对于 Pytorch GCC \< 4.9)，我们推荐用户使用 GCC 5.4，我们也不推荐使用 GCC 5.5， 因为有反馈 GCC 5.5 会导致 "segmentation fault" 并且切换到 GCC 5.4 就可以解决问题。
+
+ 2. 检查是是否 PyTorch 被正确的安装并可以使用 CUDA 算子，例如在终端中键入如下的指令。
+
+ ```shell
+ python -c 'import torch; print(torch.cuda.is_available())'
+ ```
+
+ 并判断是否是否返回 True。
+
+ 3. 如果 `torch` 的安装是正确的，检查是否正确编译了 MMCV。
+
+ ```shell
+ python -c 'import mmcv; import mmcv.ops'
+ ```
+
+ 如果 MMCV 被正确的安装了，那么上面的两条指令不会有问题。
+
+ 4. 如果 MMCV 与 PyTorch 都被正确安装了，则使用 `ipdb`、`pdb` 设置断点，直接查找哪一部分的代码导致了 `segmentation fault`。
+
+## E2CNN
+
+- "ImportError: cannot import name 'container_bacs' from 'torch.\_six'"
+
+ 1. 这是因为 `container_abcs` 在 PyTorch 1.9 之后被移除.
+
+ 2. 将文件 `python3.7/site-packages/e2cnn/nn/modules/module_list.py` 中的
+
+ ```shell
+ from torch.six import container_abcs
+ ```
+
+ 替换成
+
+ ```shell
+ TORCH_MAJOR = int(torch.__version__.split('.')[0])
+ TORCH_MINOR = int(torch.__version__.split('.')[1])
+ if TORCH_MAJOR ==1 and TORCH_MINOR < 8:
+ from torch.six import container_abcs
+ else:
+ import collections.abs as container_abcs
+ ```
+
+ 3. 或者降低 Pytorch 的版本。
+
+## Training 相关
+
+- "Loss goes Nan"
+
+ 1. 检查数据的标注是否正常，长或宽为 0 的框可能会导致回归 loss 变为 nan，一些小尺寸（宽度或高度小于 1）的框在数据增强（例如，instaboost）后也会导致此问题。因此，可以检查标注并过滤掉那些特别小甚至面积为 0 的框，并关闭一些可能会导致 0 面积框出现数据增强。
+ 2. 降低学习率：由于某些原因，例如 batch size 大小的变化，导致当前学习率可能太大。您可以降低为可以稳定训练模型的值。
+ 3. 延长 warm up 的时间：一些模型在训练初始时对学习率很敏感，您可以把 `warmup_iters` 从 500 更改为 1000 或 2000。
+ 4. 添加 gradient clipping: 一些模型需要梯度裁剪来稳定训练过程。默认的 `grad_clip` 是 `None`，你可以在 config 设置 `optimizer_config=dict(_delete_=True, grad_clip=dict(max_norm=35, norm_type=2))`。 如果你的 config 没有继承任何包含 `optimizer_config=dict(grad_clip=None)`，你可以直接设置 `optimizer_config=dict(grad_clip=dict(max_norm=35, norm_type=2))`。
+
+- "GPU out of memory"
+
+ 1. 存在大量 ground truth boxes 或者大量 anchor 的场景，可能在 assigner 会 OOM。您可以在 assigner 的配置中设置 `gpu_assign_thr=N`，这样当超过 N 个 GT boxes 时，assigner 会通过 CPU 计算 IoU。
+ 2. 在 backbone 中设置 `with_cp=True`。这使用 PyTorch 中的 `sublinear strategy` 来降低 backbone 占用的 GPU 显存。
+ 3. 通过在配置文件中设置 `fp16 = dict(loss_scale='dynamic')` 来尝试混合精度训练。
+
+- "RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one"
+
+ 1. 错误表明，您的模块有没用于产生损失的参数，这种现象可能是由于在 DDP 模式下运行代码中的不同分支造成的。
+ 2. 您可以在配置中设置 `find_unused_parameters = True` 来解决上述问题，或者手动查找那些未使用的参数。
+
+## Evaluation 相关
+
+- 使用 COCO Dataset 的测评接口时，测评结果中 AP 或者 AR = -1。
+ 1. 根据 COCO 数据集的定义，一张图像中的中等物体与小物体面积的阈值分别为 9216（96\*96）与 1024（32\*32）。
+ 2. 如果在某个区间没有物体即 GT，AP 与 AR 将被设置为 -1。
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/get_started.md b/internlm_langchain/knowledge_base/MMRotate/content/get_started.md
new file mode 100644
index 00000000..9fc4dd1c
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/get_started.md
@@ -0,0 +1,155 @@
+## 准备数据集
+
+具体的细节可以参考 [准备数据](https://github.com/open-mmlab/mmrotate/tree/main/tools/data) 下载并组织数据集。
+
+## 测试一个模型
+
+- 单个 GPU
+- 单个节点多个 GPU
+- 多个节点多个 GPU
+
+您可以使用以下命令来推理数据集。
+
+```shell
+# 单个 GPU
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]
+
+# 多个 GPU
+./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [optional arguments]
+
+# slurm 环境中多个节点
+python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments] --launcher slurm
+```
+
+例子:
+
+在 DOTA-1.0 数据集推理 RotatedRetinaNet 并生成压缩文件用于在线[提交](https://captain-whu.github.io/DOTA/evaluation.html) (首先请修改 [data_root](https://github.com/open-mmlab/mmrotate/tree/main/configs/_base_/datasets/dotav1.py))。
+
+```shell
+python ./tools/test.py \
+ configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
+ checkpoints/SOME_CHECKPOINT.pth --format-only \
+ --eval-options submission_dir=work_dirs/Task1_results
+```
+
+或者
+
+```shell
+./tools/dist_test.sh \
+ configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
+ checkpoints/SOME_CHECKPOINT.pth 1 --format-only \
+ --eval-options submission_dir=work_dirs/Task1_results
+```
+
+您可以修改 [data_root](https://github.com/open-mmlab/mmrotate/tree/main/configs/_base_/datasets/dotav1.py) 中测试集的路径为验证集或训练集路径用于离线的验证。
+
+```shell
+python ./tools/test.py \
+ configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
+ checkpoints/SOME_CHECKPOINT.pth --eval mAP
+```
+
+或者
+
+```shell
+./tools/dist_test.sh \
+ configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
+ checkpoints/SOME_CHECKPOINT.pth 1 --eval mAP
+```
+
+您也可以可视化结果。
+
+```shell
+python ./tools/test.py \
+ configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
+ checkpoints/SOME_CHECKPOINT.pth \
+ --show-dir work_dirs/vis
+```
+
+## 训练一个模型
+
+### 单 GPU 训练
+
+```shell
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+如果您想在命令行中指定工作路径，您可以增加参数 `--work_dir ${YOUR_WORK_DIR}`。
+
+### 多 GPU 训练
+
+```shell
+./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+可选参数包括:
+
+- `--no-validate` (**不建议**): 默认情况下代码将在训练期间进行评估。通过设置 `--no-validate` 关闭训练期间进行评估。
+- `--work-dir ${WORK_DIR}`: 覆盖配置文件中指定的工作目录。
+- `--resume-from ${CHECKPOINT_FILE}`: 从以前的检查点恢复训练。
+
+`resume-from` 和 `load-from` 的不同点：
+
+`resume-from` 读取模型的权重和优化器的状态，并且 epoch 也会继承于指定的检查点。通常用于恢复意外中断的训练过程。
+`load-from` 只读取模型的权重并且训练的 epoch 会从 0 开始。通常用于微调。
+
+### 使用多台机器训练
+
+如果您想使用由 ethernet 连接起来的多台机器， 您可以使用以下命令:
+
+在第一台机器上:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+在第二台机器上:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+但是，如果您不使用高速网路连接这几台机器的话，训练将会非常慢。
+
+### 使用 Slurm 来管理任务
+
+如果您在 [slurm](https://slurm.schedmd.com/) 管理的集群上运行 MMRotate，您可以使用脚本 `slurm_train.sh` (此脚本还支持单机训练)。
+
+```shell
+[GPUS=${GPUS}] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
+```
+
+如果您有多台机器联网，您可以参考 PyTorch [launch utility](https://pytorch.org/docs/stable/distributed_deprecated.html#launch-utility)。
+如果您没有像 InfiniBand 这样的高速网络，训练速度通常会很慢。
+
+### 在一台机器上启动多个作业
+
+如果您在一台机器上启动多个作业，如在一台机器上使用 8 张 GPU 训练 2 个作业，每个作业使用 4 张 GPU ，您需要为每个作业指定不同的端口号(默认为 29500 )进而避免通讯冲突。
+
+如果您使用 `dist_train.sh` 启动训练，您可以在命令行中指定端口号。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+如果您通过 Slurm 启动训练，您需要修改配置文件(通常是配置文件底部的第 6 行)进而设置不同的通讯端口。
+
+在 `config1.py` 中,
+
+```python
+dist_params = dict(backend='nccl', port=29500)
+```
+
+在 `config2.py` 中,
+
+```python
+dist_params = dict(backend='nccl', port=29501)
+```
+
+之后您可以使用 `config1.py` 和 `config2.py` 开启两个作业。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+```
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/install.md b/internlm_langchain/knowledge_base/MMRotate/content/install.md
new file mode 100644
index 00000000..6c6eca32
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/install.md
@@ -0,0 +1,174 @@
+## 依赖
+
+在本节中，我们将演示如何使用PyTorch准备环境。
+
+MMRotate 能够在 Linux 和 Windows 上运行。它依赖于 Python 3.7+, CUDA 9.2+ 和 PyTorch 1.6+。
+
+```{note}
+如果您对 PyTorch 有经验并且已经安装了它，只需跳过此部分并跳到 [下一节](#安装) 。否则，您可以按照以下步骤进行准备。
+```
+
+**第0步：** 从 [官网](https://docs.conda.io/en/latest/miniconda.html) 下载并安装 Miniconda。
+
+**第1步：** 创建一个 conda 环境并激活它.
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**第2步：** 根据 [官方说明](https://pytorch.org/get-started/locally/) 安装 PyTorch, 例如：
+
+```shell
+conda install pytorch==1.8.0 torchvision==0.9.0 cudatoolkit=10.2 -c pytorch
+```
+
+## 安装
+
+我们建议用户按照我们的最佳实践安装 MMRotate。然而，整个过程是高度可定制的。有关详细信息，请参阅 [自定义安装](#%E8%87%AA%E5%AE%9A%E4%B9%89%E5%AE%89%E8%A3%85) 部分。
+
+### 最佳实践
+
+**第0步：** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv) 和 [MMDetection](https://github.com/open-mmlab/mmdetection)
+
+```shell
+pip install -U openmim
+mim install mmcv-full
+mim install mmdet\<3.0.0
+```
+
+**第1步：** 安装 MMRotate.
+
+案例a：如果您直接开发并运行 mmrotate，请从源代码安装：
+
+```shell
+git clone https://github.com/open-mmlab/mmrotate.git
+cd mmrotate
+pip install -v -e .
+# "-v" 表示详细或更多输出
+# "-e" 表示以可编辑模式安装项目，
+# 因此，对代码进行的任何本地修改都将在不重新安装的情况下生效。
+```
+
+案例b：如果将 mmrotate 作为依赖项或第三方软件包，请使用 pip 安装它：
+
+```shell
+pip install mmrotate
+```
+
+### 验证
+
+为了验证是否正确安装了 MMRotate，我们提供了一些示例代码来运行推理演示。
+
+**第1步：** 我们需要下载配置文件和检查点文件。
+
+```shell
+mim download mmrotate --config oriented_rcnn_r50_fpn_1x_dota_le90 --dest .
+```
+
+下载需要几秒钟或更长时间，具体取决于您的网络环境。当下载完成之后，您将会在当前文件夹下找到 `oriented_rcnn_r50_fpn_1x_dota_le90.py` 和 `oriented_rcnn_r50_fpn_1x_dota_le90-6d2b2ce0.pth` 这两个文件。
+
+**第2步：** 验证推理演示
+
+选项（a）：如果从源代码安装 mmrotate，只需运行以下命令。
+
+```shell
+python demo/image_demo.py demo/demo.jpg oriented_rcnn_r50_fpn_1x_dota_le90.py oriented_rcnn_r50_fpn_1x_dota_le90-6d2b2ce0.pth --out-file result.jpg
+```
+
+您将在当前目录下看到一张名为 `result.jpg` 的新图片，其中旋转边界框绘制在汽车、公共汽车等目标上。
+
+选项（b）：如果使用 pip 安装 mmrotate，请打开 python 解释器并复制和粘贴以下代码。
+
+```python
+from mmdet.apis import init_detector, inference_detector
+import mmrotate
+
+config_file = 'oriented_rcnn_r50_fpn_1x_dota_le90.py'
+checkpoint_file = 'oriented_rcnn_r50_fpn_1x_dota_le90-6d2b2ce0.pth'
+model = init_detector(config_file, checkpoint_file, device='cuda:0')
+inference_detector(model, 'demo/demo.jpg')
+```
+
+您将看到打印的数组列表，表示检测到的旋转边界框。
+
+### 自定义安装
+
+#### CUDA 版本
+
+安装 PyTorch 时，需要指定 CUDA 的版本。如果您不清楚选择哪一个，请遵循我们的建议：
+
+- 对于基于安培架构的 NVIDIA GPU，如 GeForce 30 系列和 NVIDIA A100，必须使用 CUDA 11。
+- 对于较旧的 NVIDIA GPU，CUDA 11 向后兼容，但 CUDA 10.2 更轻量并且具有更好的兼容性。
+
+请确保 GPU 驱动程序满足最低版本要求。 请查询 [表格](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions) 以获得更多信息。
+
+```{note}
+如果遵循我们的最佳实践，安装 CUDA 运行时库就足够了，因为不会在本地编译 CUDA 代码。但是，如果您希望从源代码处编译 MMCV 或开发其他 CUDA 算子，则需要从 NVIDIA 的 [网站](https://developer.nvidia.com/cuda-downloads) 安装完整的 CUDA 工具包，其版本应与 PyTorch 的 CUDA 版本匹配。例如使用 `conda install` 命令指定 cudatoolkit 的版本。
+```
+
+#### 不使用 MIM 安装 MMCV
+
+MMCV 包含 C++ 和 CUDA 扩展，因此以复杂的方式依赖于 PyTorch。MIM 会自动解决此类依赖关系，并使安装更容易。然而，这不是必须的。
+
+要使用 pip 而不是 MIM 安装 MMCV，请遵循 [MMCV 安装指南](https://mmcv.readthedocs.io/en/latest/get_started/installation.html) 。 这需要根据 PyTorch 版本及其 CUDA 版本手动指定 find-url。
+
+例如, 以下命令安装了为 PyTorch 1.9.x 和 CUDA 10.2 构建的 mmcv-full。
+
+```shell
+pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8/index.html
+```
+
+#### 在 Google Colab 安装
+
+[Google Colab](https://research.google.com/) 通常已经安装了 PyTorch，
+因此，我们只需要使用以下命令安装 MMCV 和 MMDetection。
+
+**第1步：** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMCV](https://github.com/open-mmlab/mmcv) 和 [MMDetection](https://github.com/open-mmlab/mmdetection) 。
+
+```shell
+!pip3 install -U openmim
+!mim install mmcv-full
+!mim install mmdet
+```
+
+**第2步：** 从源码安装 MMRotate。
+
+```shell
+!git clone https://github.com/open-mmlab/mmrotate.git
+%cd mmrotate
+!pip install -e .
+```
+
+**第3步：** 验证。
+
+```python
+import mmrotate
+print(mmrotate.__version__)
+# Example output: 0.3.1
+```
+
+```{note}
+在Jupyter中，感叹号 `!` 用于调用外部可执行文件，`%cd` 是一个 [魔术命令](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) 用于更改 Python 的当前工作目录。
+```
+
+#### 在 Docker 镜像中使用 MMRotate
+
+我们提供了 [Dockerfile](https://github.com/open-mmlab/mmrotate/tree/main/docker/Dockerfile) 用于创建镜像。 请确保您的 [docker 版本](https://docs.docker.com/engine/install/) >=19.03。
+
+```shell
+# build an image with PyTorch 1.6, CUDA 10.1
+# If you prefer other versions, just modified the Dockerfile
+docker build -t mmrotate docker/
+```
+
+使用下列命令运行
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmrotate/data mmrotate
+```
+
+### 故障排除
+
+如果您在安装过程中遇到一些问题，请先查看 [FAQ](faq.md) 页面。
+如果没有找到解决方案，您可以在 GIthub 上 [提问](https://github.com/open-mmlab/mmrotate/issues/new/choose) 。
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/intro.md b/internlm_langchain/knowledge_base/MMRotate/content/intro.md
new file mode 100644
index 00000000..680bbb00
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/intro.md
@@ -0,0 +1,227 @@
+# 学习基础知识
+
+本章将向您介绍旋转目标检测的基本概念，以及旋转目标检测的框架 MMRotate，并提供了详细教程的链接。
+
+## 什么是旋转目标检测
+
+### 问题定义
+
+受益于通用检测的蓬勃发展，目前绝大多数的旋转检测模型都是基于经典的通用检测器。随着检测任务的发展，
+水平框在一些细分领域上已经无法满足研究人员的需求。通过重新定义目标表示形式以及增加回归自由度数量
+的操作来实现旋转矩形框、四边形甚至任意形状检测，我们称之为旋转目标检测。如何更加高效地进行高精度
+的旋转目标检测已成为当下的研究热点。下面列举一些旋转目标检测已经被应用或者有巨大潜力的领域：
+人脸识别、场景文字、遥感影像、自动驾驶、医学图像、机器人抓取等。
+
+### 什么是旋转框
+
+旋转目标检测与通用目标检测最大的不同就是用旋转框标注来代替水平框标注，它们的定义如下：
+
+- 水平框: 宽沿 `x` 轴方向，高沿 `y` 轴方向的矩形。通常可以用2个对角顶点的坐标表示
+ `(x_i, y_i)` (i = 1, 2)，也可以用中心点坐标以及宽和高表示
+ `(x_center, y_center, width, height)`。
+- 旋转框: 由水平框绕中心点旋转一个角度 `angle` 得到，通过添加一个弧度参数得到其旋转框定义法
+ `(x_center, y_center, width, height, theta)`。其中，`theta = angle * pi / 180`，
+ 单位为 `rad`。当旋转的角度为90°的倍数时，旋转框退化为水平框。标注软件导出的旋转框标注通常为多边形
+ `(xr_i, yr_i)` (i = 1, 2, 3, 4)，在训练时需要转换为旋转框定义法。
+
+```{note}
+在 MMRotate 中，角度参数的单位均为弧度。
+```
+
+### 旋转方向
+
+旋转框可以由水平框绕其中心点顺时针旋转或逆时针旋转得到。旋转方向和坐标系的选择密切相关。
+图像空间采用右手坐标系 `(y，x)`，其中 y 是`上->下`，x 是`左->右`。
+此时存在2种相反的旋转方向：
+
+- 顺时针 (`CW`)
+
+`CW` 的示意图
+
+```
+0-------------------> x (0 rad)
+| A-------------B
+| | |
+| | box h
+| | angle=0 |
+| D------w------C
+v
+y (pi/2 rad)
+
+```
+
+`CW` 的旋转矩阵
+
+```{math}
+\begin{pmatrix}
+\cos\alpha & -\sin\alpha \\
+\sin\alpha & \cos\alpha
+\end{pmatrix}
+```
+
+`CW` 的旋转变换
+
+```{math}
+P_A=
+\begin{pmatrix} x_A \\ y_A\end{pmatrix}
+=
+\begin{pmatrix} x_{center} \\ y_{center}\end{pmatrix} +
+\begin{pmatrix}\cos\alpha & -\sin\alpha \\
+\sin\alpha & \cos\alpha\end{pmatrix}
+\begin{pmatrix} -0.5w \\ -0.5h\end{pmatrix} \\
+=
+\begin{pmatrix} x_{center}-0.5w\cos\alpha+0.5h\sin\alpha
+\\
+y_{center}-0.5w\sin\alpha-0.5h\cos\alpha\end{pmatrix}
+```
+
+- 逆时针 (`CCW`)
+
+`CCW` 的示意图
+
+```
+0-------------------> x (0 rad)
+| A-------------B
+| | |
+| | box h
+| | angle=0 |
+| D------w------C
+v
+y (-pi/2 rad)
+
+```
+
+`CCW` 的旋转矩阵
+
+```{math}
+\begin{pmatrix}
+\cos\alpha & \sin\alpha \\
+-\sin\alpha & \cos\alpha
+\end{pmatrix}
+```
+
+`CCW` 的旋转变换
+
+```{math}
+P_A=
+\begin{pmatrix} x_A \\ y_A\end{pmatrix}
+=
+\begin{pmatrix} x_{center} \\ y_{center}\end{pmatrix} +
+\begin{pmatrix}\cos\alpha & \sin\alpha \\
+-\sin\alpha & \cos\alpha\end{pmatrix}
+\begin{pmatrix} -0.5w \\ -0.5h\end{pmatrix} \\
+=
+\begin{pmatrix} x_{center}-0.5w\cos\alpha-0.5h\sin\alpha
+\\
+y_{center}+0.5w\sin\alpha-0.5h\cos\alpha\end{pmatrix}
+```
+
+在MMCV中可以设置旋转方向的算子有：
+
+- box_iou_rotated (默认为 `CW`)
+- nms_rotated (默认为 `CW`)
+- RoIAlignRotated (默认为 `CCW`)
+- RiRoIAlignRotated (默认为 `CCW`)。
+
+```{note}
+在MMRotate 中，旋转框的旋转方向均为 `CW`。
+```
+
+### 旋转框定义法
+
+由于 `theta` 定义范围的不同，在旋转目标检测中逐渐派生出如下3种旋转框定义法：
+
+- {math}`D_{oc^{\prime}}` : OpenCV 定义法，`angle∈(0, 90°]`，`theta∈(0, pi / 2]`， `width` 与 `x` 正半轴之间的夹角为正的锐角。该定义法源于 OpenCV 中的 `cv2.minAreaRect` 函数，
+ 其返回值为 `(0, 90°]`。
+- {math}`D_{le135}` : 长边 135° 定义法，`angle∈[-45°, 135°)`，`theta∈[-pi / 4, 3 * pi / 4)` 并且 `width > height`。
+- {math}`D_{le90}` : 长边 90° 定义法，`angle∈[-90°, 90°)`，`theta∈[-pi / 2, pi / 2)` 并且 `width > height`。
+
+
+
+
+
+
+三种定义法之间的转换关系在 MMRotate 内部并不涉及，因此不多做介绍。如果想了解更多的细节，可以参考这篇[博客](https://zhuanlan.zhihu.com/p/459018810)。
+
+```{note}
+MMRotate 同时支持上述三种旋转框定义法，可以通过配置文件灵活切换。
+```
+
+需要注意的是，在 4.5.1 之前的版本中，`cv2.minAreaRect` 的返回值为 `[-90°, 0°)`
+（[参考资料](https://github.com/opencv/opencv/issues/19749)）。为了便于区分，
+将老版本的 OpenCV 定义法记作 {math}`D_{oc}`。
+
+- {math}`D_{oc^{\prime}}`: OpenCV 定义法，`opencv>=4.5.1`，`angle∈(0, 90°]`，`theta∈(0, pi / 2]`。
+- {math}`D_{oc}`: 老版的 OpenCV 定义法，`opencv<4.5.1`，`angle∈[-90°, 0°)`，`theta∈[-pi / 2, 0)`。
+
+
+
+
+
+
+两种 OpenCV 定义法的转换关系如下：
+
+```{math}
+D_{oc^{\prime}}\left( w_{oc^{\prime}},h_{oc^{\prime}},\theta _{oc^{\prime}} \right) =\begin{cases}
+ D_{oc}\left( h_{oc},w_{oc},\theta _{oc}+\pi /2 \right) , otherwise\\
+ D_{oc}\left( w_{oc},h_{oc},\theta _{oc}+\pi \right) ,\theta _{oc}=-\pi /2\\
+\end{cases}
+\\
+D_{oc}\left( w_{oc},h_{oc},\theta _{oc} \right) =\begin{cases}
+ D_{oc^{\prime}}\left( h_{oc^{\prime}},w_{oc^{\prime}},\theta _{oc^{\prime}}-\pi /2 \right) , otherwise\\
+ D_{oc^{\prime}}\left( w_{oc^{\prime}},h_{oc^{\prime}},\theta _{oc^{\prime}}-\pi \right) , \theta _{oc^{\prime}}=\pi /2\\
+\end{cases}
+```
+
+```{note}
+不管您使用的 OpenCV 版本是多少, MMRotate 都会将 OpenCV 定义法的 theta 转换为 (0, pi / 2]。
+```
+
+### 评估
+
+评估 mAP 的代码中涉及 IoU 的计算，可以直接计算旋转框 IoU，也可以将旋转框转换为多边形，然后
+计算多边形 IoU (DOTA 在线评估使用的是计算多边形 IoU)。
+
+## 什么是 MMRotate
+
+MMRotate 是一个为旋转目标检测方法提供统一训练和评估框架的工具箱，以下是其整体框架：:
+
+
+
+
+
+
+MMRotate 包括四个部分, `datasets`, `models`, `core` and `apis`.
+
+- `datasets` 用于数据加载和数据增强。 在这部分,我们支持了各种旋转目标检测数据集和数据增强预处理。
+
+- `models` 包括模型和损失函数。
+
+- `core` 为模型训练和评估提供工具。
+
+- `apis` 为模型训练、测试和推理提供高级 API。
+
+MMRotate 的模块设计如下图所示：
+
+
+
+
+
+
+其中由于旋转框定义法不同而需要注意的地方有如下几个：
+
+- 读取标注
+- 数据增强
+- 指派样本
+- 评估指标
+
+## 如何使用教程
+
+下面是 MMRotate 详细的分步指南:
+
+1. 关于安装说明, 请参阅 [安装](install.md).
+
+2. [开始](get_started.md) 介绍了 MMRotate 的基本用法.
+
+3. 如果想要更加深入了解 MMRotate，请参阅以下教程:
+
+- [配置](tutorials/customize_config.md)
+- [自定义数据集](tutorials/customize_dataset.md)
+- [自定义模型](tutorials/customize_models.md)
+- [自定义运行时](tutorials/customize_runtime.md)
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/model_zoo.md b/internlm_langchain/knowledge_base/MMRotate/content/model_zoo.md
new file mode 100644
index 00000000..b8bdc3b2
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/model_zoo.md
@@ -0,0 +1,75 @@
+## 基准和模型库
+
+- [Rotated RetinaNet-OBB/HBB](https://github.com/open-mmlab/mmrotate/tree/main/configs/rotated_retinanet/README.md) (
+ ICCV'2017)
+- [Rotated FasterRCNN-OBB](https://github.com/open-mmlab/mmrotate/tree/main/configs/rotated_faster_rcnn/README.md) (
+ TPAMI'2017)
+- [Rotated RepPoints-OBB](https://github.com/open-mmlab/mmrotate/tree/main/configs/rotated_reppoints/README.md) (
+ ICCV'2019)
+- [Rotated FCOS](https://github.com/open-mmlab/mmrotate/tree/main/configs/rotated_fcos/README.md) (ICCV'2019)
+- [RoI Transformer](https://github.com/open-mmlab/mmrotate/tree/main/configs/roi_trans/README.md) (CVPR'2019)
+- [Gliding Vertex](https://github.com/open-mmlab/mmrotate/tree/main/configs/gliding_vertex/README.md) (TPAMI'2020)
+- [Rotated ATSS-OBB](https://github.com/open-mmlab/mmrotate/tree/main/configs/rotated_atss/README.md) (CVPR'2020)
+- [CSL](https://github.com/open-mmlab/mmrotate/tree/main/configs/csl/README.md) (ECCV'2020)
+- [R3Det](https://github.com/open-mmlab/mmrotate/tree/main/configs/r3det/README.md) (AAAI'2021)
+- [S2A-Net](https://github.com/open-mmlab/mmrotate/tree/main/configs/s2anet/README.md) (TGRS'2021)
+- [ReDet](https://github.com/open-mmlab/mmrotate/tree/main/configs/redet/README.md) (CVPR'2021)
+- [Beyond Bounding-Box](https://github.com/open-mmlab/mmrotate/tree/main/configs/cfa/README.md) (CVPR'2021)
+- [Oriented R-CNN](https://github.com/open-mmlab/mmrotate/tree/main/configs/oriented_rcnn/README.md) (ICCV'2021)
+- [GWD](https://github.com/open-mmlab/mmrotate/tree/main/configs/gwd/README.md) (ICML'2021)
+- [KLD](https://github.com/open-mmlab/mmrotate/tree/main/configs/kld/README.md) (NeurIPS'2021)
+- [SASM](configs/sasm_reppoints/README.md) (AAAI'2022)
+- [KFIoU](https://github.com/open-mmlab/mmrotate/tree/main/configs/kfiou/README.md) (arXiv)
+- [G-Rep](https://github.com/open-mmlab/mmrotate/tree/main/configs/g_reppoints/README.md) (stay tuned)
+
+### DOTA v1.0 数据集上的结果
+
+| 骨干网络 | mAP | 角度编码方式 | 训练策略 | 显存占用 (GB) | 推理时间 (fps) | 增强方法 | 批量大小 | 配置 | 下载 |
+| :------------------------: | :---: | :----------: | :------: | :-----------: | :------------: | :------: | :------: | :-----------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| ResNet50 (1024,1024,200) | 59.44 | oc | 1x | 3.45 | 15.6 | - | 2 | [rotated_reppoints_r50_fpn_1x_dota_oc](../../configs/rotated_reppoints/rotated_reppoints_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_reppoints/rotated_reppoints_r50_fpn_1x_dota_oc/rotated_reppoints_r50_fpn_1x_dota_oc-d38ce217.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_reppoints/rotated_reppoints_r50_fpn_1x_dota_oc/rotated_reppoints_r50_fpn_1x_dota_oc_20220205_145010.log.json) |
+| ResNet50 (1024,1024,200) | 64.55 | oc | 1x | 3.38 | 15.7 | - | 2 | [rotated_retinanet_hbb_r50_fpn_1x_dota_oc](../../configs/rotated_retinanet/rotated_retinanet_hbb_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_hbb_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_r50_fpn_1x_dota_oc-e8a7c7df.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_hbb_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_r50_fpn_1x_dota_oc_20220121_095315.log.json) |
+| ResNet50 (1024,1024,200) | 65.59 | oc | 1x | 3.12 | 18.5 | - | 2 | [rotated_atss_hbb_r50_fpn_1x_dota_oc](../../configs/rotated_atss/rotated_atss_hbb_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_atss/rotated_atss_hbb_r50_fpn_1x_dota_oc/rotated_atss_hbb_r50_fpn_1x_dota_oc-eaa94033.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_atss/rotated_atss_hbb_r50_fpn_1x_dota_oc/rotated_atss_hbb_r50_fpn_1x_dota_oc_20220402_002230.log.json) |
+| ResNet50 (1024,1024,200) | 66.45 | oc | 1x | 3.53 | 15.3 | - | 2 | [sasm_reppoints_r50_fpn_1x_dota_oc](../../configs/sasm/sasm_reppoints_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/sasm/sasm_reppoints_r50_fpn_1x_dota_oc/sasm_reppoints_r50_fpn_1x_dota_oc-6d9edded.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/sasm/sasm_reppoints_r50_fpn_1x_dota_oc/sasm_reppoints_r50_fpn_1x_dota_oc_20220205_144938.log.json) |
+| ResNet50 (1024,1024,200) | 68.42 | le90 | 1x | 3.38 | 16.9 | - | 2 | [rotated_retinanet_obb_r50_fpn_1x_dota_le90](../../configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90/rotated_retinanet_obb_r50_fpn_1x_dota_le90-c0097bc4.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90/rotated_retinanet_obb_r50_fpn_1x_dota_le90_20220128_130740.log.json) |
+| ResNet50 (1024,1024,200) | 68.79 | le90 | 1x | 2.36 | 22.4 | - | 2 | [rotated_retinanet_obb_r50_fpn_fp16_1x_dota_le90](../../configs/rotated_retinanet_obb_r50_fpn_fp16_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_fp16_1x_dota_le90/rotated_retinanet_obb_r50_fpn_fp16_1x_dota_le90-01de71b5.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_fp16_1x_dota_le90/rotated_retinanet_obb_r50_fpn_fp16_1x_dota_le90_20220303_183714.log.json) |
+| ResNet50 (1024,1024,200) | 69.49 | le135 | 1x | 4.05 | 8.6 | - | 2 | [g_reppoints_r50_fpn_1x_dota_le135](../../configs/g_reppoints/g_reppoints_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/g_reppoints/g_reppoints_r50_fpn_1x_dota_le135/g_reppoints_r50_fpn_1x_dota_le135-b840eed7.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/g_reppoints/g_reppoints_r50_fpn_1x_dota_le135/g_reppoints_r50_fpn_1x_dota_le135_20220202_233631.log.json) |
+| ResNet50 (1024,1024,200) | 69.51 | le90 | 1x | 4.40 | 24.0 | - | 2 | [rotated_retinanet_obb_csl_gaussian_r50_fpn_fp16_1x_dota_le90](../../configs/csl/rotated_retinanet_obb_csl_gaussian_r50_fpn_fp16_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/csl/rotated_retinanet_obb_csl_gaussian_r50_fpn_fp16_1x_dota_le90/rotated_retinanet_obb_csl_gaussian_r50_fpn_fp16_1x_dota_le90-b4271aed.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/csl/rotated_retinanet_obb_csl_gaussian_r50_fpn_fp16_1x_dota_le90/rotated_retinanet_obb_csl_gaussian_r50_fpn_fp16_1x_dota_le90_20220321_010033.log.json) |
+| ResNet50 (1024,1024,200) | 69.55 | oc | 1x | 3.39 | 15.5 | - | 2 | [rotated_retinanet_hbb_gwd_r50_fpn_1x_dota_oc](../../configs/gwd/rotated_retinanet_hbb_gwd_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/gwd/rotated_retinanet_hbb_gwd_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_gwd_r50_fpn_1x_dota_oc-41fd7805.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/gwd/rotated_retinanet_hbb_gwd_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_gwd_r50_fpn_1x_dota_oc_20220120_152421.log.json) |
+| ResNet50 (1024,1024,200) | 69.60 | le90 | 1x | 3.38 | 15.1 | - | 2 | [rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le90](../../configs/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le90/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le90-03e02f75.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le90/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le90_20220209_173225.log.json) |
+| ResNet50 (1024,1024,200) | 69.63 | le135 | 1x | 3.45 | 16.1 | - | 2 | [cfa_r50_fpn_1x_dota_le135](../../configs/cfa/cfa_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/cfa/cfa_r50_fpn_1x_dota_le135/cfa_r50_fpn_1x_dota_le135-aed1cbc6.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/cfa/cfa_r50_fpn_1x_dota_le135/cfa_r50_fpn_1x_dota_le135_20220205_144859.log.json) |
+| ResNet50 (1024,1024,200) | 69.76 | oc | 1x | 3.39 | 15.6 | - | 2 | [rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_oc](../../configs/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_oc-c00be030.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_oc_20220126_081643.log.json) |
+| ResNet50 (1024,1024,200) | 69.77 | le135 | 1x | 3.38 | 15.3 | - | 2 | [rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le135](../../configs/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le135/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le135-0eaa4156.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le135/rotated_retinanet_hbb_kfiou_r50_fpn_1x_dota_le135_20220209_173257.log.json) |
+| ResNet50 (1024,1024,200) | 69.79 | le135 | 1x | 3.38 | 17.2 | - | 2 | [rotated_retinanet_obb_r50_fpn_1x_dota_le135](../../configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le135/rotated_retinanet_obb_r50_fpn_1x_dota_le135-e4131166.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le135/rotated_retinanet_obb_r50_fpn_1x_dota_le135_20220128_130755.log.json) |
+| ResNet50 (1024,1024,200) | 69.80 | oc | 1x | 3.54 | 12.4 | - | 2 | [r3det_r50_fpn_1x_dota_oc](../../configs/r3det/r3det_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/r3det/r3det_r50_fpn_1x_dota_oc/r3det_r50_fpn_1x_dota_oc-b1fb045c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/r3det/r3det_r50_fpn_1x_dota_oc/r3det_r50_fpn_1x_dota_oc_20220126_191226.log.json) |
+| ResNet50 (1024,1024,200) | 69.94 | oc | 1x | 3.39 | 15.6 | - | 2 | [rotated_retinanet_hbb_kld_r50_fpn_1x_dota_oc](../../configs/kld/rotated_retinanet_hbb_kld_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kld/rotated_retinanet_hbb_kld_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_kld_r50_fpn_1x_dota_oc-49c1f937.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kld/rotated_retinanet_hbb_kld_r50_fpn_1x_dota_oc/rotated_retinanet_hbb_kld_r50_fpn_1x_dota_oc_20220125_201832.log.json) |
+| ResNet50 (1024,1024,200) | 70.18 | oc | 1x | 3.23 | 15.6 | - | 2 | [r3det_tiny_r50_fpn_1x_dota_oc](../../configs/r3det/r3det_tiny_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/r3det/r3det_tiny_r50_fpn_1x_dota_oc/r3det_tiny_r50_fpn_1x_dota_oc-c98a616c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/r3det/r3det_tiny_r50_fpn_1x_dota_oc/r3det_tiny_r50_fpn_1x_dota_oc_20220209_171624.log.json) |
+| ResNet50 (1024,1024,200) | 70.64 | le90 | 1x | 3.12 | 18.2 | - | 2 | [rotated_atss_obb_r50_fpn_1x_dota_le90](../../configs/rotated_atss/rotated_atss_obb_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_atss/rotated_atss_obb_r50_fpn_1x_dota_le90/rotated_atss_obb_r50_fpn_1x_dota_le90-e029ca06.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_atss/rotated_atss_obb_r50_fpn_1x_dota_le90/rotated_atss_obb_r50_fpn_1x_dota_le90_20220402_002048.log.json) |
+| ResNet50 (1024,1024,200) | 70.70 | le90 | 1x | 4.18 | | - | 2 | [rotated_fcos_sep_angle_r50_fpn_1x_dota_le90](../../configs/rotated_fcos/rotated_fcos_sep_angle_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_sep_angle_r50_fpn_1x_dota_le90/rotated_fcos_sep_angle_r50_fpn_1x_dota_le90-0be71a0c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_sep_angle_r50_fpn_1x_dota_le90/rotated_fcos_sep_angle_r50_fpn_1x_dota_le90_20220409_023250.log.json) |
+| ResNet50 (1024,1024,200) | 71.28 | le90 | 1x | 4.18 | | - | 2 | [rotated_fcos_r50_fpn_1x_dota_le90](../../configs/rotated_fcos/rotated_fcos_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_r50_fpn_1x_dota_le90/rotated_fcos_r50_fpn_1x_dota_le90-d87568ed.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_r50_fpn_1x_dota_le90/rotated_fcos_r50_fpn_1x_dota_le90_20220413_163526.log.json) |
+| ResNet50 (1024,1024,200) | 71.76 | le90 | 1x | 4.23 | | - | 2 | [rotated_fcos_csl_gaussian_r50_fpn_1x_dota_le90](../../configs/rotated_fcos/rotated_fcos_csl_gaussian_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_csl_gaussian_r50_fpn_1x_dota_le90/rotated_fcos_csl_gaussian_r50_fpn_1x_dota_le90-4e044ad2.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_csl_gaussian_r50_fpn_1x_dota_le90/rotated_fcos_csl_gaussian_r50_fpn_1x_dota_le90_20220409_080616.log.json) |
+| ResNet50 (1024,1024,200) | 71.83 | oc | 1x | 3.54 | 12.4 | - | 2 | [r3det_kld_r50_fpn_1x_dota_oc](../../configs/kld/r3det_kld_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kld/r3det_kld_r50_fpn_1x_dota_oc/r3det_kld_r50_fpn_1x_dota_oc-31866226.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kld/r3det_kld_r50_fpn_1x_dota_oc/r3det_kld_r50_fpn_1x_dota_oc_20220210_114049.log.json) |
+| ResNet50 (1024,1024,200) | 71.89 | le90 | 1x | 4.18 | | - | 2 | [rotated_fcos_kld_r50_fpn_1x_dota_le90](../../configs/rotated_fcos/rotated_fcos_kld_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_kld_r50_fpn_1x_dota_le90/rotated_fcos_kld_r50_fpn_1x_dota_le90-ecafdb2b.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_fcos/rotated_fcos_kld_r50_fpn_1x_dota_le90/rotated_fcos_kld_r50_fpn_1x_dota_le90_20220409_202939.log.json) |
+| ResNet50 (1024,1024,200) | 71.94 | le135 | 1x | 3.45 | 16.1 | - | 2 | [oriented_reppoints_r50_fpn_1x_dota_le135](../../configs/oriented_reppoints/oriented_reppoints_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/orientedreppoints/oriented_reppoints_r50_fpn_1x_dota_le135/oriented_reppoints_r50_fpn_1x_dota_le135-ef072de9.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/orientedreppoints/oriented_reppoints_r50_fpn_1x_dota_le135/oriented_reppoints_r50_fpn_1x_dota_le135_20220505_092853.log.json) |
+| ResNet50 (1024,1024,200) | 72.29 | le135 | 1x | 3.19 | 18.8 | - | 2 | [rotated_atss_obb_r50_fpn_1x_dota_le135](../../configs/rotated_atss/rotated_atss_obb_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_atss/rotated_atss_obb_r50_fpn_1x_dota_le135/rotated_atss_obb_r50_fpn_1x_dota_le135-eab7bc12.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_atss/rotated_atss_obb_r50_fpn_1x_dota_le135/rotated_atss_obb_r50_fpn_1x_dota_le135_20220402_002138.log.json) |
+| ResNet50 (1024,1024,200) | 72.68 | oc | 1x | 3.62 | 12.2 | - | 2 | [r3det_kfiou_ln_r50_fpn_1x_dota_oc](../../configs/kfiou/r3det_kfiou_ln_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/r3det_kfiou_ln_r50_fpn_1x_dota_oc/r3det_kfiou_ln_r50_fpn_1x_dota_oc-8e7f049d.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kfiou/r3det_kfiou_ln_r50_fpn_1x_dota_oc/r3det_kfiou_ln_r50_fpn_1x_dota_oc_20220123_074507.log.json) |
+| ResNet50 (1024,1024,200) | 72.76 | oc | 1x | 3.44 | 14.0 | - | 2 | [r3det_tiny_kld_r50_fpn_1x_dota_oc](../../configs/kld/r3det_tiny_kld_r50_fpn_1x_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/kld/r3det_tiny_kld_r50_fpn_1x_dota_oc/r3det_tiny_kld_r50_fpn_1x_dota_oc-589e142a.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/kld/r3det_tiny_kld_r50_fpn_1x_dota_oc/r3det_tiny_kld_r50_fpn_1x_dota_oc_20220209_172917.log.json) |
+| ResNet50 (1024,1024,200) | 73.23 | le90 | 1x | 8.45 | 16.4 | - | 2 | [gliding_vertex_r50_fpn_1x_dota_le90](../../configs/gliding_vertex/gliding_vertex_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/gliding_vertex/gliding_vertex_r50_fpn_1x_dota_le90/gliding_vertex_r50_fpn_1x_dota_le90-12e7423c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/gliding_vertex/gliding_vertex_r50_fpn_1x_dota_le90/gliding_vertex_r50_fpn_1x_dota_le90_20220129_085529.log.json) |
+| ResNet50 (1024,1024,200) | 73.40 | le90 | 1x | 8.46 | 16.5 | - | 2 | [rotated_faster_rcnn_r50_fpn_1x_dota_le90](../../configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90/rotated_faster_rcnn_r50_fpn_1x_dota_le90_20220131_082156.log.json) |
+| ResNet50 (1024,1024,200) | 73.45 | oc | 40e | 3.45 | 16.1 | - | 2 | [cfa_r50_fpn_40e_dota_oc](../../configs/cfa/cfa_r50_fpn_40e_dota_oc.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/cfa/cfa_r50_fpn_40e_dota_oc/cfa_r50_fpn_40e_dota_oc-2f387232.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/cfa/cfa_r50_fpn_40e_dota_oc/cfa_r50_fpn_40e_dota_oc_20220209_171237.log.json) |
+| ResNet50 (1024,1024,200) | 73.91 | le135 | 1x | 3.14 | 15.5 | - | 2 | [s2anet_r50_fpn_1x_dota_le135](../../configs/s2anet/s2anet_r50_fpn_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/s2anet/s2anet_r50_fpn_1x_dota_le135/s2anet_r50_fpn_1x_dota_le135-5dfcf396.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/s2anet/s2anet_r50_fpn_1x_dota_le135/s2anet_r50_fpn_1x_dota_le135_20220124_163529.log.json) |
+| ResNet50 (1024,1024,200) | 74.19 | le135 | 1x | 2.17 | 17.4 | - | 2 | [s2anet_r50_fpn_fp16_1x_dota_le135](../../configs/s2anet_r50_fpn_fp16_1x_dota_le135.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/s2anet/s2anet_r50_fpn_fp16_1x_dota_le135/s2anet_r50_fpn_fp16_1x_dota_le135-5cac515c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/s2anet/s2anet_r50_fpn_fp16_1x_dota_le135/s2anet_r50_fpn_fp16_1x_dota_le135_20220303_194910.log.json) |
+| ResNet50 (1024,1024,200) | 75.63 | le90 | 1x | 7.37 | 21.2 | - | 2 | [oriented_rcnn_r50_fpn_fp16_1x_dota_le90](../../configs/oriented_rcnn_r50_fpn_fp16_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/oriented_rcnn/oriented_rcnn_r50_fpn_fp16_1x_dota_le90/oriented_rcnn_r50_fpn_fp16_1x_dota_le90-57c88621.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/oriented_rcnn/oriented_rcnn_r50_fpn_fp16_1x_dota_le90/oriented_rcnn_r50_fpn_fp16_1x_dota_le90_20220303_195049.log.json) |
+| ResNet50 (1024,1024,200) | 75.69 | le90 | 1x | 8.46 | 16.2 | - | 2 | [oriented_rcnn_r50_fpn_1x_dota_le90](../../configs/oriented_rcnn/oriented_rcnn_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/oriented_rcnn/oriented_rcnn_r50_fpn_1x_dota_le90/oriented_rcnn_r50_fpn_1x_dota_le90-6d2b2ce0.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/oriented_rcnn/oriented_rcnn_r50_fpn_1x_dota_le90/oriented_rcnn_r50_fpn_1x_dota_le90_20220127_100150.log.json) |
+| ResNet50 (1024,1024,200) | 75.75 | le90 | 1x | 7.56 | 19.3 | - | 2 | [roi_trans_r50_fpn_fp16_1x_dota_le90](../../configs/roi_trans_r50_fpn_fp16_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_r50_fpn_fp16_1x_dota_le90/roi_trans_r50_fpn_fp16_1x_dota_le90-62eb88b1.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_r50_fpn_fp16_1x_dota_le90/roi_trans_r50_fpn_fp16_1x_dota_le90_20220303_193513.log.json) |
+| ReResNet50 (1024,1024,200) | 75.99 | le90 | 1x | 7.71 | 13.3 | - | 2 | [redet_re50_refpn_fp16_1x_dota_le90](../../configs/redet_re50_refpn_fp16_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/redet/redet_re50_refpn_fp16_1x_dota_le90/redet_re50_refpn_fp16_1x_dota_le90-1e34da2d.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/redet/redet_re50_refpn_fp16_1x_dota_le90/redet_re50_refpn_fp16_1x_dota_le90_20220303_194725.log.json) |
+| ResNet50 (1024,1024,200) | 76.08 | le90 | 1x | 8.67 | 14.4 | - | 2 | [roi_trans_r50_fpn_1x_dota_le90](../../configs/roi_trans/roi_trans_r50_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_r50_fpn_1x_dota_le90/roi_trans_r50_fpn_1x_dota_le90-d1f0b77a.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_r50_fpn_1x_dota_le90/roi_trans_r50_fpn_1x_dota_le90_20220130_132727.log.json) |
+| ResNet50 (1024,1024,500) | 76.50 | le90 | 1x | | 17.5 | MS+RR | 2 | [rotated_retinanet_obb_r50_fpn_1x_dota_ms_rr_le90](../../configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_ms_rr_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_ms_rr_le90/rotated_retinanet_obb_r50_fpn_1x_dota_ms_rr_le90-1da1ec9c.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_ms_rr_le90/rotated_retinanet_obb_r50_fpn_1x_dota_ms_rr_le90_20220210_114843.log.json) |
+| ReResNet50 (1024,1024,200) | 76.68 | le90 | 1x | 9.32 | 10.9 | - | 2 | [redet_re50_refpn_1x_dota_le90](../../configs/redet/redet_re50_refpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/redet/redet_re50_fpn_1x_dota_le90/redet_re50_fpn_1x_dota_le90-724ab2da.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/redet/redet_re50_fpn_1x_dota_le90/redet_re50_fpn_1x_dota_le90_20220130_132751.log.json) |
+| Swin-tiny (1024,1024,200) | 77.51 | le90 | 1x | | 10.9 | - | 2 | [roi_trans_swin_tiny_fpn_1x_dota_le90](../../configs/roi_trans/roi_trans_swin_tiny_fpn_1x_dota_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_swin_tiny_fpn_1x_dota_le90/roi_trans_swin_tiny_fpn_1x_dota_le90-ddeee9ae.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_swin_tiny_fpn_1x_dota_le90/roi_trans_swin_tiny_fpn_1x_dota_le90_20220131_083622.log.json) |
+| ResNet50 (1024,1024,500) | 79.66 | le90 | 1x | | 14.4 | MS+RR | 2 | [roi_trans_r50_fpn_1x_dota_ms_rr_le90](../../configs/roi_trans/roi_trans_r50_fpn_1x_dota_ms_rr_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_r50_fpn_1x_dota_ms_rr_le90/roi_trans_r50_fpn_1x_dota_ms_rr_le90-fa99496f.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/roi_trans/roi_trans_r50_fpn_1x_dota_ms_rr_le90/roi_trans_r50_fpn_1x_dota_ms_rr_le90_20220205_171729.log.json) |
+| ReResNet50 (1024,1024,500) | 79.87 | le90 | 1x | | 10.9 | MS+RR | 2 | [redet_re50_refpn_1x_dota_ms_rr_le90](../../configs/redet/redet_re50_refpn_1x_dota_ms_rr_le90.py) | [model](https://download.openmmlab.com/mmrotate/v0.1.0/redet/redet_re50_fpn_1x_dota_ms_rr_le90/redet_re50_fpn_1x_dota_ms_rr_le90-fc9217b5.pth) \| [log](https://download.openmmlab.com/mmrotate/v0.1.0/redet/redet_re50_fpn_1x_dota_ms_rr_le90/redet_re50_fpn_1x_dota_ms_rr_le90_20220206_105343.log.json) |
+
+- `MS` 表示多尺度图像增强。
+- `RR` 表示随机旋转增强。
+
+上述模型都是使用 1 * 1080ti/2080ti 训练得到的，并且在 1 * 2080ti 上进行推理测试。
diff --git a/internlm_langchain/knowledge_base/MMRotate/content/useful_tools.md b/internlm_langchain/knowledge_base/MMRotate/content/useful_tools.md
new file mode 100644
index 00000000..fb7fffb1
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMRotate/content/useful_tools.md
@@ -0,0 +1,283 @@
+除了训练和测试脚本，我们在 `tools/` 文件夹内还提供了一些有用的工具。
+
+## 日志分析
+
+`tools/analysis_tools/analyze_logs.py` 通过给定的日志文件绘制 loss/mAP 曲线。 需首先执行 `pip install seaborn` 安装依赖。
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve [--keys ${KEYS}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+
+
+示例:
+
+- 绘制某次执行的分类损失
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls --legend loss_cls
+ ```
+
+- 绘制某次执行的分类和回归损失，同时将图像保存到 pdf 文件
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls loss_bbox --out losses.pdf
+ ```
+
+- 在同一张图像中比较两次执行的 mAP
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys bbox_mAP --legend run1 run2
+ ```
+
+- 计算平均训练速度
+
+ ```shell
+ python tools/analysis_tools/analyze_logs.py cal_train_time log.json [--include-outliers]
+ ```
+
+ 预计输出如下
+
+ ```text
+ -----Analyze train time of work_dirs/some_exp/20190611_192040.log.json-----
+ slowest epoch 11, average time is 1.2024
+ fastest epoch 1, average time is 1.1909
+ time std over epochs is 0.0028
+ average iter time: 1.1959 s/iter
+ ```
+
+## 可视化
+
+### 可视化数据集
+
+`tools/misc/browse_dataset.py` 帮助用户浏览检测的数据集（包括图像和检测框的标注），或将图像保存到指定目录。
+
+```shell
+python tools/misc/browse_dataset.py ${CONFIG} [-h] [--skip-type ${SKIP_TYPE[SKIP_TYPE...]}] [--output-dir ${OUTPUT_DIR}] [--not-show] [--show-interval ${SHOW_INTERVAL}]
+```
+
+## 模型部署
+
+为了使用 [`TorchServe`](https://pytorch.org/serve/) 部署一个 `MMRotate` 模型，需要进行以下几步：
+
+### 1. 转换 MMRotate 模型至 TorchServe
+
+```shell
+python tools/deployment/mmrotate2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+示例:
+
+```shell
+wget -P checkpoint \
+https://download.openmmlab.com/mmrotate/v0.1.0/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth
+
+python tools/deployment/mmrotate2torchserve.py configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py checkpoint/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth \
+--output-folder ${MODEL_STORE} \
+--model-name rotated_faster_rcnn
+```
+
+**Note**: ${MODEL_STORE} 需要是一个文件夹的绝对路径。
+
+### 2. 构建 `mmrotate-serve` docker 镜像
+
+```shell
+docker build -t mmrotate-serve:latest docker/serve/
+```
+
+### 3. 运行 `mmrotate-serve` 镜像
+
+请参考官方文档 [基于 docker 运行 TorchServe](https://github.com/pytorch/serve/blob/master/docker/README.md#running-torchserve-in-a-production-docker-environment).
+
+为了使镜像能够使用 GPU 资源，需要安装 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)。之后可以传递 `--gpus` 参数以在 GPU 上运行。
+
+示例：
+
+```shell
+docker run --rm \
+--cpus 8 \
+--gpus device=0 \
+-p8080:8080 -p8081:8081 -p8082:8082 \
+--mount type=bind,source=$MODEL_STORE,target=/home/model-server/model-store \
+mmrotate-serve:latest
+```
+
+参考 [该文档](https://github.com/pytorch/serve/blob/master/docs/rest_api.md) 了解关于推理 (8080)，管理 (8081) 和指标 (8082) 等 API 的信息。
+
+### 4. 测试部署
+
+```shell
+curl -O https://raw.githubusercontent.com/open-mmlab/mmrotate/main/demo/demo.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T demo.jpg
+```
+
+您应该获得类似于以下内容的响应：
+
+```json
+[
+ {
+ "class_name": "small-vehicle",
+ "bbox": [
+ 584.9473266601562,
+ 327.2749938964844,
+ 38.45665740966797,
+ 16.898427963256836,
+ -0.7229751944541931
+ ],
+ "score": 0.9766026139259338
+ },
+ {
+ "class_name": "small-vehicle",
+ "bbox": [
+ 152.0239715576172,
+ 305.92572021484375,
+ 43.144744873046875,
+ 18.85024642944336,
+ 0.014928221702575684
+ ],
+ "score": 0.972826361656189
+ },
+ {
+ "class_name": "large-vehicle",
+ "bbox": [
+ 160.58056640625,
+ 437.3690185546875,
+ 55.6795654296875,
+ 19.31710433959961,
+ 0.007036328315734863
+ ],
+ "score": 0.888836681842804
+ },
+ {
+ "class_name": "large-vehicle",
+ "bbox": [
+ 666.2868041992188,
+ 1011.3961181640625,
+ 60.396209716796875,
+ 21.821645736694336,
+ 0.8549195528030396
+ ],
+ "score": 0.8240180015563965
+ }
+]
+```
+
+另外，你也可以使用 `test_torchserver.py` 来比较 TorchServe 和 PyTorch 的结果，并进行可视化。
+
+```shell
+python tools/deployment/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}] [--score-thr ${SCORE_THR}]
+```
+
+示例：
+
+```shell
+python tools/deployment/test_torchserver.py \
+demo/demo.jpg \
+configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py \
+rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth \
+rotated_fater_rcnn
+```
+
+## 模型复杂度
+
+`tools/analysis_tools/get_flops.py` 是改编自 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) 的脚本，用于计算给定模型的 FLOPs 和参数量。
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+预计输出如下
+
+```text
+==============================
+Input shape: (3, 1024, 1024)
+Flops: 215.92 GFLOPs
+Params: 36.42 M
+==============================
+```
+
+**注意**: 此工具仍处于实验阶段，我们并不能保证计算结果是绝对正确的。你可以将结果用于简单的比较，
+但在技术报告或论文中采用之前请仔细检查
+
+1. FLOPs 与输入大小相关，但参数量与其无关。默认输入大小是(1, 3, 1024, 1024)。
+2. 一些算子例如 DCN 或自定义算子并未包含在 FLOPs 计算中，所以 S2A-Net 和基于 RepPoints 的模型的 FLOPs 计算是错误的。
+ 详细信息请查看 [`mmcv.cnn.get_model_complexity_info()`](https://github.com/open-mmlab/mmcv/blob/master/mmcv/cnn/utils/flops_counter.py)。
+3. 两阶段检测器的 FLOPs 取决于候选的数量。
+
+### 准备发布模型
+
+`tools/model_converters/publish_model.py` 帮助用户准备他们将发布的模型。
+
+在将模型上传到 AWS 之前，你可能需要
+
+1. 将模型权重转换至 CPU
+2. 删除优化器的状态
+3. 计算权重文件的哈希值并附加到文件名后
+
+```shell
+python tools/model_converters/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+例如,
+
+```shell
+python tools/model_converters/publish_model.py work_dirs/rotated_faster_rcnn/latest.pth rotated_faster_rcnn_r50_fpn_1x_dota_le90_20190801.pth
+```
+
+最终输出的文件名是 `rotated_faster_rcnn_r50_fpn_1x_dota_le90_20190801-{hash id}.pth`。
+
+## 基准测试
+
+### FPS 基准
+
+`tools/analysis_tools/benchmark.py` 帮助用户计算 FPS。 FPS 值包括模型前向传播和后处理。为了得到更准确的数值，目前只支持单 GPU 分布式启动。
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=${PORT} tools/analysis_tools/benchmark.py \
+ ${CONFIG} \
+ ${CHECKPOINT} \
+ [--repeat-num ${REPEAT_NUM}] \
+ [--max-iter ${MAX_ITER}] \
+ [--log-interval ${LOG_INTERVAL}] \
+ --launcher pytorch
+```
+
+示例: 假设你已经下载了 `Rotated Faster R-CNN` 模型权重到 `checkpoints/` 文件夹
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=29500 tools/analysis_tools/benchmark.py \
+ configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py \
+ checkpoints/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth \
+ --launcher pytorch
+```
+
+## 杂项
+
+### 打印完整配置文件
+
+`tools/misc/print_config.py` 输出整个配置文件并整合其所有导入。
+
+```shell
+python tools/misc/print_config.py ${CONFIG} [-h] [--options ${OPTIONS [OPTIONS...]}]
+```
+
+## 混淆矩阵
+
+混淆矩阵是预测结果的概要
+
+`tools/analysis_tools/confusion_matrix.py` 可以分析预测结果并绘制混淆矩阵。
+
+首先执行 `tools/test.py` 将检测结果保存为 `.pkl` 文件。
+
+之后执行
+
+```
+python tools/analysis_tools/confusion_matrix.py ${CONFIG} ${DETECTION_RESULTS} ${SAVE_DIR} --show
+```
+
+你会得到一个类似于下图的混淆矩阵:
+
+
diff --git a/internlm_langchain/knowledge_base/MMRotate/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMRotate/vector_store/index.faiss
new file mode 100644
index 00000000..b7434bbe
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMRotate/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/1_config.md b/internlm_langchain/knowledge_base/MMSegmentation/content/1_config.md
new file mode 100644
index 00000000..dfcf0f96
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/1_config.md
@@ -0,0 +1,577 @@
+# 教程1：了解配置文件
+
+我们将模块化和继承性设计融入到我们的配置文件系统中，方便进行各种实验。如果您想查看配置文件，你可以运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置文件。你也可以通过传递参数 `--cfg-options xxx.yyy=zzz` 来查看更新的配置信息。
+
+## 配置文件的结构
+
+在 `config/_base_ ` 文件夹下面有4种基本组件类型： 数据集(dataset)，模型(model)，训练策略(schedule)和运行时的默认设置(default runtime)。许多模型都可以很容易地通过组合这些组件进行实现，比如 DeepLabV3，PSPNet。使用 `_base_` 下的组件构建的配置信息叫做原始配置 (primitive)。
+
+对于同一个文件夹下的所有配置文件，建议**只有一个**对应的**原始配置文件**。所有其他的配置文件都应该继承自这个原始配置文件，从而保证每个配置文件的最大继承深度为 3。
+
+为了便于理解，我们建议社区贡献者从现有的方法继承。例如，如果您在 DeepLabV3 基础上进行了一些修改，用户可以先通过指定 `_base_ = ../deeplabv3/deeplabv3_r50-d8_4xb2-40k_cityscapes-512x1024.py` 继承基本的 DeepLabV3 结构，然后在配置文件中修改必要的字段。
+
+如果你正在构建一个全新的方法，它不与现有的任何方法共享基本组件，您可以在`config`下创建一个新的文件夹`xxxnet` ，详细文档请参考[mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
+
+## 配置文件命名风格
+
+我们遵循以下格式来命名配置文件，建议社区贡献者遵循相同的风格。
+
+```text
+{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}
+```
+
+配置文件的文件名分为五个部分，组成文件名每一个部分和组件之间都用`_`连接，每个部分或组件中的每个单词都要用`-`连接。
+
+- `{algorithm name}`: 算法的名称，如 `deeplabv3`, `pspnet` 等。
+- `{model component names}`: 算法中使用的组件名称，如主干(backbone)、解码头(head)等。例如，`r50-d8 `表示使用ResNet50主干网络，并使用主干网络的8倍下采样输出作为下一级的输入。
+- `{training settings}`: 训练时的参数设置，如 `batch size`、数据增强(augmentation)、损失函数(loss)、学习率调度器(learning rate scheduler)和训练轮数(epochs/iterations)。例如: `4xb4-ce-linearlr-40K` 意味着使用4个gpu，每个gpu4个图像，使用交叉熵损失函数(CrossEntropy)，线性学习率调度程序，训练40K iterations。
+ 一些缩写:
+ - `{gpu x batch_per_gpu}`: GPU数量和每个GPU的样本数。`bN ` 表示每个GPU的batch size为N，如 `8xb2` 为8个gpu x 每个gpu2张图像的缩写。如果未提及，则默认使用 `4xb4 `。
+ - `{schedule}`: 训练计划，选项有`20k`，`40k`等。`20k ` 和 `40k` 分别表示20000次迭代(iterations)和40000次迭代(iterations)。
+- `{training dataset information}`: 训练数据集名称，如 `cityscapes `， `ade20k ` 等，以及输入分辨率。例如: `cityscapes-768x768 `表示使用 `cityscapes` 数据集进行训练，输入分辨率为`768x768 `。
+- `{testing dataset information}` (可选): 测试数据集名称。当您的模型在一个数据集上训练但在另一个数据集上测试时，请将测试数据集名称添加到此处。如果没有这一部分，则意味着模型是在同一个数据集上进行训练和测试的。
+
+## PSPNet 的一个例子
+
+为了帮助用户熟悉对这个现代语义分割系统的完整配置文件和模块，我们对使用ResNet50V1c作为主干网络的PSPNet的配置文件作如下的简要注释和说明。要了解更详细的用法和每个模块对应的替换方法，请参阅API文档。
+
+```python
+_base_ = [
+ '../_base_/models/pspnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
+ '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
+] # 我们可以在基本配置文件的基础上 构建新的配置文件
+crop_size = (512, 1024)
+data_preprocessor = dict(size=crop_size)
+model = dict(data_preprocessor=data_preprocessor)
+```
+
+`_base_/models/pspnet_r50-d8.py`是使用ResNet50V1c作为主干网络的PSPNet的基本模型配置文件。
+
+```python
+# 模型设置
+norm_cfg = dict(type='SyncBN', requires_grad=True) # 分割框架通常使用 SyncBN
+data_preprocessor = dict( # 数据预处理的配置项，通常包括图像的归一化和增强
+ type='SegDataPreProcessor', # 数据预处理的类型
+ mean=[123.675, 116.28, 103.53], # 用于归一化输入图像的平均值
+ std=[58.395, 57.12, 57.375], # 用于归一化输入图像的标准差
+ bgr_to_rgb=True, # 是否将图像从 BGR 转为 RGB
+ pad_val=0, # 图像的填充值
+ seg_pad_val=255) # 'gt_seg_map'的填充值
+model = dict(
+ type='EncoderDecoder', # 分割器(segmentor)的名字
+ data_preprocessor=data_preprocessor,
+ pretrained='open-mmlab://resnet50_v1c', # 加载使用 ImageNet 预训练的主干网络
+ backbone=dict(
+ type='ResNetV1c', # 主干网络的类别，更多细节请参考 mmseg/models/backbones/resnet.py
+ depth=50, # 主干网络的深度，通常为 50 和 101
+ num_stages=4, # 主干网络状态(stages)的数目
+ out_indices=(0, 1, 2, 3), # 每个状态(stage)产生的特征图输出的索引
+ dilations=(1, 1, 2, 4), # 每一层(layer)的空心率(dilation rate)
+ strides=(1, 2, 1, 1), # 每一层(layer)的步长(stride)
+ norm_cfg=norm_cfg, # 归一化层(norm layer)的配置项
+ norm_eval=False, # 是否冻结 BN 里的统计项
+ style='pytorch', # 主干网络的风格，'pytorch' 意思是步长为2的层为 3x3 卷积， 'caffe' 意思是步长为2的层为 1x1 卷积
+ contract_dilation=True), # 当空洞率 > 1, 是否压缩第一个空洞层
+ decode_head=dict(
+ type='PSPHead', # 解码头(decode head)的类别。可用选项请参 mmseg/models/decode_heads
+ in_channels=2048, # 解码头的输入通道数
+ in_index=3, # 被选择特征图(feature map)的索引
+ channels=512, # 解码头中间态(intermediate)的通道数
+ pool_scales=(1, 2, 3, 6), # PSPHead 平均池化(avg pooling)的规模(scales)。 细节请参考文章内容
+ dropout_ratio=0.1, # 进入最后分类层(classification layer)之前的 dropout 比例
+ num_classes=19, # 分割前景的种类数目。 通常情况下，cityscapes 为19，VOC为21，ADE20k 为150
+ norm_cfg=norm_cfg, # 归一化层的配置项
+ align_corners=False, # 解码过程中调整大小(resize)的 align_corners 参数
+ loss_decode=dict( # 解码头(decode_head)里的损失函数的配置项
+ type='CrossEntropyLoss', # 分割时使用的损失函数的类别
+ use_sigmoid=False, # 分割时是否使用 sigmoid 激活
+ loss_weight=1.0)), # 解码头的损失权重
+ auxiliary_head=dict(
+ type='FCNHead', # 辅助头(auxiliary head)的种类。可用选项请参考 mmseg/models/decode_heads
+ in_channels=1024, # 辅助头的输入通道数
+ in_index=2, # 被选择的特征图(feature map)的索引
+ channels=256, # 辅助头中间态(intermediate)的通道数
+ num_convs=1, # FCNHead 里卷积(convs)的数目，辅助头中通常为1
+ concat_input=False, # 在分类层(classification layer)之前是否连接(concat)输入和卷积的输出
+ dropout_ratio=0.1, # 进入最后分类层(classification layer)之前的 dropout 比例
+ num_classes=19, # 分割前景的种类数目。 通常情况下，cityscapes 为19，VOC为21，ADE20k 为150
+ norm_cfg=norm_cfg, # 归一化层的配置项
+ align_corners=False, # 解码过程中调整大小(resize)的 align_corners 参数
+ loss_decode=dict( # 辅助头(auxiliary head)里的损失函数的配置项
+ type='CrossEntropyLoss', # 分割时使用的损失函数的类别
+ use_sigmoid=False, # 分割时是否使用 sigmoid 激活
+ loss_weight=0.4)), # 辅助头损失的权重，默认设置为0.4
+ # 模型训练和测试设置项
+ train_cfg=dict(), # train_cfg 当前仅是一个占位符
+ test_cfg=dict(mode='whole')) # 测试模式，可选参数为 'whole' 和 'slide'. 'whole': 在整张图像上全卷积(fully-convolutional)测试。 'slide': 在输入图像上做滑窗预测
+```
+
+`_base_/datasets/cityscapes.py`是数据集的基本配置文件。
+
+```python
+# 数据集设置
+dataset_type = 'CityscapesDataset' # 数据集类型，这将被用来定义数据集
+data_root = 'data/cityscapes/' # 数据的根路径
+crop_size = (512, 1024) # 训练时的裁剪大小
+train_pipeline = [ # 训练流程
+ dict(type='LoadImageFromFile'), # 第1个流程，从文件路径里加载图像
+ dict(type='LoadAnnotations'), # 第2个流程，对于当前图像，加载它的标注图像
+ dict(type='RandomResize', # 调整输入图像大小(resize)和其标注图像的数据增广流程
+ scale=(2048, 1024), # 图像裁剪的大小
+ ratio_range=(0.5, 2.0), # 数据增广的比例范围
+ keep_ratio=True), # 调整图像大小时是否保持纵横比
+ dict(type='RandomCrop', # 随机裁剪当前图像和其标注图像的数据增广流程
+ crop_size=crop_size, # 随机裁剪的大小
+ cat_max_ratio=0.75), # 单个类别可以填充的最大区域的比
+ dict(type='RandomFlip', # 翻转图像和其标注图像的数据增广流程
+ prob=0.5), # 翻转图像的概率
+ dict(type='PhotoMetricDistortion'), # 光学上使用一些方法扭曲当前图像和其标注图像的数据增广流程
+ dict(type='PackSegInputs') # 打包用于语义分割的输入数据
+]
+test_pipeline = [
+ dict(type='LoadImageFromFile'), # 第1个流程，从文件路径里加载图像
+ dict(type='Resize', # 使用调整图像大小(resize)增强
+ scale=(2048, 1024), # 图像缩放的大小
+ keep_ratio=True), # 在调整图像大小时是否保留长宽比
+ # 在' Resize '之后添加标注图像
+ # 不需要做调整图像大小(resize)的数据变换
+ dict(type='LoadAnnotations'), # 加载数据集提供的语义分割标注
+ dict(type='PackSegInputs') # 打包用于语义分割的输入数据
+]
+train_dataloader = dict( # 训练数据加载器(dataloader)的配置
+ batch_size=2, # 每一个GPU的batch size大小
+ num_workers=2, # 为每一个GPU预读取数据的进程个数
+ persistent_workers=True, # 在一个epoch结束后关闭worker进程，可以加快训练速度
+ sampler=dict(type='InfiniteSampler', shuffle=True), # 训练时进行随机洗牌(shuffle)
+ dataset=dict( # 训练数据集配置
+ type=dataset_type, # 数据集类型，详见mmseg/datassets/
+ data_root=data_root, # 数据集的根目录
+ data_prefix=dict(
+ img_path='leftImg8bit/train', seg_map_path='gtFine/train'), # 训练数据的前缀
+ pipeline=train_pipeline)) # 数据处理流程，它通过之前创建的train_pipeline传递。
+val_dataloader = dict(
+ batch_size=1, # 每一个GPU的batch size大小
+ num_workers=4, # 为每一个GPU预读取数据的进程个数
+ persistent_workers=True, # 在一个epoch结束后关闭worker进程，可以加快训练速度
+ sampler=dict(type='DefaultSampler', shuffle=False), # 训练时不进行随机洗牌(shuffle)
+ dataset=dict( # 测试数据集配置
+ type=dataset_type, # 数据集类型，详见mmseg/datassets/
+ data_root=data_root, # 数据集的根目录
+ data_prefix=dict(
+ img_path='leftImg8bit/val', seg_map_path='gtFine/val'), # 测试数据的前缀
+ pipeline=test_pipeline)) # 数据处理流程，它通过之前创建的test_pipeline传递。
+test_dataloader = val_dataloader
+# 精度评估方法，我们在这里使用 IoUMetric 进行评估
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = val_evaluator
+```
+
+`_base_/schedules/schedule_40k.py`
+
+```python
+# optimizer
+optimizer = dict(type='SGD', # 优化器种类，更多细节可参考 https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py
+ lr=0.01, # 优化器的学习率，参数的使用细节请参照对应的 PyTorch 文档
+ momentum=0.9, # 动量大小 (Momentum)
+ weight_decay=0.0005) # SGD 的权重衰减 (weight decay)
+optim_wrapper = dict(type='OptimWrapper', # 优化器包装器(Optimizer wrapper)为更新参数提供了一个公共接口
+ optimizer=optimizer, # 用于更新模型参数的优化器(Optimizer)
+ clip_grad=None) # 如果 'clip_grad' 不是None，它将是 ' torch.nn.utils.clip_grad' 的参数。
+# 学习策略
+param_scheduler = [
+ dict(
+ type='PolyLR', # 调度流程的策略，同样支持 Step, CosineAnnealing, Cyclic 等. 请从 https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py 参考 LrUpdater 的细节
+ eta_min=1e-4, # 训练结束时的最小学习率
+ power=0.9, # 多项式衰减 (polynomial decay) 的幂
+ begin=0, # 开始更新参数的时间步(step)
+ end=40000, # 停止更新参数的时间步(step)
+ by_epoch=False) # 是否按照 epoch 计算训练时间
+]
+# 40k iteration 的训练计划
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+# 默认钩子(hook)配置
+default_hooks = dict(
+ timer=dict(type='IterTimerHook'), # 记录迭代过程中花费的时间
+ logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False), # 从'Runner'的不同组件收集和写入日志
+ param_scheduler=dict(type='ParamSchedulerHook'), # 更新优化器中的一些超参数，例如学习率
+ checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000), # 定期保存检查点(checkpoint)
+ sampler_seed=dict(type='DistSamplerSeedHook')) # 用于分布式训练的数据加载采样器
+```
+
+in `_base_/default_runtime.py`
+
+```python
+# 将注册表的默认范围设置为mmseg
+default_scope = 'mmseg'
+# environment
+env_cfg = dict(
+ cudnn_benchmark=True,
+ mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+ dist_cfg=dict(backend='nccl'),
+)
+log_level = 'INFO'
+log_processor = dict(by_epoch=False)
+load_from = None # 从文件中加载检查点(checkpoint)
+resume = False # 是否从已有的模型恢复
+```
+
+这些都是用于训练和测试PSPNet的配置文件，要加载和解析它们，我们可以使用[MMEngine](https://github.com/open-mmlab/mmengine)实现的[Config](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('configs/pspnet/pspnet_r50-d8_4xb2-40k_cityscapes-512x1024.py')
+print(cfg.train_dataloader)
+```
+
+```shell
+{'batch_size': 2,
+ 'num_workers': 2,
+ 'persistent_workers': True,
+ 'sampler': {'type': 'InfiniteSampler', 'shuffle': True},
+ 'dataset': {'type': 'CityscapesDataset',
+ 'data_root': 'data/cityscapes/',
+ 'data_prefix': {'img_path': 'leftImg8bit/train',
+ 'seg_map_path': 'gtFine/train'},
+ 'pipeline': [{'type': 'LoadImageFromFile'},
+ {'type': 'LoadAnnotations'},
+ {'type': 'RandomResize',
+ 'scale': (2048, 1024),
+ 'ratio_range': (0.5, 2.0),
+ 'keep_ratio': True},
+ {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75},
+ {'type': 'RandomFlip', 'prob': 0.5},
+ {'type': 'PhotoMetricDistortion'},
+ {'type': 'PackSegInputs'}]}}
+```
+
+`cfg `是`mmengine.config.Config `的一个实例。它的接口与dict对象相同，也允许将配置值作为属性访问。更多信息请参见[MMEngine](https://github.com/open-mmlab/mmengine)中的[config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)。
+
+## FAQ
+
+### 忽略基础配置文件里的一些字段
+
+有时，您可以设置`_delete_=True `来忽略基本配置文件中的某些字段。您可以参考[MMEngine](https://github.com/open-mmlab/mmengine)中的[config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)来获得一些简单的指导。
+
+例如，在MMSegmentation中，如果您想在下面的配置文件`pspnet.py `中修改PSPNet的主干网络:
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+ type='EncoderDecoder',
+ pretrained='torchvision://resnet50',
+ backbone=dict(
+ type='ResNetV1c',
+ depth=50,
+ num_stages=4,
+ out_indices=(0, 1, 2, 3),
+ dilations=(1, 1, 2, 4),
+ strides=(1, 2, 1, 1),
+ norm_cfg=norm_cfg,
+ norm_eval=False,
+ style='pytorch',
+ contract_dilation=True),
+ decode_head=dict(
+ type='PSPHead',
+ in_channels=2048,
+ in_index=3,
+ channels=512,
+ pool_scales=(1, 2, 3, 6),
+ dropout_ratio=0.1,
+ num_classes=19,
+ norm_cfg=norm_cfg,
+ align_corners=False,
+ loss_decode=dict(
+ type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+```
+
+用以下代码加载并解析配置文件`pspnet.py`:
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('pspnet.py')
+print(cfg.model)
+```
+
+```shell
+{'type': 'EncoderDecoder',
+ 'pretrained': 'torchvision://resnet50',
+ 'backbone': {'type': 'ResNetV1c',
+ 'depth': 50,
+ 'num_stages': 4,
+ 'out_indices': (0, 1, 2, 3),
+ 'dilations': (1, 1, 2, 4),
+ 'strides': (1, 2, 1, 1),
+ 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+ 'norm_eval': False,
+ 'style': 'pytorch',
+ 'contract_dilation': True},
+ 'decode_head': {'type': 'PSPHead',
+ 'in_channels': 2048,
+ 'in_index': 3,
+ 'channels': 512,
+ 'pool_scales': (1, 2, 3, 6),
+ 'dropout_ratio': 0.1,
+ 'num_classes': 19,
+ 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+ 'align_corners': False,
+ 'loss_decode': {'type': 'CrossEntropyLoss',
+ 'use_sigmoid': False,
+ 'loss_weight': 1.0}}}
+```
+
+`ResNet`和`HRNet`使用不同的关键字构建，编写一个新的配置文件`hrnet.py`，如下所示:
+
+```python
+_base_ = 'pspnet.py'
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+ pretrained='open-mmlab://msra/hrnetv2_w32',
+ backbone=dict(
+ _delete_=True,
+ type='HRNet',
+ norm_cfg=norm_cfg,
+ extra=dict(
+ stage1=dict(
+ num_modules=1,
+ num_branches=1,
+ block='BOTTLENECK',
+ num_blocks=(4, ),
+ num_channels=(64, )),
+ stage2=dict(
+ num_modules=1,
+ num_branches=2,
+ block='BASIC',
+ num_blocks=(4, 4),
+ num_channels=(32, 64)),
+ stage3=dict(
+ num_modules=4,
+ num_branches=3,
+ block='BASIC',
+ num_blocks=(4, 4, 4),
+ num_channels=(32, 64, 128)),
+ stage4=dict(
+ num_modules=3,
+ num_branches=4,
+ block='BASIC',
+ num_blocks=(4, 4, 4, 4),
+ num_channels=(32, 64, 128, 256)))))
+```
+
+用以下代码加载并解析配置文件`hrnet.py`:
+
+```python
+from mmengine.config import Config
+cfg = Config.fromfile('hrnet.py')
+print(cfg.model)
+```
+
+```shell
+{'type': 'EncoderDecoder',
+ 'pretrained': 'open-mmlab://msra/hrnetv2_w32',
+ 'backbone': {'type': 'HRNet',
+ 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+ 'extra': {'stage1': {'num_modules': 1,
+ 'num_branches': 1,
+ 'block': 'BOTTLENECK',
+ 'num_blocks': (4,),
+ 'num_channels': (64,)},
+ 'stage2': {'num_modules': 1,
+ 'num_branches': 2,
+ 'block': 'BASIC',
+ 'num_blocks': (4, 4),
+ 'num_channels': (32, 64)},
+ 'stage3': {'num_modules': 4,
+ 'num_branches': 3,
+ 'block': 'BASIC',
+ 'num_blocks': (4, 4, 4),
+ 'num_channels': (32, 64, 128)},
+ 'stage4': {'num_modules': 3,
+ 'num_branches': 4,
+ 'block': 'BASIC',
+ 'num_blocks': (4, 4, 4, 4),
+ 'num_channels': (32, 64, 128, 256)}}},
+ 'decode_head': {'type': 'PSPHead',
+ 'in_channels': 2048,
+ 'in_index': 3,
+ 'channels': 512,
+ 'pool_scales': (1, 2, 3, 6),
+ 'dropout_ratio': 0.1,
+ 'num_classes': 19,
+ 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True},
+ 'align_corners': False,
+ 'loss_decode': {'type': 'CrossEntropyLoss',
+ 'use_sigmoid': False,
+ 'loss_weight': 1.0}}}
+```
+
+`_delete_=True` 将用新的键去替换 `backbone` 字段内所有旧的键。
+
+### 使用配置文件里的中间变量
+
+配置文件中会使用一些中间变量，例如数据集(datasets)字段里的 `train_pipeline`/`test_pipeline`。 需要注意的是，在子配置文件里修改中间变量时，您需要再次传递这些变量给对应的字段。例如，我们想改变在训练或测试PSPNet时采用的多尺度策略 (multi scale strategy)，`train_pipeline`/`test_pipeline` 是我们需要修改的中间变量。
+
+```python
+_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
+crop_size = (512, 1024)
+img_norm_cfg = dict(
+ mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ dict(type='RandomResize',
+ img_scale=(2048, 1024),
+ ratio_range=(1., 2.),
+ keep_ration=True),
+ dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
+ dict(type='RandomFlip', flip_ratio=0.5),
+ dict(type='PhotoMetricDistortion'),
+ dict(type='PackSegInputs'),
+]
+test_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='Resize',
+ scale=(2048, 1024),
+ keep_ratio=True),
+ dict(type='LoadAnnotations'),
+ dict(type='PackSegInputs')
+]
+train_dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(
+ img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+ pipeline=train_pipeline)
+test_dataset=dict(
+ type=dataset_type,
+ data_root=data_root,
+ data_prefix=dict(
+ img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
+ pipeline=test_pipeline)
+train_dataloader = dict(dataset=train_dataset)
+val_dataloader = dict(dataset=test_dataset)
+test_dataloader = val_dataloader
+```
+
+我们首先需要定义新的 `train_pipeline`/`test_pipeline` 然后传递到 `dataset` 里。
+
+类似的，如果我们想从 `SyncBN` 切换到 `BN` 或者 `MMSyncBN`，我们需要替换配置文件里的每一个 `norm_cfg`。
+
+```python
+_base_ = '../pspnet/pspnet_r50-d8_4xb4-40k_cityscpaes-512x1024.py'
+norm_cfg = dict(type='BN', requires_grad=True)
+model = dict(
+ backbone=dict(norm_cfg=norm_cfg),
+ decode_head=dict(norm_cfg=norm_cfg),
+ auxiliary_head=dict(norm_cfg=norm_cfg))
+```
+
+## 通过脚本参数修改配置文件
+
+在[training script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/train.py)和[testing script](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/test.py)中，我们支持脚本参数 `--cfg-options`，它可以帮助用户覆盖所使用的配置中的一些设置，`xxx=yyy` 格式的键值对将合并到配置文件中。
+
+例如，这是一个简化的脚本 `demo_script.py `:
+
+```python
+import argparse
+
+from mmengine.config import Config, DictAction
+
+def parse_args():
+ parser = argparse.ArgumentParser(description='Script Example')
+ parser.add_argument('config', help='train config file path')
+ parser.add_argument(
+ '--cfg-options',
+ nargs='+',
+ action=DictAction,
+ help='override some settings in the used config, the key-value pair '
+ 'in xxx=yyy format will be merged into config file. If the value to '
+ 'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+ 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+ 'Note that the quotation marks are necessary and that no white space '
+ 'is allowed.')
+ args = parser.parse_args()
+ return args
+
+def main():
+ args = parse_args()
+
+ cfg = Config.fromfile(args.config)
+ if args.cfg_options is not None:
+ cfg.merge_from_dict(args.cfg_options)
+
+ print(cfg)
+
+if __name__ == '__main__':
+ main()
+```
+
+一个配置文件示例 `demo_config.py` 如下所示:
+
+```python
+backbone = dict(
+ type='ResNetV1c',
+ depth=50,
+ num_stages=4,
+ out_indices=(0, 1, 2, 3),
+ dilations=(1, 1, 2, 4),
+ strides=(1, 2, 1, 1),
+ norm_eval=False,
+ style='pytorch',
+ contract_dilation=True)
+```
+
+运行 `demo_script.py`:
+
+```shell
+python demo_script.py demo_config.py
+```
+
+```shell
+Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+```
+
+通过脚本参数修改配置:
+
+```shell
+python demo_script.py demo_config.py --cfg-options backbone.depth=101
+```
+
+```shell
+Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 101, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+```
+
+- 更新列表/元组的值。
+
+ 如果要更新的值是一个 list 或 tuple。例如，需要在配置文件 `demo_config.py ` 的 `backbone ` 中设置 `stride =(1,2,1,1) `。
+ 如果您想更改这个键，你可以用两种方式进行指定:
+
+ 1. `--cfg-options backbone.strides="(1, 1, 1, 1)"`. 注意引号 " 是支持 list/tuple 数据类型所必需的。
+
+ ```shell
+ python demo_script.py demo_config.py --cfg-options backbone.strides="(1, 1, 1, 1)"
+ ```
+
+ ```shell
+ Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 1, 1, 1), 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+ ```
+
+ 2. `--cfg-options backbone.strides=1,1,1,1`. 注意，在指定的值中**不允许**有空格。
+
+ 另外，如果原来的类型是tuple，通过这种方式修改后会自动转换为list。
+
+ ```shell
+ python demo_script.py demo_config.py --cfg-options backbone.strides=1,1,1,1
+ ```
+
+ ```shell
+ Config (path: demo_config.py): {'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': [1, 1, 1, 1], 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}}
+ ```
+
+```{note}
+ 这种修改方法仅支持修改string、int、float、boolean、None、list和tuple类型的配置项。
+ 具体来说，对于list和tuple类型的配置项，它们内部的元素也必须是上述七种类型之一。
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/2_dataset_prepare.md b/internlm_langchain/knowledge_base/MMSegmentation/content/2_dataset_prepare.md
new file mode 100644
index 00000000..c6b13970
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/2_dataset_prepare.md
@@ -0,0 +1,714 @@
+# 教程2：准备数据集
+
+我们建议将数据集根目录符号链接到 `$MMSEGMENTATION/data`。
+如果您的目录结构不同，您可能需要更改配置文件中相应的路径。
+对于中国境内的用户，我们也推荐通过开源数据平台 [OpenDataLab](https://opendatalab.com/) 来下载dsdl标准数据，以获得更好的下载和使用体验，这里有一个下载dsdl数据集并进行训练的案例[DSDLReadme](../../../configs/dsdl/README.md)，欢迎尝试。
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│ ├── cityscapes
+│ │ ├── leftImg8bit
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ ├── gtFine
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── VOCdevkit
+│ │ ├── VOC2012
+│ │ │ ├── JPEGImages
+│ │ │ ├── SegmentationClass
+│ │ │ ├── ImageSets
+│ │ │ │ ├── Segmentation
+│ │ ├── VOC2010
+│ │ │ ├── JPEGImages
+│ │ │ ├── SegmentationClassContext
+│ │ │ ├── ImageSets
+│ │ │ │ ├── SegmentationContext
+│ │ │ │ │ ├── train.txt
+│ │ │ │ │ ├── val.txt
+│ │ │ ├── trainval_merged.json
+│ │ ├── VOCaug
+│ │ │ ├── dataset
+│ │ │ │ ├── cls
+│ ├── ade
+│ │ ├── ADEChallengeData2016
+│ │ │ ├── annotations
+│ │ │ │ ├── training
+│ │ │ │ ├── validation
+│ │ │ ├── images
+│ │ │ │ ├── training
+│ │ │ │ ├── validation
+│ ├── coco_stuff10k
+│ │ ├── images
+│ │ │ ├── train2014
+│ │ │ ├── test2014
+│ │ ├── annotations
+│ │ │ ├── train2014
+│ │ │ ├── test2014
+│ │ ├── imagesLists
+│ │ │ ├── train.txt
+│ │ │ ├── test.txt
+│ │ │ ├── all.txt
+│ ├── coco_stuff164k
+│ │ ├── images
+│ │ │ ├── train2017
+│ │ │ ├── val2017
+│ │ ├── annotations
+│ │ │ ├── train2017
+│ │ │ ├── val2017
+│ ├── CHASE_DB1
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ ├── validation
+│ ├── DRIVE
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ ├── validation
+│ ├── HRF
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ ├── validation
+│ ├── STARE
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ ├── validation
+| ├── dark_zurich
+| │ ├── gps
+| │ │ ├── val
+| │ │ └── val_ref
+| │ ├── gt
+| │ │ └── val
+| │ ├── LICENSE.txt
+| │ ├── lists_file_names
+| │ │ ├── val_filenames.txt
+| │ │ └── val_ref_filenames.txt
+| │ ├── README.md
+| │ └── rgb_anon
+| │ | ├── val
+| │ | └── val_ref
+| ├── NighttimeDrivingTest
+| | ├── gtCoarse_daytime_trainvaltest
+| | │ └── test
+| | │ └── night
+| | └── leftImg8bit
+| | | └── test
+| | | └── night
+│ ├── loveDA
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ │ ├── test
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── potsdam
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── vaihingen
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── iSAID
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ │ ├── test
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── synapse
+│ │ ├── img_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ │ ├── ann_dir
+│ │ │ ├── train
+│ │ │ ├── val
+│ ├── REFUGE
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── test
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── test
+│ ├── mapillary
+│ │ ├── training
+│ │ │ ├── images
+│ │ │ ├── v1.2
+| │ │ │ ├── instances
+| │ │ │ ├── labels
+| │ │ │ └── panoptic
+│ │ │ ├── v2.0
+| │ │ │ ├── instances
+| │ │ │ ├── labels
+| │ │ │ ├── panoptic
+| │ │ │ └── polygons
+│ │ ├── validation
+│ │ │ ├── images
+| │ │ ├── v1.2
+| │ │ │ ├── instances
+| │ │ │ ├── labels
+| │ │ │ └── panoptic
+│ │ │ ├── v2.0
+| │ │ │ ├── instances
+| │ │ │ ├── labels
+| │ │ │ ├── panoptic
+| │ │ │ └── polygons
+│ ├── bdd100k
+│ │ ├── images
+│ │ │ └── 10k
+| │ │ │ ├── test
+| │ │ │ ├── train
+| │ │ │ └── val
+│ │ └── labels
+│ │ │ └── sem_seg
+| │ │ │ ├── colormaps
+| │ │ │ │ ├──train
+| │ │ │ │ └──val
+| │ │ │ ├── masks
+| │ │ │ │ ├──train
+| │ │ │ │ └──val
+| │ │ │ ├── polygons
+| │ │ │ │ ├──sem_seg_train.json
+| │ │ │ │ └──sem_seg_val.json
+| │ │ │ └── rles
+| │ │ │ │ ├──sem_seg_train.json
+| │ │ │ │ └──sem_seg_val.json
+```
+
+## Cityscapes
+
+Cityscapes [官方网站](https://www.cityscapes-dataset.com/)可以下载 Cityscapes 数据集，按照官网要求注册并登陆后，数据可以在[这里](https://www.cityscapes-dataset.com/downloads/)找到。
+
+按照惯例，`**labelTrainIds.png` 用于 cityscapes 训练。
+我们提供了一个基于 [cityscapesscripts](https://github.com/mcordts/cityscapesScripts) 的[脚本](https://github.com/open-mmlab/mmsegmentation/blob/1.x/tools/dataset_converters/cityscapes.py)用于生成 `**labelTrainIds.png`。
+
+```shell
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/cityscapes.py data/cityscapes --nproc 8
+```
+
+## Pascal VOC
+
+Pascal VOC 2012 可从[此处](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar)下载。
+此外，Pascal VOC 数据集的最新工作通常利用额外的增强数据，可以在[这里](http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/semantic_contours/benchmark.tgz)找到。
+
+如果您想使用增强的 VOC 数据集，请运行以下命令将增强数据的标注转换为正确的格式。
+
+```shell
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/voc_aug.py data/VOCdevkit data/VOCdevkit/VOCaug --nproc 8
+```
+
+请参考[拼接数据集文档](../advanced_guides/add_datasets.md#拼接数据集)及 [voc_aug 配置示例](../../../configs/_base_/datasets/pascal_voc12_aug.py)以详细了解如何将它们拼接并合并训练。
+
+## ADE20K
+
+ADE20K 的训练和验证集可以从这个[链接](http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip)下载。
+如果需要下载测试数据集，可以在[官网](http://host.robots.ox.ac.uk/)注册后，下载[测试集](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar)。
+
+## Pascal Context
+
+Pascal Context 的训练和验证集可以从[此处](http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar)下载。注册后，您也可以从[此处](http://host.robots.ox.ac.uk:8080/eval/downloads/VOC2010test.tar)下载测试集。
+
+从原始数据集中抽出部分数据作为验证集，您可以从[此处](https://codalabuser.blob.core.windows.net/public/trainval_merged.json)下载 trainval_merged.json 文件。
+
+请先安装 [Detail](https://github.com/zhanghang1989/detail-api) 工具然后运行以下命令将标注转换为正确的格式。
+
+```shell
+python tools/dataset_converters/pascal_context.py data/VOCdevkit data/VOCdevkit/VOC2010/trainval_merged.json
+```
+
+## COCO Stuff 10k
+
+数据可以通过 wget 在[这里](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip)下载。
+
+对于 COCO Stuff 10k 数据集，请运行以下命令下载并转换数据集。
+
+```shell
+# 下载
+mkdir coco_stuff10k && cd coco_stuff10k
+wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/cocostuff-10k-v1.1.zip
+
+# 解压
+unzip cocostuff-10k-v1.1.zip
+
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/coco_stuff10k.py /path/to/coco_stuff10k --nproc 8
+```
+
+按照惯例，`/path/to/coco_stuff164k/annotations/*2014/*_labelTrainIds.png` 中的 mask 标注用于 COCO Stuff 10k 的训练和测试。
+
+## COCO Stuff 164k
+
+对于 COCO Stuff 164k 数据集，请运行以下命令下载并转换增强的数据集。
+
+```shell
+# 下载
+mkdir coco_stuff164k && cd coco_stuff164k
+wget http://images.cocodataset.org/zips/train2017.zip
+wget http://images.cocodataset.org/zips/val2017.zip
+wget http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip
+
+# 解压
+unzip train2017.zip -d images/
+unzip val2017.zip -d images/
+unzip stuffthingmaps_trainval2017.zip -d annotations/
+
+# --nproc 表示 8 个转换进程，也可以省略。
+python tools/dataset_converters/coco_stuff164k.py /path/to/coco_stuff164k --nproc 8
+```
+
+按照惯例，`/path/to/coco_stuff164k/annotations/*2017/*_labelTrainIds.png` 中的 mask 标注用于 COCO Stuff 164k 的训练和测试。
+
+此数据集的详细信息可在[此处](https://github.com/nightrome/cocostuff#downloads)找到。
+
+## CHASE DB1
+
+CHASE DB1 的训练和验证集可以从[此处](https://staffnet.kingston.ac.uk/~ku15565/CHASE_DB1/assets/CHASEDB1.zip)下载。
+
+请运行以下命令，准备 CHASE DB1 数据集：
+
+```shell
+python tools/dataset_converters/chase_db1.py /path/to/CHASEDB1.zip
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## DRIVE
+
+按照[官网](https://drive.grand-challenge.org/)要求，注册并登陆后，便可以下载 DRIVE 的训练和验证数据集。
+
+要将 DRIVE 数据集转换为 MMSegmentation 的格式，请运行以下命令：
+
+```shell
+python tools/dataset_converters/drive.py /path/to/training.zip /path/to/test.zip
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## HRF
+
+请下载 [health.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy.zip)、[glaucoma.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma.zip)、[diabetic_retinopathy.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy.zip)、[healthy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/healthy_manualsegm.zip)、[glaucoma_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/glaucoma_manualsegm.zip) 和 [diabetic_retinopathy_manualsegm.zip](https://www5.cs.fau.de/fileadmin/research/datasets/fundus-images/diabetic_retinopathy_manualsegm.zip)，无需解压，可以直接运行以下命令，准备 HRF 数据集：
+
+```shell
+python tools/dataset_converters/hrf.py /path/to/healthy.zip /path/to/healthy_manualsegm.zip /path/to/glaucoma.zip /path/to/glaucoma_manualsegm.zip /path/to/diabetic_retinopathy.zip /path/to/diabetic_retinopathy_manualsegm.zip
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## STARE
+
+请下载 [stare images.tar](http://cecas.clemson.edu/~ahoover/stare/probing/stare-images.tar)、[labels-ah.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-ah.tar) 和 [labels-vk.tar](http://cecas.clemson.edu/~ahoover/stare/probing/labels-vk.tar)，无需解压，可以直接运行以下命令，准备 STARE 数据集：
+
+```shell
+python tools/dataset_converters/stare.py /path/to/stare-images.tar /path/to/labels-ah.tar /path/to/labels-vk.tar
+```
+
+该脚本将自动调整数据集目录结构，使其满足 MMSegmentation 数据集加载要求。
+
+## Dark Zurich
+
+由于我们只支持在此数据集上的模型测试，因此您只需要下载并解压[验证数据集](https://data.vision.ee.ethz.ch/csakarid/shared/GCMA_UIoU/Dark_Zurich_val_anon.zip)。
+
+## Nighttime Driving
+
+由于我们只支持在此数据集上的模型测试，因此您只需要下载并解压[验证数据集](http://data.vision.ee.ethz.ch/daid/NighttimeDriving/NighttimeDrivingTest.zip)。
+
+## LoveDA
+
+数据可以从[此处](https://drive.google.com/drive/folders/1ibYV0qwn4yuuh068Rnc-w4tPi0U0c-ti?usp=sharing)下载 LaveDA 数据集。
+
+或者可以从 [zenodo](https://zenodo.org/record/5706578#.YZvN7SYRXdF) 下载。下载后，无需解压，直接运行以下命令：
+
+```shell
+# 下载 Train.zip
+wget https://zenodo.org/record/5706578/files/Train.zip
+# 下载 Val.zip
+wget https://zenodo.org/record/5706578/files/Val.zip
+# 下载 Test.zip
+wget https://zenodo.org/record/5706578/files/Test.zip
+```
+
+请对于 LoveDA 数据集，请运行以下命令调整数据集目录。
+
+```shell
+python tools/dataset_converters/loveda.py /path/to/loveDA
+```
+
+可将模型对 LoveDA 的测试集的预测结果上传至到数据集[测试服务器](https://codalab.lisn.upsaclay.fr/competitions/421)，查看评测结果。
+
+有关 LoveDA 的更多详细信息，可查看[此处](https://github.com/Junjue-Wang/LoveDA).
+
+## ISPRS Potsdam
+
+[Potsdam](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-potsdam.aspx) 城市语义分割数据集用于 2D 语义分割竞赛 —— Potsdam。
+
+数据集可以在竞赛[主页](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx)上请求获得。
+这里也提供了[BaiduNetdisk](https://pan.baidu.com/s/1K-cLVZnd1X7d8c26FQ-nGg?pwd=mseg)，提取码：mseg、 [Google Drive](https://drive.google.com/drive/folders/1w3EJuyUGet6_qmLwGAWZ9vw5ogeG0zLz?usp=sharing)以及[OpenDataLab](https://opendatalab.com/ISPRS_Potsdam/download)。
+实验中需要下载 '2_Ortho_RGB.zip' 和 '5_Labels_all_noBoundary.zip'。
+
+对于 Potsdam 数据集，请运行以下命令调整数据集目录。
+
+```shell
+python tools/dataset_converters/potsdam.py /path/to/potsdam
+```
+
+在我们的默认设置中，将生成 3456 张图像用于训练和 2016 张图像用于验证。
+
+## ISPRS Vaihingen
+
+[Vaihingen](https://www.isprs.org/education/benchmarks/UrbanSemLab/2d-sem-label-vaihingen.aspx) 城市语义分割数据集用于 2D 语义分割竞赛 —— Vaihingen。
+
+数据集可以在竞赛[主页](https://www.isprs.org/education/benchmarks/UrbanSemLab/default.aspx)上请求获得。
+这里也提供了[BaiduNetdisk](https://pan.baidu.com/s/109D3WLrLafsuYtLeerLiiA?pwd=mseg)，提取码：mseg 、 [Google Drive](https://drive.google.com/drive/folders/1w3NhvLVA2myVZqOn2pbiDXngNC7NTP_t?usp=sharing)。
+实验中需要下载 'ISPRS_semantic_labeling_Vaihingen.zip' 和 'ISPRS_semantic_labeling_Vaihingen_ground_truth_eroded_COMPLETE.zip'。
+
+对于 Vaihingen 数据集，请运行以下命令调整数据集目录。
+
+```shell
+python tools/dataset_converters/vaihingen.py /path/to/vaihingen
+```
+
+在我们的默认设置（`clip_size`=512, `stride_size`=256）中，将生成 344 张图像用于训练和 398 张图像用于验证。
+
+## iSAID
+
+iSAID 数据集可从 [DOTA-v1.0](https://captain-whu.github.io/DOTA/dataset.html) 下载训练/验证/测试数据集的图像数据，
+
+并从 [iSAID](https://captain-whu.github.io/iSAID/dataset.html)下载训练/验证数据集的标注数据。
+
+该数据集是航空图像实例分割和语义分割任务的大规模数据集。
+
+下载 iSAID 数据集后，您可能需要按照以下结构进行数据集准备。
+
+```none
+├── data
+│ ├── iSAID
+│ │ ├── train
+│ │ │ ├── images
+│ │ │ │ ├── part1.zip
+│ │ │ │ ├── part2.zip
+│ │ │ │ ├── part3.zip
+│ │ │ ├── Semantic_masks
+│ │ │ │ ├── images.zip
+│ │ ├── val
+│ │ │ ├── images
+│ │ │ │ ├── part1.zip
+│ │ │ ├── Semantic_masks
+│ │ │ │ ├── images.zip
+│ │ ├── test
+│ │ │ ├── images
+│ │ │ │ ├── part1.zip
+│ │ │ │ ├── part2.zip
+```
+
+```shell
+python tools/dataset_converters/isaid.py /path/to/iSAID
+```
+
+在我们的默认设置（`patch_width`=896, `patch_height`=896, `overlap_area`=384）中，将生成 33978 张图像用于训练和 11644 张图像用于验证。
+
+## LIP(Look Into Person) dataset
+
+该数据集可以从[此页面](https://lip.sysuhcp.com/overview.php)下载。
+
+请运行以下命令来解压数据集。
+
+```shell
+unzip LIP.zip
+cd LIP
+unzip TrainVal_images.zip
+unzip TrainVal_parsing_annotations.zip
+cd TrainVal_parsing_annotations
+unzip TrainVal_parsing_annotations.zip
+mv train_segmentations ../
+mv val_segmentations ../
+cd ..
+```
+
+LIP 数据集的内容包括：
+
+```none
+├── data
+│ ├── LIP
+│ │ ├── train_images
+│ │ │ ├── 1000_1234574.jpg
+│ │ │ ├── ...
+│ │ ├── train_segmentations
+│ │ │ ├── 1000_1234574.png
+│ │ │ ├── ...
+│ │ ├── val_images
+│ │ │ ├── 100034_483681.jpg
+│ │ │ ├── ...
+│ │ ├── val_segmentations
+│ │ │ ├── 100034_483681.png
+│ │ │ ├── ...
+```
+
+## Synapse dataset
+
+此数据集可以从[此页面](https://www.synapse.org/#!Synapse:syn3193805/wiki/)下载。
+
+遵循 [TransUNet](https://arxiv.org/abs/2102.04306) 的数据准备设定，将原始训练集（30 次扫描）拆分为新的训练集（18 次扫描）和验证集（12 次扫描）。请运行以下命令来准备数据集。
+
+```shell
+unzip RawData.zip
+cd ./RawData/Training
+```
+
+然后创建 `train.txt` 和 `val.txt` 以拆分数据集。
+
+根据 TransUnet，以下是数据集的划分。
+
+train.txt
+
+```none
+img0005.nii.gz
+img0006.nii.gz
+img0007.nii.gz
+img0009.nii.gz
+img0010.nii.gz
+img0021.nii.gz
+img0023.nii.gz
+img0024.nii.gz
+img0026.nii.gz
+img0027.nii.gz
+img0028.nii.gz
+img0030.nii.gz
+img0031.nii.gz
+img0033.nii.gz
+img0034.nii.gz
+img0037.nii.gz
+img0039.nii.gz
+img0040.nii.gz
+```
+
+val.txt
+
+```none
+img0008.nii.gz
+img0022.nii.gz
+img0038.nii.gz
+img0036.nii.gz
+img0032.nii.gz
+img0002.nii.gz
+img0029.nii.gz
+img0003.nii.gz
+img0001.nii.gz
+img0004.nii.gz
+img0025.nii.gz
+img0035.nii.gz
+```
+
+synapse 数据集的内容包括：
+
+```none
+├── Training
+│ ├── img
+│ │ ├── img0001.nii.gz
+│ │ ├── img0002.nii.gz
+│ │ ├── ...
+│ ├── label
+│ │ ├── label0001.nii.gz
+│ │ ├── label0002.nii.gz
+│ │ ├── ...
+│ ├── train.txt
+│ ├── val.txt
+```
+
+然后，使用此命令转换 synapse 数据集。
+
+```shell
+python tools/dataset_converters/synapse.py --dataset-path /path/to/synapse
+```
+
+注意，MMSegmentation 的默认评估指标（例如 mean dice value）是在 2D 切片图像上计算的，这与 [TransUNet](https://arxiv.org/abs/2102.04306) 等一些论文中的 3D 扫描结果是不同的。
+
+## REFUGE
+
+在 [REFUGE Challenge](https://refuge.grand-challenge.org) 官网上注册并下载 [REFUGE 数据集](https://refuge.grand-challenge.org/REFUGE2Download)。
+
+然后，解压 `REFUGE2.zip`，原始数据集的内容包括：
+
+```none
+├── REFUGE2
+│ ├── REFUGE2
+│ │ ├── Annotation-Training400.zip
+│ │ ├── REFUGE-Test400.zip
+│ │ ├── REFUGE-Test-GT.zip
+│ │ ├── REFUGE-Training400.zip
+│ │ ├── REFUGE-Validation400.zip
+│ │ ├── REFUGE-Validation400-GT.zip
+│ ├── __MACOSX
+```
+
+请运行以下命令转换 REFUGE 数据集：
+
+```shell
+python tools/convert_datasets/refuge.py --raw_data_root=/path/to/refuge/REFUGE2/REFUGE2
+```
+
+脚本会将目录结构转换如下：
+
+```none
+│ ├── REFUGE
+│ │ ├── images
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── test
+│ │ ├── annotations
+│ │ │ ├── training
+│ │ │ ├── validation
+│ │ │ ├── test
+```
+
+包含 400 张用于训练的图像、400 张用于验证的图像和 400 张用于测试的图像，这与 REFUGE 2018 数据集相同。
+
+## Mapillary Vistas Datasets
+
+- Mapillary Vistas [官方网站](https://www.mapillary.com/dataset/vistas) 可以下载 Mapillary Vistas 数据集，按照官网要求注册并登陆后，数据可以在[这里](https://www.mapillary.com/dataset/vistas)找到。
+
+- Mapillary Vistas 数据集使用 8-bit with color-palette 来存储标签。不需要进行转换操作。
+
+- 假设您已将数据集 zip 文件放在 `mmsegmentation/data/mapillary` 中
+
+- 请运行以下命令来解压数据集。
+
+ ```bash
+ cd data/mapillary
+ unzip An-ZjB1Zm61yAZG0ozTymz8I8NqI4x0MrYrh26dq7kPgfu8vf9ImrdaOAVOFYbJ2pNAgUnVGBmbue9lTgdBOb5BbKXIpFs0fpYWqACbrQDChAA2fdX0zS9PcHu7fY8c-FOvyBVxPNYNFQuM.zip
+ ```
+
+- 解压后，您将获得类似于此结构的 Mapillary Vistas 数据集。语义分割 mask 标签在 `labels` 文件夹中。
+
+ ```none
+ mmsegmentation
+ ├── mmseg
+ ├── tools
+ ├── configs
+ ├── data
+ │ ├── mapillary
+ │ │ ├── training
+ │ │ │ ├── images
+ │ │ │ ├── v1.2
+ | │ │ │ ├── instances
+ | │ │ │ ├── labels
+ | │ │ │ └── panoptic
+ │ │ │ ├── v2.0
+ | │ │ │ ├── instances
+ | │ │ │ ├── labels
+ | │ │ │ ├── panoptic
+ | │ │ │ └── polygons
+ │ │ ├── validation
+ │ │ │ ├── images
+ | │ │ ├── v1.2
+ | │ │ │ ├── instances
+ | │ │ │ ├── labels
+ | │ │ │ └── panoptic
+ │ │ │ ├── v2.0
+ | │ │ │ ├── instances
+ | │ │ │ ├── labels
+ | │ │ │ ├── panoptic
+ | │ │ │ └── polygons
+ ```
+
+- 您可以在配置中使用 `MapillaryDataset_v1` 和 `Mapillary Dataset_v2` 设置数据集版本。
+ 在此处 [V1.2](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v1.py) 和 [V2.0](https://github.com/open-mmlab/mmsegmentation/blob/main/configs/_base_/datasets/mapillary_v2.py) 查看 Mapillary Vistas 数据集配置文件
+
+## LEVIR-CD
+
+[LEVIR-CD](https://justchenhao.github.io/LEVIR/) 大规模遥感建筑变化检测数据集。
+
+数据集可以在[主页](https://justchenhao.github.io/LEVIR/)上请求获得。
+
+数据集的补充版本可以在[主页](https://github.com/S2Looking/Dataset)上请求获得。
+
+请下载数据集的补充版本，然后解压 `LEVIR-CD+.zip`，数据集的内容包括：
+
+```none
+│ ├── LEVIR-CD+
+│ │ ├── train
+│ │ │ ├── A
+│ │ │ ├── B
+│ │ │ ├── label
+│ │ ├── test
+│ │ │ ├── A
+│ │ │ ├── B
+│ │ │ ├── label
+```
+
+对于 LEVIR-CD 数据集，请运行以下命令无重叠裁剪影像：
+
+```shell
+python tools/dataset_converters/levircd.py --dataset-path /path/to/LEVIR-CD+ --out_dir /path/to/LEVIR-CD
+```
+
+裁剪后的影像大小为256x256，与原论文保持一致。
+
+## BDD100K
+
+- 可以从[官方网站](https://bdd-data.berkeley.edu/) 下载 BDD100K数据集（语义分割任务主要是10K数据集），按照官网要求注册并登陆后，数据可以在[这里](https://bdd-data.berkeley.edu/portal.html#download)找到。
+
+- 图像数据对应的名称是是`10K Images`, 语义分割标注对应的名称是`Segmentation`
+
+- 下载后，可以使用以下代码进行解压
+
+ ```bash
+ unzip ~/bdd100k_images_10k.zip -d ~/mmsegmentation/data/
+ unzip ~/bdd100k_sem_seg_labels_trainval.zip -d ~/mmsegmentation/data/
+ ```
+
+就可以得到以下文件结构了：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│ ├── bdd100k
+│ │ ├── images
+│ │ │ └── 10k
+| │ │ │ ├── test
+| │ │ │ ├── train
+| │ │ │ └── val
+│ │ └── labels
+│ │ │ └── sem_seg
+| │ │ │ ├── colormaps
+| │ │ │ │ ├──train
+| │ │ │ │ └──val
+| │ │ │ ├── masks
+| │ │ │ │ ├──train
+| │ │ │ │ └──val
+| │ │ │ ├── polygons
+| │ │ │ │ ├──sem_seg_train.json
+| │ │ │ │ └──sem_seg_val.json
+| │ │ │ └── rles
+| │ │ │ │ ├──sem_seg_train.json
+| │ │ │ │ └──sem_seg_val.json
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/3_inference.md b/internlm_langchain/knowledge_base/MMSegmentation/content/3_inference.md
new file mode 100644
index 00000000..0afcb4b0
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/3_inference.md
@@ -0,0 +1,244 @@
+# 教程3：使用预训练模型推理
+
+MMSegmentation 在 [Model Zoo](../Model_Zoo.md) 中为语义分割提供了预训练的模型，并支持多个标准数据集，包括 Cityscapes、ADE20K 等。
+本说明将展示如何使用现有模型对给定图像进行推理。
+关于如何在标准数据集上测试现有模型，请参阅本[指南](./4_train_test.md)
+
+MMSegmentation 为用户提供了数个接口，以便轻松使用预训练的模型进行推理。
+
+- [教程3：使用预训练模型推理](#教程3使用预训练模型推理)
+ - [推理器](#推理器)
+ - [基本使用](#基本使用)
+ - [初始化](#初始化)
+ - [可视化预测结果](#可视化预测结果)
+ - [模型列表](#模型列表)
+ - [推理 API](#推理-api)
+ - [mmseg.apis.init_model](#mmsegapisinit_model)
+ - [mmseg.apis.inference_model](#mmsegapisinference_model)
+ - [mmseg.apis.show_result_pyplot](#mmsegapisshow_result_pyplot)
+
+## 推理器
+
+在 MMSegmentation 中，我们提供了最**方便的**方式 `MMSegInferencer` 来使用模型。您只需 3 行代码就可以获得图像的分割掩膜。
+
+### 基本使用
+
+以下示例展示了如何使用 `MMSegInferencer` 对单个图像执行推理。
+
+```
+>>> from mmseg.apis import MMSegInferencer
+>>> # 将模型加载到内存中
+>>> inferencer = MMSegInferencer(model='deeplabv3plus_r18-d8_4xb2-80k_cityscapes-512x1024')
+>>> # 推理
+>>> inferencer('demo/demo.png', show=True)
+```
+
+可视化结果应如下所示：
+
+
+
+ 
+
+
+此外，您可以使用 `MMSegInferencer` 来处理一个包含多张图片的 `list`：
+
+```
+# 输入一个图片 list
+>>> images = [image1, image2, ...] # image1 可以是文件路径或 np.ndarray
+>>> inferencer(images, show=True, wait_time=0.5) # wait_time 是延迟时间，0 表示无限
+
+# 或输入图像目录
+>>> images = $IMAGESDIR
+>>> inferencer(images, show=True, wait_time=0.5)
+
+# 保存可视化渲染彩色分割图和预测结果
+# out_dir 是保存输出结果的目录，img_out_dir 和 pred_out_dir 为 out_dir 的子目录
+# 以保存可视化渲染彩色分割图和预测结果
+>>> inferencer(images, out_dir='outputs', img_out_dir='vis', pred_out_dir='pred')
+```
+
+推理器有一个可选参数 `return_datasamples`，其默认值为 False，推理器的返回值默认为 `dict` 类型，包括 'visualization' 和 'predictions' 两个 key。
+如果 `return_datasamples=True` 推理器将返回 [`SegDataSample`](../advanced_guides/structures.md) 或其列表。
+
+```
+result = inferencer('demo/demo.png')
+# 结果是一个包含 'visualization' 和 'predictions' 两个 key 的 `dict`
+# 'visualization' 包含彩色分割图
+print(result['visualization'].shape)
+# (512, 683, 3)
+
+# 'predictions' 包含带有标签索引的分割掩膜
+print(result['predictions'].shape)
+# (512, 683)
+
+result = inferencer('demo/demo.png', return_datasamples=True)
+print(type(result))
+#
+
+
+### 2.4 切换分支为 dev-1.x
+
+正如您在[ mmsegmentation 官网](https://github.com/open-mmlab/mmsegmentation/tree/main)所见，该仓库有许多分支，默认分支`main`为稳定的发行版本，以及用于贡献者进行开发的`dev-1.x`分支。`dev-1.x`分支是贡献者们用来提交创意和 PR 的分支，`dev-1.x`分支的内容会被周期性的合入到`main`分支。
+
+
+回到 VSCODE 中，在终端执行命令
+
+```bash
+git checkout dev-1.x
+```
+
+### 2.5 创新属于自己的新分支
+
+在基于`dev-1.x`分支下，使用如下命令，创建属于您自己的分支。
+
+```bash
+# git checkout -b 您的GitHubID/您的分支想要实现的功能的名字
+# git checkout -b AI-Tianlong/support_GID_dataset
+git checkout -b {您的GitHubID/您的分支想要实现的功能的名字}
+```
+
+### 2.6 配置 pre-commit
+
+OpenMMLab 仓库对代码质量有着较高的要求，所有提交的 PR 必须要通过代码格式检查。pre-commit 详细配置参阅[配置 pre-commit](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html#pre-commit)。
+
+## 步骤 3：在`mmsegmentation/projects`下贡献您的代码
+
+**先对 GID 数据集进行分析**
+
+这里以贡献高分 2 号遥感图像语义分割数据集 GID 为例，GID 数据集是由我国自主研发的高分 2 号卫星所拍摄的光学遥感图像所创建，经图像预处理后共提供了 150 张 6800x7200 像素的 RGB 三通道遥感图像。并提供了两种不同类别数的数据标注，一种是包含 5 类有效物体的 RGB 标签，另一种是包含 15 类有效物体的 RGB 标签。本教程将针对 5 类标签进行数据集贡献流程讲解。
+
+GID 的 5 类有效标签分别为：0-背景-\[0,0,0\](mask 标签值-标签名称-RGB 标签值)、1-建筑-\[255,0,0\]、2-农田-\[0,255,0\]、3-森林-\[0,0,255\]、4-草地-\[255,255,0\]、5-水-\[0,0,255\]。在语义分割任务中，标签是与原图尺寸一致的单通道图像，标签图像中的像素值为真实样本图像中对应像素所包含的物体的类别。GID 数据集提供的是具有 RGB 三通道的彩色标签，为了模型的训练需要将 RGB 标签转换为 mask 标签。并且由于图像尺寸为 6800x7200 像素，对于神经网络的训练来有些过大，所以将每张图像裁切成了没有重叠的 512x512 的图像以便进行训练。
+
+
+### 3.1 在`mmsegmentation/projects`下创建新的项目文件夹
+
+在`mmsegmentation/projects`下创建文件夹`gid_dataset`
+
+
+### 3.2 贡献您的数据集代码
+
+为了最终能将您在 projects 中贡献的代码更加顺畅的移入核心库中（对代码要求质量更高），非常建议按照核心库的目录来编辑您的数据集文件。
+关于数据集有 4 个必要的文件：
+
+- **1** `mmseg/datasets/gid.py` 定义了数据集的尾缀、CLASSES、PALETTE、reduce_zero_label等
+- **2** `configs/_base_/gid.py` GID 数据集的配置文件，定义了数据集的`dataset_type`（数据集类型，`mmseg/datasets/gid.py`中注册的数据集的类名）、`data_root`(数据集所在的根目录，建议将数据集通过软连接的方式将数据集放至`mmsegmentation/data`)、`train_pipline`(训练的数据流)、`test_pipline`(测试和验证时的数据流)、`img_rations`(多尺度预测时的多尺度配置)、`tta_pipeline`（多尺度预测）、`train_dataloader`(训练集的数据加载器)、`val_dataloader`(验证集的数据加载器)、`test_dataloader`(测试集的数据加载器)、`val_evaluator`(验证集的评估器)、`test_evaluator`(测试集的评估器)。
+- **3** 使用了 GID 数据集的模型训练配置文件
+ 这个是可选的，但是强烈建议您添加。在核心库中，所贡献的数据集需要和参考文献中所提出的结果精度对齐，为了后期将您贡献的代码合并入核心库。如您的算力充足，最好能提供对应的模型配置文件在您贡献的数据集上所验证的结果以及相应的权重文件，并撰写较为详细的README.md文档。[示例参考结果](https://github.com/open-mmlab/mmsegmentation/tree/main/configs/deeplabv3plus#mapillary-vistas-v12)
+ 
+- **4** 使用如下命令格式： 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`来添加您的数据集介绍，包括但不限于数据集的下载方式，数据集目录结构、数据集生成等一些必要性的文字性描述和运行命令。以更好地帮助用户能更快的实现数据集的准备工作。
+
+### 3.3 贡献`tools/dataset_converters/gid.py`
+
+由于 GID 数据集是由未经过切分的 6800x7200 图像所构成的数据集，并且没有划分训练集、验证集与测试集。以及其标签为 RGB 彩色标签，需要将标签转换为单通道的 mask label。为了方便训练，首先将 GID 数据集进行裁切和标签转换，并进行数据集划分，构建为 mmsegmentation 所支持的格式。
+
+```python
+# tools/dataset_converters/gid.py
+import argparse
+import glob
+import math
+import os
+import os.path as osp
+from PIL import Image
+
+import mmcv
+import numpy as np
+from mmengine.utils import ProgressBar, mkdir_or_exist
+
+def parse_args():
+ parser = argparse.ArgumentParser(
+ description='Convert GID dataset to mmsegmentation format')
+ parser.add_argument('dataset_img_path', help='GID images folder path')
+ parser.add_argument('dataset_label_path', help='GID labels folder path')
+ parser.add_argument('--tmp_dir', help='path of the temporary directory')
+ parser.add_argument('-o', '--out_dir', help='output path', default='data/gid')
+ parser.add_argument(
+ '--clip_size',
+ type=int,
+ help='clipped size of image after preparation',
+ default=256)
+ parser.add_argument(
+ '--stride_size',
+ type=int,
+ help='stride of clipping original images',
+ default=256)
+ args = parser.parse_args()
+ return args
+
+GID_COLORMAP = dict(
+ Background=(0, 0, 0), #0-背景-黑色
+ Building=(255, 0, 0), #1-建筑-红色
+ Farmland=(0, 255, 0), #2-农田-绿色
+ Forest=(0, 0, 255), #3-森林-蓝色
+ Meadow=(255, 255, 0),#4-草地-黄色
+ Water=(0, 0, 255)#5-水-蓝色
+)
+palette = list(GID_COLORMAP.values())
+classes = list(GID_COLORMAP.keys())
+
+#############用列表来存一个 RGB 和一个类别的对应################
+def colormap2label(palette):
+ colormap2label_list = np.zeros(256**3, dtype = np.longlong)
+ for i, colormap in enumerate(palette):
+ colormap2label_list[(colormap[0] * 256 + colormap[1])*256+colormap[2]] = i
+ return colormap2label_list
+
+#############给定那个列表，和vis_png然后生成masks_png################
+def label_indices(RGB_label, colormap2label_list):
+ RGB_label = RGB_label.astype('int32')
+ idx = (RGB_label[:, :, 0] * 256 + RGB_label[:, :, 1]) * 256 + RGB_label[:, :, 2]
+ # print(idx.shape)
+ return colormap2label_list[idx]
+
+def RGB2mask(RGB_label, colormap2label_list):
+ # RGB_label = np.array(Image.open(RGB_label).convert('RGB')) #打开RGB_png
+ mask_label = label_indices(RGB_label, colormap2label_list) # .numpy()
+ return mask_label
+
+colormap2label_list = colormap2label(palette)
+
+def clip_big_image(image_path, clip_save_dir, args, to_label=False):
+ """
+ Original image of GID dataset is very large, thus pre-processing
+ of them is adopted. Given fixed clip size and stride size to generate
+ clipped image, the intersection of width and height is determined.
+ For example, given one 6800 x 7200 original image, the clip size is
+ 256 and stride size is 256, thus it would generate 29 x 27 = 783 images
+ whose size are all 256 x 256.
+
+ """
+
+ image = mmcv.imread(image_path, channel_order='rgb')
+ # image = mmcv.bgr2gray(image)
+
+ h, w, c = image.shape
+ clip_size = args.clip_size
+ stride_size = args.stride_size
+
+ num_rows = math.ceil((h - clip_size) / stride_size) if math.ceil(
+ (h - clip_size) /
+ stride_size) * stride_size + clip_size >= h else math.ceil(
+ (h - clip_size) / stride_size) + 1
+ num_cols = math.ceil((w - clip_size) / stride_size) if math.ceil(
+ (w - clip_size) /
+ stride_size) * stride_size + clip_size >= w else math.ceil(
+ (w - clip_size) / stride_size) + 1
+
+ x, y = np.meshgrid(np.arange(num_cols + 1), np.arange(num_rows + 1))
+ xmin = x * clip_size
+ ymin = y * clip_size
+
+ xmin = xmin.ravel()
+ ymin = ymin.ravel()
+ xmin_offset = np.where(xmin + clip_size > w, w - xmin - clip_size,
+ np.zeros_like(xmin))
+ ymin_offset = np.where(ymin + clip_size > h, h - ymin - clip_size,
+ np.zeros_like(ymin))
+ boxes = np.stack([
+ xmin + xmin_offset, ymin + ymin_offset,
+ np.minimum(xmin + clip_size, w),
+ np.minimum(ymin + clip_size, h)
+ ], axis=1)
+
+ if to_label:
+ image = RGB2mask(image, colormap2label_list) #这里得改一下
+
+ for count, box in enumerate(boxes):
+ start_x, start_y, end_x, end_y = box
+ clipped_image = image[start_y:end_y,
+ start_x:end_x] if to_label else image[
+ start_y:end_y, start_x:end_x, :]
+ img_name = osp.basename(image_path).replace('.tif', '')
+ img_name = img_name.replace('_label', '')
+ if count % 3 == 0:
+ mmcv.imwrite(
+ clipped_image.astype(np.uint8),
+ osp.join(
+ clip_save_dir.replace('train', 'val'),
+ f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+ else:
+ mmcv.imwrite(
+ clipped_image.astype(np.uint8),
+ osp.join(
+ clip_save_dir,
+ f'{img_name}_{start_x}_{start_y}_{end_x}_{end_y}.png'))
+ count += 1
+
+def main():
+ args = parse_args()
+
+ """
+ According to this paper: https://ieeexplore.ieee.org/document/9343296/
+ select 15 images contained in GID, , which cover the whole six
+ categories, to generate train set and validation set.
+
+ According to Paper: https://ieeexplore.ieee.org/document/9343296/
+
+ """
+
+ if args.out_dir is None:
+ out_dir = osp.join('data', 'gid')
+ else:
+ out_dir = args.out_dir
+
+ print('Making directories...')
+ mkdir_or_exist(osp.join(out_dir, 'img_dir', 'train'))
+ mkdir_or_exist(osp.join(out_dir, 'img_dir', 'val'))
+ mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'train'))
+ mkdir_or_exist(osp.join(out_dir, 'ann_dir', 'val'))
+
+ src_path_list = glob.glob(os.path.join(args.dataset_img_path, '*.tif'))
+ print(f'Find {len(src_path_list)} pictures')
+
+ prog_bar = ProgressBar(len(src_path_list))
+
+ dst_img_dir = osp.join(out_dir, 'img_dir', 'train')
+ dst_label_dir = osp.join(out_dir, 'ann_dir', 'train')
+
+ for i, img_path in enumerate(src_path_list):
+ label_path = osp.join(args.dataset_label_path, osp.basename(img_path.replace('.tif', '_label.tif')))
+
+ clip_big_image(img_path, dst_img_dir, args, to_label=False)
+ clip_big_image(label_path, dst_label_dir, args, to_label=True)
+ prog_bar.update()
+
+ print('Done!')
+
+if __name__ == '__main__':
+ main()
+```
+
+### 3.4 贡献`mmseg/datasets/gid.py`
+
+可参考[`projects/mapillary_dataset/mmseg/datasets/mapillary.py`](https://github.com/open-mmlab/mmsegmentation/blob/main/projects/mapillary_dataset/mmseg/datasets/mapillary.py)并在此基础上修改相应变量以适配您的数据集。
+
+```python
+# mmseg/datasets/gid.py
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmseg.datasets.basesegdataset import BaseSegDataset
+from mmseg.registry import DATASETS
+
+# 注册数据集类
+@DATASETS.register_module()
+class GID_Dataset(BaseSegDataset):
+ """Gaofen Image Dataset (GID)
+
+ Dataset paper link:
+ https://www.sciencedirect.com/science/article/pii/S0034425719303414
+ https://x-ytong.github.io/project/GID.html
+
+ GID 6 classes: background(others), built-up, farmland, forest, meadow, water
+
+ In This example, select 10 images from GID dataset as training set,
+ and select 5 images as validation set.
+ The selected images are listed as follows:
+
+ GF2_PMS1__L1A0000647767-MSS1
+ GF2_PMS1__L1A0001064454-MSS1
+ GF2_PMS1__L1A0001348919-MSS1
+ GF2_PMS1__L1A0001680851-MSS1
+ GF2_PMS1__L1A0001680853-MSS1
+ GF2_PMS1__L1A0001680857-MSS1
+ GF2_PMS1__L1A0001757429-MSS1
+ GF2_PMS2__L1A0000607681-MSS2
+ GF2_PMS2__L1A0000635115-MSS2
+ GF2_PMS2__L1A0000658637-MSS2
+ GF2_PMS2__L1A0001206072-MSS2
+ GF2_PMS2__L1A0001471436-MSS2
+ GF2_PMS2__L1A0001642620-MSS2
+ GF2_PMS2__L1A0001787089-MSS2
+ GF2_PMS2__L1A0001838560-MSS2
+
+ The ``img_suffix`` is fixed to '.tif' and ``seg_map_suffix`` is
+ fixed to '.tif' for GID.
+ """
+ METAINFO = dict(
+ classes=('Others', 'Built-up', 'Farmland', 'Forest',
+ 'Meadow', 'Water'),
+
+ palette=[[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 255, 255],
+ [255, 255, 0], [0, 0, 255]])
+
+ def __init__(self,
+ img_suffix='.png',
+ seg_map_suffix='.png',
+ reduce_zero_label=None,
+ **kwargs) -> None:
+ super().__init__(
+ img_suffix=img_suffix,
+ seg_map_suffix=seg_map_suffix,
+ reduce_zero_label=reduce_zero_label,
+ **kwargs)
+```
+
+### 3.5 贡献使用 GID 的训练 config file
+
+```python
+_base_ = [
+ '../../../configs/_base_/models/deeplabv3plus_r50-d8.py',
+ './_base_/datasets/gid.py',
+ '../../../configs/_base_/default_runtime.py',
+ '../../../configs/_base_/schedules/schedule_240k.py'
+]
+custom_imports = dict(
+ imports=['projects.gid_dataset.mmseg.datasets.gid'])
+
+crop_size = (256, 256)
+data_preprocessor = dict(size=crop_size)
+model = dict(
+ data_preprocessor=data_preprocessor,
+ pretrained='open-mmlab://resnet101_v1c',
+ backbone=dict(depth=101),
+ decode_head=dict(num_classes=6),
+ auxiliary_head=dict(num_classes=6))
+
+```
+
+### 3.6 撰写`docs/zh_cn/user_guides/2_dataset_prepare.md`
+
+**Gaofen Image Dataset (GID)**
+
+- GID 数据集可在[此处](https://x-ytong.github.io/project/Five-Billion-Pixels.html)进行下载。
+- GID 数据集包含 150 张 6800x7200 的大尺寸图像，标签为 RGB 标签。
+- 此处选择 15 张图像生成训练集和验证集，该 15 张图像包含了所有六类信息。所选的图像名称如下：
+
+```None
+ GF2_PMS1__L1A0000647767-MSS1
+ GF2_PMS1__L1A0001064454-MSS1
+ GF2_PMS1__L1A0001348919-MSS1
+ GF2_PMS1__L1A0001680851-MSS1
+ GF2_PMS1__L1A0001680853-MSS1
+ GF2_PMS1__L1A0001680857-MSS1
+ GF2_PMS1__L1A0001757429-MSS1
+ GF2_PMS2__L1A0000607681-MSS2
+ GF2_PMS2__L1A0000635115-MSS2
+ GF2_PMS2__L1A0000658637-MSS2
+ GF2_PMS2__L1A0001206072-MSS2
+ GF2_PMS2__L1A0001471436-MSS2
+ GF2_PMS2__L1A0001642620-MSS2
+ GF2_PMS2__L1A0001787089-MSS2
+ GF2_PMS2__L1A0001838560-MSS2
+```
+
+执行以下命令进行裁切及标签的转换，需要修改为您所存储 15 张图像及标签的路径。
+
+```
+python projects/gid_dataset/tools/dataset_converters/gid.py [15 张图像的路径] [15 张标签的路径]
+```
+
+完成裁切后的 GID 数据结构如下：
+
+```none
+mmsegmentation
+├── mmseg
+├── tools
+├── configs
+├── data
+│ ├── gid
+│ │ ├── ann_dir
+| │ │ │ ├── train
+| │ │ │ ├── val
+│ │ ├── img_dir
+| │ │ │ ├── train
+| │ │ │ ├── val
+
+```
+
+### 3.7 贡献的代码及文档通过`pre-commit`检查
+
+使用命令
+
+```bash
+git add .
+git commit -m "添加描述"
+git push
+```
+
+### 3.8 在 GitHub 中向 mmsegmentation 提交 PR
+
+具体步骤可见[《OpenMMLab 贡献代码指南》](https://mmcv.readthedocs.io/zh_CN/latest/community/contributing.html)
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/customize_runtime.md b/internlm_langchain/knowledge_base/MMSegmentation/content/customize_runtime.md
new file mode 100644
index 00000000..a80aca63
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/customize_runtime.md
@@ -0,0 +1,162 @@
+# 自定义运行设定
+
+## 实现自定义钩子
+
+### Step 1: 创建一个新的钩子
+
+MMEngine 已实现了训练和测试常用的[钩子](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md),
+当有定制化需求时, 可以按照如下示例实现适用于自身训练需求的钩子, 例如想修改一个超参数 `model.hyper_paramete` 的值, 让它随着训练迭代次数而变化:
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence
+
+from mmengine.hooks import Hook
+from mmengine.model import is_model_wrapper
+
+from mmseg.registry import HOOKS
+
+
+@HOOKS.register_module()
+class NewHook(Hook):
+ """Docstring for NewHook.
+ """
+
+ def __init__(self, a: int, b: int) -> None:
+ self.a = a
+ self.b = b
+
+ def before_train_iter(self,
+ runner,
+ batch_idx: int,
+ data_batch: Optional[Sequence[dict]] = None) -> None:
+ cur_iter = runner.iter
+ # 当模型被包在 wrapper 里时获取这个模型
+ if is_model_wrapper(runner.model):
+ model = runner.model.module
+ model.hyper_parameter = self.a * cur_iter + self.b
+```
+
+### Step 2: 导入一个新的钩子
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
+假设 NewHook 在 `mmseg/engine/hooks/new_hook.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/hooks/__init__.py` 来导入它.
+ 新定义的模块应该在 `mmseg/engine/hooks/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .new_hook import NewHook
+
+__all__ = [..., NewHook]
+```
+
+- 在配置文件里使用 custom_imports 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.hooks.new_hook'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+可以按照如下方式, 在训练或测试中配置并使用自定义的钩子. 不同钩子在同一位点的优先级可以参考[这里](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md#%E5%86%85%E7%BD%AE%E9%92%A9%E5%AD%90), 自定义钩子如果没有指定优先, 默认是 `NORMAL`.
+
+```python
+custom_hooks = [
+ dict(type='NewHook', a=a_value, b=b_value, priority='ABOVE_NORMAL')
+]
+```
+
+## 实现自定义优化器
+
+### Step 1: 创建一个新的优化器
+
+如果增加一个叫作 `MyOptimizer` 的优化器, 它有参数 `a`, `b` 和 `c`. 推荐在 `mmseg/engine/optimizers/my_optimizer.py` 文件中实现
+
+```python
+from mmseg.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+ def __init__(self, a, b, c)
+```
+
+### Step 2: 导入一个新的优化器
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面,
+假设 `MyOptimizer` 在 `mmseg/engine/optimizers/my_optimizer.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
+ 新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- 在配置文件里使用 `custom_imports` 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+随后需要修改配置文件 `optim_wrapper` 里的 `optimizer` 参数, 如果要使用你自己的优化器 `MyOptimizer`, 字段可以被修改成:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+ optimizer=dict(type='MyOptimizer',
+ a=a_value, b=b_value, c=c_value),
+ clip_grad=None)
+```
+
+## 实现自定义优化器封装构造器
+
+### Step 1: 创建一个新的优化器封装构造器
+
+构造器可以用来创建优化器, 优化器包, 以及自定义模型网络不同层的超参数. 一些模型的优化器可能会根据特定的参数而调整, 例如 BatchNorm 层的 weight decay. 使用者可以通过自定义优化器构造器来精细化设定不同参数的优化策略.
+
+```python
+from mmengine.optim import DefaultOptimWrapperConstructor
+from mmseg.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
+ def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
+
+ def __call__(self, model):
+
+ return my_optimizer
+```
+
+默认的优化器构造器在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L19) 被实现, 它也可以用来作为新的优化器构造器的模板.
+
+### Step 2: 导入一个新的优化器封装构造器
+
+为了让上面定义的模块可以被执行的程序发现, 这个模块需要先被导入主命名空间 (main namespace) 里面, 假设 `MyOptimizerConstructor` 在 `mmseg/engine/optimizers/my_optimizer_constructor.py` 里面, 有两种方式去实现它:
+
+- 修改 `mmseg/engine/optimizers/__init__.py` 来导入它.
+ 新定义的模块应该在 `mmseg/engine/optimizers/__init__.py` 里面导入, 这样注册器可以发现并添加这个新的模块:
+
+```python
+from .my_optimizer_constructor import MyOptimizerConstructor
+```
+
+- 在配置文件里使用 `custom_imports` 来手动导入它.
+
+```python
+custom_imports = dict(imports=['mmseg.engine.optimizers.my_optimizer_constructor'], allow_failed_imports=False)
+```
+
+### Step 3: 修改配置文件
+
+随后需要修改配置文件 `optim_wrapper` 里的 `constructor` 参数, 如果要使用你自己的优化器封装构造器 `MyOptimizerConstructor`, 字段可以被修改成:
+
+```python
+optim_wrapper = dict(type='OptimWrapper',
+ constructor='MyOptimizerConstructor',
+ clip_grad=None)
+```
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/data_flow.md b/internlm_langchain/knowledge_base/MMSegmentation/content/data_flow.md
new file mode 100644
index 00000000..20dbe07e
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/data_flow.md
@@ -0,0 +1,90 @@
+# 数据流
+
+在本章节中，我们将介绍 [Runner](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html) 管理的内部模块之间的数据流和数据格式约定。
+
+## 数据流概述
+
+[Runner](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/design/runner.md) 相当于 MMEngine 中的“集成器”。它覆盖了框架的所有方面，并肩负着组织和调度几乎所有模块的责任，这意味着各模块之间的数据流也由 `Runner` 控制。 如 [MMEngine 中的 Runner 文档](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)所示，下图展示了基本的数据流。
+
+
+
+虚线边框、灰色填充形状代表不同的数据格式，而实心框表示模块/方法。由于 MMEngine 极大的灵活性和可扩展性，一些重要的基类可以被继承，并且它们的方法可以被覆写。 上图所示数据流仅适用于当用户没有自定义 `Runner` 中的 `TrainLoop`、`ValLoop` 和 `TestLoop`，并且没有在其自定义模型中覆写 `train_step`、`val_step` 和 `test_step` 方法时。MMSegmentation 中 loop 的默认设置如下：使用`IterBasedTrainLoop` 训练模型，共计 20000 次迭代，并且在每 2000 次迭代后进行一次验证。
+
+```python
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+```
+
+在上图中，红色线表示 [train_step](./models.md#train_step)，在每次训练迭代中，数据加载器（dataloader）从存储中加载图像并传输到数据预处理器（data preprocessor），数据预处理器会将图像放到特定的设备上，并将数据堆叠到批处理中，之后模型接受批处理数据作为输入，最后将模型的输出发送给优化器（optimizer）。蓝色线表示 [val_step](./models.md#val_step) 和 [test_step](./models.md#test_step)。这两个过程的数据流除了模型输出与 `train_step` 不同外，其余均和 `train_step` 类似。由于在评估时模型参数会被冻结，因此模型的输出将被传递给 [Evaluator](./evaluation.md#ioumetric)。
+来计算指标。
+
+## MMSegmentation 中的数据流约定
+
+在上面的图中，我们可以看到基本的数据流。在本节中，我们将分别介绍数据流中涉及的数据的格式约定。
+
+### 数据加载器到数据预处理器
+
+数据加载器（DataLoader）是 MMEngine 的训练和测试流程中的一个重要组件。
+从概念上讲，它源于 [PyTorch](https://pytorch.org/) 并保持一致。DataLoader 从文件系统加载数据，原始数据通过数据准备流程后被发送给数据预处理器。
+
+MMSegmentation 在 [PackSegInputs](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/transforms/formatting.py#L12) 中定义了默认数据格式， 它是 `train_pipeline` 和 `test_pipeline` 的最后一个组件。有关数据转换 `pipeline` 的更多信息，请参阅[数据转换文档](./transforms.md)。
+
+在没有任何修改的情况下，PackSegInputs 的返回值通常是一个包含 `inputs` 和 `data_samples` 的 `dict`。以下伪代码展示了 mmseg 中数据加载器输出的数据类型，它是从数据集中获取的一批数据样本，数据加载器将它们打包成一个字典列表。`inputs` 是输入进模型的张量列表，`data_samples` 包含了输入图像的 meta information 和相应的 ground truth。
+
+```python
+dict(
+ inputs=List[torch.Tensor],
+ data_samples=List[SegDataSample]
+)
+```
+
+**注意：** [SegDataSample](https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/structures/seg_data_sample.py) 是 MMSegmentation 的数据结构接口，用于连接不同组件。`SegDataSample` 实现了抽象数据元素 `mmengine.structures.BaseDataElement`，更多信息请在 [MMEngine](https://github.com/open-mmlab/mmengine) 中参阅 [SegDataSample 文档](./structures.md)和[数据元素文档](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)。
+
+### 数据预处理器到模型
+
+虽然在[上面的图](##数据流概述)中分开绘制了数据预处理器和模型，但数据预处理器是模型的一部分，因此可以在[模型教程](./models.md)中找到数据预处理器章节。
+
+数据预处理器的返回值是一个包含 `inputs` 和 `data_samples` 的字典，其中 `inputs` 是批处理图像的 4D 张量，`data_samples` 中添加了一些用于数据预处理的额外元信息。当传递给网络时，字典将被解包为两个值。 以下伪代码展示了数据预处理器的返回值和模型的输入值。
+
+```python
+dict(
+ inputs=torch.Tensor,
+ data_samples=List[SegDataSample]
+)
+```
+
+```python
+class Network(BaseSegmentor):
+
+ def forward(self, inputs: torch.Tensor, data_samples: List[SegDataSample], mode: str):
+ pass
+```
+
+**注意：** 模型的前向传播有 3 种模式，由输入参数 mode 控制，更多信息请参阅[模型教程](./models.md)。
+
+### 模型输出
+
+如[模型教程](./models.md#forward) ***（[中文链接待更新](./models.md#forward)）*** 所提到的 3 种前向传播具有 3 种输出。
+`train_step` 和 `test_step`（或 `val_step`）分别对应于 `'loss'` 和 `'predict'`。
+
+在 `test_step` 或 `val_step` 中，推理结果会被传递给 `Evaluator` 。您可以参阅[评估文档](./evaluation.md)来获取更多关于 `Evaluator` 的信息。
+
+在推理后，MMSegmentation 中的 [BaseSegmentor](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L15) 会对推理结果进行简单的后处理以打包推理结果。神经网络生成的分割 logits，经过 `argmax` 操作后的分割 mask 和 ground truth（如果存在）将被打包到类似 `SegDataSample` 的实例。 [postprocess_result](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/segmentors/base.py#L132) 的返回值是一个 **`SegDataSample`的`List`**。下图显示了这些 `SegDataSample` 实例的关键属性。
+
+
+
+与数据预处理器一致，损失函数也是模型的一部分，它是[解码头](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L142)的属性之一。
+
+在 MMSegmentation 中，`decode_head` 的 [loss_by_feat](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/models/decode_heads/decode_head.py#L291) 方法是用于计算损失的统一接口。
+
+参数：
+
+- seg_logits (Tensor)：解码头前向函数的输出
+- batch_data_samples (List\[SegDataSample\])：分割数据样本，通常包括如 `metainfo` 和 `gt_sem_seg` 等信息
+
+返回值：
+
+- dict\[str, Tensor\]：一个损失组件的字典
+
+**注意：** `train_step` 将损失传递进 OptimWrapper 以更新模型中的权重，更多信息请参阅 [train_step](./models.md#train_step)。
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/datasets.md b/internlm_langchain/knowledge_base/MMSegmentation/content/datasets.md
new file mode 100644
index 00000000..b45f2d22
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/datasets.md
@@ -0,0 +1,363 @@
+# 数据集
+
+在 MMSegmentation 算法库中, 所有 Dataset 类的功能有两个: 加载[预处理](../user_guides/2_dataset_prepare.md) 之后的数据集的信息, 和将数据送入[数据集变换流水线](https://github.com/open-mmlab/mmsegmentation/blob/main/mmseg/datasets/basesegdataset.py#L141) 中, 进行[数据变换操作](./transforms.md). 加载的数据集信息包括两类: 元信息 (meta information), 数据集本身的信息, 例如数据集总共的类别, 和它们对应调色盘信息: 数据信息 (data information) 是指每组数据中图片和对应标签的路径. 下文中介绍了 MMSegmentation 1.x 中数据集的常用接口, 和 mmseg 数据集基类中数据信息加载与修改数据集类别的逻辑, 以及数据集与数据变换流水线 (pipeline) 的关系.
+
+## 常用接口
+
+以 Cityscapes 为例, 介绍数据集常用接口. 如需运行以下示例, 请在当前工作目录下的 `data` 目录下载并[预处理](../user_guides/2_dataset_prepare.md#cityscapes) Cityscapes 数据集.
+
+实例化 Cityscapes 训练数据集:
+
+```python
+from mmengine.registry import init_default_scope
+from mmseg.datasets import CityscapesDataset
+
+init_default_scope('mmseg')
+
+data_root = 'data/cityscapes/'
+data_prefix=dict(img_path='leftImg8bit/train', seg_map_path='gtFine/train')
+train_pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+ dict(type='RandomFlip', prob=0.5),
+ dict(type='PackSegInputs')
+]
+
+dataset = CityscapesDataset(data_root=data_root, data_prefix=data_prefix, test_mode=False, pipeline=train_pipeline)
+```
+
+查看训练数据集长度:
+
+```python
+print(len(dataset))
+
+2975
+```
+
+获取数据信息, 数据信息的类型是一个字典, 包括 `'img_path'` 字段的存放图片的路径和 `'seg_map_path'` 字段存放分割标注的路径, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`(主要功能在下文中介绍), 还有存放已加载标签字段 `'seg_fields'`, 和当前样本的索引字段 `'sample_idx'`.
+
+```python
+# 获取数据集中第一组样本的数据信息
+print(dataset.get_data_info(0))
+
+{'img_path': 'data/cityscapes/leftImg8bit/train/aachen/aachen_000000_000019_leftImg8bit.png',
+ 'seg_map_path': 'data/cityscapes/gtFine/train/aachen/aachen_000000_000019_gtFine_labelTrainIds.png',
+ 'label_map': None,
+ 'reduce_zero_label': False,
+ 'seg_fields': [],
+ 'sample_idx': 0}
+```
+
+获取数据集元信息, MMSegmentation 的数据集元信息的类型同样是一个字典, 包括 `'classes'` 字段存放数据集类别, `'palette'` 存放数据集类别对应的可视化时调色盘的颜色, 以及标签重映射的字段 `'label_map'` 和 `'reduce_zero_label'`.
+
+```python
+print(dataset.metainfo)
+
+{'classes': ('road',
+ 'sidewalk',
+ 'building',
+ 'wall',
+ 'fence',
+ 'pole',
+ 'traffic light',
+ 'traffic sign',
+ 'vegetation',
+ 'terrain',
+ 'sky',
+ 'person',
+ 'rider',
+ 'car',
+ 'truck',
+ 'bus',
+ 'train',
+ 'motorcycle',
+ 'bicycle'),
+ 'palette': [[128, 64, 128],
+ [244, 35, 232],
+ [70, 70, 70],
+ [102, 102, 156],
+ [190, 153, 153],
+ [153, 153, 153],
+ [250, 170, 30],
+ [220, 220, 0],
+ [107, 142, 35],
+ [152, 251, 152],
+ [70, 130, 180],
+ [220, 20, 60],
+ [255, 0, 0],
+ [0, 0, 142],
+ [0, 0, 70],
+ [0, 60, 100],
+ [0, 80, 100],
+ [0, 0, 230],
+ [119, 11, 32]],
+ 'label_map': None,
+ 'reduce_zero_label': False}
+```
+
+数据集 `__getitem__` 方法的返回值, 是经过数据增强的样本数据的输出, 同样也是一个字典, 包括两个字段, `'inputs'` 字段是当前样本经过数据增强操作的图像, 类型为 torch.Tensor, `'data_samples'` 字段存放的数据类型是 MMSegmentation 1.x 新添加的数据结构 [`Segdatasample`](./structures.md), 其中`gt_sem_seg` 字段是经过数据增强的标签数据.
+
+```python
+print(dataset[0])
+
+{'inputs': tensor([[[131, 130, 130, ..., 23, 23, 23],
+ [132, 132, 132, ..., 23, 22, 23],
+ [134, 133, 133, ..., 23, 23, 23],
+ ...,
+ [ 66, 67, 67, ..., 71, 71, 71],
+ [ 66, 67, 66, ..., 68, 68, 68],
+ [ 67, 67, 66, ..., 70, 70, 70]],
+
+ [[143, 143, 142, ..., 28, 28, 29],
+ [145, 145, 145, ..., 28, 28, 29],
+ [145, 145, 145, ..., 27, 28, 29],
+ ...,
+ [ 75, 75, 76, ..., 80, 81, 81],
+ [ 75, 76, 75, ..., 80, 80, 80],
+ [ 77, 76, 76, ..., 82, 82, 82]],
+
+ [[126, 125, 126, ..., 21, 21, 22],
+ [127, 127, 128, ..., 21, 21, 22],
+ [127, 127, 126, ..., 21, 21, 22],
+ ...,
+ [ 63, 63, 64, ..., 69, 69, 70],
+ [ 64, 65, 64, ..., 69, 69, 69],
+ [ 65, 66, 66, ..., 72, 71, 71]]], dtype=torch.uint8),
+ 'data_samples':
+ | 功能 | +原版 | +新版 | +
| 加载预训练模型 | +--load_from=$CHECKPOINT | +--cfg-options load_from=$CHECKPOINT | +
| 从特定检查点恢复训练 | +--resume-from=$CHECKPOINT | +--resume=$CHECKPOINT | +
| 从最新的检查点恢复训练 | +--auto-resume | +--resume='auto' | +
| 训练期间是否不评估检查点 | +--no-validate | +--cfg-options val_cfg=None val_dataloader=None val_evaluator=None | +
| 指定训练设备 | +--gpu-id=$DEVICE_ID | +- | +
| 是否为不同进程设置不同的种子 | +--diff-seed | +--cfg-options randomness.diff_rank_seed=True | +是否为 CUDNN 后端设置确定性选项 | +--deterministic | +--cfg-options randomness.deterministic=True | +
| 功能 | +0.x | +1.x | +
| 指定评测指标 | +--eval mIoU | +--cfg-options test_evaluator.type=IoUMetric | +
| 测试时数据增强 | +--aug-test | +--tta | +
| 测试时是否只保存预测结果不计算评测指标 | +--format-only | +--cfg-options test_evaluator.format_only=True | +
| 原版 | ++ +```python +data = dict( + samples_per_gpu=4, + workers_per_gpu=4, + train=dict(...), + val=dict(...), + test=dict(...), +) +``` + + | +
| 新版 | ++ +```python +train_dataloader = dict( + batch_size=4, + num_workers=4, + dataset=dict(...), + sampler=dict(type='DefaultSampler', shuffle=True) # 必须 +) + +val_dataloader = dict( + batch_size=4, + num_workers=4, + dataset=dict(...), + sampler=dict(type='DefaultSampler', shuffle=False) # 必须 +) + +test_dataloader = val_dataloader +``` + + | +
| 原版 | ++ +```python +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', reduce_zero_label=True), + dict(type='Resize', img_scale=(2560, 640), ratio_range=(0.5, 2.0)), + dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_semantic_seg']), +] +``` + + | +
| 新版 | ++ +```python +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', reduce_zero_label=True), + dict( + type='RandomResize', + scale=(2560, 640), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='PackSegInputs') +] +``` + + | +
| 原版 | ++ +```python +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(2560, 640), + # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75], + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=True), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +``` + + | +
| 新版 | ++ +```python +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=(2560, 640), keep_ratio=True), + dict(type='LoadAnnotations', reduce_zero_label=True), + dict(type='PackSegInputs') +] +img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75] +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='Resize', scale_factor=r, keep_ratio=True) + for r in img_ratios + ], + [ + dict(type='RandomFlip', prob=0., direction='horizontal'), + dict(type='RandomFlip', prob=1., direction='horizontal') + ], [dict(type='LoadAnnotations')], [dict(type='PackSegInputs')] + ]) +] +``` + + | +
| 原版 | ++ +```python +evaluation = dict(interval=2000, metric='mIoU', pre_eval=True) +``` + + | +
| 新版 | ++ +```python +val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU']) +test_evaluator = val_evaluator +``` + + | +
| 原版 | ++ +```python +optimizer = dict(type='AdamW', lr=0.0001, weight_decay=0.0005) +optimizer_config = dict(grad_clip=dict(max_norm=1, norm_type=2)) +``` + + | +
| 新版 | ++ +```python +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0005), + clip_grad=dict(max_norm=1, norm_type=2)) +``` + + | +
| 原版 | ++ +```python +lr_config = dict( + policy='poly', + warmup='linear', + warmup_iters=1500, + warmup_ratio=1e-6, + power=1.0, + min_lr=0.0, + by_epoch=False) +``` + + | +
| 新版 | ++ +```python +param_scheduler = [ + dict( + type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500), + dict( + type='PolyLR', + power=1.0, + begin=1500, + end=160000, + eta_min=0.0, + by_epoch=False, + ) +] +``` + + | +
| 原版 | ++ +```python +runner = dict(type='IterBasedRunner', max_iters=20000) +``` + + | +
| 新版 | ++ +```python +# `val_interval` 是旧版本的 `evaluation.interval`。 +train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000) +val_cfg = dict(type='ValLoop') # 使用默认的验证循环。 +test_cfg = dict(type='TestLoop') # 使用默认的测试循环。 +``` + + | +
| 原版 | ++ +```python +log_config = dict( + interval=100, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook'), + ]) +``` + + | +
| 新版 | ++ +```python +default_hooks = dict( + ... + logger=dict(type='LoggerHook', interval=100), +) +vis_backends = [dict(type='LocalVisBackend'), + dict(type='TensorboardVisBackend')] +visualizer = dict( + type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer') +``` + + | +
+
+
+ | MMSegmentation 0.x | +MMSegmentation 1.x | +
| mmseg.api | +mmseg.api | +
| - mmseg.core | ++ mmseg.engine | +
| mmseg.datasets | +mmseg.datasets | +
| mmseg.models | +mmseg.models | +
| - mmseg.ops | ++ mmseg.structure | +
| mmseg.utils | +mmseg.utils | +
| + | + mmseg.evaluation | +
| + | + mmseg.registry | +
+
+
+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+然后你可以找到他们本地的路径和使用下面的脚本文件对其进行可视化：
+
+```python
+import mmcv
+import os.path as osp
+import torch
+
+# `PixelData` 是 MMEngine 中用于定义像素级标注或预测的数据结构。
+# 请参考下面的MMEngine数据结构教程文件：
+# https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html#pixeldata
+
+from mmengine.structures import PixelData
+
+# `SegDataSample` 是在 MMSegmentation 中定义的不同组件之间的数据结构接口，
+# 它包括 ground truth、语义分割的预测结果和预测逻辑。
+# 详情请参考下面的 `SegDataSample` 教程文件：
+# https://github.com/open-mmlab/mmsegmentation/blob/1.x/docs/en/advanced_guides/structures.md
+
+from mmseg.structures import SegDataSample
+from mmseg.visualization import SegLocalVisualizer
+
+out_file = 'out_file_cityscapes'
+save_dir = './work_dirs'
+
+image = mmcv.imread(
+ osp.join(
+ osp.dirname(__file__),
+ './aachen_000000_000019_leftImg8bit.png'
+ ),
+ 'color')
+sem_seg = mmcv.imread(
+ osp.join(
+ osp.dirname(__file__),
+ './aachen_000000_000019_gtFine_labelTrainIds.png' # noqa
+ ),
+ 'unchanged')
+sem_seg = torch.from_numpy(sem_seg)
+gt_sem_seg_data = dict(data=sem_seg)
+gt_sem_seg = PixelData(**gt_sem_seg_data)
+data_sample = SegDataSample()
+data_sample.gt_sem_seg = gt_sem_seg
+
+seg_local_visualizer = SegLocalVisualizer(
+ vis_backends=[dict(type='LocalVisBackend')],
+ save_dir=save_dir)
+
+# 数据集的元信息通常包括类名的 `classes` 和
+# 用于可视化每个前景颜色的 `palette` 。
+# 所有类名和调色板都在此文件中定义：
+# https://github.com/open-mmlab/mmsegmentation/blob/1.x/mmseg/utils/class_names.py
+
+seg_local_visualizer.dataset_meta = dict(
+ classes=('road', 'sidewalk', 'building', 'wall', 'fence',
+ 'pole', 'traffic light', 'traffic sign',
+ 'vegetation', 'terrain', 'sky', 'person', 'rider',
+ 'car', 'truck', 'bus', 'train', 'motorcycle',
+ 'bicycle'),
+ palette=[[128, 64, 128], [244, 35, 232], [70, 70, 70],
+ [102, 102, 156], [190, 153, 153], [153, 153, 153],
+ [250, 170, 30], [220, 220, 0], [107, 142, 35],
+ [152, 251, 152], [70, 130, 180], [220, 20, 60],
+ [255, 0, 0], [0, 0, 142], [0, 0, 70],
+ [0, 60, 100], [0, 80, 100], [0, 0, 230],
+ [119, 11, 32]])
+
+# 当`show=True`时，直接显示结果，
+# 当 `show=False`时，结果将保存在本地文件夹中。
+
+seg_local_visualizer.add_datasample(out_file, image,
+ data_sample, show=False)
+```
+
+可视化后的图像结果和它的对应的 ground truth 图像可以在 `./work_dirs/vis_data/vis_image/` 路径找到，文件名字是：`out_file_cityscapes_0.png` ：
+
+
+
+
+
+
+如果你想知道更多的关于可视化的使用指引，你可以参考 MMEngine 中的[可视化教程](<[https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md)>)
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/content/visualization_feature_map.md b/internlm_langchain/knowledge_base/MMSegmentation/content/visualization_feature_map.md
new file mode 100644
index 00000000..fda99bb5
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSegmentation/content/visualization_feature_map.md
@@ -0,0 +1,201 @@
+# wandb记录特征图可视化
+
+MMSegmentation 1.x 提供了 Weights & Biases 的后端支持，方便对项目代码结果的可视化和管理。
+
+## Wandb的配置
+
+安装 Weights & Biases 的过程可以参考 [官方安装指南](https://docs.wandb.ai/quickstart)，具体的步骤如下:
+
+```shell
+pip install wandb
+wandb login
+```
+
+在 `vis_backend` 中添加 `WandbVisBackend`。
+
+```python
+vis_backends=[dict(type='LocalVisBackend'),
+ dict(type='TensorboardVisBackend'),
+ dict(type='WandbVisBackend')]
+```
+
+## 测试数据和结果及特征图的可视化
+
+`SegLocalVisualizer` 是继承自 MMEngine 中 `Visualizer` 类的子类，适用于 MMSegmentation 可视化，有关 `Visualizer` 的详细信息请参考在 MMEngine 中的[可视化教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html) 。
+
+以下是一个关于 `SegLocalVisualizer` 的示例，首先你可以使用下面的命令下载这个案例中的数据：
+
+
+
+
+
+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+
+wget https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
+
+```
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+from typing import Type
+
+import mmcv
+import torch
+import torch.nn as nn
+
+from mmengine.model import revert_sync_batchnorm
+from mmengine.structures import PixelData
+from mmseg.apis import inference_model, init_model
+from mmseg.structures import SegDataSample
+from mmseg.utils import register_all_modules
+from mmseg.visualization import SegLocalVisualizer
+
+
+class Recorder:
+ """record the forward output feature map and save to data_buffer."""
+
+ def __init__(self) -> None:
+ self.data_buffer = list()
+
+ def __enter__(self, ):
+ self._data_buffer = list()
+
+ def record_data_hook(self, model: nn.Module, input: Type, output: Type):
+ self.data_buffer.append(output)
+
+ def __exit__(self, *args, **kwargs):
+ pass
+
+
+def visualize(args, model, recorder, result):
+ seg_visualizer = SegLocalVisualizer(
+ vis_backends=[dict(type='WandbVisBackend')],
+ save_dir='temp_dir',
+ alpha=0.5)
+ seg_visualizer.dataset_meta = dict(
+ classes=model.dataset_meta['classes'],
+ palette=model.dataset_meta['palette'])
+
+ image = mmcv.imread(args.img, 'color')
+
+ seg_visualizer.add_datasample(
+ name='predict',
+ image=image,
+ data_sample=result,
+ draw_gt=False,
+ draw_pred=True,
+ wait_time=0,
+ out_file=None,
+ show=False)
+
+ # add feature map to wandb visualizer
+ for i in range(len(recorder.data_buffer)):
+ feature = recorder.data_buffer[i][0] # remove the batch
+ drawn_img = seg_visualizer.draw_featmap(
+ feature, image, channel_reduction='select_max')
+ seg_visualizer.add_image(f'feature_map{i}', drawn_img)
+
+ if args.gt_mask:
+ sem_seg = mmcv.imread(args.gt_mask, 'unchanged')
+ sem_seg = torch.from_numpy(sem_seg)
+ gt_mask = dict(data=sem_seg)
+ gt_mask = PixelData(**gt_mask)
+ data_sample = SegDataSample()
+ data_sample.gt_sem_seg = gt_mask
+
+ seg_visualizer.add_datasample(
+ name='gt_mask',
+ image=image,
+ data_sample=data_sample,
+ draw_gt=True,
+ draw_pred=False,
+ wait_time=0,
+ out_file=None,
+ show=False)
+
+ seg_visualizer.add_image('image', image)
+
+
+def main():
+ parser = ArgumentParser(
+ description='Draw the Feature Map During Inference')
+ parser.add_argument('img', help='Image file')
+ parser.add_argument('config', help='Config file')
+ parser.add_argument('checkpoint', help='Checkpoint file')
+ parser.add_argument('--gt_mask', default=None, help='Path of gt mask file')
+ parser.add_argument('--out-file', default=None, help='Path to output file')
+ parser.add_argument(
+ '--device', default='cuda:0', help='Device used for inference')
+ parser.add_argument(
+ '--opacity',
+ type=float,
+ default=0.5,
+ help='Opacity of painted segmentation map. In (0, 1] range.')
+ parser.add_argument(
+ '--title', default='result', help='The image identifier.')
+ args = parser.parse_args()
+
+ register_all_modules()
+
+ # build the model from a config file and a checkpoint file
+ model = init_model(args.config, args.checkpoint, device=args.device)
+ if args.device == 'cpu':
+ model = revert_sync_batchnorm(model)
+
+ # show all named module in the model and use it in source list below
+ for name, module in model.named_modules():
+ print(name)
+
+ source = [
+ 'decode_head.fusion.stages.0.query_project.activate',
+ 'decode_head.context.stages.0.key_project.activate',
+ 'decode_head.context.bottleneck.activate'
+ ]
+ source = dict.fromkeys(source)
+
+ count = 0
+ recorder = Recorder()
+ # registry the forward hook
+ for name, module in model.named_modules():
+ if name in source:
+ count += 1
+ module.register_forward_hook(recorder.record_data_hook)
+ if count == len(source):
+ break
+
+ with recorder:
+ # test a single image, and record feature map to data_buffer
+ result = inference_model(model, args.img)
+
+ visualize(args, model, recorder, result)
+
+
+if __name__ == '__main__':
+ main()
+
+```
+
+将上述代码保存为 feature_map_visual.py，在终端执行如下代码
+
+```shell
+python feature_map_visual.py ${图像} ${配置文件} ${检查点文件} [可选参数]
+```
+
+样例
+
+```shell
+python feature_map_visual.py \
+aachen_000000_000019_leftImg8bit.png \
+configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth \
+--gt_mask aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+可视化后的图像结果和它的对应的 feature map图像会出现在wandb账户中
+
+
+
+
+
diff --git a/internlm_langchain/knowledge_base/MMSegmentation/vector_store/index.faiss b/internlm_langchain/knowledge_base/MMSegmentation/vector_store/index.faiss
new file mode 100644
index 00000000..05f74a44
Binary files /dev/null and b/internlm_langchain/knowledge_base/MMSegmentation/vector_store/index.faiss differ
diff --git a/internlm_langchain/knowledge_base/MMSkeleton/content/CONTRIBUTING.md b/internlm_langchain/knowledge_base/MMSkeleton/content/CONTRIBUTING.md
new file mode 100644
index 00000000..32d9604f
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSkeleton/content/CONTRIBUTING.md
@@ -0,0 +1,27 @@
+# Contributing to MMSkeleton
+
+All kinds of contributions are welcome, including but not limited to the following.
+
+- Fixes (typo, bugs)
+- New features and components
+
+## Workflow
+
+1. fork and pull the latest mmskeleton
+2. checkout a new branch (do not use master branch for PRs)
+3. commit your changes
+4. create a PR
+
+Note
+- If you plan to add some new features that involve large changes, it is encouraged to open an issue for discussion first.
+- If you are the author of some papers and would like to include your method to mmskeleton,
+please contact Sijie Yan (yysijie@gmail). We will much appreciate your contribution.
+
+## Code style
+
+### Python
+We adopt [PEP8](https://www.python.org/dev/peps/pep-0008/) as the preferred code style.
+We use [flake8](http://flake8.pycqa.org/en/latest/) as the linter and [yapf](https://github.com/google/yapf) as the formatter.
+Please upgrade to the latest yapf (>=0.27.0) and refer to the [configuration](../.style.yapf).
+
+>Before you create a PR, make sure that your code lints and is formatted by yapf.
\ No newline at end of file
diff --git a/internlm_langchain/knowledge_base/MMSkeleton/content/CREATE_APPLICATION.md b/internlm_langchain/knowledge_base/MMSkeleton/content/CREATE_APPLICATION.md
new file mode 100644
index 00000000..0b56cb97
--- /dev/null
+++ b/internlm_langchain/knowledge_base/MMSkeleton/content/CREATE_APPLICATION.md
@@ -0,0 +1,44 @@
+## Create an MMSkeleton Application
+
+MMSkeleton provides various models, datasets, apis, operators for various applications,
+such as pose estimation, human detection, action recognition and dataset building.
+The workflow of a application is defined by a **processor**, which is usually a python function.
+
+In MMSkeleton, an application is defined in a configuration file.
+It is a `.json`, `.yaml` or `.py` file including `processor_cfg` field.
+Here is an example:
+
+```yaml
+# yaml
+
+processor_cfg:
+ type:
+
+ 
+