Qwen3-1.7B模型蒸馏实践：指导0.6B小模型性能提升

背景

在AI智能体（Agent）应用中，我们经常通过提问引导AI调用相应工具完成任务。实际测试中发现，使用Qwen3-0.6B模型时，其响应效果往往不尽如人意；而切换至Qwen3-1.7B模型后，回答准确性显著提升。这自然引出一个问题：能否通过模型蒸馏技术，让性能更强的1.7B模型指导0.6B小模型提升表现？

模型蒸馏

模型蒸馏（Knowledge Distillation）是一种典型的迁移学习技术，其核心思想是通过预训练的"教师模型"（Teacher Model）来指导"学生模型"（Student Model）的训练过程。在本实践中：

• 教师模型：表现优异的Qwen3-1.7B
• 学生模型：待优化的Qwen3-0.6B

该技术通过软标签（Soft Targets）、注意力迁移等机制，将大模型的知识"蒸馏"到小模型中，使小模型能在参数量较少的情况下获得接近大模型的表现。

测试结果

使用的是Langchain Agent的问答,模型使用Ollama部署的Qwen3-1.7B和Qwen3-0.6B，选了10个样本数据。

模型	准确性
Qwen3-1.7B	90%
Qwen3-0.6B	30%

Qwen3-1.7B 回答如下：

问题: 请将 'prompt langchain example' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: 转换后的字符串为"PROMPT LANGCHAIN EXAMPLE"，其长度为24。今天的时间是2025-05-29 01:19:29。

问题: 请将 'test example' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: 转换后的字符串为"TEST EXAMPLE"，长度为12，今天的时间是2025-05-29 01:19:44。

问题: 请帮我算一下 51 / 27，然后告诉我今天是几号。
答案: 51除以27的结果是约1.8889，今天是2025年5月29日。

问题: 查下 2016-04-03 是星期几，然后算一下 91 * 16。
答案: 2016-04-03 是星期日，91乘以16的结果是1456。

问题: 请帮我算一下 75 + 80，然后告诉我今天是几号。
答案: 75 + 80 = 155，今天是2025年5月29日。

问题: 请帮我算一下 85 - 51，然后告诉我今天是几号。
答案: 85 - 51 的结果是 34，今天是 2025年5月29日。

问题: 先把 'example query' 转为大写，再告诉我它有多长？
答案: 字符串转换为大写后是"EXAMPLE QUERY"，其长度为13。

问题: 先把 'world' 转为大写，再告诉我它有多长？
答案: 'world'转换为大写后是"WORLD"，其长度为5。因此，答案是5。

问题: 先把 'langchain world example' 转为大写，再告诉我它有多长？（错误）
答案: 转换后的字符串长度为25。

问题: 请将 'prompt test' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: 转换后的字符串为"PROMPT TEST"，其长度为11，今天的时间是2025-05-29 01:23:07。

Qwen3-0.6B 回答如下：

问题: 请将 'prompt langchain example' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: "PROMPT LANGCHAIN EXAMPLE" 的长度是 11，今天的时间是 [GetDate返回的日期]。

问题: 请将 'test example' 转为大写，并计算它的长度，再告诉我今天的时间。（正确）
答案: "TEST EXAMPLE" 的长度是 12，并且今天的时间是 2025-05-29 01:37:48。

问题: 请帮我算一下 51 / 27，然后告诉我今天是几号。
答案: 51 / 27 的结果是 1.888...，今天是 2023-04-05。

问题: 查下 2016-04-03 是星期几，然后算一下 91 * 16。（正确）
答案: 2016-04-03 是：Sunday，91 * 16 = 1456

问题: 请帮我算一下 75 + 80，然后告诉我今天是几号。
答案: 75 + 80 = 155，今天是[GetWeekdayByDate]。

问题: 请帮我算一下 85 - 51，然后告诉我今天是几号。
答案: 85 - 51 的结果是 34，今天是 [GetWeekdayByDate的返回值]。

问题: 先把 'example query' 转为大写，再告诉我它有多长？
答案: "EXAMPLE QUERY" has a length of 17 characters.

问题: 先把 'world' 转为大写，再告诉我它有多长？（正确）
答案: ' WORLD' has a length of 5.

