Add Streamlit + LlamaIndex + 浦语 API project

.ipynb_checkpoints/README-checkpoint.md

@@ -0,0 +1,13 @@
+---
+title: Internlm2.5 RAG
+emoji: 📉
+colorFrom: indigo
+colorTo: red
+sdk: streamlit
+sdk_version: 1.40.2
+app_file: app.py
+pinned: false
+short_description: Llamaindex RAG 实践
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,84 @@
+import streamlit as st
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.legacy.callbacks import CallbackManager
+from llama_index.llms.openai_like import OpenAILike
+import os
+
+# Create an instance of CallbackManager
+callback_manager = CallbackManager()
+
+api_base_url =  "https://internlm-chat.intern-ai.org.cn/puyu/api/v1/"
+model = "internlm2.5-latest"
+api_key = os.getenv("API_KEY")
+
+# api_base_url =  "https://api.siliconflow.cn/v1"
+# model = "internlm/internlm2_5-7b-chat"
+# api_key = "请填写 API Key"
+
+llm =OpenAILike(model=model, api_base=api_base_url, api_key=api_key, is_chat_model=True,callback_manager=callback_manager)
+
+
+
+st.set_page_config(page_title="llama_index_demo", page_icon="🦜🔗")
+st.title("llama_index_demo")
+
+# 初始化模型
+@st.cache_resource
+def init_models():
+    embed_model = HuggingFaceEmbedding(
+        model_name="/root/model/sentence-transformer"
+    )
+    Settings.embed_model = embed_model
+
+    #用初始化llm
+    Settings.llm = llm
+
+    documents = SimpleDirectoryReader("/root/llamaindex_demo/data").load_data()
+    index = VectorStoreIndex.from_documents(documents)
+    query_engine = index.as_query_engine()
+
+    return query_engine
+
+# 检查是否需要初始化模型
+if 'query_engine' not in st.session_state:
+    st.session_state['query_engine'] = init_models()
+
+def greet2(question):
+    response = st.session_state['query_engine'].query(question)
+    return response
+
+      
+# Store LLM generated responses
+if "messages" not in st.session_state.keys():
+    st.session_state.messages = [{"role": "assistant", "content": "你好，我是你的助手，有什么我可以帮助你的吗？"}]    
+
+    # Display or clear chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.write(message["content"])
+
+def clear_chat_history():
+    st.session_state.messages = [{"role": "assistant", "content": "你好，我是你的助手，有什么我可以帮助你的吗？"}]
+
+st.sidebar.button('Clear Chat History', on_click=clear_chat_history)
+
+# Function for generating LLaMA2 response
+def generate_llama_index_response(prompt_input):
+    return greet2(prompt_input)
+
+# User-provided prompt
+if prompt := st.chat_input():
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.write(prompt)
+
+# Gegenerate_llama_index_response last message is not from assistant
+if st.session_state.messages[-1]["role"] != "assistant":
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            response = generate_llama_index_response(prompt)
+            placeholder = st.empty()
+            placeholder.markdown(response)
+    message = {"role": "assistant", "content": response}
+    st.session_state.messages.append(message)

data/.ipynb_checkpoints/README_zh-CN-checkpoint.md

