Hunyuan-1.8B-Instruct

作者

模型介绍

混元是腾讯开源的高效大型语言模型系列，旨在适应各种计算环境的多样化部署。从边缘设备到高并发生产系统，这些模型通过先进的量化支持和超长上下文能力，提供最佳性能。

我们已经发布了一系列混元密集模型，包括预训练和指令微调版本，参数规模分别为0.5B、1.8B、4B和7B。这些模型采用了与混元-A13B类似的训练策略，从而继承了其强大的性能特性。这一全面的模型家族使灵活的部署优化成为可能——从小型变体的资源受限边缘计算到大型模型的高吞吐量生产环境，同时在各种场景中保持强大的能力。

关键特性和优势

  • 混合推理支持：支持快速和慢速思考模式，允许用户根据需要灵活选择。
  • 超长上下文理解：原生支持256K上下文窗口，在长文本任务上保持稳定的性能。
  • 增强的代理能力：针对代理任务进行了优化，在BFCL-v3、τ-Bench和C3-Bench等基准测试中取得领先结果。
  • 高效的推理：利用分组查询注意力（GQA）并支持多种量化格式，实现高效的推理。

相关新闻

  • 2025.7.30 我们已经在 Hugging Face 上开源了 Hunyuan-0.5B-Pretrain、Hunyuan-0.5B-Instruct、Hunyuan-1.8B-Pretrain、Hunyuan-1.8B-Instruct、Hunyuan-4B-Pretrain、Hunyuan-4B-Instruct、Hunyuan-7B-Pretrain 和 Hunyuan-7B-Instruct。

基准测试

注意：以下基准测试是在几个 基础模型 上通过 TRT-LLM 后端进行评估的。

模型Hunyuan-0.5B-PretrainHunyuan-1.8B-PretrainHunyuan-4B-PretrainHunyuan-7B-Pretrain
MMLU54.0264.6274.0179.82
MMLU-Redux54.7264.4273.5379
MMLU-Pro31.1538.6551.9157.79
SuperGPQA17.2324.9827.2830.47
BBH45.9274.3275.1782.95
GPQA27.7635.8143.5244.07
GSM8K55.6477.2687.4988.25
MATH42.9562.8572.2574.85
EvalPlus39.7160.6767.7666.96
MultiPL-E21.8345.9259.8760.41
MBPP43.3866.1476.4676.19
CRUX-O30.7536.8856.560.75
中文 SimpleQA12.5122.3130.5338.86
simpleQA (5shot)2.383.614.215.69
主题基准Hunyuan-0.5B-InstructHunyuan-1.8B-InstructHunyuan-4B-InstructHunyuan-7B-Instruct
数学AIME 2024
AIME 2025
MATH		17.2
20
48.5		56.7
53.9
86		78.3
66.5
92.6		81.1
75.3
93.7
科学GPQA-Diamond
OlympiadBench		23.3
29.6		47.2
63.4		61.1
73.1		60.1
76.5
编程Livecodebench
Fullstackbench		11.1
20.9		31.5
42		49.4
54.6		57
56.3
推理BBH
DROP
ZebraLogic		40.3
52.8
34.5		64.6
76.7
74.6		83
78.2
83.5		87.8
85.9
85.1
指令
跟随		IF-Eval
SysBench		49.7
28.1		67.6
55.5		76.6
68		79.3
72.7
代理BFCL v3
τ-Bench
ComplexFuncBench
C3-Bench		49.8
14.4
13.9
45.3		58.3
18.2
22.3
54.6		67.9
30.1
26.3
64.3		70.8
35.3
29.2
68.5
长
上下文		PenguinScrolls
longbench-v2
FRAMES		53.9
34.7
41.9		73.1
33.2
55.6		83.1
44.1
79.2		82
43
78.6

使用 transformers

首先，请安装 transformers。我们稍后会将其合并到主分支中。

pip install git+https://github.com/huggingface/transformers@4970b23cedaf745f963779b4eae68da281e8c6ca

我们的模型默认使用慢思考推理，有两种方法可以禁用 CoT 推理。

  1. 在调用 apply_chat_template 时传递 “enable_thinking=False”。
  2. 在提示前添加 “/no_think” 将强制模型不使用 CoT 推理。同样，在提示前添加 “/think” 将强制模型进行 CoT 推理。

以下代码片段展示了如何使用 transformers 库加载和应用模型。它还演示了如何启用和禁用推理模式，以及如何解析推理过程和最终输出。

我们以 tencent/Hunyuan-7B-Instruct 为例

from modelscope import AutoModelForCausalLM, AutoTokenizer
import os
import re