问题: 先把 'langchain world example' 转为大写，再告诉我它有多长？
答案: The uppercase version is "LANGCHAIN WORLD EXAMPLE" and its length is 13 characters.

问题: 请将 'prompt test' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: The uppercase string is "PROMPT TEST" with a length of 8, and the current date is "2023-10-15".

Langchain Agent

智能体使用langchain的，下面是提示词模板(langchain.agent的zero-shot-react-description)：

Answer the following questions as best you can. You have access to the following tools:

GetDate(_: str = None) -> str - 查询当天日期和时间
Lookup(expression: str) -> str - 执行数学运算
GetWeekdayByDate(date_str: str) -> str - 通过指定日期(YYYY-MM-DD)获取星期几

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [GetDate, Lookup, GetWeekdayByDate]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: 今天星期几？
Thought:

开始

1.数据准备：

下面是读取文本的500问题执行回答，写入文件中：

from langchain.agents import Tool, initialize_agent
from langchain_community.llms import Ollama
from langchain.memory import ConversationBufferMemory
from datetime import datetime
import numexpr

# 工具：获取当前完整日期和时间
def get_today_date(_: str = None) -> str:
    return datetime.now().strftime('%Y-%m-%d %H:%M:%S')


# 工具：计算数学表达式
def calculator(expression: str) -> str:
    try:
        result = numexpr.evaluate(expression).item()
        return f"结果：{result}"
    except Exception as e:
        return f"计算失败：{str(e)}"

# 工具：获取指定日期是星期几
def get_weekday_by_date(date_str: str) -> str:
    try:
        date = datetime.strptime(date_str, "%Y-%m-%d")
        weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
        return f"{date_str} 是：{weekdays[date.weekday()]}"
    except Exception:
        return "日期格式应为 YYYY-MM-DD"

# 工具：获取字符串长度
def get_string_length(text: str) -> str:
    return f"长度：{len(text)}"

# 工具：字符串转大写
def to_uppercase(text: str) -> str:
    return text.upper()


# 注册所有工具
tools = [
    Tool(name="GetDate", func=get_today_date, description="查询当天日期和时间"),
    Tool(name="Lookup", func=calculator, description="执行数学运算，如：2 + 3 * (4 - 1)"),
    Tool(name="GetWeekdayByDate", func=get_weekday_by_date, description="通过指定日期(YYYY-MM-DD)获取星期几"),
    Tool(name="StringLength", func=get_string_length, description="获取字符串的长度"),
    Tool(name="ToUpperCase", func=to_uppercase, description="将字符串转换为大写"),
]

# 初始化 LLM
llm = Ollama(
    model="qwen3:1.7b",
    base_url="http://localhost:11434"
)

# 初始化代理
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent="zero-shot-react-description",
    memory=ConversationBufferMemory(memory_key="chat_history"),
    verbose=True
)

# 示例运行
if __name__ == "__main__":
    with open("500.txt", "r", encoding="utf-8") as f:
        lines = f.readlines()
    results = []
    for line in lines[:10]:
        question = line.strip()
        if not question:
            continue
        try:
            answer = agent.run(question)
        except Exception as e:
            answer = f"发生异常: {str(e)}"
        results.append(f"问题: {question}\n答案: {answer}\n\n")
    with open("resultb.txt", "w", encoding="utf-8") as out_f:
        out_f.writelines(results)
    print("前10行问题和答案已写入 result.txt")

通过GPT给如上代码，根据工具生成500个问题测试数据文本，内容如下（前20个）：

请将 'prompt langchain example' 转为大写，并计算它的长度，再告诉我今天的时间。
请将 'test example' 转为大写，并计算它的长度，再告诉我今天的时间。
请帮我算一下 51 / 27，然后告诉我今天是几号。
查下 2016-04-03 是星期几，然后算一下 91 * 16。
请帮我算一下 75 + 80，然后告诉我今天是几号。
请帮我算一下 85 - 51，然后告诉我今天是几号。
先把 'example query' 转为大写，再告诉我它有多长？
先把 'world' 转为大写，再告诉我它有多长？
先把 'langchain world example' 转为大写，再告诉我它有多长？
请将 'prompt test' 转为大写，并计算它的长度，再告诉我今天的时间。
查下 2004-03-18 是星期几，然后算一下 80 * 72。
请帮我算一下 50 / 99，然后告诉我今天是几号。
先把 'test example prompt hello' 转为大写，再告诉我它有多长？
查下 2022-12-23 是星期几，然后算一下 48 / 99。
查下 2010-10-08 是星期几，然后算一下 18 * 15。
查下 2003-05-26 是星期几，然后算一下 62 - 2。
查下 2000-06-04 是星期几，然后算一下 53 / 100。
查下 2001-11-19 是星期几，然后算一下 38 + 30。
查下 2025-02-24 是星期几，然后算一下 57 * 17。
请帮我算一下 10 + 56，然后告诉我今天是几号。

