InternLM3

InternLM3-8B-instruct FastAPI部署

InternLM3 开源了一个具有 80 亿参数的指令模型，名为 InternLM3-8B-Instruct，旨在用于通用任务和高级推理。该模型具有以下特点：

在降低成本的同时提升性能：在推理和知识密集型任务中，表现超越了像 Llama3.1-8B 和 Qwen2.5-7B 等模型。值得注意的是，InternLM3 仅在 4 万亿高质量标记上进行训练，比其他同规模的语言模型节省了超过 75% 的训练成本。
深度思考能力：InternLM3 支持两种模式：一种是通过长链思维解决复杂推理任务的深度思考模式，另一种是用于流畅用户交互的正常响应模式。

环境配置

实验所依赖的基础开发环境如下：

----------------
ubuntu 22.04
Python 3.12.3
cuda 12.1
pytorch 2.3.0
----------------

本文默认学习者已安装好以上 Pytorch(cuda) 环境，如未安装请自行安装。

首先 pip 换源加速下载并安装依赖包：

# 升级pip
python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# FastAPI 相关依赖
pip install requests==2.32.3
pip install fastapi==0.104.1
pip install uvicorn==0.24.0

# Langchain 相关依赖
pip install langchain==0.3.7

# WebDemo 相关依赖
pip install streamlit==1.41.1

# LoRA微调 相关依赖
pip install peft==0.11.1          # 用于 LoRA 微调

# 通用依赖
pip install modelscope==1.22.0    # 用于模型下载和管理
pip install transformers==4.47.1  # Hugging Face 的模型库，用于加载和训练模型
pip install sentencepiece==0.2.0  # 用于处理文本数据
pip install accelerate==0.34.2    # 用于分布式训练和混合精度训练
pip install datasets==2.20.0      # 用于加载和处理数据集

考虑到部分同学配置环境可能会遇到一些问题，我们在 AutoDL 平台准备了 InternLM3-8b-Instruct 的环境镜像，点击下方链接并直接创建 AutoDL 示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/self-llm-internlm3

模型下载

modelscope 是一个模型管理和下载工具，支持从魔搭 (Modelscope) 等平台快速下载模型。

这里使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数 model_name_or_path 为模型名称或者本地路径，第二个参数 cache_dir 为模型的下载路径，第三个参数 revision 为模型的版本号。

在 /root/autodl-tmp 路径下新建 model_download.py 文件并在其中粘贴以下代码，并保存文件。

from modelscope import snapshot_download

model_dir = snapshot_download('Shanghai_AI_Laboratory/internlm3-8b-instruct', cache_dir='./', revision='master')

注意：记得修改 cache_dir 为你的模型下载路径哦~

在终端运行 python /root/autodl-tmp/model_download.py 执行下载，模型大小为 18GB 左右，下载模型大概需要5-30分钟。

代码准备

新建 api.py 文件并在其中输入以下内容，粘贴代码后请及时保存文件。记得将tokenizer和model的路径改成上面模型下载的cache_dir的路径。以下代码有很详细的注释，大家如有不理解的地方，欢迎提出 issue 。

from fastapi import FastAPI, Request
from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
import uvicorn
import json
import datetime
import torch

# 设置设备参数
DEVICE = "cuda"  # 使用CUDA
DEVICE_ID = "0"  # CUDA设备ID，如果未设置则为空
CUDA_DEVICE = f"{DEVICE}:{DEVICE_ID}" if DEVICE_ID else DEVICE  # 组合CUDA设备信息

# 清理GPU内存函数
def torch_gc():
    if torch.cuda.is_available():  # 检查是否可用CUDA
        with torch.cuda.device(CUDA_DEVICE):  # 指定CUDA设备
            torch.cuda.empty_cache()  # 清空CUDA缓存
            torch.cuda.ipc_collect()  # 收集CUDA内存碎片

# 创建FastAPI应用
app = FastAPI(
    title="InternLM Chat API",
    description="API for InternLM 3 chat model",
    version="1.0.0"
)

# 添加GET方法的根路由
@app.get("/")
async def root():
    return {
        "message": "Welcome to InternLM Chat API",
        "status": "healthy",
        "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    }

# 处理POST请求的端点
@app.post("/v1/chat")
async def create_chat(request: Request):
    global model, tokenizer  # 声明全局变量以便在函数内部使用模型和分词器
    json_post_raw = await request.json()  # 获取POST请求的JSON数据
    json_post = json.dumps(json_post_raw)  # 将JSON数据转换为字符串
    json_post_list = json.loads(json_post)  # 将字符串转换为Python对象
    prompt = json_post_list.get('prompt')  # 获取用户的问题
    # 构建对话模板
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": prompt},
    ]
    tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to("cuda")
    generated_ids = model.generate(tokenized_chat, max_new_tokens=1024, temperature=1, repetition_penalty=1.005, top_k=40, top_p=0.8)
    generated_ids = [
        output_ids[len(input_ids):] for input_ids, output_ids in zip(tokenized_chat, generated_ids)
    ]
    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
    now = datetime.datetime.now()  # 获取当前时间
    time = now.strftime("%Y-%m-%d %H:%M:%S")  # 格式化时间为字符串
    # 构建响应JSON
    answer = {
        "response": response,
        "status": 200,
        "time": time
    }
    # 构建日志信息
    log = "[" + time + "] " + '", prompt:"' + prompt + '", response:"' + repr(response) + '"'
    print(log)  # 打印日志
    torch_gc()  # 执行GPU内存清理
    return answer  # 返回响应

