许可证：llama3.1
语言：

• 英语
• 德语
• 法语
• 意大利语
• 葡萄牙语
• 印地语
• 西班牙语
• 泰语
  库名称：transformers
  流水线标签：文本生成
  标签：
• llama-3.1
• meta
• autoawq
  数据集：
• nvidia/HelpSteer2
  基础模型：
• nvidia/Llama-3.1-Nemotron-70B-Instruct-HF

量化模型信息

[!重要]
本仓库是nvidia/Llama-3.1-Nemotron-70B-Instruct-HF模型的AWQ 4位量化版本，该模型是NVIDIA基于meta-llama/Meta-Llama-3.1-70B-Instruct定制的版本，最初由Meta AI发布。

此模型使用AutoAWQ从FP16量化至INT4，采用GEMM内核、零点量化和128的分组大小。

硬件配置：Intel Xeon CPU E5-2699A v4 @ 2.40GHz，256GB内存，2块NVIDIA RTX 3090显卡。该模型应支持任何兼容LLama 3.1 70B Instruct AWQ INT4的平台。

以下是Transformers、AutoAWQ、文本生成接口（TGI）和vLLM的模型使用（推理）信息，以及量化复现细节。

原始模型信息

Llama-3.1-Nemotron-70B-Instruct是NVIDIA定制的大型语言模型，旨在提升LLM生成响应对用户查询的有用性。

该模型在Arena Hard上达到85.0分，AlpacaEval 2 LC上达到57.6分，GPT-4-Turbo MT-Bench上达到8.98分，这些分数被认为可以预测LMSys Chatbot Arena Elo。

截至2024年10月1日，该模型在所有三个自动对齐基准测试中排名第一（AlpacaEval 2 LC已验证），超越了GPT-4o和Claude 3.5 Sonnet等前沿模型。

截至2024年10月24日，该模型在ChatBot Arena排行榜上的Elo得分为1267（±7），排名第9，风格控制排名第26。

原始模型使用RLHF（特别是REINFORCE）、Llama-3.1-Nemotron-70B-Reward和HelpSteer2-Preference prompts在Llama-3.1-70B-Instruct模型上作为初始策略进行训练。

nvidia/Llama-3.1-Nemotron-70B-Instruct-HF已从Llama-3.1-Nemotron-70B-Instruct转换而来，以支持HuggingFace Transformers代码库。请注意，评估结果可能与Llama-3.1-Nemotron-70B-Instruct在NeMo-Aligner中的评估结果略有不同。

[!注意]
Terrell的说明：量化至AWQ 4位将进一步影响评估结果。

模型使用

为了使用此量化模型，支持不同的解决方案，如transformers、autoawq或text-generation-inference。

[!注意]
要在INT4精度下运行Llama 3.1 Nemotron 70B Instruct AWQ的推理，加载模型检查点需要约35 GiB的VRAM，不包括KV缓存或CUDA图，因此应确保有略高于此的VRAM可用。

🤗 Transformers

要在INT4精度下运行Llama 3.1 Nemotron 70B Instruct AWQ的推理，需要安装以下包：

pip install -q --upgrade transformers autoawq accelerate

要运行Llama 3.1 Nemotron 70B Instruct AWQ的INT4精度推理，AWQ模型可以通过AutoModelForCausalLM像其他因果语言建模模型一样实例化。按常规方式运行推理。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AwqConfig

model_id = "ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4"
quantization_config = AwqConfig(
    bits=4,
    fuse_max_seq_len=512, # 注意：根据您的用例更新此值
    do_fuse=True,
)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
  model_id,
  torch_dtype=torch.float16,
  low_cpu_mem_usage=True,
  device_map="auto",
  quantization_config=quantization_config
)

prompt = [
  {"role": "system", "content": "你是一个乐于助人的助手，以海盗的方式回答。"},
  {"role": "user", "content": "什么是深度学习？"},
]
inputs = tokenizer.apply_chat_template(
  prompt,
  tokenize=True,
  add_generation_prompt=True,
  return_tensors="pt",
  return_dict=True,
).to("cuda")

outputs = model.generate(**inputs, do_sample=True, max_new_tokens=256)
print(tokenizer.batch_decode(outputs[:, inputs['input_ids'].shape[1]:], skip_special_tokens=True)[0])

AutoAWQ

要在INT4精度下运行Llama 3.1 Nemotron 70B Instruct AWQ的推理，需要安装以下包：

pip install -q --upgrade transformers autoawq accelerate

或者，尽管AutoAWQ基于🤗 transformers，但也可以选择通过AutoAWQ运行，这是推荐的方法。

import torch
from awq import AutoAWQForCausalLM
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoAWQForCausalLM.from_pretrained(
  model_id,
  torch_dtype=torch.float16,
  low_cpu_mem_usage=True,
  device_map="auto",
)

prompt = [
  {"role": "system", "content": "你是一个乐于助人的助手，以海盗的方式回答。"},
  {"role": "user", "content": "什么是深度学习？"},
]
inputs = tokenizer.apply_chat_template(
  prompt,
  tokenize=True,
  add_generation_prompt=True,
  return_tensors="pt",
  return_dict=True,
).to("cuda")

outputs = model.generate(**inputs, do_sample=True, max_new_tokens=256)
print(tokenizer.batch_decode(outputs[:, inputs['input_ids'].shape[1]:], skip_special_tokens=True)[0])

AutoAWQ脚本改编自AutoAWQ/examples/generate.py。

🤗 文本生成推理（TGI）