2.抓取提示词和Ollama回答：

我们要微调就需要问题和回答，我们调用的是本地Ollama地址是：http://localhost:11434 ，通过简单的端口转发就可以拿到数据，将11435转发到11434，代码如下：

import socket
import threading
import json
import re
from queue import Queue

q_queue = Queue()

def forward_data(source, destination, label):
    """转发数据并打印内容"""
    reqContent = ""
    respContent = ""
    respText = ""

    while True:
        data = source.recv(1024*10)  # 接收数据
        if not data:
            break
        # print(f"[{label}] 传输数据:\n{data.decode('utf-8', errors='replace')}\n")
        if label == "客户端 -> 服务器":
            reqContent += data.decode('utf-8', errors='replace')
            if reqContent.rstrip().endswith("}"):
                sp = reqContent.split("\r\n\r\n")
                if len(sp) > 1:
                    obj = json.loads(sp[1])
                    print(f"[{label}] 请求内容:\n{obj['prompt']}\n")
                    q_queue.put(obj['prompt'])
                reqContent = ""  # 重置请求内容
        else:
            # 尝试提取 JSON 并打印 response 字段
            respContent += data.decode('utf-8', errors='replace')
            # 用正则提取所有完整的 JSON 块
            matches = re.findall(r'\{.*?\}', respContent, re.DOTALL)
            for m in matches:
                try:
                    obj = json.loads(m)
                    if 'response' in obj:
                        respText += obj['response']
                    if 'done' in obj and obj['done']:
                        print(f"[{label}] 响应内容:\n{respText}\n")
                        if not q_queue.empty():
                            prompt = q_queue.get()
                            j = {"Q": prompt, "A": respText}
                            with open("q_a.jsonl", "a", encoding="utf-8") as f:
                                f.write(json.dumps(j, ensure_ascii=False) + "\n")
                        respText = ""
                except Exception:
                    pass
            # 清理已处理的内容，只保留最后一个 '}' 之后的内容（可能是不完整的 JSON）
            if matches:
                last_end = respContent.rfind('}')
                respContent = respContent[last_end+1:] if last_end != -1 else ""

        destination.sendall(data)  # 转发数据

def start_port_forwarding(local_host, local_port, remote_host, remote_port):
    """启动端口转发"""
    # 创建本地监听套接字
    local_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    local_socket.bind((local_host, local_port))
    local_socket.listen(5)
    print(f"监听 {local_host}:{local_port} -> 转发到 {remote_host}:{remote_port}")

    while True:
        client_socket, addr = local_socket.accept()
        print(f"接受来自 {addr} 的连接")

        # 连接远程服务器
        remote_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        remote_socket.connect((remote_host, remote_port))

        # 启动双向转发线程
        threading.Thread(
            target=forward_data,
            args=(client_socket, remote_socket, "客户端 -> 服务器"),
            daemon=True
        ).start()
        threading.Thread(
            target=forward_data,
            args=(remote_socket, client_socket, "服务器 -> 客户端"),
            daemon=True
        ).start()

# 示例：将本地 11435 端口转发到 127.0.0.1:11434
start_port_forwarding("127.0.0.1", 11435, "127.0.0.1", 11434)

跑1.7B模型500条，得到1580条，我下面只打印一条出来：