# 主函数入口
if __name__ == '__main__':
    # 加载预训练的分词器和模型
    model_path = '/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct'
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, trust_remote_code=True).cuda()
    model = model.eval()

    # 启动FastAPI应用
    # 用6006端口可以将autodl的端口映射到本地，从而在本地使用api
    uvicorn.run(app, host='0.0.0.0', port=6006, workers=1)  # 在指定端口和主机上启动应用

然后在当前文件的路径下面运行:

python api.py

出现下面的信息就说明成功运行了。

调用API

默认部署在 6006 端口，通过 POST 方法进行调用。可以使用命令行curl和代码的方式来调用。

命令行:

curl -X POST "http://localhost:6006/v1/chat" \
     -H 'Content-Type: application/json' \
     -d '{"prompt": "你好"}'

或者使用实际IP地址：

curl -X POST "http://<your-ip>:6006/v1/chat" \
     -H 'Content-Type: application/json' \
     -d '{"prompt": "你好"}'

返回结果:

使用 python 中的 requests 库进行调用，创建 request.py 文件，复制下面的代码，运行 python request.py 。

import requests
import json

def get_completion(prompt):
    headers = {'Content-Type': 'application/json'}
    data = {"prompt": prompt}
    response = requests.post(url='http://127.0.0.1:6006/v1/chat', headers=headers, data=json.dumps(data))
    return response.json()['response']

if __name__ == '__main__':
    print(get_completion('你好'))

返回结果:

同时, 这是我们部署的FastAPI的Terminal页面, 还可以看到如下信息

这里简要对上述控制台信息进行解释:

INFO: ... "GET /_stcore/health HTTP/1.1" 404 Not Found
INFO: ... "GET /_stcore/host-config HTTP/1.1" 404 Not Found

这些是来自 Streamlit 的健康检查请求，返回 404 是正常的，因为我们的 FastAPI 服务器没有实现这些端点
这表明可能有 Streamlit 应用试图连接到这个端口，但这不影响我们的 API 功能

INFO: ... "POST / HTTP/1.1" 405 Method Not Allowed

这是失败的API调用记录
显示了请求时间、用户输入和模型响应
405 Method Not Allowed 表示请求方法不允许
有请求试图向根路径 ("/") 发送 POST 请求
返回 405 是因为我们只在根路径定义了 GET 方法，而不是 POST

[2025-01-19 12:40:08] ", prompt:"你好", response:"'你好！很高兴见到你。有什么我可以帮助你的吗？'"
INFO: ... "POST /v1/chat HTTP/1.1" 200 OK

这是成功的API调用记录
显示了请求时间、用户输入和模型响应
200 OK 表示请求成功处理

InternLM3-8B-Instruct Langchain 接入

环境配置

实验所依赖的基础开发环境如下：

----------------
ubuntu 22.04
Python 3.12.3
cuda 12.1
pytorch 2.3.0
----------------

本文默认学习者已安装好以上 Pytorch(cuda) 环境，如未安装请自行安装。

首先 pip 换源加速下载并安装依赖包：

# 升级pip
python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# FastAPI 相关依赖
pip install requests==2.32.3
pip install fastapi==0.104.1
pip install uvicorn==0.24.0

# Langchain 相关依赖
pip install langchain==0.3.7

# WebDemo 相关依赖
pip install streamlit==1.41.1

# LoRA微调 相关依赖
pip install peft==0.11.1          # 用于 LoRA 微调

# 通用依赖
pip install modelscope==1.22.0    # 用于模型下载和管理
pip install transformers==4.47.1  # Hugging Face 的模型库，用于加载和训练模型
pip install sentencepiece==0.2.0  # 用于处理文本数据
pip install accelerate==0.34.2    # 用于分布式训练和混合精度训练
pip install datasets==2.20.0      # 用于加载和处理数据集

考虑到部分同学配置环境可能会遇到一些问题，我们在 AutoDL 平台准备了 InternLM3-8b-Instruct 的环境镜像，点击下方链接并直接创建 AutoDL 示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/self-llm-internlm3

模型下载

modelscope 是一个模型管理和下载工具，支持从魔搭 (Modelscope) 等平台快速下载模型。

这里使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数 model_name_or_path 为模型名称或者本地路径，第二个参数 cache_dir 为模型的下载路径，第三个参数 revision 为模型的版本号。

在 /root/autodl-tmp 路径下新建 model_download.py 文件并在其中粘贴以下代码，并保存文件。

from modelscope import snapshot_download

model_dir = snapshot_download('Shanghai_AI_Laboratory/internlm3-8b-instruct', cache_dir='./', revision='master')

注意：记得修改 cache_dir 为你的模型下载路径哦~

代码准备

为便捷构建 LLM 应用，我们需要基于本地部署的 InternLM3-8B-Instruct，自定义一个 LLM 类，将 InternLM3-8B-Instruct 接入到 LangChain 框架中。完成自定义 LLM 类之后，可以以完全一致的方式调用 LangChain 的接口，而无需考虑底层模型调用的不一致。