model_name_or_path = "tencent/Hunyuan-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
model = AutoModelForCausalLM.from_pretrained(model_name_or_path, device_map="auto")  # You may want to use bfloat16 and/or move to GPU here
messages = [
    {"role": "user", "content": "Write a short summary of the benefits of regular exercise"},
]
tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True,return_tensors="pt",
                                                enable_thinking=True # Toggle thinking mode (default: True)
                                                )
                                                
outputs = model.generate(tokenized_chat.to(model.device), max_new_tokens=2048)

output_text = tokenizer.decode(outputs[0])
print("output_text=",output_text)
think_pattern = r'<think>(.*?)</think>'
think_matches = re.findall(think_pattern, output_text, re.DOTALL)

answer_pattern = r'<answer>(.*?)</answer>'
answer_matches = re.findall(answer_pattern, output_text, re.DOTALL)

think_content = [match.strip() for match in think_matches][0]
answer_content = [match.strip() for match in answer_matches][0]
print(f"thinking_content:{think_content}\n\n")
print(f"answer_content:{answer_content}\n\n")

我们建议使用以下一组参数进行推理。请注意，我们的模型没有默认的系统提示。


{
  "do_sample": true,
  "top_k": 20,
  "top_p": 0.8,
  "repetition_penalty": 1.05,
  "temperature": 0.7
}

训练数据格式

如果您需要微调我们的 Instruct 模型，我们建议将数据处理成以下格式，对应于慢思考和快思考场景。

# think_pattern
think = ""
answer = ""
think_pattern = f"<think>\n{think}\n</think>\n<answer>\n{answer}\n</answer>"

# fast think pattern
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "/no_think海水为什么是咸的" },
    {"role": "assistant", "content": "<think>\n\n</think>\n<answer>\n海水是咸的主要是因为其中含有许多溶解在水中的盐类和矿物质。这些盐类和矿物质来自于地球表面的岩石和土壤中的化学物质，随着时间的推移，它们被带到了海洋中。当海水蒸发时，水分蒸发掉了，但盐类和矿物质仍然留在水中，导致海水变得更加咸味。因此，海水的咸度是由其中的盐类和矿物质的含量决定的。\n</answer>"}
]

# slow think pattern
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "1+1=" },
    {"role": "assistant", "content": "<think>\n嗯，用户问的是1加1等于多少。首先，我需要确认这是一个基本的算术问题。1加1在十进制的数学体系中，通常的结果是2。不过，可能需要考虑是否有其他情况，比如二进制或者其他数制，但用户没有特别说明，所以默认应该是十进制。另外，有时候可能会有脑筋急转弯的情况，比如在某些语境下1+1可能等于1（比如1滴水加1滴水还是1滴水），但通常数学问题中都是2。所以最准确的回答应该是2。</think>\n<answer>\n在十进制的基本算术运算中，1加1的结果是2。这是数学中最基础的加法运算之一，遵循自然数的加法规则。因此，1 + 1 = 2。\n</answer>"}
]

from modelscope import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("Tencent-Hunyuan/Hunyuan-1.8B-Instruct", trust_remote_code=True)
train_ids = tokenizer.apply_chat_template(messages)

使用 LLaMA-Factory 进行训练

在接下来的章节中，我们将介绍如何使用 LLaMA-Factory 来微调 Hunyuan 模型。

先决条件

验证以下依赖项的安装：

  • LLaMA-Factory: 请遵循官方安装指南
  • DeepSpeed (可选): 请遵循官方安装指南
  • Transformer 库: 使用配套分支（Hunyuan 提交的代码正在审核中）pip install git+https://github.com/huggingface/transformers@4970b23cedaf745f963779b4eae68da281e8c6ca

数据准备

我们需要准备一个自定义数据集：

  1. 将您的数据组织成 json 格式，并放置在 LLaMA-Factory 中的 data 目录下。当前实现使用 sharegpt 数据集格式，需要以下结构：
[
  {
    "messages": [
      {
        "role": "system",
        "content": "System prompt (optional)"
      },
      {
        "role": "user",
        "content": "Human instruction"
      },
      {
        "role": "assistant",
        "content": "Model response"
      }
    ]
  }
]

有关详细信息，请参阅前面提到的数据格式部分。

  1. 在 data/dataset_info.json 文件中按照以下格式定义您的数据集：
"dataset_name": {
  "file_name": "dataset.json",
  "formatting": "sharegpt",
  "columns": {
    "messages": "messages"
  },
  "tags": {
    "role_tag": "role",
    "content_tag": "content",
    "user_tag": "user",
    "assistant_tag": "assistant",
    "system_tag": "system"
  }
}