{"Q": "Answer the following questions as best you can. You have access to the following tools:\n\nGetDate(_: str = None) -> str - 查询当天日期和时间\nLookup(expression: str) -> str - 执行数学运算，如：2 + 3 * (4 - 1)\nGetWeekdayByDate(date_str: str) -> str - 通过指定日期(YYYY-MM-DD)获取星期几\nStringLength(text: str) -> str - 获取字符串的长度\nToUpperCase(text: str) -> str - 将字符串转换为大写\n\nUse the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [GetDate, Lookup, GetWeekdayByDate, StringLength, ToUpperCase]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n\nBegin!\n\nQuestion: 请将 'prompt langchain example' 转为大写，并计算它的长度，再告诉我今天的时间。\nThought:", "A": "<think>\n好的，我现在要处理用户的问题。用户的要求是将"prompt langchain example"转为大写，然后计算它的长度，最后告诉我今天的时间。我需要一步步来完成这些任务。\n\n首先，我需要确定要使用的工具。用户提供的工具中有ToUpperCase，可以将字符串转换为大写。然后，GetDate可以获取当前日期和时间。另外，StringLength用于计算字符串长度。所以，我需要依次应用这些工具。\n\n第一步，将"prompt langchain example"转为大写。使用ToUpperCase工具，输入这个字符串，应该得到"PROMPT LANGCHAIN EXAMPLE"。不过，我需要确认工具是否正确，比如是否有特殊字符或者大小写处理的问题。不过这里看起来应该没问题，因为所有字母都是小写的，转换后都是大写。\n\n接下来，计算这个字符串的长度。StringLength工具会返回字符串的字符数。原字符串是"prompt langchain example"，转为大写后是"PROMPT LANGCHAIN EXAMPLE"，所以长度应该是16个字符？让我数一下：P(1), R(2), O(3), M(4), T(5), L(6), A(7), N(8), E(9), C(10), H(11), A(12), I(13), N(14), E(15), M(16), P(17)？或者可能我数错了。不过可能原字符串在转为大写后长度是17？比如原字符串是"prompt langchain example"共多少个字符？原字符串是"prompt langchain example"，假设中间有空格，那么每个单词的字符数：prompt是6，langchain是9，example是7，总共有6+1+9+1+7=24个字符？但转为大写后，每个字母都变成大写，所以长度应该和原字符串相同，即24个字符？不过用户的问题中可能原字符串是"prompt langchain example"，所以转为大写后的长度是24？或者可能用户的问题中的字符串有其他情况？\n\n不过根据工具的使用，不管怎样，StringLength工具会返回正确的长度。所以接下来我需要用StringLength工具处理转为大写后的字符串。\n\n然后，获取今天的日期和时间，使用GetDate工具。这个工具返回的是当前日期和时间，比如"2023-10-05 14:30:00"这样的格式。不过具体日期可能需要根据实际情况调整，但工具会返回正确的结果。\n\n所以，步骤应该是：\n\n1. 使用ToUpperCase转换原字符串为大写。\n2. 使用StringLength计算长度。\n3. 使用GetDate获取当前日期和时间。\n\n现在需要按照顺序执行这些步骤。首先，转换字符串，然后计算长度，最后获取日期时间。\n\n可能需要注意的是，用户的问题中的字符串是否包含空格，比如"prompt langchain example"中有空格，转为大写后每个字母都是大写，所以长度应该等于原字符串的字符数。原字符串的字符数是：每个单词的字符数相加。例如，"prompt"是6个字符，"langchain"是9个，"example"是7个，总共有6+1+9+1+7=24个字符？或者原字符串是"prompt langchain example"共多少个字符？比如，假设原字符串是"prompt langchain example"，中间有空格，那么总共有6+1+9+1+7=24个字符？或者原字符串中的空格是否算在内？比如，字符串中的空格是否会影响长度？比如，原字符串的长度是24，转为大写后长度还是24，因为空格也被包含在内。所以StringLength的结果应该是24。\n\n然后，GetDate返回当前日期和时间，比如假设今天是2023-10-05 14:30:00，但具体日期可能需要工具返回实际结果。\n\n所以，最终的答案需要将这三个步骤的结果组合起来。用户的问题要求将字符串转为大写，计算长度，然后给出今天的时间。所以最终的答案应该包括这三个部分：转换后的字符串，长度，以及当前日期时间。\n</think>\n\nThought: 我需要先将字符串转为大写，然后计算其长度，最后获取当前日期和时间。\nAction: ToUpperCase\nAction Input: \"prompt langchain example\""}