基于本地部署的 InternLM3-8B-Instruct 自定义 LLM 类并不复杂，我们只需从 LangChain.llms.base.LLM 类继承一个子类，并重写构造函数与 _call 函数即可：

在当前路径新建一个 LLM.py 文件，并输入以下内容，粘贴代码后记得保存文件。

from langchain.llms.base import LLM
from typing import Any, List, Optional
from langchain.callbacks.manager import CallbackManagerForLLMRun
from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig, LlamaTokenizerFast
import torch

class InternLM3_8B_Instruct(LLM):
    # 基于本地 internlm3-8b-instruct 自定义 LLM 类
    tokenizer: AutoTokenizer = None
    model: AutoModelForCausalLM = None        
    def __init__(self, mode_name_or_path :str):

        super().__init__()
        print("正在从本地加载模型...")
        self.tokenizer = AutoTokenizer.from_pretrained(mode_name_or_path, use_fast=False, trust_remote_code=True)
        self.model = AutoModelForCausalLM.from_pretrained(mode_name_or_path, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True)
        self.model.generation_config = GenerationConfig.from_pretrained(mode_name_or_path, trust_remote_code=True)
        print("完成本地模型的加载")
        
    def _call(self, prompt : str, stop: Optional[List[str]] = None,
                run_manager: Optional[CallbackManagerForLLMRun] = None,
                **kwargs: Any):

        messages = [{"role": "user", "content": prompt }]
        input_ids = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        model_inputs = self.tokenizer([input_ids], return_tensors="pt").to('cuda')
        generated_ids = self.model.generate(model_inputs.input_ids, attention_mask=model_inputs['attention_mask'], max_new_tokens=512)
        generated_ids = [
            output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
        ]
        response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]        
        return response
    @property
    def _llm_type(self) -> str:
        return "InternLM3_8B_Instruct"
    
if __name__ == '__main__':
    
    # # 外部测试, 需要修改模型路径和LLM文件路径
    # from LLM import InternLM3_8B_Instruct
    
    llm = InternLM3_8B_Instruct(mode_name_or_path = "/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct")
    print(llm.invoke("你是谁"))

在上述类定义中，我们分别重写了构造函数和 _call 函数：对于构造函数，我们在对象实例化的一开始加载本地部署的 InternLM3_8b_instruct 模型，从而避免每一次调用都需要重新加载模型带来的时间过长；_call 函数是 LLM 类的核心函数，LangChain 会调用该函数来调用 LLM，在该函数中，我们调用已实例化模型的 generate 方法，从而实现对模型的调用并返回调用结果。

在整体项目中，我们将上述代码封装为 LLM.py，后续将直接从该文件中引入自定义的 LLM 类。

调用

然后就可以像使用任何其他的langchain大模型功能一样使用了。

注意：记得修改模型路径为你的路径哦~

from LLM import InternLM3_8B_Instruct
    
llm = InternLM3_8B_Instruct(mode_name_or_path = "/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct")
print(llm.invoke("你是谁"))

结果如下：

InternLM3-8B-Instruct WebDemo 部署

环境配置

实验所依赖的基础开发环境如下：

----------------
ubuntu 22.04
Python 3.12.3
cuda 12.1
pytorch 2.3.0
----------------

本文默认学习者已安装好以上 Pytorch(cuda) 环境，如未安装请自行安装。

首先 pip 换源加速下载并安装依赖包：

# 升级pip
python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# FastAPI 相关依赖
pip install requests==2.32.3
pip install fastapi==0.104.1
pip install uvicorn==0.24.0

# Langchain 相关依赖
pip install langchain==0.3.7

# WebDemo 相关依赖
pip install streamlit==1.41.1

# LoRA微调 相关依赖
pip install peft==0.11.1          # 用于 LoRA 微调

# 通用依赖
pip install modelscope==1.22.0    # 用于模型下载和管理
pip install transformers==4.47.1  # Hugging Face 的模型库，用于加载和训练模型
pip install sentencepiece==0.2.0  # 用于处理文本数据
pip install accelerate==0.34.2    # 用于分布式训练和混合精度训练
pip install datasets==2.20.0      # 用于加载和处理数据集

考虑到部分同学配置环境可能会遇到一些问题，我们在 AutoDL 平台准备了 InternLM3-8b-Instruct 的环境镜像，点击下方链接并直接创建 AutoDL 示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/self-llm-internlm3

模型下载

modelscope 是一个模型管理和下载工具，支持从魔搭 (Modelscope) 等平台快速下载模型。

这里使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数 model_name_or_path 为模型名称或者本地路径，第二个参数 cache_dir 为模型的下载路径，第三个参数 revision 为模型的版本号。

在 /root/autodl-tmp 路径下新建 model_download.py 文件并在其中粘贴以下代码，并保存文件。

from modelscope import snapshot_download

model_dir = snapshot_download('Shanghai_AI_Laboratory/internlm3-8b-instruct', cache_dir='./', revision='master')

注意：记得修改 cache_dir 为你的模型下载路径哦~

在终端运行 python /root/autodl-tmp/model_download.py 执行下载，模型大小为 18GB 左右，下载模型大概需要5-30分钟。

代码准备

在/root/autodl-tmp路径下新建 chatBot.py 文件并在其中输入以下内容，粘贴代码后记得保存文件。下面的代码有很详细的注释，大家如有不理解的地方，欢迎提出 issue。