@@ -0,0 +1,304 @@
+<div align="center">
+  <img src="https://github.com/InternLM/lmdeploy/assets/36994684/0cf8d00f-e86b-40ba-9b54-dc8f1bc6c8d8" width="600"/>
+  <br /><br />
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/InternLM/xtuner?style=social)](https://github.com/InternLM/xtuner/stargazers)
+[![license](https://img.shields.io/github/license/InternLM/xtuner.svg)](https://github.com/InternLM/xtuner/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/xtuner)](https://pypi.org/project/xtuner/)
+[![Downloads](https://static.pepy.tech/badge/xtuner)](https://pypi.org/project/xtuner/)
+[![issue resolution](https://img.shields.io/github/issues-closed-raw/InternLM/xtuner)](https://github.com/InternLM/xtuner/issues)
+[![open issues](https://img.shields.io/github/issues-raw/InternLM/xtuner)](https://github.com/InternLM/xtuner/issues)
+
+👋 加入我们：[![Static Badge](https://img.shields.io/badge/-grey?style=social&logo=wechat&label=微信)](https://cdn.vansin.top/internlm/xtuner.jpg)
+[![Static Badge](https://img.shields.io/badge/-grey?style=social&logo=twitter&label=推特)](https://twitter.com/intern_lm)
+[![Static Badge](https://img.shields.io/badge/-grey?style=social&logo=discord&label=Discord)](https://discord.gg/xa29JuW87d)
+
+🔍 探索我们的模型：
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🤗%20Huggingface)](https://huggingface.co/xtuner)
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🤖%20ModelScope)](https://www.modelscope.cn/organization/xtuner)
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🧰%20OpenXLab)](https://openxlab.org.cn/usercenter/xtuner)
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🧠%20WiseModel)](https://www.wisemodel.cn/organization/xtuner)
+
+[English](README.md) | 简体中文
+
+</div>
+
+## 🚀 Speed Benchmark
+
+- XTuner 与 LLaMA-Factory 在 Llama2-7B 模型上的训练效率对比
+
+<div align=center>
+  <img src="https://github.com/InternLM/xtuner/assets/41630003/9c9dfdf4-1efb-4daf-84bf-7c379ae40b8b" style="width:80%">
+</div>
+
+- XTuner 与 LLaMA-Factory 在 Llama2-70B 模型上的训练效率对比
+
+<div align=center>
+  <img src="https://github.com/InternLM/xtuner/assets/41630003/5ba973b8-8885-4b72-b51b-c69fa1583bdd" style="width:80%">
+</div>
+
+## 🎉 更新
+- **\[2024/07\]** 支持 [MiniCPM](xtuner/configs/minicpm/) 模型!
+- **\[2024/07\]** 支持训练 [DPO](https://github.com/InternLM/xtuner/tree/main/xtuner/configs/dpo)， [ORPO](https://github.com/InternLM/xtuner/tree/main/xtuner/configs/orpo) 还有 [Reward Model](https://github.com/InternLM/xtuner/tree/main/xtuner/configs/reward_model) ! 并且能够支持打包数据以及序列并行功能！ 请参考 [文档](https://xtuner.readthedocs.io/zh-cn/latest/dpo/overview.html) 了解更多信息。
+- **\[2024/07\]** 支持 [InternLM 2.5](xtuner/configs/internlm/internlm2_5_chat_7b/) 模型!
+- **\[2024/06\]** 支持 [DeepSeek V2](xtuner/configs/deepseek/deepseek_v2_chat/) models! **训练速度提升一倍！**
+- **\[2024/04\]** 多模态大模型 [LLaVA-Phi-3-mini](https://huggingface.co/xtuner/llava-phi-3-mini-hf) 发布！快速开始请查阅此[文档](xtuner/configs/llava/phi3_mini_4k_instruct_clip_vit_large_p14_336)！
+- **\[2024/04\]** 多模态大模型 [LLaVA-Llama-3-8B](https://huggingface.co/xtuner/llava-llama-3-8b) 和 [LLaVA-Llama-3-8B-v1.1](https://huggingface.co/xtuner/llava-llama-3-8b-v1_1) 发布！快速开始请查阅此[文档](xtuner/configs/llava/llama3_8b_instruct_clip_vit_large_p14_336)！
+- **\[2024/04\]** 支持 [Llama 3](xtuner/configs/llama) 模型！
+- **\[2024/04\]** 支持序列并行训练策略以实现语言模型超长上下文训练！\[[文档](https://github.com/InternLM/xtuner/blob/docs/docs/zh_cn/acceleration/train_extreme_long_sequence.rst)\] \[[速度基准](https://github.com/InternLM/xtuner/blob/docs/docs/zh_cn/acceleration/benchmark.rst)\]
+- **\[2024/02\]** 支持 [Gemma](xtuner/configs/gemma) 模型！
+- **\[2024/02\]** 支持 [Qwen1.5](xtuner/configs/qwen/qwen1_5) 模型！
+- **\[2024/01\]** 支持 [InternLM2](xtuner/configs/internlm) 模型！同时，最新版的多模态大模型 [LLaVA-Internlm2-7B](https://huggingface.co/xtuner/llava-internlm2-7b) / [20B](https://huggingface.co/xtuner/llava-internlm2-20b) 发布，其表现出强大的性能！
+- **\[2024/01\]** 支持 [DeepSeek-MoE](https://huggingface.co/deepseek-ai/deepseek-moe-16b-chat) 模型！20GB 显存即可实现 QLoRA 微调，4x80GB 即可实现全参数微调。快速开始请查阅相关[配置文件](xtuner/configs/deepseek/)！
+- **\[2023/12\]** 🔥 支持多模态模型 VLM（[LLaVA-v1.5](https://github.com/haotian-liu/LLaVA)）预训练和指令微调！快速开始请查阅此[文档](xtuner/configs/llava/README_zh-CN.md)！
+- **\[2023/12\]** 🔥 支持 [Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1) 模型！快速开始请查阅此[文档](xtuner/configs/mixtral/README.md)！
+- **\[2023/11\]** 支持 [ChatGLM3-6B](xtuner/configs/chatglm) 模型！
+- **\[2023/10\]** 支持 [MSAgent-Bench](https://modelscope.cn/datasets/damo/MSAgent-Bench) 数据集，并且微调所得大语言模型可应用至 [Lagent](https://github.com/InternLM/lagent) 框架！
+- **\[2023/10\]** 优化数据处理逻辑以兼容 `system` 字段，相关细节请查阅[文档](docs/zh_cn/user_guides/dataset_format.md)！
+- **\[2023/09\]** 支持 [InternLM-20B](xtuner/configs/internlm) 系列模型！
+- **\[2023/09\]** 支持 [Baichuan2](xtuner/configs/baichuan) 系列模型！
+- **\[2023/08\]** XTuner 正式发布！众多微调模型已上传至 [HuggingFace](https://huggingface.co/xtuner)！
+
+## 📖 介绍
+
+XTuner 是一个高效、灵活、全能的轻量化大模型微调工具库。
+
+**高效**
+
+- 支持大语言模型 LLM、多模态图文模型 VLM 的预训练及轻量级微调。XTuner 支持在 8GB 显存下微调 7B 模型，同时也支持多节点跨设备微调更大尺度模型（70B+）。
+- 自动分发高性能算子（如 FlashAttention、Triton kernels 等）以加速训练吞吐。
+- 兼容 [DeepSpeed](https://github.com/microsoft/DeepSpeed) 🚀，轻松应用各种 ZeRO 训练优化策略。
+
+**灵活**
+
+- 支持多种大语言模型，包括但不限于 [InternLM](https://huggingface.co/internlm)、[Mixtral-8x7B](https://huggingface.co/mistralai)、[Llama 2](https://huggingface.co/meta-llama)、[ChatGLM](https://huggingface.co/THUDM)、[Qwen](https://huggingface.co/Qwen)、[Baichuan](https://huggingface.co/baichuan-inc)。
+- 支持多模态图文模型 LLaVA 的预训练与微调。利用 XTuner 训得模型 [LLaVA-InternLM2-20B](https://huggingface.co/xtuner/llava-internlm2-20b) 表现优异。
+- 精心设计的数据管道，兼容任意数据格式，开源数据或自定义数据皆可快速上手。
+- 支持 [QLoRA](http://arxiv.org/abs/2305.14314)、[LoRA](http://arxiv.org/abs/2106.09685)、全量参数微调等多种微调算法，支撑用户根据具体需求作出最优选择。
+
+**全能**
+
+- 支持增量预训练、指令微调与 Agent 微调。
+- 预定义众多开源对话模版，支持与开源或训练所得模型进行对话。
+- 训练所得模型可无缝接入部署工具库 [LMDeploy](https://github.com/InternLM/lmdeploy)、大规模评测工具库 [OpenCompass](https://github.com/open-compass/opencompass) 及 [VLMEvalKit](https://github.com/open-compass/VLMEvalKit)。
+
+## 🔥 支持列表
+
+<table>
+<tbody>
+<tr align="center" valign="middle">
+<td>
+  <b>模型</b>
+</td>
+<td>
+  <b>数据集</b>
+</td>
+<td>
+  <b>数据格式</b>
+</td>
+ <td>
+  <b>微调算法</b>
+</td>
+</tr>
+<tr valign="top">
+<td align="left" valign="top">
+<ul>
+  <li><a href="https://huggingface.co/internlm">InternLM 2 / 2.5</a></li>
+  <li><a href="https://huggingface.co/meta-llama">Llama 2 / 3</a></li>
+  <li><a href="https://huggingface.co/collections/microsoft/phi-3-6626e15e9585a200d2d761e3">Phi-3</a></li>
+  <li><a href="https://huggingface.co/THUDM/chatglm2-6b">ChatGLM2</a></li>
+  <li><a href="https://huggingface.co/THUDM/chatglm3-6b">ChatGLM3</a></li>
+  <li><a href="https://huggingface.co/Qwen/Qwen-7B">Qwen</a></li>
+  <li><a href="https://huggingface.co/baichuan-inc/Baichuan2-7B-Base">Baichuan2</a></li>
+  <li><a href="https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1">Mixtral</a></li>
+  <li><a href="https://huggingface.co/deepseek-ai/DeepSeek-V2-Chat">DeepSeek V2</a></li>
+  <li><a href="https://huggingface.co/google">Gemma</a></li>
+  <li><a href="https://huggingface.co/openbmb">MiniCPM</a></li>
+  <li>...</li>
+</ul>
+</td>
+<td>
+<ul>
+  <li><a href="https://modelscope.cn/datasets/damo/MSAgent-Bench">MSAgent-Bench</a></li>
+  <li><a href="https://huggingface.co/datasets/fnlp/moss-003-sft-data">MOSS-003-SFT</a> 🔧</li>
+  <li><a href="https://huggingface.co/datasets/tatsu-lab/alpaca">Alpaca en</a> / <a href="https://huggingface.co/datasets/silk-road/alpaca-data-gpt4-chinese">zh</a></li>
+  <li><a href="https://huggingface.co/datasets/WizardLM/WizardLM_evol_instruct_V2_196k">WizardLM</a></li>
+  <li><a href="https://huggingface.co/datasets/timdettmers/openassistant-guanaco">oasst1</a></li>
+  <li><a href="https://huggingface.co/datasets/garage-bAInd/Open-Platypus">Open-Platypus</a></li>
+  <li><a href="https://huggingface.co/datasets/HuggingFaceH4/CodeAlpaca_20K">Code Alpaca</a></li>
+  <li><a href="https://huggingface.co/datasets/burkelibbey/colors">Colorist</a> 🎨</li>
+  <li><a href="https://github.com/WangRongsheng/ChatGenTitle">Arxiv GenTitle</a></li>
+  <li><a href="https://github.com/LiuHC0428/LAW-GPT">Chinese Law</a></li>
+  <li><a href="https://huggingface.co/datasets/Open-Orca/OpenOrca">OpenOrca</a></li>
+  <li><a href="https://huggingface.co/datasets/shibing624/medical">Medical Dialogue</a></li>
+  <li>...</li>
+</ul>
+</td>
+<td>
+<ul>
+  <li><a href="docs/zh_cn/user_guides/incremental_pretraining.md">Incremental Pre-training</a> </li>
+  <li><a href="docs/zh_cn/user_guides/single_turn_conversation.md">Single-turn Conversation SFT</a> </li>
+  <li><a href="docs/zh_cn/user_guides/multi_turn_conversation.md">Multi-turn Conversation SFT</a> </li>
+</ul>
+</td>
+<td>
+<ul>
+  <li><a href="http://arxiv.org/abs/2305.14314">QLoRA</a></li>
+  <li><a href="http://arxiv.org/abs/2106.09685">LoRA</a></li>
+  <li>全量参数微调</li>
+  <li><a href="https://arxiv.org/abs/2305.18290">DPO</a></li>
+  <li><a href="https://arxiv.org/abs/2403.07691">ORPO</a></li>
+  <li>Reward Model</a></li>
+</ul>
+</td>
+</tr>
+</tbody>
+</table>
+
+## 🛠️ 快速上手
+
+### 安装
+
+- 推荐使用 conda 先构建一个 Python-3.10 的虚拟环境
+
+  ```bash
+  conda create --name xtuner-env python=3.10 -y
+  conda activate xtuner-env
+  ```
+
+- 通过 pip 安装 XTuner：
+
+  ```shell
+  pip install -U xtuner
+  ```
+
+  亦可集成 DeepSpeed 安装：
+
+  ```shell
+  pip install -U 'xtuner[deepspeed]'
+  ```
+
+- 从源码安装 XTuner：
+
+  ```shell
+  git clone https://github.com/InternLM/xtuner.git
+  cd xtuner
+  pip install -e '.[all]'
+  ```
+
+### 微调
+
+XTuner 支持微调大语言模型。数据集预处理指南请查阅[文档](./docs/zh_cn/user_guides/dataset_prepare.md)。
+
+- **步骤 0**，准备配置文件。XTuner 提供多个开箱即用的配置文件，用户可以通过下列命令查看：
+
+  ```shell
+  xtuner list-cfg
+  ```
+
+  或者，如果所提供的配置文件不能满足使用需求，请导出所提供的配置文件并进行相应更改：
+
+  ```shell
+  xtuner copy-cfg ${CONFIG_NAME} ${SAVE_PATH}
+  vi ${SAVE_PATH}/${CONFIG_NAME}_copy.py
+  ```
+
+- **步骤 1**，开始微调。
+
+  ```shell
+  xtuner train ${CONFIG_NAME_OR_PATH}
+  ```
+
+  例如，我们可以利用 QLoRA 算法在 oasst1 数据集上微调 InternLM2.5-Chat-7B：
+
+  ```shell
+  # 单卡
+  xtuner train internlm2_5_chat_7b_qlora_oasst1_e3 --deepspeed deepspeed_zero2
+  # 多卡
+  (DIST) NPROC_PER_NODE=${GPU_NUM} xtuner train internlm2_5_chat_7b_qlora_oasst1_e3 --deepspeed deepspeed_zero2
+  (SLURM) srun ${SRUN_ARGS} xtuner train internlm2_5_chat_7b_qlora_oasst1_e3 --launcher slurm --deepspeed deepspeed_zero2
+  ```
+
+  - `--deepspeed` 表示使用 [DeepSpeed](https://github.com/microsoft/DeepSpeed) 🚀 来优化训练过程。XTuner 内置了多种策略，包括 ZeRO-1、ZeRO-2、ZeRO-3 等。如果用户期望关闭此功能，请直接移除此参数。
+
+  - 更多示例，请查阅[文档](./docs/zh_cn/user_guides/finetune.md)。
+
+- **步骤 2**，将保存的 PTH 模型（如果使用的DeepSpeed，则将会是一个文件夹）转换为 HuggingFace 模型：
+
+  ```shell
+  xtuner convert pth_to_hf ${CONFIG_NAME_OR_PATH} ${PTH} ${SAVE_PATH}
+  ```
+
+### 对话
+
+XTuner 提供与大语言模型对话的工具。
+
+```shell
+xtuner chat ${NAME_OR_PATH_TO_LLM} --adapter {NAME_OR_PATH_TO_ADAPTER} [optional arguments]
+```
+
+例如：
+
+与 InternLM2.5-Chat-7B 对话：
+
+```shell
+xtuner chat internlm/internlm2-chat-7b --prompt-template internlm2_chat
+```
+
+更多示例，请查阅[文档](./docs/zh_cn/user_guides/chat.md)。
+
+### 部署
+
+- **步骤 0**，将 HuggingFace adapter 合并到大语言模型：
+
+  ```shell
+  xtuner convert merge \
+      ${NAME_OR_PATH_TO_LLM} \
+      ${NAME_OR_PATH_TO_ADAPTER} \
+      ${SAVE_PATH} \
+      --max-shard-size 2GB
+  ```
+
+- **步骤 1**，使用任意推理框架部署微调后的大语言模型，例如 [LMDeploy](https://github.com/InternLM/lmdeploy) 🚀：
+
+  ```shell
+  pip install lmdeploy
+  python -m lmdeploy.pytorch.chat ${NAME_OR_PATH_TO_LLM} \
+      --max_new_tokens 256 \
+      --temperture 0.8 \
+      --top_p 0.95 \
+      --seed 0
+  ```
+
+  🔥 追求速度更快、显存占用更低的推理？欢迎体验 [LMDeploy](https://github.com/InternLM/lmdeploy) 提供的 4-bit 量化！使用指南请见[文档](https://github.com/InternLM/lmdeploy/tree/main#quantization)。
+
+### 评测
+
+- 推荐使用一站式平台 [OpenCompass](https://github.com/InternLM/opencompass) 来评测大语言模型，其目前已涵盖 50+ 数据集的约 30 万条题目。
+
+## 🤝 贡献指南
+
+我们感谢所有的贡献者为改进和提升 XTuner 所作出的努力。请参考[贡献指南](.github/CONTRIBUTING.md)来了解参与项目贡献的相关指引。
+
+## 🎖️ 致谢
+
+- [Llama 2](https://github.com/facebookresearch/llama)
+- [DeepSpeed](https://github.com/microsoft/DeepSpeed)
+- [QLoRA](https://github.com/artidoro/qlora)
+- [LMDeploy](https://github.com/InternLM/lmdeploy)
+- [LLaVA](https://github.com/haotian-liu/LLaVA)
+
+## 🖊️ 引用
+
+```bibtex
+@misc{2023xtuner,
+    title={XTuner: A Toolkit for Efficiently Fine-tuning LLM},
+    author={XTuner Contributors},
+    howpublished = {\url{https://github.com/InternLM/xtuner}},
+    year={2023}
+}
+```
+
+## 开源许可证
+
+该项目采用 [Apache License 2.0 开源许可证](LICENSE)。同时，请遵守所使用的模型与数据集的许可证。

data/.ipynb_checkpoints/readme-checkpoint.md

@@ -0,0 +1,505 @@
+# Qwen整体介绍
+Qwen模型架构讲解直播：[直播链接](https://meeting.tencent.com/v2/cloud-record/share?id=0be29bb2-0648-4aeb-9baa-c9dc91dfc7a6&from=3&is-single=false&record_type=2)
+
+Qwen的整体架构与Llama2类似，如下图所示:
+![框架图](./img/framework.JPG)  
+
+其中:   
+- `tokenizer`将文本转为词表里面的数值。
+- 数值经过`embedding`得到一一对应的向量。
+- `attention_mask`是用来看见左边、右边，双向等等来设定。
+- 各类下游任务，`Casual`,`seqcls`等，基本都是基础模型`model`后面接对应的`Linear`层，还有损失函数不一样。
+
+
+
+# 1 Qwen2Config
+Qwen2Config中包含一些自定义的超参数，例如`vocab_size`,`hidden_size`,`num_hidden_layers`, `num_attention_heads`等。类似于`dict`可以调用里面的超参数:`config.pad_token_id`。 
+## 1.1 Qwen2Model 
+### 1.1.1 初始化
+
+- 设置了模型的两个属性:`padding_idx`（用于指定填充标记的索引），`vocab_size`（词汇表的大小）
+- 初始化了模型的嵌入层、解码器层、归一化层
+- 嵌入层（`nn.Embedding`）：模型使用嵌入层将输入的标记映射成密集的向量表示。
+- 解码器层（`nn.ModuleList()`）：模型包含多个解码器层，这些层都是由 `Qwen2DecoderLayer``  定义
+- 归一化层 `Qwen2RMSNorm`：归一化层使用的是 Root Mean Square Layer Normalization
+- 设置了是否使用 `gradient_checkpoint` 主要是用来节省显存
+- 调用 `post_init()` 完成一些初始化和准备检查的代码
+
+```python
+class Qwen2Model(Qwen2PreTrainedModel):
+    def __init__(self, config: Qwen2Config):
+        super().__init__(config)
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+
+        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+        self.layers = nn.ModuleList(
+            [Qwen2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self.norm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+```
+对于`post_init`函数：
+主要是对参数进行初始化，以及初始化梯度检查点作用  
+```python
+def post_init(self):
+    """
+    A method executed at the end of each Transformer model initialization, to execute code that needs the model's
+    modules properly initialized (such as weight initialization).
+    """
+    self.init_weights()
+    self._backward_compatibility_gradient_checkpointing()
+```
+
+### 1.1.2 Forward
+在此只对核心主干进行讲解:
+```python
+inputs_embeds = self.embed_tokens(input_ids)
+# embed positions
+hidden_states = inputs_embeds
+
+for idx, decoder_layer in enumerate(self.layers):
+    # 将所有的hidden_states保存成tuple
+    if output_hidden_states:
+        all_hidden_states += (hidden_states,)
+    # 将hs送入每一层decoder_layer
+    layer_outputs = decoder_layer(
+        hidden_states,
+        attention_mask=attention_mask,
+        position_ids=position_ids,
+        past_key_value=past_key_value,
+        output_attentions=output_attentions,
+        use_cache=use_cache,
+    )
+    # 取出上一层decoder_输出的hs,再传入下一个layer
+    # 只要第一个,第二个是cache的一个类，然后进入下一个layer
+    hidden_states = layer_outputs[0]
+    
+# 将最后layers输出后的hidden_states进行标准化  
+hidden_states = self.norm(hidden_states)
+    
+# 加上最后一层的hidden_states
+if output_hidden_states:
+    all_hidden_states += (hidden_states,)
+```
+- 如果保存`output_hidden_states`的话，就是第一个为`input_ids`进行`emb`，然后保存到`n-1`层的`decoder_layer`的输出`hs`，再加上最后一层`layer`的输出`hs`进行过`norm`后的`hs`.
+- 最后是以`BaseModelOutputWithPast`的形式输出。
+
+## 1.2 Qwen2DecoderLayer
+
+<div align=center>
+    <img src='./img/decoderlayer.png'>
+</div>
+
+### 1.2.1 初始化
+`layer`三件套:`attn`+`MLP`+`norm`
+
+```python
+QWEN2_ATTENTION_CLASSES = {
+    "eager": Qwen2Attention,  # 一般情况下是这个
+    "flash_attention_2": Qwen2FlashAttention2,
+    "sdpa": Qwen2SdpaAttention,
+}
+
+class Qwen2DecoderLayer(nn.Module):
+    def __init__(self, config: Qwen2Config):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.self_attn = QWEN2_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)
+
+        self.mlp = Qwen2MLP(config)
+        self.input_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+```
+这里面的`input_layernorm`和`post_attention_layernorm`内容是一样的，只是应用的顺序不一样。
+### 1.1.2 Forward
+可配合图食用，效果更佳:
+- 首先复制一份`hidden_states`为`residual`,然后将`hidden_states`送入`Norm`,再送入`attn`模块。
+- 得到`attn`的输出后，再复制一份`residual`，再将`hidden_states`送入`Norm`，`mlp`，再与`residual`进行相加。最后输出的就是这个`hidden_states`啦。  
+
+```python
+residual = hidden_states
+#  标准化后送入attn
+hidden_states = self.input_layernorm(hidden_states)  # RMSNorm标准化
+# Self Attention
+hidden_states, self_attn_weights, present_key_value = self.self_attn(  
+    hidden_states=hidden_states,
+    attention_mask=attention_mask,
+    position_ids=position_ids,
+    past_key_value=past_key_value,
+    output_attentions=output_attentions,
+    use_cache=use_cache,
+    **kwargs,
+)
+
+# 残差与新的hidden_states相加
+hidden_states = residual + hidden_states
+
+# Fully Connected
+residual = hidden_states
+# 同样的RMSNorm标准化
+hidden_states = self.post_attention_layernorm(hidden_states)
+hidden_states = self.mlp(hidden_states)
+hidden_states = residual + hidden_states
+
+outputs = (hidden_states,)
+
+return outputs
+```
+
+## 1.3 Qwen2Attention
+<div align=center>
+    <img src='./img/Qwen2Attention.png'>
+</div>
+
+### 1.3.1 初始化
+核心参数解析:
+- `num_key_value_heads`:表示键值对的头数
+- `num_key_value_groups`:表示键值对的组数，计算为`num_heads` // `num_key_value_headsGQA`的实现！！
+- `q_proj`,`k_proj`,`v_proj`,`o_proj`四个`Linear`操作。后续`LoRa`也基本都对他动的刀子.
+
+```python
+class Qwen2Attention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config: Qwen2Config):
+        super().__init__()
+        self.config = config
+        self.layer_idx = layer_idx
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.hidden_size // self.num_heads
+        self.num_key_value_heads = config.num_key_value_heads
+        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
+        self.max_position_embeddings = config.max_position_embeddings
+        self.rope_theta = config.rope_theta
+        self.is_causal = True
+        self.attention_dropout = config.attention_dropout
+
+        if (self.head_dim * self.num_heads) != self.hidden_size:
+            raise ValueError(
+                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
+                f" and `num_heads`: {self.num_heads})."
+            )
+        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=config.attention_bias)
+        self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=config.attention_bias)
+        self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=config.attention_bias)
+        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=config.attention_bias)
+        
+        self.rotary_emb = Qwen2RotaryEmbedding(
+            self.head_dim,
+            max_position_embeddings=self.max_position_embeddings,
+            base=self.rope_theta,
+        )
+```
+- `config`里面的参数可直接看`Qwen2Config`里面的介绍  
+
+```python
+max_position_embeddings (`int`, *optional*, defaults to 32768):
+            The maximum sequence length that this model might ever be used with.
+            
+rope_theta (`float`, *optional*, defaults to 10000.0):
+            The base period of the RoPE embeddings.
+```
+### 1.3.2 Forward
+- 首先将`hidden_states`送入`Linear`中得到`query`、`key`与`value`。
+- 使用旋转位置嵌入操作`rotary_emb`，使用了旋转位置嵌入的余弦和正弦部分，将他们与`query`和`key`相乘，并将结果相加，从而实现旋转位置嵌入的效果。
+- 将`key_states`和`value_states`重复`group`次，再执行`dot attn`操作。
+- 在`dot attn`操作后得到`attn_weights`,加上`attention_mask`从而实现读取掩盖操作，在经过`softmax`与`value_states`相乘。得到`attn_output`。
+- 再将上述的`attn_output`进行`reshape`操作，送入`o_proj`，得到最终的输出。  
+
+```python
+# 获取形状信息,hidden_states输入的为(bs,T,hd)
+bsz, q_len, _ = hidden_states.size()
+
+# 对hidden_states进行Linear生成query、key、value
+query_states = self.q_proj(hidden_states)
+key_states = self.k_proj(hidden_states)
+value_states = self.v_proj(hidden_states)
+
+ # reshape多头处理--分块--(bs,T,heads,hd_d)
+query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+
+# 将旋转位置嵌入应用于查询和键张量。使用了旋转位置嵌入的余弦和正弦��分，将它们与查询和键张量相乘，并将结果相加，从而实现旋转位置嵌入的效果
+cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
+query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
+
+# 先将key_states和value_states重复了num_key_value_groups次
+key_states = repeat_kv(key_states, self.num_key_value_groups)
+value_states = repeat_kv(value_states, self.num_key_value_groups)
+
+# 使用dot attn实现q*kT/hd_d^0.5
+attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
+
+# 然后 attn_weights 加上 attention_mask，实现读取顺序
+attn_weights = attn_weights + attention_mask
+
+# softmax + dropout + values_states相乘
+attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training)
+attn_output = torch.matmul(attn_weights, value_states)
+
+# 转置，修改形状等reshape操作
+attn_output = attn_output.transpose(1, 2).contiguous()
+attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
+
+# 最后在进行一次o_proj
+attn_output = self.o_proj(attn_output)
+
+# 返回结果
+return attn_output, attn_weights, past_key_value
+```
+
+### 1.3.3 细节Debug
+#### 1.3.3.1 GQA
+<div align=center>
+    <img src='./img/GQA.png'>
+</div>
+
+> 主旨:GQA和MQA不需要在推理的过程存储那么多的kv cache, 那么kv cache占用的显存就变小，那么我们LLM serving可以处理的请求数量就更多
+
+1. 定义初始张量
+```python
+import torch
+
+## shape:(batch, seq_len, head, head_dim)
+query = torch.randn(10, 128, 8, 128)
+key = torch.randn(10, 128, 2, 128)
+value = torch.randn(10, 128, 2, 128)
+
+## 在此设置组数为4
+groups = query.shape[-2] // key.shape[-2]
+```
+2. 之后进行扩展key，value的操作  
+在`GQA`中，`key`和`value`都要比`query`小`group`倍，但是为在后续做矩阵乘法时方便，我们需要先把`key`和`value`的`head`利用expand扩展张量到和`query`相同的维度。方便后续计算。  
+
+```python
+# 定义输入x， n_rep是需要重复的次数，在这里一般是组数
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+
+    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+    # dont need repeat here means multi head attention
+    if n_rep == 1:
+        return hidden_states
+    # first we expand x to (bs, seq_len, head, group, head_dim)
+    hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+    # reshape make head -> head * group
+    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+```
+3. 矩阵乘法得到`score`与`output`
+后面就是征程的`kqv`相乘了
+```python
+#(bs, head, seq_len, head_dim)
+query = query.transpose(1, 2)
+key = repeat_kv(key.transpose(1, 2), 4)
+value = repeat_kv(value.transpose(1, 2), 4)
+scores = torch.matmul(query, key.transpose(2, 3)) / math.sqrt(head_dim)
+scores = torch.nn.functional.softmax(scores, dim=-1)
+
+out = torch.matmul(scores, value)
+#上一步转置了，还得转回去
+out = out.transpose(1, 2)
+```
+**补充：**   
+**为什么要用expand之后再reshape而不能直接用tensor自带的repeat?** 
+- `expand` 方法用于对张量进行扩展，但不实际分配新的内存。它返回的张量与原始张量共享相同的数据
+- `repeat` 方法通过实际复制数据来扩展张量。它返回的新张量不与原始张量共享数据，扩展后的张量占用了更多的内存。
+
+
+#### 1.3.3.2 apply_rotary_pos_emb
+位置编码的含义是对每一个token的每一个dim赋予不同的位置信息。
+公式定义:  
+<div align=center>
+    <img src='./img/ROPE1.png'>
+</div> 
+
+概念：通过旋转编码，使得每个token既有相对位置信息，又有绝对位置信息。
+- 既能以自注意力矩阵偏置的形式作用于 $A_{t,s}$,直接反映两个token的相对位置信息，又能拆解到向量 $q_{t}$ 和 $k_{s}$ 上，通过直接编码token的绝对位置实现。
+- RoPE本质是实现对特征向量的旋转操作，如果以二维特征向量举例，对于相邻两个token来说，其对应同一个 $\theta$,其定义为:  
+<div align=center>
+    <img src='./img/ROPE2.png'>
+</div> 
+
+可得，其本质就是: $q_{t}$, $k_{s}$ 旋转后的结果，就是 $q_{t}$, $k_{s}$乘上cos再加上 $q_{t}$, $k_{s}$翻转维度并取反一维后乘上sin。
+- 对于高纬向量，由于奇、复数维度两两交错实现较为复杂，则现在可简化为将特征维度一切二，如下图所示，在实现过程中对前后各半进行的操作即为rotate_half操作： 
+<div align=center>
+    <img src='./img/ROPE3.png'>
+</div> 
+
+
+代码实现：  
+先定义旋转角度
+```python
+class Qwen2RotaryEmbedding(nn.Module):
+    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
+        super().__init__()
+        # 定义初始值
+        self.dim = dim
+        self.max_position_embeddings = max_position_embeddings
+        self.base = base
+        # 定义旋转角
+        inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, dtype=torch.int64).float().to(device) / self.dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        # Build here to make `torch.jit.trace` work.
+        self._set_cos_sin_cache(
+            seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
+        )
+    # 为seq里面的每个token形成独一无二的旋转角嵌入(外积)
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+        t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.int64).type_as(self.inv_freq)
+
+        freqs = torch.outer(t, self.inv_freq)
+        # 生成角度信息(利用注册机制生成self.cos_cached与sin_cached
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        if seq_len > self.max_seq_len_cached:
+            self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)
+
+        return (
+            self.cos_cached[:seq_len].to(dtype=x.dtype),
+            self.sin_cached[:seq_len].to(dtype=x.dtype),
+        )
+```
+首先要先生成角度:
+$$
+\theta = \left(\frac{1}{10000^{2n/d}}\right)
+$$
+
+其中，n表示维度数，其取值范围为[0, 1, ..., d/2-1]  
+<div align=center>
+    <img src='./img/ROPE4.png'>
+</div> 
+
+然后将上述生成角度与每一个位置乘积，区分一个seq中各个词：其实等价于:
+$$\theta = \left(\frac{i}{10000^{2n/d}}\right)$$  
+其中: `i`为行数。  
+<div align=center>
+    <img src='./img/ROPE5.png'>
+</div> 
+
+emb将二者cat起来，得到dim维度，每dim/2一循环：  
+<div align=center>
+    <img src='./img/ROPE6.png'>
+</div> 
+
+然后，在取出位置编码信息`cos`与`sin`的时候，就是将`seq`的部分切出来，原先设置的1024是最大`pos`编码，每次用的时候只取当下`seq_len`的即可.之前求得外积，是为了保证`seq`里面得每一个词都能有不同的1024个位置编码。
+<div align=center>
+    <img src='./img/ROPE7.png'>
+</div> 
+
+进行旋转嵌入:  
+```python
+# 后半部分和前半部分进行了交换，并且将后半部分的符号取反。
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):
+    """Applies Rotary Position Embedding to the query and key tensors.
+
+    query and key tensors rotated using the Rotary Position Embedding.
+    """
+    cos = cos[position_ids].unsqueeze(unsqueeze_dim)
+    sin = sin[position_ids].unsqueeze(unsqueeze_dim)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+```
+对应公式：  
+<div align=center>
+    <img src='./img/ROPE8.png'>
+</div> 
+
+其中，下标t则表示位于同一行，也就是同一`seq_len`，对于相邻的两个元素，
+
+#### 1.3.3.3 读取顺序attention_mask
+第一步的时候只能看到自己，第二步只能看到0、1...其余的都是负无穷。 
+<div align=center>
+    <img src='./img/Mask1.png'>
+</div> 
+
+经过softmax，对应负无穷的位置权重为0，从而实现只能从左往右。
+<div align=center>
+    <img src='./img/Mask2.png'>
+</div> 
+
+- `attn`形状为(bs,heads,T,T),`values`的形状为(bs,heads,T,hd),最终落实到[30,30]×[30,128]上，30表示一句话的步长，也就是总词数。
+- `value`里面每一个词有128个维度来描述，对于第一个词，由于`attn`为下三角，所以每一个维度都只有第一个非零元素1进行相乘，其他的都是×0。
+- - 对于第二行，则是前两个有不同的权值，让value的128个维度分别依据这两个的权重，在128个维度上根据前两行，计算得出output的第二个词(第二步或者第二行)的128个维度.... 这种加权，体现出考虑前词关系。
+- 第n步则对应有n个权重，用来描述从1到n个步之间的各个关系，进而计算出各个维度。
+- 每一个矩阵乘法的结果相当于是下一个词的dim，那么score则是根据mask来判断，能通过前几个词对应dim的值从而进行加权，进而得到下一个词的该dim上的值。
+<div align=center>
+    <img src='./img/Mask3.png'>
+</div>
+- 对于推理的过程，问询不一样长没关系，因为所有的权重都是dim-dim，得到的attention_score是一个seq,seq的，权重跟seq的大小没关系。其都是后面的dim维度的参数。
+- 推理过程的attention_mask可有可无，是一个一个吐，循环cat到下一个，每一次都取最后一个，代表着预测的是下一个token。
+
+## 1.4 Qwen2 MLP
+
+<div align=center>
+    <img src='./img/MLP1.png'>
+</div>
+
+输入`hidden_state`并行送入两个`Linear`层，其中一个激活一下，再与另一个相乘，最终再经过一个`Linear`，输出最终结果。
+```python
+class Qwen2MLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        # 这俩不必多说
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+
+        # 三个全连接层
+        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, x):
+        down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+        return down_proj
+```
+## 1.5 Qwen2RMSNorm
+计算公式:
+
+<img src="./img/RMSNorm_formulation.jpg" width="400" height="auto">
+
+其中:
+- $x$是层的输入的`hidden_state`
+- $w_i$ 表示的是`hidden_state`的最后一个维度的值
+- $n$ 表示上面输入的最后一个维度的数量。
+- $\epsilon$ 表示是很小的数，防止除0。
+
+```python
+class Qwen2RMSNorm(nn.Module):  # 标准化层
+    def __init__(self, hidden_size, eps=1e-6):
+        """
+        Qwen2RMSNorm is equivalent to T5LayerNorm
+        """
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+```
+- `torch.rsqrt`表示输入的东西开根的导数。
+- `.pow(2).mean(-1, keepdim=True)`表示对最后一个维度平方并取均值。

data/README_zh-CN.md

@@ -0,0 +1,304 @@
+<div align="center">
+  <img src="https://github.com/InternLM/lmdeploy/assets/36994684/0cf8d00f-e86b-40ba-9b54-dc8f1bc6c8d8" width="600"/>
+  <br /><br />
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/InternLM/xtuner?style=social)](https://github.com/InternLM/xtuner/stargazers)
+[![license](https://img.shields.io/github/license/InternLM/xtuner.svg)](https://github.com/InternLM/xtuner/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/xtuner)](https://pypi.org/project/xtuner/)
+[![Downloads](https://static.pepy.tech/badge/xtuner)](https://pypi.org/project/xtuner/)
+[![issue resolution](https://img.shields.io/github/issues-closed-raw/InternLM/xtuner)](https://github.com/InternLM/xtuner/issues)
+[![open issues](https://img.shields.io/github/issues-raw/InternLM/xtuner)](https://github.com/InternLM/xtuner/issues)
+
+👋 加入我们：[![Static Badge](https://img.shields.io/badge/-grey?style=social&logo=wechat&label=微信)](https://cdn.vansin.top/internlm/xtuner.jpg)
+[![Static Badge](https://img.shields.io/badge/-grey?style=social&logo=twitter&label=推特)](https://twitter.com/intern_lm)
+[![Static Badge](https://img.shields.io/badge/-grey?style=social&logo=discord&label=Discord)](https://discord.gg/xa29JuW87d)
+
+🔍 探索我们的模型：
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🤗%20Huggingface)](https://huggingface.co/xtuner)
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🤖%20ModelScope)](https://www.modelscope.cn/organization/xtuner)
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🧰%20OpenXLab)](https://openxlab.org.cn/usercenter/xtuner)
+[![Static Badge](https://img.shields.io/badge/-gery?style=social&label=🧠%20WiseModel)](https://www.wisemodel.cn/organization/xtuner)
+
+[English](README.md) | 简体中文
+
+</div>
+
+## 🚀 Speed Benchmark
+
+- XTuner 与 LLaMA-Factory 在 Llama2-7B 模型上的训练效率对比
+
+<div align=center>
+  <img src="https://github.com/InternLM/xtuner/assets/41630003/9c9dfdf4-1efb-4daf-84bf-7c379ae40b8b" style="width:80%">
+</div>
+
+- XTuner 与 LLaMA-Factory 在 Llama2-70B 模型上的训练效率对比
+
+<div align=center>
+  <img src="https://github.com/InternLM/xtuner/assets/41630003/5ba973b8-8885-4b72-b51b-c69fa1583bdd" style="width:80%">
+</div>
+
+## 🎉 更新
+- **\[2024/07\]** 支持 [MiniCPM](xtuner/configs/minicpm/) 模型!
+- **\[2024/07\]** 支持训练 [DPO](https://github.com/InternLM/xtuner/tree/main/xtuner/configs/dpo)， [ORPO](https://github.com/InternLM/xtuner/tree/main/xtuner/configs/orpo) 还有 [Reward Model](https://github.com/InternLM/xtuner/tree/main/xtuner/configs/reward_model) ! 并且能够支持打包数据以及序列并行功能！ 请参考 [文档](https://xtuner.readthedocs.io/zh-cn/latest/dpo/overview.html) 了解更多信息。
+- **\[2024/07\]** 支持 [InternLM 2.5](xtuner/configs/internlm/internlm2_5_chat_7b/) 模型!
+- **\[2024/06\]** 支持 [DeepSeek V2](xtuner/configs/deepseek/deepseek_v2_chat/) models! **训练速度提升一倍！**
+- **\[2024/04\]** 多模态大模型 [LLaVA-Phi-3-mini](https://huggingface.co/xtuner/llava-phi-3-mini-hf) 发布！快速开始请查阅此[文档](xtuner/configs/llava/phi3_mini_4k_instruct_clip_vit_large_p14_336)！
+- **\[2024/04\]** 多模态大模型 [LLaVA-Llama-3-8B](https://huggingface.co/xtuner/llava-llama-3-8b) 和 [LLaVA-Llama-3-8B-v1.1](https://huggingface.co/xtuner/llava-llama-3-8b-v1_1) 发布！快速开始请查阅此[文档](xtuner/configs/llava/llama3_8b_instruct_clip_vit_large_p14_336)！
+- **\[2024/04\]** 支持 [Llama 3](xtuner/configs/llama) 模型！
+- **\[2024/04\]** 支持序列并行训练策略以实现语言模型超长上下文训练！\[[文档](https://github.com/InternLM/xtuner/blob/docs/docs/zh_cn/acceleration/train_extreme_long_sequence.rst)\] \[[速度基准](https://github.com/InternLM/xtuner/blob/docs/docs/zh_cn/acceleration/benchmark.rst)\]
+- **\[2024/02\]** 支持 [Gemma](xtuner/configs/gemma) 模型！
+- **\[2024/02\]** 支持 [Qwen1.5](xtuner/configs/qwen/qwen1_5) 模型！
+- **\[2024/01\]** 支持 [InternLM2](xtuner/configs/internlm) 模型！同时，最新版的多模态大模型 [LLaVA-Internlm2-7B](https://huggingface.co/xtuner/llava-internlm2-7b) / [20B](https://huggingface.co/xtuner/llava-internlm2-20b) 发布，其表现出强大的性能！
+- **\[2024/01\]** 支持 [DeepSeek-MoE](https://huggingface.co/deepseek-ai/deepseek-moe-16b-chat) 模型！20GB 显存即可实现 QLoRA 微调，4x80GB 即可实现全参数微调。快速开始请查阅相关[配置文件](xtuner/configs/deepseek/)！
+- **\[2023/12\]** 🔥 支持多模态模型 VLM（[LLaVA-v1.5](https://github.com/haotian-liu/LLaVA)）预训练和指令微调！快速开始请查阅此[文档](xtuner/configs/llava/README_zh-CN.md)！
+- **\[2023/12\]** 🔥 支持 [Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1) 模型！快速开始请查阅此[文档](xtuner/configs/mixtral/README.md)！
+- **\[2023/11\]** 支持 [ChatGLM3-6B](xtuner/configs/chatglm) 模型！
+- **\[2023/10\]** 支持 [MSAgent-Bench](https://modelscope.cn/datasets/damo/MSAgent-Bench) 数据集，并且微调所得大语言模型可应用至 [Lagent](https://github.com/InternLM/lagent) 框架！
+- **\[2023/10\]** 优化数据处理逻辑以兼容 `system` 字段，相关细节请查阅[文档](docs/zh_cn/user_guides/dataset_format.md)！
+- **\[2023/09\]** 支持 [InternLM-20B](xtuner/configs/internlm) 系列模型！
+- **\[2023/09\]** 支持 [Baichuan2](xtuner/configs/baichuan) 系列模型！
+- **\[2023/08\]** XTuner 正式发布！众多微调模型已上传至 [HuggingFace](https://huggingface.co/xtuner)！
+
+## 📖 介绍
+
+XTuner 是一个高效、灵活、全能的轻量化大模型微调工具库。
+
+**高效**
+
+- 支持大语言模型 LLM、多模态图文模型 VLM 的预训练及轻量级微调。XTuner 支持在 8GB 显存下微调 7B 模型，同时也支持多节点跨设备微调更大尺度模型（70B+）。
+- 自动分发高性能算子（如 FlashAttention、Triton kernels 等）以加速训练吞吐。
+- 兼容 [DeepSpeed](https://github.com/microsoft/DeepSpeed) 🚀，轻松应用各种 ZeRO 训练优化策略。
+
+**灵活**
+
+- 支持多种大语言模型，包括但不限于 [InternLM](https://huggingface.co/internlm)、[Mixtral-8x7B](https://huggingface.co/mistralai)、[Llama 2](https://huggingface.co/meta-llama)、[ChatGLM](https://huggingface.co/THUDM)、[Qwen](https://huggingface.co/Qwen)、[Baichuan](https://huggingface.co/baichuan-inc)。
+- 支持多模态图文模型 LLaVA 的预训练与微调。利用 XTuner 训得模型 [LLaVA-InternLM2-20B](https://huggingface.co/xtuner/llava-internlm2-20b) 表现优异。
+- 精心设计的数据管道，兼容任意数据格式，开源数据或自定义数据皆可快速上手。
+- 支持 [QLoRA](http://arxiv.org/abs/2305.14314)、[LoRA](http://arxiv.org/abs/2106.09685)、全量参数微调等多种微调算法，支撑用户根据具体需求作出最优选择。
+
+**全能**
+
+- 支持增量预训练、指令微调与 Agent 微调。
+- 预定义众多开源对话模版，支持与开源或训练所得模型进行对话。
+- 训练所得模型可无缝接入部署工具库 [LMDeploy](https://github.com/InternLM/lmdeploy)、大规模评测工具库 [OpenCompass](https://github.com/open-compass/opencompass) 及 [VLMEvalKit](https://github.com/open-compass/VLMEvalKit)。
+
+## 🔥 支持列表
+
+<table>
+<tbody>
+<tr align="center" valign="middle">
+<td>
+  <b>模型</b>
+</td>
+<td>
+  <b>数据集</b>
+</td>
+<td>
+  <b>数据格式</b>
+</td>
+ <td>
+  <b>微调算法</b>
+</td>
+</tr>
+<tr valign="top">
+<td align="left" valign="top">
+<ul>
+  <li><a href="https://huggingface.co/internlm">InternLM 2 / 2.5</a></li>
+  <li><a href="https://huggingface.co/meta-llama">Llama 2 / 3</a></li>
+  <li><a href="https://huggingface.co/collections/microsoft/phi-3-6626e15e9585a200d2d761e3">Phi-3</a></li>
+  <li><a href="https://huggingface.co/THUDM/chatglm2-6b">ChatGLM2</a></li>
+  <li><a href="https://huggingface.co/THUDM/chatglm3-6b">ChatGLM3</a></li>
+  <li><a href="https://huggingface.co/Qwen/Qwen-7B">Qwen</a></li>
+  <li><a href="https://huggingface.co/baichuan-inc/Baichuan2-7B-Base">Baichuan2</a></li>
+  <li><a href="https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1">Mixtral</a></li>
+  <li><a href="https://huggingface.co/deepseek-ai/DeepSeek-V2-Chat">DeepSeek V2</a></li>
+  <li><a href="https://huggingface.co/google">Gemma</a></li>
+  <li><a href="https://huggingface.co/openbmb">MiniCPM</a></li>
+  <li>...</li>
+</ul>
+</td>
+<td>
+<ul>
+  <li><a href="https://modelscope.cn/datasets/damo/MSAgent-Bench">MSAgent-Bench</a></li>
+  <li><a href="https://huggingface.co/datasets/fnlp/moss-003-sft-data">MOSS-003-SFT</a> 🔧</li>
+  <li><a href="https://huggingface.co/datasets/tatsu-lab/alpaca">Alpaca en</a> / <a href="https://huggingface.co/datasets/silk-road/alpaca-data-gpt4-chinese">zh</a></li>
+  <li><a href="https://huggingface.co/datasets/WizardLM/WizardLM_evol_instruct_V2_196k">WizardLM</a></li>
+  <li><a href="https://huggingface.co/datasets/timdettmers/openassistant-guanaco">oasst1</a></li>
+  <li><a href="https://huggingface.co/datasets/garage-bAInd/Open-Platypus">Open-Platypus</a></li>
+  <li><a href="https://huggingface.co/datasets/HuggingFaceH4/CodeAlpaca_20K">Code Alpaca</a></li>
+  <li><a href="https://huggingface.co/datasets/burkelibbey/colors">Colorist</a> 🎨</li>
+  <li><a href="https://github.com/WangRongsheng/ChatGenTitle">Arxiv GenTitle</a></li>
+  <li><a href="https://github.com/LiuHC0428/LAW-GPT">Chinese Law</a></li>
+  <li><a href="https://huggingface.co/datasets/Open-Orca/OpenOrca">OpenOrca</a></li>
+  <li><a href="https://huggingface.co/datasets/shibing624/medical">Medical Dialogue</a></li>
+  <li>...</li>
+</ul>
+</td>
+<td>
+<ul>
+  <li><a href="docs/zh_cn/user_guides/incremental_pretraining.md">Incremental Pre-training</a> </li>
+  <li><a href="docs/zh_cn/user_guides/single_turn_conversation.md">Single-turn Conversation SFT</a> </li>
+  <li><a href="docs/zh_cn/user_guides/multi_turn_conversation.md">Multi-turn Conversation SFT</a> </li>
+</ul>
+</td>
+<td>
+<ul>
+  <li><a href="http://arxiv.org/abs/2305.14314">QLoRA</a></li>
+  <li><a href="http://arxiv.org/abs/2106.09685">LoRA</a></li>
+  <li>全量参数微调</li>
+  <li><a href="https://arxiv.org/abs/2305.18290">DPO</a></li>
+  <li><a href="https://arxiv.org/abs/2403.07691">ORPO</a></li>
+  <li>Reward Model</a></li>
+</ul>
+</td>
+</tr>
+</tbody>
+</table>
+
+## 🛠️ 快速上手
+
+### 安装
+
+- 推荐使用 conda 先构建一个 Python-3.10 的虚拟环境
+
+  ```bash
+  conda create --name xtuner-env python=3.10 -y
+  conda activate xtuner-env
+  ```
+
+- 通过 pip 安装 XTuner：
+
+  ```shell
+  pip install -U xtuner
+  ```
+
+  亦可集成 DeepSpeed 安装：
+
+  ```shell
+  pip install -U 'xtuner[deepspeed]'
+  ```
+
+- 从源码安装 XTuner：
+
+  ```shell
+  git clone https://github.com/InternLM/xtuner.git
+  cd xtuner
+  pip install -e '.[all]'
+  ```
+
+### 微调
+
+XTuner 支持微调大语言模型。数据集预处理指南请查阅[文档](./docs/zh_cn/user_guides/dataset_prepare.md)。
+
+- **步骤 0**，准备配置文件。XTuner 提供多个开箱即用的配置文件，用户可以通过下列命令查看：
+
+  ```shell
+  xtuner list-cfg
+  ```
+
+  或者，如果所提供的配置文件不能满足使用需求，请导出所提供的配置文件并进行相应更改：
+
+  ```shell
+  xtuner copy-cfg ${CONFIG_NAME} ${SAVE_PATH}
+  vi ${SAVE_PATH}/${CONFIG_NAME}_copy.py
+  ```
+
+- **步骤 1**，开始微调。
+
+  ```shell
+  xtuner train ${CONFIG_NAME_OR_PATH}
+  ```
+
+  例如，我们可以利用 QLoRA 算法在 oasst1 数据集上微调 InternLM2.5-Chat-7B：
+
+  ```shell
+  # 单卡
+  xtuner train internlm2_5_chat_7b_qlora_oasst1_e3 --deepspeed deepspeed_zero2
+  # 多卡
+  (DIST) NPROC_PER_NODE=${GPU_NUM} xtuner train internlm2_5_chat_7b_qlora_oasst1_e3 --deepspeed deepspeed_zero2
+  (SLURM) srun ${SRUN_ARGS} xtuner train internlm2_5_chat_7b_qlora_oasst1_e3 --launcher slurm --deepspeed deepspeed_zero2
+  ```
+
+  - `--deepspeed` 表示使用 [DeepSpeed](https://github.com/microsoft/DeepSpeed) 🚀 来优化训练过程。XTuner 内置了多种策略，包括 ZeRO-1、ZeRO-2、ZeRO-3 等。如果用户期望关闭此功能，请直接移除此参数。
+
+  - 更多示例，请查阅[文档](./docs/zh_cn/user_guides/finetune.md)。
+
+- **步骤 2**，将保存的 PTH 模型（如果使用的DeepSpeed，则将会是一个文件夹）转换为 HuggingFace 模型：
+
+  ```shell
+  xtuner convert pth_to_hf ${CONFIG_NAME_OR_PATH} ${PTH} ${SAVE_PATH}
+  ```
+
+### 对话
+
+XTuner 提供与大语言模型对话的工具。
+
+```shell
+xtuner chat ${NAME_OR_PATH_TO_LLM} --adapter {NAME_OR_PATH_TO_ADAPTER} [optional arguments]
+```
+
+例如：
+
+与 InternLM2.5-Chat-7B 对话：
+
+```shell
+xtuner chat internlm/internlm2-chat-7b --prompt-template internlm2_chat
+```
+
+更多示例，请查阅[文档](./docs/zh_cn/user_guides/chat.md)。
+
+### 部署
+
+- **步骤 0**，将 HuggingFace adapter 合并到大语言模型：
+
+  ```shell
+  xtuner convert merge \
+      ${NAME_OR_PATH_TO_LLM} \
+      ${NAME_OR_PATH_TO_ADAPTER} \
+      ${SAVE_PATH} \
+      --max-shard-size 2GB
+  ```
+
+- **步骤 1**，使用任意推理框架部署微调后的大语言模型，例如 [LMDeploy](https://github.com/InternLM/lmdeploy) 🚀：
+
+  ```shell
+  pip install lmdeploy
+  python -m lmdeploy.pytorch.chat ${NAME_OR_PATH_TO_LLM} \
+      --max_new_tokens 256 \
+      --temperture 0.8 \
+      --top_p 0.95 \
+      --seed 0
+  ```
+
+  🔥 追求速度更快、显存占用更低的推理？欢迎体验 [LMDeploy](https://github.com/InternLM/lmdeploy) 提供的 4-bit 量化！使用指南请见[文档](https://github.com/InternLM/lmdeploy/tree/main#quantization)。
+
+### 评测
+
+- 推荐使用一站式平台 [OpenCompass](https://github.com/InternLM/opencompass) 来评测大语言模型，其目前已涵盖 50+ 数据集的约 30 万条题目。
+
+## 🤝 贡献指南
+
+我们感谢所有的贡献者为改进和提升 XTuner 所作出的努力。请参考[贡献指南](.github/CONTRIBUTING.md)来了解参与项目贡献的相关指引。
+
+## 🎖️ 致谢
+
+- [Llama 2](https://github.com/facebookresearch/llama)
+- [DeepSpeed](https://github.com/microsoft/DeepSpeed)
+- [QLoRA](https://github.com/artidoro/qlora)
+- [LMDeploy](https://github.com/InternLM/lmdeploy)
+- [LLaVA](https://github.com/haotian-liu/LLaVA)
+
+## 🖊️ 引用
+
+```bibtex
+@misc{2023xtuner,
+    title={XTuner: A Toolkit for Efficiently Fine-tuning LLM},
+    author={XTuner Contributors},
+    howpublished = {\url{https://github.com/InternLM/xtuner}},
+    year={2023}
+}
+```
+
+## 开源许可证
+
+该项目采用 [Apache License 2.0 开源许可证](LICENSE)。同时，请遵守所使用的模型与数据集的许可证。

data/readme.md

@@ -0,0 +1,505 @@
+# Qwen整体介绍
+Qwen模型架构讲解直播：[直播链接](https://meeting.tencent.com/v2/cloud-record/share?id=0be29bb2-0648-4aeb-9baa-c9dc91dfc7a6&from=3&is-single=false&record_type=2)
+
+Qwen的整体架构与Llama2类似，如下图所示:
+![框架图](./img/framework.JPG)  
+
+其中:   
+- `tokenizer`将文本转为词表里面的数值。
+- 数值经过`embedding`得到一一对应的向量。
+- `attention_mask`是用来看见左边、右边，双向等等来设定。
+- 各类下游任务，`Casual`,`seqcls`等，基本都是基础模型`model`后面接对应的`Linear`层，还有损失函数不一样。
+
+
+
+# 1 Qwen2Config
+Qwen2Config中包含一些自定义的超参数，例如`vocab_size`,`hidden_size`,`num_hidden_layers`, `num_attention_heads`等。类似于`dict`可以调用里面的超参数:`config.pad_token_id`。 
+## 1.1 Qwen2Model 
+### 1.1.1 初始化
+
+- 设置了模型的两个属性:`padding_idx`（用于指定填充标记的索引），`vocab_size`（词汇表的大小）
+- 初始化了模型的嵌入层、解码器层、归一化层
+- 嵌入层（`nn.Embedding`）：模型使用嵌入层将输入的标记映射成密集的向量表示。
+- 解码器层（`nn.ModuleList()`）：模型包含多个解码器层，这些层都是由 `Qwen2DecoderLayer``  定义
+- 归一化层 `Qwen2RMSNorm`：归一化层使用的是 Root Mean Square Layer Normalization
+- 设置了是否使用 `gradient_checkpoint` 主要是用来节省显存
+- 调用 `post_init()` 完成一些初始化和准备检查的代码
+
+```python
+class Qwen2Model(Qwen2PreTrainedModel):
+    def __init__(self, config: Qwen2Config):
+        super().__init__(config)
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+
+        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+        self.layers = nn.ModuleList(
+            [Qwen2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self.norm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+```
+对于`post_init`函数：
+主要是对参数进行初始化，以及初始化梯度检查点作用  
+```python
+def post_init(self):
+    """
+    A method executed at the end of each Transformer model initialization, to execute code that needs the model's
+    modules properly initialized (such as weight initialization).
+    """
+    self.init_weights()
+    self._backward_compatibility_gradient_checkpointing()
+```
+
+### 1.1.2 Forward
+在此只对核心主干进行讲解:
+```python
+inputs_embeds = self.embed_tokens(input_ids)
+# embed positions
+hidden_states = inputs_embeds
+
+for idx, decoder_layer in enumerate(self.layers):
+    # 将所有的hidden_states保存成tuple
+    if output_hidden_states:
+        all_hidden_states += (hidden_states,)
+    # 将hs送入每一层decoder_layer
+    layer_outputs = decoder_layer(
+        hidden_states,
+        attention_mask=attention_mask,
+        position_ids=position_ids,
+        past_key_value=past_key_value,
+        output_attentions=output_attentions,
+        use_cache=use_cache,
+    )
+    # 取出上一层decoder_输出的hs,再传入下一个layer
+    # 只要第一个,第二个是cache的一个类，然后进入下一个layer
+    hidden_states = layer_outputs[0]
+    
+# 将最后layers输出后的hidden_states进行标准化  
+hidden_states = self.norm(hidden_states)
+    
+# 加上最后一层的hidden_states
+if output_hidden_states:
+    all_hidden_states += (hidden_states,)
+```
+- 如果保存`output_hidden_states`的话，就是第一个为`input_ids`进行`emb`，然后保存到`n-1`层的`decoder_layer`的输出`hs`，再加上最后一层`layer`的输出`hs`进行过`norm`后的`hs`.
+- 最后是以`BaseModelOutputWithPast`的形式输出。
+
+## 1.2 Qwen2DecoderLayer
+
+<div align=center>
+    <img src='./img/decoderlayer.png'>
+</div>
+
+### 1.2.1 初始化
+`layer`三件套:`attn`+`MLP`+`norm`
+
+```python
+QWEN2_ATTENTION_CLASSES = {
+    "eager": Qwen2Attention,  # 一般情况下是这个
+    "flash_attention_2": Qwen2FlashAttention2,
+    "sdpa": Qwen2SdpaAttention,
+}
+
+class Qwen2DecoderLayer(nn.Module):
+    def __init__(self, config: Qwen2Config):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.self_attn = QWEN2_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)
+
+        self.mlp = Qwen2MLP(config)
+        self.input_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+```
+这里面的`input_layernorm`和`post_attention_layernorm`内容是一样的，只是应用的顺序不一样。
+### 1.1.2 Forward
+可配合图食用，效果更佳:
+- 首先复制一份`hidden_states`为`residual`,然后将`hidden_states`送入`Norm`,再送入`attn`模块。
+- 得到`attn`的输出后，再复制一份`residual`，再将`hidden_states`送入`Norm`，`mlp`，再与`residual`进行相加。最后输出的就是这个`hidden_states`啦。  
+
+```python
+residual = hidden_states
+#  标准化后送入attn
+hidden_states = self.input_layernorm(hidden_states)  # RMSNorm标准化
+# Self Attention
+hidden_states, self_attn_weights, present_key_value = self.self_attn(  
+    hidden_states=hidden_states,
+    attention_mask=attention_mask,
+    position_ids=position_ids,
+    past_key_value=past_key_value,
+    output_attentions=output_attentions,
+    use_cache=use_cache,
+    **kwargs,
+)
+
+# 残差与新的hidden_states相加
+hidden_states = residual + hidden_states
+
+# Fully Connected
+residual = hidden_states
+# 同样的RMSNorm标准化
+hidden_states = self.post_attention_layernorm(hidden_states)
+hidden_states = self.mlp(hidden_states)
+hidden_states = residual + hidden_states
+
+outputs = (hidden_states,)
+
+return outputs
+```
+
+## 1.3 Qwen2Attention
+<div align=center>
+    <img src='./img/Qwen2Attention.png'>
+</div>
+
+### 1.3.1 初始化
+核心参数解析:
+- `num_key_value_heads`:表示键值对的头数
+- `num_key_value_groups`:表示键值对的组数，计算为`num_heads` // `num_key_value_headsGQA`的实现！！
+- `q_proj`,`k_proj`,`v_proj`,`o_proj`四个`Linear`操作。后续`LoRa`也基本都对他动的刀子.
+
+```python
+class Qwen2Attention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config: Qwen2Config):
+        super().__init__()
+        self.config = config
+        self.layer_idx = layer_idx
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.hidden_size // self.num_heads
+        self.num_key_value_heads = config.num_key_value_heads
+        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
+        self.max_position_embeddings = config.max_position_embeddings
+        self.rope_theta = config.rope_theta
+        self.is_causal = True
+        self.attention_dropout = config.attention_dropout
+
+        if (self.head_dim * self.num_heads) != self.hidden_size:
+            raise ValueError(
+                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
+                f" and `num_heads`: {self.num_heads})."
+            )
+        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=config.attention_bias)
+        self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=config.attention_bias)
+        self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=config.attention_bias)
+        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=config.attention_bias)
+        
+        self.rotary_emb = Qwen2RotaryEmbedding(
+            self.head_dim,
+            max_position_embeddings=self.max_position_embeddings,
+            base=self.rope_theta,
+        )
+```
+- `config`里面的参数可直接看`Qwen2Config`里面的介绍  
+
+```python
+max_position_embeddings (`int`, *optional*, defaults to 32768):
+            The maximum sequence length that this model might ever be used with.
+            
+rope_theta (`float`, *optional*, defaults to 10000.0):
+            The base period of the RoPE embeddings.
+```
+### 1.3.2 Forward
+- 首先将`hidden_states`送入`Linear`中得到`query`、`key`与`value`。
+- 使用旋转位置嵌入操作`rotary_emb`，使用了旋转位置嵌入的余弦和正弦部分，将他们与`query`和`key`相乘，并将结果相加，从而实现旋转位置嵌入的效果。
+- 将`key_states`和`value_states`重复`group`次，再执行`dot attn`操作。
+- 在`dot attn`操作后得到`attn_weights`,加上`attention_mask`从而实现读取掩盖操作，在经过`softmax`与`value_states`相乘。得到`attn_output`。
+- 再将上述的`attn_output`进行`reshape`操作，送入`o_proj`，得到最终的输出。  
+
+```python
+# 获取形状信息,hidden_states输入的为(bs,T,hd)
+bsz, q_len, _ = hidden_states.size()
+
+# 对hidden_states进行Linear生成query、key、value
+query_states = self.q_proj(hidden_states)
+key_states = self.k_proj(hidden_states)
+value_states = self.v_proj(hidden_states)
+
+ # reshape多头处理--分块--(bs,T,heads,hd_d)
+query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+
+# 将旋转位置嵌入应用于查询和键张量。使用了旋转位置嵌入的余弦和正弦��分，将它们与查询和键张量相乘，并将结果相加，从而实现旋转位置嵌入的效果
+cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
+query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
+
+# 先将key_states和value_states重复了num_key_value_groups次
+key_states = repeat_kv(key_states, self.num_key_value_groups)
+value_states = repeat_kv(value_states, self.num_key_value_groups)
+
+# 使用dot attn实现q*kT/hd_d^0.5
+attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
+
+# 然后 attn_weights 加上 attention_mask，实现读取顺序
+attn_weights = attn_weights + attention_mask
+
+# softmax + dropout + values_states相乘
+attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training)
+attn_output = torch.matmul(attn_weights, value_states)
+
+# 转置，修改形状等reshape操作
+attn_output = attn_output.transpose(1, 2).contiguous()
+attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
+
+# 最后在进行一次o_proj
+attn_output = self.o_proj(attn_output)
+
+# 返回结果
+return attn_output, attn_weights, past_key_value
+```
+
+### 1.3.3 细节Debug
+#### 1.3.3.1 GQA
+<div align=center>
+    <img src='./img/GQA.png'>
+</div>
+
+> 主旨:GQA和MQA不需要在推理的过程存储那么多的kv cache, 那么kv cache占用的显存就变小，那么我们LLM serving可以处理的请求数量就更多
+
+1. 定义初始张量
+```python
+import torch
+
+## shape:(batch, seq_len, head, head_dim)
+query = torch.randn(10, 128, 8, 128)
+key = torch.randn(10, 128, 2, 128)
+value = torch.randn(10, 128, 2, 128)
+
+## 在此设置组数为4
+groups = query.shape[-2] // key.shape[-2]
+```
+2. 之后进行扩展key，value的操作  
+在`GQA`中，`key`和`value`都要比`query`小`group`倍，但是为在后续做矩阵乘法时方便，我们需要先把`key`和`value`的`head`利用expand扩展张量到和`query`相同的维度。方便后续计算。  
+
+```python
+# 定义输入x， n_rep是需要重复的次数，在这里一般是组数
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+
+    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+    # dont need repeat here means multi head attention
+    if n_rep == 1:
+        return hidden_states
+    # first we expand x to (bs, seq_len, head, group, head_dim)
+    hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+    # reshape make head -> head * group
+    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+```
+3. 矩阵乘法得到`score`与`output`
+后面就是征程的`kqv`相乘了
+```python
+#(bs, head, seq_len, head_dim)
+query = query.transpose(1, 2)
+key = repeat_kv(key.transpose(1, 2), 4)
+value = repeat_kv(value.transpose(1, 2), 4)
+scores = torch.matmul(query, key.transpose(2, 3)) / math.sqrt(head_dim)
+scores = torch.nn.functional.softmax(scores, dim=-1)
+
+out = torch.matmul(scores, value)
+#上一步转置了，还得转回去
+out = out.transpose(1, 2)
+```
+**补充：**   
+**为什么要用expand之后再reshape而不能直接用tensor自带的repeat?** 
+- `expand` 方法用于对张量进行扩展，但不实际分配新的内存。它返回的张量与原始张量共享相同的数据
+- `repeat` 方法通过实际复制数据来扩展张量。它返回的新张量不与原始张量共享数据，扩展后的张量占用了更多的内存。
+
+
+#### 1.3.3.2 apply_rotary_pos_emb
+位置编码的含义是对每一个token的每一个dim赋予不同的位置信息。
+公式定义:  
+<div align=center>
+    <img src='./img/ROPE1.png'>
+</div> 
+
+概念：通过旋转编码，使得每个token既有相对位置信息，又有绝对位置信息。
+- 既能以自注意力矩阵偏置的形式作用于 $A_{t,s}$,直接反映两个token的相对位置信息，又能拆解到向量 $q_{t}$ 和 $k_{s}$ 上，通过直接编码token的绝对位置实现。
+- RoPE本质是实现对特征向量的旋转操作，如果以二维特征向量举例，对于相邻两个token来说，其对应同一个 $\theta$,其定义为:  
+<div align=center>
+    <img src='./img/ROPE2.png'>
+</div> 
+
+可得，其本质就是: $q_{t}$, $k_{s}$ 旋转后的结果，就是 $q_{t}$, $k_{s}$乘上cos再加上 $q_{t}$, $k_{s}$翻转维度并取反一维后乘上sin。
+- 对于高纬向量，由于奇、复数维度两两交错实现较为复杂，则现在可简化为将特征维度一切二，如下图所示，在实现过程中对前后各半进行的操作即为rotate_half操作： 
+<div align=center>
+    <img src='./img/ROPE3.png'>
+</div> 
+
+
+代码实现：  
+先定义旋转角度
+```python
+class Qwen2RotaryEmbedding(nn.Module):
+    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
+        super().__init__()
+        # 定义初始值
+        self.dim = dim
+        self.max_position_embeddings = max_position_embeddings
+        self.base = base
+        # 定义旋转角
+        inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, dtype=torch.int64).float().to(device) / self.dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        # Build here to make `torch.jit.trace` work.
+        self._set_cos_sin_cache(
+            seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
+        )
+    # 为seq里面的每个token形成独一无二的旋转角嵌入(外积)
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+        t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.int64).type_as(self.inv_freq)
+
+        freqs = torch.outer(t, self.inv_freq)
+        # 生成角度信息(利用注册机制生成self.cos_cached与sin_cached
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        if seq_len > self.max_seq_len_cached:
+            self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)
+
+        return (
+            self.cos_cached[:seq_len].to(dtype=x.dtype),
+            self.sin_cached[:seq_len].to(dtype=x.dtype),
+        )
+```
+首先要先生成角度:
+$$
+\theta = \left(\frac{1}{10000^{2n/d}}\right)
+$$
+
+其中，n表示维度数，其取值范围为[0, 1, ..., d/2-1]  
+<div align=center>
+    <img src='./img/ROPE4.png'>
+</div> 
+
+然后将上述生成角度与每一个位置乘积，区分一个seq中各个词：其实等价于:
+$$\theta = \left(\frac{i}{10000^{2n/d}}\right)$$  
+其中: `i`为行数。  
+<div align=center>
+    <img src='./img/ROPE5.png'>
+</div> 
+
+emb将二者cat起来，得到dim维度，每dim/2一循环：  
+<div align=center>
+    <img src='./img/ROPE6.png'>
+</div> 
+
+然后，在取出位置编码信息`cos`与`sin`的时候，就是将`seq`的部分切出来，原先设置的1024是最大`pos`编码，每次用的时候只取当下`seq_len`的即可.之前求得外积，是为了保证`seq`里面得每一个词都能有不同的1024个位置编码。
+<div align=center>
+    <img src='./img/ROPE7.png'>
+</div> 
+
+进行旋转嵌入:  
+```python
+# 后半部分和前半部分进行了交换，并且将后半部分的符号取反。
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):
+    """Applies Rotary Position Embedding to the query and key tensors.
+
+    query and key tensors rotated using the Rotary Position Embedding.
+    """
+    cos = cos[position_ids].unsqueeze(unsqueeze_dim)
+    sin = sin[position_ids].unsqueeze(unsqueeze_dim)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+```
+对应公式：  
+<div align=center>
+    <img src='./img/ROPE8.png'>
+</div> 
+
+其中，下标t则表示位于同一行，也就是同一`seq_len`，对于相邻的两个元素，
+
+#### 1.3.3.3 读取顺序attention_mask
+第一步的时候只能看到自己，第二步只能看到0、1...其余的都是负无穷。 
+<div align=center>
+    <img src='./img/Mask1.png'>
+</div> 
+
+经过softmax，对应负无穷的位置权重为0，从而实现只能从左往右。
+<div align=center>
+    <img src='./img/Mask2.png'>
+</div> 
+
+- `attn`形状为(bs,heads,T,T),`values`的形状为(bs,heads,T,hd),最终落实到[30,30]×[30,128]上，30表示一句话的步长，也就是总词数。
+- `value`里面每一个词有128个维度来描述，对于第一个词，由于`attn`为下三角，所以每一个维度都只有第一个非零元素1进行相乘，其他的都是×0。
+- - 对于第二行，则是前两个有不同的权值，让value的128个维度分别依据这两个的权重，在128个维度上根据前两行，计算得出output的第二个词(第二步或者第二行)的128个维度.... 这种加权，体现出考虑前词关系。
+- 第n步则对应有n个权重，用来描述从1到n个步之间的各个关系，进而计算出各个维度。
+- 每一个矩阵乘法的结果相当于是下一个词的dim，那么score则是根据mask来判断，能通过前几个词对应dim的值从而进行加权，进而得到下一个词的该dim上的值。
+<div align=center>
+    <img src='./img/Mask3.png'>
+</div>
+- 对于推理的过程，问询不一样长没关系，因为所有的权重都是dim-dim，得到的attention_score是一个seq,seq的，权重跟seq的大小没关系。其都是后面的dim维度的参数。
+- 推理过程的attention_mask可有可无，是一个一个吐，循环cat到下一个，每一次都取最后一个，代表着预测的是下一个token。
+
+## 1.4 Qwen2 MLP
+
+<div align=center>
+    <img src='./img/MLP1.png'>
+</div>
+
+输入`hidden_state`并行送入两个`Linear`层，其中一个激活一下，再与另一个相乘，最终再经过一个`Linear`，输出最终结果。
+```python
+class Qwen2MLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        # 这俩不必多说
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+
+        # 三个全连接层
+        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, x):
+        down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+        return down_proj
+```
+## 1.5 Qwen2RMSNorm
+计算公式:
+
+<img src="./img/RMSNorm_formulation.jpg" width="400" height="auto">
+
+其中:
+- $x$是层的输入的`hidden_state`
+- $w_i$ 表示的是`hidden_state`的最后一个维度的值
+- $n$ 表示上面输入的最后一个维度的数量。
+- $\epsilon$ 表示是很小的数，防止除0。
+
+```python
+class Qwen2RMSNorm(nn.Module):  # 标准化层
+    def __init__(self, hidden_size, eps=1e-6):
+        """
+        Qwen2RMSNorm is equivalent to T5LayerNorm
+        """
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+```
+- `torch.rsqrt`表示输入的东西开根的导数。
+- `.pow(2).mean(-1, keepdim=True)`表示对最后一个维度平方并取均值。

data/xtuner

@@ -0,0 +1 @@
+Subproject commit 90192ffe42612b0f88409432e7b4860294432bcc

download_hf.py

@@ -0,0 +1,7 @@
+import os
+
+# 设置环境变量
+os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
+
+# 下载模型
+os.system('huggingface-cli download --resume-download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 --local-dir /root/model/sentence-transformer')

llamaindex_RAG.py

@@ -0,0 +1,48 @@
+import os 
+os.environ['NLTK_DATA'] = '/root/nltk_data'
+
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+from llama_index.core.settings import Settings
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.legacy.callbacks import CallbackManager
+from llama_index.llms.openai_like import OpenAILike
+
+
+# Create an instance of CallbackManager
+callback_manager = CallbackManager()
+
+api_base_url =  "https://internlm-chat.intern-ai.org.cn/puyu/api/v1/"
+model = "internlm2.5-latest"
+api_key = os.getenv("API_KEY")
+
+# api_base_url =  "https://api.siliconflow.cn/v1"
+# model = "internlm/internlm2_5-7b-chat"
+# api_key = "请填写 API Key"
+
+
+
+llm =OpenAILike(model=model, api_base=api_base_url, api_key=api_key, is_chat_model=True,callback_manager=callback_manager)
+
+
+#初始化一个HuggingFaceEmbedding对象，用于将文本转换为向量表示
+embed_model = HuggingFaceEmbedding(
+#指定了一个预训练的sentence-transformer模型的路径
+    model_name="/root/model/sentence-transformer"
+)
+#将创建的嵌入模型赋值给全局设置的embed_model属性，
+#这样在后续的索引构建过程中就会使用这个模型。
+Settings.embed_model = embed_model
+
+#初始化llm
+Settings.llm = llm
+
+#从指定目录读取所有文档，并加载数据到内存中
+documents = SimpleDirectoryReader("/root/llamaindex_demo/data").load_data()
+#创建一个VectorStoreIndex，并使用之前加载的文档来构建索引。
+# 此索引将文档转换为向量，并存储这些向量以便于快速检索。
+index = VectorStoreIndex.from_documents(documents)
+# 创建一个查询引擎，这个引擎可以接收查询并返回相关文档的响应。
+query_engine = index.as_query_engine()
+response = query_engine.query("Qwen2Attention是什么?")
+
+print(response)

requirements.txt

@@ -0,0 +1,156 @@
+# This file may be used to create an environment using:
+# $ conda create --name <env> --file <this file>
+# platform: linux-64
+_libgcc_mutex=0.1=main
+_openmp_mutex=5.1=1_gnu
+aiohappyeyeballs=2.4.3=pypi_0
+aiohttp=3.11.7=pypi_0
+aiosignal=1.3.1=pypi_0
+altair=5.5.0=pypi_0
+annotated-types=0.7.0=pypi_0
+anyio=4.6.2.post1=pypi_0
+async-timeout=5.0.1=pypi_0
+attrs=24.2.0=pypi_0
+beautifulsoup4=4.12.3=pypi_0
+blinker=1.9.0=pypi_0
+bzip2=1.0.8=h5eee18b_6
+ca-certificates=2024.9.24=h06a4308_0
+cachetools=5.5.0=pypi_0
+certifi=2024.8.30=pypi_0
+charset-normalizer=3.4.0=pypi_0
+click=8.1.7=pypi_0
+dataclasses-json=0.6.7=pypi_0
+deprecated=1.2.15=pypi_0
+dirtyjson=1.0.8=pypi_0
+distro=1.9.0=pypi_0
+einops=0.7.0=pypi_0
+exceptiongroup=1.2.2=pypi_0
+filelock=3.16.1=pypi_0
+filetype=1.2.0=pypi_0
+frozenlist=1.5.0=pypi_0
+fsspec=2024.10.0=pypi_0
+gitdb=4.0.11=pypi_0
+gitpython=3.1.43=pypi_0
+greenlet=3.1.1=pypi_0
+h11=0.14.0=pypi_0
+httpcore=1.0.7=pypi_0
+httpx=0.27.2=pypi_0
+huggingface-hub=0.26.2=pypi_0
+idna=3.10=pypi_0
+instructorembedding=1.0.1=pypi_0
+jinja2=3.1.4=pypi_0
+jiter=0.7.1=pypi_0
+joblib=1.4.2=pypi_0
+jsonschema=4.23.0=pypi_0
+jsonschema-specifications=2024.10.1=pypi_0
+ld_impl_linux-64=2.40=h12ee557_0
+libffi=3.4.4=h6a678d5_1
+libgcc-ng=11.2.0=h1234567_1
+libgomp=11.2.0=h1234567_1
+libstdcxx-ng=11.2.0=h1234567_1
+libuuid=1.41.5=h5eee18b_0
+llama-cloud=0.1.5=pypi_0
+llama-index=0.11.20=pypi_0
+llama-index-agent-openai=0.3.4=pypi_0
+llama-index-cli=0.3.1=pypi_0
+llama-index-core=0.11.23=pypi_0
+llama-index-embeddings-huggingface=0.3.1=pypi_0
+llama-index-embeddings-instructor=0.2.1=pypi_0
+llama-index-embeddings-openai=0.2.5=pypi_0
+llama-index-indices-managed-llama-cloud=0.6.0=pypi_0
+llama-index-legacy=0.9.48.post4=pypi_0
+llama-index-llms-openai=0.2.16=pypi_0
+llama-index-llms-openai-like=0.2.0=pypi_0
+llama-index-llms-replicate=0.3.0=pypi_0
+llama-index-multi-modal-llms-openai=0.2.3=pypi_0
+llama-index-program-openai=0.2.0=pypi_0
+llama-index-question-gen-openai=0.2.0=pypi_0
+llama-index-readers-file=0.2.2=pypi_0
+llama-index-readers-llama-parse=0.3.0=pypi_0
+llama-parse=0.5.15=pypi_0
+markdown-it-py=3.0.0=pypi_0
+markupsafe=3.0.2=pypi_0
+marshmallow=3.23.1=pypi_0
+mdurl=0.1.2=pypi_0
+mpmath=1.3.0=pypi_0
+multidict=6.1.0=pypi_0
+mypy-extensions=1.0.0=pypi_0
+narwhals=1.14.2=pypi_0
+ncurses=6.4=h6a678d5_0
+nest-asyncio=1.6.0=pypi_0
+networkx=3.4.2=pypi_0
+nltk=3.9.1=pypi_0
+numpy=1.26.4=pypi_0
+nvidia-cublas-cu12=12.1.3.1=pypi_0
+nvidia-cuda-cupti-cu12=12.1.105=pypi_0
+nvidia-cuda-nvrtc-cu12=12.1.105=pypi_0
+nvidia-cuda-runtime-cu12=12.1.105=pypi_0
+nvidia-cudnn-cu12=9.1.0.70=pypi_0
+nvidia-cufft-cu12=11.0.2.54=pypi_0
+nvidia-curand-cu12=10.3.2.106=pypi_0
+nvidia-cusolver-cu12=11.4.5.107=pypi_0
+nvidia-cusparse-cu12=12.1.0.106=pypi_0
+nvidia-nccl-cu12=2.21.5=pypi_0
+nvidia-nvjitlink-cu12=12.4.127=pypi_0
+nvidia-nvtx-cu12=12.1.105=pypi_0
+openai=1.55.0=pypi_0
+openssl=3.0.15=h5eee18b_0
+packaging=24.2=pypi_0
+pandas=2.2.3=pypi_0
+pillow=10.4.0=pypi_0
+pip=24.2=py310h06a4308_0
+propcache=0.2.0=pypi_0
+protobuf=5.26.1=pypi_0
+pyarrow=18.0.0=pypi_0
+pydantic=2.10.1=pypi_0
+pydantic-core=2.27.1=pypi_0
+pydeck=0.9.1=pypi_0
+pygments=2.18.0=pypi_0
+pypdf=4.3.1=pypi_0
+python=3.10.15=he870216_1
+python-dateutil=2.9.0.post0=pypi_0
+pytz=2024.2=pypi_0
+pyyaml=6.0.2=pypi_0
+readline=8.2=h5eee18b_0
+referencing=0.35.1=pypi_0
+regex=2024.11.6=pypi_0
+requests=2.32.3=pypi_0
+rich=13.9.4=pypi_0
+rpds-py=0.21.0=pypi_0
+safetensors=0.4.5=pypi_0
+scikit-learn=1.5.2=pypi_0
+scipy=1.14.1=pypi_0
+sentence-transformers=2.7.0=pypi_0
+setuptools=75.1.0=py310h06a4308_0
+six=1.16.0=pypi_0
+smmap=5.0.1=pypi_0
+sniffio=1.3.1=pypi_0
+soupsieve=2.6=pypi_0
+sqlalchemy=2.0.36=pypi_0
+sqlite=3.45.3=h5eee18b_0
+streamlit=1.39.0=pypi_0
+striprtf=0.0.26=pypi_0
+sympy=1.13.1=pypi_0
+tenacity=8.5.0=pypi_0
+threadpoolctl=3.5.0=pypi_0
+tiktoken=0.8.0=pypi_0
+tk=8.6.14=h39e8969_0
+tokenizers=0.20.3=pypi_0
+toml=0.10.2=pypi_0
+torch=2.5.0+cu121=pypi_0
+torchaudio=2.5.0+cu121=pypi_0
+torchvision=0.20.0+cu121=pypi_0
+tornado=6.4.2=pypi_0
+tqdm=4.67.1=pypi_0
+transformers=4.46.3=pypi_0
+triton=3.1.0=pypi_0
+typing-extensions=4.12.2=pypi_0
+typing-inspect=0.9.0=pypi_0
+tzdata=2024.2=pypi_0
+urllib3=2.2.3=pypi_0
+watchdog=5.0.3=pypi_0
+wheel=0.44.0=py310h06a4308_0
+wrapt=1.17.0=pypi_0
+xz=5.4.6=h5eee18b_1
+yarl=1.18.0=pypi_0
+zlib=1.2.13=h5eee18b_1

test_internlm.py

@@ -0,0 +1,24 @@
+from openai import OpenAI
+import os
+
+base_url = "https://internlm-chat.intern-ai.org.cn/puyu/api/v1/"
+# api_key = "sk-请填写准确的 token！"
+api_key = os.getenv("API_KEY")
+model="internlm2.5-latest"
+
+# base_url = "https://api.siliconflow.cn/v1"
+# api_key = "sk-请填写准确的 token！"
+# model="internlm/internlm2_5-7b-chat"
+
+client = OpenAI(
+    api_key=api_key , 
+    base_url=base_url,
+)
+
+chat_rsp = client.chat.completions.create(
+    model=model,
+    messages=[{"role": "user", "content": "Qwen2Attention是什么？"}],
+)
+
+for choice in chat_rsp.choices:
+    print(choice.message.content)