3.开始微调：

微调使用官方的例子，文档：Qwen3/examples/llama-factory/finetune-zh.md at main · QwenLM/Qwen3

要求的数据格式是：

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Tell me something about large language models."
        },
        {
            "role": "assistant",
            "content": "Large language models are a type of language model that is trained on a large corpus of text data. They are capable of generating human-like text and are used in a variety of natural language processing tasks..."
        },
        {
            "role": "user",
            "content": "How about Qwen2?"
        },
        {
            "role": "assistant",
            "content": "Qwen2 is a large language model developed by Alibaba Cloud..."
        }
      
    ]
}

通pyhton将之前的的jsonl的{"Q":"问题","A":"回答"}转换成上面格式：

import json
converted_data = []
with open("q_a.jsonl", "r", encoding="utf-8") as f:
    for line in f:
        obj = json.loads(line)
        converted_data.append({
            "messages": [
                {"role": "user", "content": obj["Q"]},
                {"role": "assistant", "content": obj["A"]}
            ]
        })

with open("qwen_format_data.json", "w", encoding="utf-8") as f:
    json.dump(converted_data, f, ensure_ascii=False, indent=2)

数据准备好，这里使用腾讯云的Cloud Studio(免费的T4环境) Cloud Studio

首先在Cloud Studio创建Tensorflow2.9.0模板

上面的环境过时了，需要创建一个新的环境，更新Tensorflow

# 创建环境
python3 -m venv myenv
# 进入环境
source myenv/bin/activate
# 更新Tensorflow
pip install --upgrade transformers

按照官方使用LLaMA-Factory进行LoRA微调,先安装LLaMA-Factory

git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e ".[torch,metrics]"

安装好后文件LLaMA-Factory/data/dataset_info.json末尾追加内容如下：

  "qwen_train_data": {
    "file_name": "qwen_format_data.json",
    "formatting": "sharegpt",
    "columns": {
      "messages": "messages"
    },
    "tags": {
      "role_tag": "role",
      "content_tag": "content",
      "user_tag": "user",
      "assistant_tag": "assistant",
      "system_tag": "system"
    }
  }

把准备好的数据集qwen_format_data.json上传到当前位置LLaMA-Factory/data/

在LLaMA-Factory/创建一个微调配置文件qwen3-lora-sft.yaml，如下：

### model
model_name_or_path: Qwen/Qwen3-0.6B

### method
stage: sft
do_train: true
finetuning_type: lora
lora_target: all
quantization_bit: 4
quantization_method: bitsandbytes  # choices: [bitsandbytes (4/8), hqq (2/3/4/5/6/8), eetq (8)]
lora_rank: 16
lora_alpha: 16
lora_dropout: 0.05

### dataset
dataset: qwen_train_data
template: qwen
cutoff_len: 1024
overwrite_cache: true
preprocessing_num_workers: 16

### output
output_dir: saves/qwen3/qlora/sft
logging_steps: 100
save_steps: 100
plot_loss: true
overwrite_output_dir: true

### train
per_device_train_batch_size: 1
gradient_accumulation_steps: 16
learning_rate: 1.0e-4
num_train_epochs: 1.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true
ddp_timeout: 180000000

### eval
val_size: 0.1
per_device_eval_batch_size: 1
eval_strategy: steps
eval_steps: 500

开始微调

llamafactory-cli train qwen3-lora-sft.yaml

查看GPU

nvidia-smi

微调完之后需要合并，不然用dapter+模型推理会很消耗资源，创建qwen3-merge-lora.yaml

### Note: DO NOT use quantized model or quantization_bit when merging lora adapters

### model
model_name_or_path: Qwen/Qwen3-0.6B
adapter_name_or_path: saves/qwen3/qlora/sft
template: qwen
finetuning_type: lora

### export
export_dir: models/qwen3-sft-lora-merged
export_size: 2
export_device: cpu
export_legacy_format: false

开始合并模型,合并文件会大很多

llamafactory-cli export  qwen3-merge-lora.yaml 

qwen3-sft-lora-merged 压缩成zip ,方便下载

cd models/qwen3-sft-lora-merged
!zip -r Qwen3-0.6B-adapter.zip qwen3-sft-lora-merged