# 导入所需的库
from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig, TextIteratorStreamer
from threading import Thread
import torch
import streamlit as st

# 在侧边栏中创建一个标题和一个链接
with st.sidebar:
    st.markdown("## InternLM3-8B LLM")
    "[开源大模型食用指南 self-llm](https://github.com/datawhalechina/self-llm.git)"
    # 创建一个滑块，用于选择最大长度，范围在0到1024之间，默认值为512
    max_length = st.slider("max_length", 0, 1024, 512, step=1)

# 创建一个标题和一个副标题
st.title("💬 InternLM3-8B Chatbot")
st.caption("🚀 A streamlit chatbot powered by Self-LLM")

# 定义模型路径
model_name_or_path = '/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct'

# 定义一个函数，用于获取模型和tokenizer
@st.cache_resource
def get_model():
    # 从预训练的模型中获取tokenizer
    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, use_fast=False, trust_remote_code=True)
    # 从预训练的模型中获取模型，并设置模型参数
    model = AutoModelForCausalLM.from_pretrained(model_name_or_path, torch_dtype=torch.bfloat16,  device_map="auto", trust_remote_code=True)
  
    return tokenizer, model

# 加载 InternLM3-8B 的model和tokenizer
tokenizer, model = get_model()

# 如果session_state中没有"messages"，则创建一个包含默认消息的列表
if "messages" not in st.session_state:
    st.session_state["messages"] = [{"role": "assistant", "content": "有什么可以帮您的？"}]

# 遍历session_state中的所有消息，并显示在聊天界面上
for msg in st.session_state.messages:
    st.chat_message(msg["role"]).write(msg["content"])

# 如果用户在聊天输入框中输入了内容，则执行以下操作
if prompt := st.chat_input():
    # 将用户的输入添加到session_state中的messages列表中
    st.session_state.messages.append({"role": "user", "content": prompt})
    # 在聊天界面上显示用户的输入
    st.chat_message("user").write(prompt)
    
    # 构建输入     
    input_ids = tokenizer.apply_chat_template(st.session_state.messages,tokenize=False,add_generation_prompt=True)
    model_inputs = tokenizer([input_ids], return_tensors="pt")['input_ids'].to('cuda')

    
    streamer = TextIteratorStreamer(tokenizer=tokenizer, skip_special_tokens=True, skip_prompt=True)
    kwargs = {'inputs': model_inputs, 'streamer': streamer, 'max_new_tokens': max_length}

    # Generation
    thread = Thread(target=model.generate, kwargs=kwargs)
    thread.start()


    # 在聊天界面上显示模型的输出
    with st.chat_message("assistant"):
        response = st.write_stream(streamer)
    # 将模型的输出添加到session_state中的messages列表中
    st.session_state.messages.append({"role": "assistant", "content": response})

运行 demo

在终端中运行以下命令，启动 streamlit 服务，server.port 可以更换端口

streamlit run /root/autodl-tmp/chatBot.py --server.address 127.0.0.1 --server.port 6006

在本地浏览器中打开链接 http://localhost:6006/ ，即可查看部署的 WebDemo 聊天界面。运行效果如下：

InternLM3-8b-Instruct LoRA 微调

本节我们简要介绍如何基于 transformers、peft 等框架，使用由笔者合作开源的 Chat-甄嬛项目中的嬛嬛数据集作为微调数据集，对 InternLM3-8b-Instruct 模型进行 LoRA 微调, 以构建一个能够模拟甄嬛对话风格的个性化 LLM , 数据集路径为../../dataset/huanhuan.json。

LoRA 是一种高效微调方法，深入了解其原理可参见博客：知乎|深入浅出 LoRA。

本教程会在同目录下给大家提供一个 notebook 文件 (04-InternLM3-8B-Instruct LoRA.ipynb) ，来帮助大家更好的学习。

环境配置

实验所依赖的基础开发环境如下：

----------------
ubuntu 22.04
Python 3.12.3
cuda 12.1
pytorch 2.3.0
----------------

本文默认学习者已安装好以上 Pytorch(cuda) 环境，如未安装请自行安装。

首先 pip 换源加速下载并安装依赖包：

# 升级pip
python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# FastAPI 相关依赖
pip install requests==2.32.3
pip install fastapi==0.104.1
pip install uvicorn==0.24.0

# Langchain 相关依赖
pip install langchain==0.3.7

# WebDemo 相关依赖
pip install streamlit==1.41.1

# LoRA微调 相关依赖
pip install peft==0.11.1          # 用于 LoRA 微调

# 通用依赖
pip install modelscope==1.22.0    # 用于模型下载和管理
pip install transformers==4.47.1  # Hugging Face 的模型库，用于加载和训练模型
pip install sentencepiece==0.2.0  # 用于处理文本数据
pip install accelerate==0.34.2    # 用于分布式训练和混合精度训练
pip install datasets==2.20.0      # 用于加载和处理数据集

考虑到部分同学配置环境可能会遇到一些问题，我们在 AutoDL 平台准备了 InternLM3-8b-Instruct 的环境镜像，点击下方链接并直接创建 AutoDL 示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/self-llm-internlm3

模型下载

modelscope 是一个模型管理和下载工具，支持从魔搭 (Modelscope) 等平台快速下载模型。

这里使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数 model_name_or_path 为模型名称或者本地路径，第二个参数 cache_dir 为模型的下载路径，第三个参数 revision 为模型的版本号。