训练执行

  1. 将 train/llama_factory_support/example_configs 目录下的所有文件复制到 LLaMA-Factory 中的 example/hunyuan 目录。
  2. 修改配置文件 hunyuan_full.yaml 中的模型路径和数据集名称。根据需要调整其他配置：
### model
model_name_or_path: [!!!add the model path here!!!]

### dataset
dataset: [!!!add the dataset name here!!!]
  1. 执行训练命令： *​​单节点训练​​注意：设置环境变量 DISABLE_VERSION_CHECK 为 1 以避免版本冲突。export DISABLE_VERSION_CHECK=1 llamafactory-cli train examples/hunyuan/hunyuan_full.yaml *多节点训练​​在每个节点上执行以下命令。根据您的环境配置 NNODES、NODE_RANK、MASTER_ADDR 和 MASTER_PORT：export DISABLE_VERSION_CHECK=1 FORCE_TORCHRUN=1 NNODES=${NNODES} NODE_RANK=${NODE_RANK} MASTER_ADDR=${MASTER_ADDR} MASTER_PORT=${MASTER_PORT} \ llamafactory-cli train examples/hunyuan/hunyuan_full.yaml

量化压缩

我们使用了自己开发的 AngleSlim 压缩工具来生成 FP8 和 INT4 量化模型。AngleSlim 是一套致力于创建更用户友好、全面且高效的模型压缩解决方案的工具集。

FP8 量化

我们使用了 FP8 静态量化，FP8 量化采用 8 位浮点格式，通过少量校准数据（无需训练）预先确定量化尺度，将模型权重和激活值转换为 FP8 格式，以提高推理效率并降低部署门槛。您可以使用 AngleSlim 量化，也可以直接下载我们的开源量化完成模型进行使用 链接。

INT4 量化

我们使用 GPTQ 和 AWQ 算法实现了 W4A16 量化。

GPTQ 按层处理模型权重，使用少量校准数据来最小化量化权重的重构误差，并通过近似海森逆矩阵的优化过程逐层调整权重。该过程无需重新训练模型，仅需少量校准数据即可对权重进行量化，从而提高推理效率并降低部署门槛。 AWQ 使用少量校准数据（无需训练），统计计算激活值的幅度。对于每个权重通道，计算一个缩放系数 s 来扩展重要权重的数值范围，以便在量化过程中保留更多信息。

您可以使用 AngleSlim 量化，也可以直接下载我们已经完成量化的开源模型来使用 LINK。

量化基准

本小节描述了混沌量化模型的基准指标。

基准量化Hunyuan-0.5B-InstructHunyuan-1.8B-InstructHunyuan-4B-InstructHunyuan-7B-Instruct
DROPB16
FP8
Int4GPTQ
Int4AWQ		52.8
51.6
50.9
48.9		76.7
75.1
73.0
71.7		78.2
78.3
78.1
78.2		85.9
86.0
85.7
85.9
GPQA-DiamondB16
FP8
Int4GPTQ
Int4AWQ		23.3
22.5
23.3
23.3		47.2
47.7
44.43
43.62		61.1
60.2
58.1
–		60.1
60.1
60.0
60.1
OlympiadBenchB16
FP8
Int4GPTQ
Int4AWQ		29.6
29.6
26.8
26.3		63.4
62.5
60.9
61.7		73.1
73.1
71.1
71.2		76.5
76.6
76.2
76.4
AIME 2024B16
FP8
Int4GPTQ
Int4AWQ		17.2
17.2
–
–		56.7
55.17
–
–		78.3
76.6
–
–		81.1
80.9
81.0
80.9

部署

对于部署，您可以使用 TensorRT-LLM、vLLM 或 SGLang 等框架来服务模型并创建与 OpenAI 兼容的 API 端点。

图片: https://hub.docker.com/r/hunyuaninfer/hunyuan-7B/tags

TensorRT-LLM

Docker 镜像

我们提供了基于最新版本 TensorRT-LLM 的预构建 Docker 镜像。

我们以 tencent/Hunyuan-7B-Instruct 为例

  • 开始：

https://hub.docker.com/r/hunyuaninfer/hunyuan-large/tags

docker pull hunyuaninfer/hunyuan-7B:hunyuan-moe-7B-trtllm

docker run --privileged --user root --name hunyuanLLM_infer --rm -it --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 --gpus=all hunyuaninfer/hunyuan-7B:hunyuan-moe-7B-trtllm
  • 准备配置文件：
cat >/path/to/extra-llm-api-config.yml <<EOF
use_cuda_graph: true
cuda_graph_padding_enabled: true
cuda_graph_batch_sizes:
- 1
- 2
- 4
- 8
- 16
- 32
print_iter_log: true
EOF
  • 启动 API 服务器：