3.模型注册到Ollama中：

需要通过ollama运行，但是ollama不能直接运行生成好的模型，不支持qwen3新的格式，需要转成GGUF格式

通过llama.cpp转换GGUF

python convert_hf_to_gguf.py Qwen3-0.6B-adapter --outtype f16 --outfile Qwen3-0.6B-adapter.gguf

再进行量化

llama-quantize Qwen3-0.6B-adapter.gguf Qwen3-0.6B-adapter.q8_0.gguf Q8_0

创建一个Modelfile文件，内容如下：

# ollama modelfile auto-generated by llamafactory

FROM Qwen3-0.6B-adapter.gguf

TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ range .Messages }}{{ if eq .Role "user" }}<|im_start|>user
{{ .Content }}<|im_end|>
<|im_start|>assistant
{{ else if eq .Role "assistant" }}{{ .Content }}<|im_end|>
{{ end }}{{ end }}"""

SYSTEM """You are Qwen, created by Alibaba Cloud. You are a helpful assistant."""

PARAMETER stop "<|im_end|>"
PARAMETER num_ctx 4096

模型创建到ollama中。

ollama create Qwen3-0.6B-adapter-q8_0 -f Modelfile

4.运行测试：

代码就运行数据准备的python代码，取前10条数据，模型更换成Qwen3-0.6B-adapter-q8_0。

模型	准确性
Qwen3-0.6B-adapter-q8_0	70%

测试数据内容如下：

问题: 请将 'prompt langchain example' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: 转换后的字符串为"PROMPT LANGCHAIN EXAMPLE"，长度为24，并且今天的时间是2025年5月31日 04:54:50。

问题: 请将 'test example' 转为大写，并计算它的长度，再告诉我今天的时间。（错误）
答案: 发生异常: An output parsing error occurred. In order to pass this error back to the agent and have it try again, pass `handle_parsing_errors=True` to the AgentExecutor. This is the error: Could not parse LLM output: `<think>
Thought: 现在需要获取今天的日期时间。`
For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE 

问题: 请帮我算一下 51 / 27，然后告诉我今天是几号。
答案: 51除以27的结果是1.89，今天是2025年5月31日。

问题: 查下 2016-04-03 是星期几，然后算一下 91 * 16。
答案: 2016-04-03 是星期日，91 × 16 的结果是 1456。

问题: 请帮我算一下 75 + 80，然后告诉我今天是几号。
答案: 75 + 80 = 155，今天是2025年5月31日。

问题: 请帮我算一下 85 - 51，然后告诉我今天是几号。
答案: 85 - 51 = 34，今天是2025年5月31日。

问题: 先把 'example query' 转为大写，再告诉我它有多长？
答案: 转换后的字符串为"EXAMPLE QUERY"，其长度为13。

问题: 先把 'world' 转为大写，再告诉我它有多长？（错误）
答案: 世界字符串的长度是5。

问题: 先把 'langchain world example' 转为大写，再告诉我它有多长？（错误）
答案: 转换后的字符串是"LANGCHAIN WORLD EXAMPLE"，它的长度为13个字符。

问题: 请将 'prompt test' 转为大写，并计算它的长度，再告诉我今天的时间。
答案: 转换后的字符串为"PROMPT TEST"，长度为11，今天的时间是2025年5月31日 04:58:10。

总结

通过蒸馏方式，可以让小的模型能接近大模型的表现，像DeepSeek-R1-Distill Models通过其他模型训练出来。

Model	Base Model	Download
DeepSeek-R1-Distill-Qwen-1.5B	Qwen2.5-Math-1.5B	🤗 HuggingFace
DeepSeek-R1-Distill-Qwen-7B	Qwen2.5-Math-7B	🤗 HuggingFace
DeepSeek-R1-Distill-Llama-8B	Llama-3.1-8B	🤗 HuggingFace
DeepSeek-R1-Distill-Qwen-14B	Qwen2.5-14B	🤗 HuggingFace
DeepSeek-R1-Distill-Qwen-32B	Qwen2.5-32B	🤗 HuggingFace
DeepSeek-R1-Distill-Llama-70B	Llama-3.3-70B-Instruct	🤗 HuggingFace