在 /root/autodl-tmp 路径下新建 model_download.py 文件并在其中粘贴以下代码，并保存文件。

from modelscope import snapshot_download

model_dir = snapshot_download('Shanghai_AI_Laboratory/internlm3-8b-instruct', cache_dir='./', revision='master')

注意：记得修改 cache_dir 为你的模型下载路径哦~

在终端运行 python /root/autodl-tmp/model_download.py 执行下载，模型大小为 18GB 左右，下载模型大概需要5-30分钟。

指令集构建

LLM 的微调一般指指令微调过程。所谓指令微调，是说我们使用的微调数据形如：

{
  "instruction": "回答以下用户问题，仅输出答案。",
  "input": "1+1等于几?",
  "output": "2"
}

其中，instruction 是用户指令，告知模型其需要完成的任务；input 是用户输入，是完成用户指令所必须的输入内容；output 是模型应该给出的输出。

即我们的核心训练目标是让模型具有理解并遵循用户指令的能力。因此，在指令集构建时，我们应针对我们的目标任务，针对性构建任务指令集。

例如，在本节我们使用由笔者合作开源的 Chat-甄嬛 项目作为示例，我们的目标是构建一个能够模拟甄嬛对话风格的个性化 LLM，因此我们构造的指令形如：

{
  "instruction": "你是谁？",
  "input": "",
  "output": "家父是大理寺少卿甄远道。"
}

我们所构造的全部指令数据集会被保存在根目录下。

数据格式化

LoRA 训练的数据是需要经过格式化、编码之后再输入给模型进行训练的，如果是熟悉 Pytorch 模型训练流程的同学会知道，我们一般需要将输入文本编码为 input_ids，将输出文本编码为 labels，编码之后的结果都是多维的向量。

为了得到 InternLM3-8b-Instruct 的 Prompt Template，使用 tokenizer 构建 messages 并打印，查看 chat_template 的输出格式

messages = [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": '你好呀'},
            {"role": "assistant", "content": '有什么可以帮你的？'}
            ]
# 使用chat_template将messages格式化并打印
print(tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True))


## 得到输出结果如下

# <s><|im_start|>system
# You are a helpful assistant.<|im_end|>
# <|im_start|>user
# 你好呀<|im_end|>
# <|im_start|>assistant
# 有什么可以帮你的？<|im_end|>
# <|im_start|>assistant

然后我们就可以定义预处理函数 process_func，这个函数用于对每一个样本，编码其输入、输出文本并返回一个编码后的字典，方便模型使用：

system_prompt = '现在你要扮演皇帝身边的女人--甄嬛'

def process_func(example):
    MAX_LENGTH = 384    # Llama分词器会将一个中文字切分为多个token，因此需要放开一些最大长度，保证数据的完整性
    input_ids, attention_mask, labels = [], [], []
    # 构建指令部分的输入
    instruction = tokenizer(
        f"<s><|im_start|>system\n{system_prompt}<|im_end|>\n" 
        f"<|im_start|>user\n{example['instruction'] + example['input']}<|im_end|>\n"  
        f"<|im_start|>assistant\n",  
        add_special_tokens=False   
    )
    # 构建模型回复部分的输入
    response = tokenizer(
        f"{example['output']}",
        add_special_tokens=False 
    )
    # 拼接指令和回复部分的 input_ids
    input_ids = instruction["input_ids"] + response["input_ids"] + [tokenizer.pad_token_id]
    # 拼接指令和回复部分的 attention_mask
    attention_mask = instruction["attention_mask"] + response["attention_mask"] + [1]  # 因为 EOS token 也需要关注，所以补充为 1
    # 构建标签
    # 对于指令部分，使用 -100 忽略其损失计算；对于回复部分，保留其 input_ids 作为标签
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"] + [tokenizer.pad_token_id]  
    # 如果总长度超过最大长度，进行截断
    if len(input_ids) > MAX_LENGTH: 
        input_ids = input_ids[:MAX_LENGTH]
        attention_mask = attention_mask[:MAX_LENGTH]
        labels = labels[:MAX_LENGTH]
    return {
        "input_ids": input_ids,
        "attention_mask": attention_mask,
        "labels": labels
    }

补充: InternLM3-8b-Instruct 采用的 Prompt Template格式如下：

<s><|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
你是谁？<|im_end|>
<|im_start|>assistant
我是一个有用的助手。<|im_end|>

加载 tokenizer 和半精度模型 (model)

tokenizer 是将文本转换为模型 (model) 能理解的数字的工具，model 是根据这些数字生成文本的核心部分。

以半精度形式加载 model, 如果你的显卡比较新的话，可以用 torch.bfolat 形式加载。对于自定义模型，必须指定 trust_remote_code=True ，以确保加载自定义代码时不会报错。

model_path = '/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct'

tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False, trust_remote_code=True)

# 在internlm3-8b-instruct/tokenizer_config.json中, 128131 是 '<|im_end|>' token值
tokenizer.pad_token_id = tokenizer.eos_token_id = 128131  

model = AutoModelForCausalLM.from_pretrained(model_path, device_map="auto",
                                             torch_dtype=torch.bfloat16, 
                                             trust_remote_code=True)

注意：此处要记得修改为自己的模型路径哦~

