许可证：llama3.1 语言：

• 英语
• 德语
• 法语
• 意大利语
• 葡萄牙语
• 印地语
• 西班牙语
• 泰语 库名称：transformers 流水线标签：文本生成 标签：
• llama-3.1
• meta
• autogptq

[!重要提示] 本仓库是原始模型 meta-llama/Meta-Llama-3.1-8B-Instruct 的社区驱动量化版本，该模型是由 Meta AI 发布的 FP16 半精度官方版本。

模型信息

Meta Llama 3.1 系列多语言大语言模型（LLMs）是一组预训练和指令调优的生成模型，包含 8B、70B 和 405B 规模（文本输入/文本输出）。Llama 3.1 指令调优的纯文本模型（8B、70B、405B）针对多语言对话用例进行了优化，在常见的行业基准测试中表现优于许多开源和闭源的聊天模型。

本仓库包含使用 AutoGPTQ 从 FP16 量化到 INT4 的 meta-llama/Meta-Llama-3.1-8B-Instruct，采用 GPTQ 内核执行零点量化，分组大小为 128。

模型使用

[!注意] 要在 INT4 精度下运行 Llama 3.1 8B Instruct GPTQ 的推理，仅加载模型检查点就需要约 4 GiB 的显存，不包括 KV 缓存或 CUDA 图，这意味着需要有略高于此的显存可用。

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

🤗 transformers

要在 INT4 精度下运行 Llama 3.1 8B Instruct GPTQ 的推理，需要安装以下软件包：

pip install -q --upgrade transformers accelerate optimum
pip install -q --no-build-isolation auto-gptq

要在 INT4 精度下运行 Llama 3.1 8B Instruct GPTQ 的推理，可以通过 AutoModelForCausalLM 实例化 GPTQ 模型，并正常进行推理。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.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, skip_special_tokens=True))

AutoGPTQ

要在 INT4 精度下运行 Llama 3.1 8B Instruct GPTQ 的推理，需要安装以下软件包：

pip install -q --upgrade transformers accelerate optimum
pip install -q --no-build-isolation auto-gptq

或者，尽管它是基于 🤗 transformers 构建的，但也可以通过 AutoGPTQ 运行，这是上面推荐的更优方法。

import torch
from auto_gptq import AutoGPTQForCausalLM
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoGPTQForCausalLM.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, skip_special_tokens=True))

AutoGPTQ 脚本改编自 AutoGPTQ/examples/quantization/basic_usage.py。

🤗 文本生成推理（TGI）

要在 INT4 精度下使用 Marlin 内核运行 text-generation-launcher 以优化推理速度，需要安装 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=hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4 \
  -e QUANTIZE=gptq \
  -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="hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-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

要使用 INT4 精度运行 vLLM 的 Llama 3.1 8B Instruct GPTQ，需要安装 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 hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4 \
  --quantization gptq_marlin \
  --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": "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-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="hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4",
  messages=[
    {"role": "system", "content": "你是一个乐于助人的助手。"},
    {"role": "user", "content": "什么是深度学习？"},
  ],
  max_tokens=128,
)

量化复现

[!注意] 要使用 AutoGPTQ 量化 Llama 3.1 8B Instruct，需要使用至少能够容纳整个模型的 CPU RAM 的实例，即约 8GiB，以及具有 16GiB 显存的 NVIDIA GPU 来进行量化。

要在 INT4 精度下使用 GPTQ 量化 Llama 3.1 8B Instruct，需要安装以下软件包：

pip install -q --upgrade transformers accelerate optimum
pip install -q --no-build-isolation auto-gptq

然后运行以下脚本，改编自 AutoGPTQ/examples/quantization/basic_usage.py。

import random

import numpy as np
import torch

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from datasets import load_dataset
from transformers import AutoTokenizer

pretrained_model_dir = "meta-llama/Meta-Llama-3.1-8B-Instruct"
quantized_model_dir = "meta-llama/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"

print("加载分词器、数据集并对数据集进行分词...")
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_dir, use_fast=True)
dataset = load_dataset("Salesforce/wikitext", "wikitext-2-raw-v1", split="train")
encodings = tokenizer("\n\n".join(dataset["text"]), return_tensors="pt")

print("设置随机种子...")
random.seed(0)
np.random.seed(0)
torch.random.manual_seed(0)

print("设置校准样本...")
nsamples = 128
seqlen = 2048
calibration_samples = []
for _ in range(nsamples):
    i = random.randint(0, encodings.input_ids.shape[1] - seqlen - 1)
    j = i + seqlen
    input_ids = encodings.input_ids[:, i:j]
    attention_mask = torch.ones_like(input_ids)
    calibration_samples.append({"input_ids": input_ids, "attention_mask": attention_mask})

quantize_config = BaseQuantizeConfig(
    bits=4,  # 将模型量化为 4 位
    group_size=128,  # 建议将该值设置为 128
    desc_act=True,  # 设置为 False 可以显著加快推理速度，但困惑度可能会稍差
    sym=True,  # 使用对称量化，使范围对称，允许精确表示值 0（可以提供加速）
    damp_percent=0.1,  # 参见 https://github.com/AutoGPTQ/AutoGPTQ/issues/196
)

# 加载未量化的模型，默认情况下，模型将始终加载到 CPU 内存中
print("加载未量化的模型...")
model = AutoGPTQForCausalLM.from_pretrained(pretrained_model_dir, quantize_config)

# 量化模型，样本应为字典列表，其键只能是 "input_ids" 和 "attention_mask"
print("使用校准样本量化模型...")
model.quantize(calibration_samples)

# 使用 safetensors 保存量化后的模型
model.save_quantized(quantized_model_dir, use_safetensors=True)