要使用Marlin内核运行text-generation-launcher以优化推理速度，在INT4精度下运行Llama 3.1 Nemotron 70B Instruct AWQ，需要安装Docker（参见安装说明）和huggingface_hub Python包，因为需要登录Hugging Face Hub。

pip install -q --upgrade huggingface_hub
huggingface-cli login

然后只需运行TGI v2.2.0（或更高版本）的Docker容器：

docker run --gpus all --shm-size 1g -ti -p 8080:80 \
  -v hf_cache:/data \
  -e MODEL_ID=ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4 \
  -e NUM_SHARD=4 \
  -e QUANTIZE=awq \
  -e HF_TOKEN=$(cat ~/.cache/huggingface/token) \
  -e MAX_INPUT_LENGTH=4000 \
  -e MAX_TOTAL_TOKENS=4096 \
  ghcr.io/huggingface/text-generation-inference:2.2.0

[!注意]
TGI将暴露不同的端点，查看所有可用端点请参阅TGI OpenAPI规范。

向部署的TGI端点发送请求，兼容OpenAI OpenAPI规范即/v1/chat/completions：

curl 0.0.0.0:8080/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "tgi",
    "messages": [
      {
        "role": "system",
        "content": "你是一个乐于助人的助手。"
      },
      {
        "role": "user",
        "content": "什么是深度学习？"
      }
    ],
    "max_tokens": 128
  }'

或通过huggingface_hub Python客户端编程实现：

import os
from huggingface_hub import InferenceClient

client = InferenceClient(base_url="http://0.0.0.0:8080", api_key=os.getenv("HF_TOKEN", "-"))

chat_completion = client.chat.completions.create(
  model="ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4",
  messages=[
    {"role": "system", "content": "你是一个乐于助人的助手。"},
    {"role": "user", "content": "什么是深度学习？"},
  ],
  max_tokens=128,
)

或者，也可以使用OpenAI Python客户端（参见安装说明）：

import os
from openai import OpenAI

client = OpenAI(base_url="http://0.0.0.0:8080/v1", api_key=os.getenv("OPENAI_API_KEY", "-"))

chat_completion = client.chat.completions.create(
  model="tgi",
  messages=[
    {"role": "system", "content": "你是一个乐于助人的助手。"},
    {"role": "user", "content": "什么是深度学习？"},
  ],
  max_tokens=128,
)

vLLM

要使用vLLM运行Llama 3.1 70B Instruct AWQ的INT4精度推理，需要安装Docker（参见安装说明）并运行最新的vLLM Docker容器：

docker run --runtime nvidia --gpus all --ipc=host -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4 \
  --tensor-parallel-size 4 \
  --max-model-len 4096

向部署的vLLM端点发送请求，兼容OpenAI OpenAPI规范即/v1/chat/completions：

curl 0.0.0.0:8000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4",
    "messages": [
      {
        "role": "system",
        "content": "你是一个乐于助人的助手。"
      },
      {
        "role": "user",
        "content": "什么是深度学习？"
      }
    ],
    "max_tokens": 128
  }'

或通过openai Python客户端编程实现（参见安装说明）：

import os
from openai import OpenAI

client = OpenAI(base_url="http://0.0.0.0:8000/v1", api_key=os.getenv("VLLM_API_KEY", "-"))

chat_completion = client.chat.completions.create(
  model="ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4",
  messages=[
    {"role": "system", "content": "你是一个乐于助人的助手。"},
    {"role": "user", "content": "什么是深度学习？"},
  ],
  max_tokens=128,
)

量化复现信息

[!注意]
要使用AutoAWQ量化Llama 3.1 Nemotron 70B Instruct，需要使用至少能够容纳整个模型的CPU RAM的实例，即约140GiB，以及一块40GiB VRAM的NVIDIA GPU进行量化。

要量化Llama 3.1 Nemotron 70B Instruct，首先安装以下包：

pip install -q --upgrade transformers autoawq accelerate

此量化是在单节点上完成的，配置为Intel Xeon CPU E5-2699A v4 @ 2.40GHz，256GB内存，2块NVIDIA RTX 3090（每块24GB VRAM，总计48GB VRAM）。

我最初改编了hugging-quants/Meta-Llama-3.1-70B-Instruct-AWQ-INT4，因此非常感谢Hugging Quants团队、AutoAWQ团队和MIT HAN Lab的LLM-AWQ。我还要特别感谢科罗拉多大学博尔德分校的David Dobolyi教授和Hugging Face的Marc Sun，特别是AutoAWQ PR#630。

改编自AutoAWQ/examples/quantize.py和hugging-quants/Meta-Llama-3.1-70B-Instruct-AWQ-INT4：

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer
import torch

# 清空缓存
torch.cuda.empty_cache()

# 内存限制 - 根据硬件限制设置
max_memory = {0: "22GiB", 1: "22GiB", "cpu": "160GiB"}

model_path = "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF"
quant_path = "ibnzterrell/Nvidia-Llama-3.1-Nemotron-70B-Instruct-HF-AWQ-INT4"
quant_config = {
  "zero_point": True,
  "q_group_size": 128,
  "w_bit": 4,
  "version": "GEMM"
  
}

# 加载模型 - 注意：虽然这将层加载到CPU中，但量化仍需要GPU（和VRAM）！（通过nvidia-smi验证）
model = AutoAWQForCausalLM.from_pretrained(
    model_path,
    use_cache=False,
    max_memory=max_memory,
    device_map="cpu"
)

tokenizer = AutoTokenizer.from_pretrained(model_path)

# 量化
model.quantize(
    tokenizer,
    quant_config=quant_config
)

# 保存量化模型
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

print(f'模型已量化并保存在"{quant_path}"')