如果想要查看模型结构，可以打印模型：

print(model)

# 输出结果如下

# InternLM3ForCausalLM(
#   (model): InternLM3Model(
#     (embed_tokens): Embedding(128512, 4096, padding_idx=2)
#     (layers): ModuleList(
#       (0-47): 48 x InternLM3DecoderLayer(
#         (self_attn): InternLM3SdpaAttention(
#           (q_proj): Linear(in_features=4096, out_features=4096, bias=False)
#           (k_proj): Linear(in_features=4096, out_features=256, bias=False)
#           (v_proj): Linear(in_features=4096, out_features=256, bias=False)
#           (o_proj): Linear(in_features=4096, out_features=4096, bias=False)
#           (rotary_emb): InternLM3RotaryEmbedding()
#         )
#         (mlp): InternLM3MLP(
#           (gate_proj): Linear(in_features=4096, out_features=10240, bias=False)
#           (up_proj): Linear(in_features=4096, out_features=10240, bias=False)
#           (down_proj): Linear(in_features=10240, out_features=4096, bias=False)
#           (act_fn): SiLU()
#         )
#         (input_layernorm): InternLM3RMSNorm((4096,), eps=1e-05)
#         (post_attention_layernorm): InternLM3RMSNorm((4096,), eps=1e-05)
#       )
#     )
#     (norm): InternLM3RMSNorm((4096,), eps=1e-05)
#     (rotary_emb): InternLM3RotaryEmbedding()
#   )
#   (lm_head): Linear(in_features=4096, out_features=128512, bias=False)
# )

上面打印了 InternLM3Model 的模型结构，可以看到里面的 self_attn 和 mlp 是两个主要的模块，因此可以考虑将这两个模块作为 LoRA 微调的 target_modules , 包括 q_proj, k_proj, v_proj, o_proj 以及 gate_proj、up_proj 和 down_proj 。

通常我们只对 self_attn 模块中的 q_proj, k_proj, v_proj, o_proj进行微调，本教程里我们也将对这四个模块进行微调演示，感兴趣的同学可以自行尝试添加对 mlp 中的三个 proj 模块进行微调。

定义 LoraConfig

LoraConfig类用于设置 LoRA 微调参数，虽然可以设置很多参数，但主要的参数没多少，简单讲一讲，感兴趣的同学可以直接看源码。

task_type：模型类型
target_modules：需要训练的模型层的名字，主要就是 attention部分的层，不同的模型对应的层的名字不同，可以传入数组，也可以字符串，也可以正则表达式。
r：LoRA的秩，具体可以看 LoRA原理。
lora_alpha：LoRA alaph ，具体作用参见 LoRA 原理。
lora_dropout: LoRA 层的 Dropout 比例，用于防止过拟合，具体作用参见 LoRA 原理。

LoRA的缩放是啥嘞？当然不是 r（秩），这个缩放就是 lora_alpha/r, 在这个 LoraConfig中缩放就是 4 倍。

from peft import LoraConfig, TaskType, get_peft_model

config = LoraConfig(
    task_type=TaskType.CAUSAL_LM, 
    target_modules=["q_proj", "k_proj","v_proj", "o_proj"], # 可以自行添加更多微调的target_modules
    inference_mode=False,     # 训练模式
    r=8,                      # LoRA 秩
    lora_alpha=32,            # LoRA alaph，具体作用参见 LoRA 原理
    lora_dropout=0.1          # Dropout 比例
)

自定义 TrainingArguments 参数

TrainingArguments类用于设置微调训练过程中的配置参数，这个类的源码也介绍了每个参数的具体作用，当然大家可以来自行探索，这里就简单说几个常用的。

output_dir：模型的输出路径
per_device_train_batch_size：顾名思义 batch_size，批量大小
gradient_accumulation_steps: 梯度累加，如果你的显存比较小，那可以把 batch_size 设置小一点，梯度累加增大一些。
logging_steps：多少步，输出一次 log
num_train_epochs：顾名思义 epoch，训练轮次
gradient_checkpointing：梯度检查，这个一旦开启，模型就必须执行 model.enable_input_require_grads()，这个原理大家可以自行探索，这里就不细说了。

args = TrainingArguments(
    output_dir="/root/autodl-tmp/internlm3-8b-instruct_lora_output",
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
    logging_steps=10,
    num_train_epochs=3,
    save_steps=100, 
    learning_rate=1e-4,
    save_on_each_node=True,
    gradient_checkpointing=True
)

使用 Trainer 训练

我们使用 Trainer 类来管理训练过程。TrainingArguments 用于设置训练参数，Trainer 则负责实际的训练逻辑。

trainer = Trainer(
    model=model,                 # 要训练的模型
    args=args,                   # 训练参数
    train_dataset=tokenized_id,  # 训练数据集
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),  # 数据整理器
)
trainer.train()                  # 开始训练

如上配置中, 训练时间大概为 30-40 分钟, 其中 3729 组数据, 训练轮次为 3 轮, 每 4 步梯度累加更新一次(real batch size=1*4=4), 每 100 步保存一次 checkpoint, 总共大约 2800 步 (3729/4*3 ~= 2796)

加载 LoRA 权重推理

训练好了之后可以使用如下方式加载 LoRA权重进行推理：

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
from peft import PeftModel