trtllm-serve \
  /path/to/HunYuan-moe-7B \
  --host localhost \
  --port 8000 \
  --backend pytorch \
  --max_batch_size 32 \
  --max_num_tokens 16384 \
  --tp_size 2 \
  --kv_cache_free_gpu_memory_fraction 0.6 \
  --trust_remote_code \
  --extra_llm_api_options /path/to/extra-llm-api-config.yml

vllm

启动

请使用 vLLM 版本 v0.10.0 或更高版本进行推理。

我们以 tencent/Hunyuan-7B-Instruct 为例

  • 下载模型文件：
    • Huggingface：将由 vllm 自动下载。
    • ModelScope：modelscope download --model Tencent-Hunyuan/Hunyuan-7B-Instruct
  • 通过 Huggingface 下载的模型：
export MODEL_PATH=tencent/Hunyuan-7B-Instruct
  • 通过 ModelScope 下载的模型：
export MODEL_PATH=/root/.cache/modelscope/hub/models/Tencent-Hunyuan/Hunyuan-7B-Instruct/
  • 启动 API 服务器：
python3 -m vllm.entrypoints.openai.api_server \
    --host 0.0.0.0 \
    --port 8000 \
    --trust-remote-code \
    --model ${MODEL_PATH} \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --quantization experts_int8 \
    --served-model-name hunyuan \
    2>&1 | tee log_server.txt
  • 成功运行服务脚本后，运行请求脚本
curl http://0.0.0.0:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
"model": "hunyuan",
"messages": [
    {
        "role": "system",
        "content": [{"type": "text", "text": "You are a helpful assistant."}]
    },
    {
        "role": "user",
        "content": [{"type": "text", "text": "请按面积大小对四大洋进行排序，并给出面积最小的洋是哪一个？直接输出结果。"}]
    }
],
"max_tokens": 2048,
"temperature":0.7,
"top_p": 0.6,
"top_k": 20,
"repetition_penalty": 1.05,
"stop_token_ids": [127960]
}'

定量模型部署

本节描述了使用 vLLM 部署后量化模型的过程。

默认服务器在 BF16 模式下运行。

Int8 定量模型部署

部署 HunYuan-7B 模型的仅 Int8 权重版本只需设置环境变量

接下来我们启动 Int8 服务。运行：

python3 -m vllm.entrypoints.openai.api_server \
    --host 0.0.0.0 \
    --port 8000 \
    --trust-remote-code \
    --model ${MODEL_PATH} \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --served-model-name hunyuan \
    --quantization experts_int8 \
    2>&1 | tee log_server.txt
Int4 定量模型部署

部署 HunYuan-7B 模型的仅 Int4 权重版本只需设置环境变量，使用 GPTQ 方法

export MODEL_PATH=PATH_TO_INT4_MODEL

接下来我们启动 Int4 服务。运行

python3 -m vllm.entrypoints.openai.api_server \
    --host 0.0.0.0 \
    --port 8000 \
    --trust-remote-code \
    --model ${MODEL_PATH} \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --served-model-name hunyuan \
    --quantization gptq_marlin \
    2>&1 | tee log_server.txt
FP8 定量模型部署

部署 HunYuan-7B 模型的 W8A8C8 版本只需设置环境变量

接下来我们启动 FP8 服务。运行

python3 -m vllm.entrypoints.openai.api_server \
    --host 0.0.0.0 \
    --port 8000 \
    --trust-remote-code \
    --model ${MODEL_PATH} \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --served-model-name hunyuan \
    --kv-cache-dtype fp8 \
    2>&1 | tee log_server.txt

SGLang

Docker 镜像

我们还提供了一个基于最新版 SGLang 构建的预构建 Docker 镜像。

我们以 tencent/Hunyuan-7B-Instruct 为例

开始步骤：

  • 拉取 Docker 镜像
docker pull lmsysorg/sglang:latest
  • 启动 API 服务器：
docker run --entrypoint="python3" --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    --ulimit nproc=10000 \
    --privileged \
    --ipc=host \
     lmsysorg/sglang:latest \
SGLANG_USE_MODELSCOPE=true     -m sglang.launch_server --model-path hunyuan/huanyuan_7B --tp 4 --trust-remote-code --host 0.0.0.0 --port 30000

联系我们

如果您想给我们的研发和产品团队留言，欢迎联系我们的开源团队。您也可以通过电子邮件 (hunyuan_opensource@tencent.com) 联系我们。

原创文章，转载请注明： 转载自诺德美地科技

本文链接地址: Hunyuan-1.8B-Instruct

发表评论