model_path = '/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct'
lora_path = '/root/autodl-tmp/internlm3-8b-instruct_lora_output/checkpoint-2796' # 这里改成 LoRA 输出对应 checkpoint 地址和最终的 epoch 数值 2796

# 加载tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

# 加载模型
model = AutoModelForCausalLM.from_pretrained(model_path, 
                                             device_map="auto",
                                             torch_dtype=torch.bfloat16, 
                                             trust_remote_code=True).eval()

# 加载lora权重
model = PeftModel.from_pretrained(model, model_id=lora_path)

prompt = "你是谁？"
system_prompt = "现在你要扮演皇帝身边的女人--甄嬛"
print("prompt: ", prompt)
print("system_prompt: ", system_prompt)

inputs = tokenizer.apply_chat_template([{"role": "system", "content": system_prompt},
                                        {"role": "user", "content": prompt}],
                                       add_generation_prompt=True,
                                       tokenize=True,
                                       return_tensors="pt",
                                       return_dict=True
                                       ).to(model.device)  # 将 inputs 移动到模型所在的设备，确保设备一致性


gen_kwargs = {"max_length": 2500, "do_sample": True, "top_k": 1}
with torch.no_grad():
    outputs = model.generate(**inputs, **gen_kwargs)
    outputs = outputs[:, inputs['input_ids'].shape[1]:]
    print("output: ", tokenizer.decode(outputs[0], skip_special_tokens=True))

注意修改为自己的模型路径哦~‘

如果显示 Some parameters are on the meta device because they were offloaded to the cpu. 的报错，需要将实例关机，重启后单独运行本条代码。

internlm3-8b-instruct 与o1

InternLM3-8b-instruct与o1

Open AI o1（又名o1，也称草莓模型，这个名字的又来是因为早期人们发现gpt总是数不对strawberry中有几个r），是Open AI于2024年9月12日发布的一款通过大规模强化学习算法训练的大模型。区别于其他大模型产品，o1不需要用户再输入复杂的提示词，而是通过强化学习，将思维链内化后进行持续训练。

如图，通过思维链式的问题拆解，模型可以不断验证、纠错，尝试新的方法，这一过程显著提升了模型的推理能力。 OpenAI o1的关键技术在于RL的搜索与学习机制。基于大型语言模型（LLM）已有的推理能力，通过迭代式的Bootstrap，模型能够产生合理的推理过程。这一过程不仅限于COT，还可能包括在常识问答（Common Sense QA）中对问题答案的潜在推理反思。通过将这种合理推理过程融入训练，模型学会了潜在的推理。随后，利用强大的计算资源实现Post-Training阶段的Scaling。这一技术路线与STaR的扩展版本非常相似。

同时，OpenAI o1的出现验证了后训练扩展律（Post-Training Scaling Laws），为上述技术路线的成功提供了有力支持。后训练扩展律的出现让许多学者重新思考推理的定义，一个合理的回答是“将思考时间转化为能力”，即通过增加思考推理时间来提升模型能力。随着在Post-Training阶段RL搜索的增强和在推理阶段的搜索时间增强，模型的能力得到了提升。模型在这过程中学习的是合理推理的过程，TreeSearch在其中起到了诱导合理推理过程产生的作用，或基于合理推理过程构建相应的偏序对形成系统的奖励信号。在模型的训练过程中，TreeSearch方法有助于构建系统的奖励信号，这在后续的技术路径推演中会提到。在推理阶段，搜索过程可能基于多样的TreeSearch方法实现。更有趣的是，模型的Bootstrap有助于构建新的高质量数据，这些数据中的Rationales促进了模型的进一步提升。

此外，o1的性能随着更多的强化学习（训练时间计算）和更多的思考时间（测试时间计算）而持续提高。在数学方面，在2024年的AIME（一个旨在挑战美国最聪明高中生的考试）测评中，GPT-4o只解决了13%的问题，o1的得分是83%。在编码方面，GPT-4o在竞争性编程问题(Codeforces)上的得分是11%，o1 是89%。在博士级别的科学问题(GPQA Diamond)，GPT4o是56.1%，o1则超越人类博士69.7%，达到了恐怖的78%。虽然在写作、文字编辑等自然领域反而逊色于gpt-4o体现出o1仍存在适用性问题，但是强大的推理能力让许多研究者们趋之若鹜，短短数个月的时间里出现了不少类似o1推理链的构想。

环境配置依赖

环境依赖如下：

----------------------
 Transformer >=4.48 
 Torch == 2.3.0     
 Cuda ==  12.1  
----------------------

本文默认学习者已安装好以上 Pytorch(cuda) 环境，如未安装请自行安装。

准备工作

# 升级pip
python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

pip install modelscope
pip install accelerate

考虑到部分同学配置环境可能会遇到一些问题，我们在 AutoDL 平台准备了 InternLM3-8b-Instruct 的环境镜像，点击下方链接并直接创建 AutoDL 示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/self-llm-internlm3

模型下载

modelscope 是一个模型管理和下载工具，支持从魔搭 (Modelscope) 等平台快速下载模型。

这里使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数为模型名称，第二个参数 cache_dir 为模型的下载路径，第三个参数 revision 为模型的版本号。

在 /root/autodl-tmp 路径下新建 model_download.py 文件并在其中粘贴以下代码，并保存文件。

from modelscope import snapshot_download, AutoModel, AutoTokenizer

model_dir = snapshot_download('Shanghai_AI_Laboratory/internlm3-8b-instruct', cache_dir='./', revision='master')

注意：记得修改 cache_dir 为你的模型下载路径哦~

在终端运行 python /root/autodl-tmp/model_download.py 执行下载，模型大小为 18GB 左右，下载模型大概需要5-30分钟。

核心代码

from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
import torch

class InternLM3_8B_Instruct:
    tokenizer: AutoTokenizer = None
    model: AutoModelForCausalLM = None

    def __init__(self, model_name_or_path: str):
        print("正在从本地加载模型")
        self.tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, use_fast=False, trust_remote_code=True)
        self.model = AutoModelForCausalLM.from_pretrained(model_name_or_path, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True)
        self.model.generation_config = GenerationConfig.from_pretrained(model_name_or_path, trust_remote_code=True)

    def generate_response(self, prompt: str, max_new_tokens: int = 512):
        input_ids = self.tokenizer(prompt, return_tensors="pt").input_ids.to('cuda')
        attention_mask = input_ids.ne(self.tokenizer.pad_token_id).long().to('cuda')

        with torch.no_grad():
            generated_ids = self.model.generate(
                input_ids,
                attention_mask=attention_mask,
                max_new_tokens=max_new_tokens
            )

        response = self.tokenizer.decode(generated_ids[0], skip_special_tokens=True)
        return response

    def generate_response_stream(self, prompt: str, max_new_tokens: int = 512):
        input_ids = self.tokenizer(prompt, return_tensors="pt").input_ids.to('cuda')
        attention_mask = input_ids.ne(self.tokenizer.pad_token_id).long().to('cuda')

        with torch.no_grad():
            for output in self.model.stream_generate(
                input_ids,
                attention_mask=attention_mask,
                max_new_tokens=max_new_tokens
            ):
                # Decode and yield the output token by token
                output_str = self.tokenizer.decode(output, skip_special_tokens=True)
                yield output_str

if __name__ == '__main__':
    model_path = "/root/autodl-tmp/Shanghai_AI_Laboratory/internlm3-8b-instruct"
    llm = InternLM3_8B_Instruct(model_path)
    prompt = """
你是一位在数学竞赛领域具有丰富经验的数学专家。你通过系统性的思考和严谨的推理来解决问题。
在面对以下数学问题时，请遵循以下思考过程：
## 深入理解问题
在尝试解决问题之前，请花时间完全理解问题：
- 实际上被问的是哪个问题？
- 给定的条件是什么，它们告诉我们什么？
- 是否有任何特殊的限制或假设？
- 哪些信息是关键的，哪些是辅助的？
## 多角度分析
在解决问题之前，进行彻底的分析：
- 涉及哪些数学概念和性质？
- 你能回忆起类似的经典问题或解决方法吗？
- 图表或表格是否有助于可视化问题？
- 是否有需要单独考虑的特殊情况？
## 系统性思考
规划你的解决方案路径：
- 提出多种可能的解决方法
- 分析每种方法的可行性和优点
- 选择最合适的方法，并解释为什么
- 将复杂问题分解为更小、更易管理的步骤
## 严谨证明
在解决问题的过程中：
- 为每一步提供坚实的理由
- 为关键结论提供详细的证明
- 注意逻辑联系
- 警惕可能的疏忽
## 反复验证
完成解决方案后：
- 验证你的结果是否满足所有条件
- 检查是否有被忽视的特殊情况
- 考虑解决方案是否可以优化或简化
- 审视你的推理过程
记住：
1. 花时间深入思考，而不是急于求成
2. 严谨地证明每个关键结论
3. 保持开放的心态，尝试不同的方法
4. 总结有价值的解决问题的方法
5. 保持健康的怀疑态度，多次验证

你的回应应反映出深厚的数学理解力和精确的逻辑思考，使你的解决方案路径和推理对他人清晰易懂。

当准备好后，请以以下格式呈现你的完整解决方案：
- 清晰的问题理解
- 详细的解决方案过程
- 关键见解
- 彻底的验证

专注于清晰、逻辑性的思路进展，详细解释你的数学推理。以提问者使用的语言提供答案，并在最后使用 '\\boxed{}' 重复最终答案。

现在，请解决以下数学问题[5的十次方等于多少？]
"""
    # Generate response in one go
    response = llm.generate_response(prompt=prompt)
    print(response)

    # # 流式输出
    # print("Streaming response:")
    # for part in llm.generate_response_stream(prompt=prompt):
    #     print(part, end='', flush=True)

将代码保存到文件中，需要修改存放模型的路径，接着使用命令

python 文件名.py

即可运行。

InternLM3-8B-instruct FastAPI部署

环境配置

模型下载

代码准备

调用API

InternLM3-8B-Instruct Langchain 接入

环境配置

模型下载

代码准备

调用

InternLM3-8B-Instruct WebDemo 部署

环境配置

模型下载

代码准备

运行 demo

InternLM3-8b-Instruct LoRA 微调

环境配置

模型下载

指令集构建

数据格式化

加载 tokenizer 和半精度模型 (model)

定义 LoraConfig

自定义 TrainingArguments 参数

使用 Trainer 训练

加载 LoRA 权重推理

internlm3-8b-instruct 与o1

环境配置依赖

准备工作

模型下载

核心代码

结果展示