大模型高效部署方法对比：以 LLaMA2 为例

使用 Docker 运行 Web 服务器

mkdir data
docker run --gpus all --shm-size 1g -p 8080:80 \
-v data:/data ghcr.io/huggingface/text-generation-inference:0.9 \
  --model-id huggyllama/llama-13b \
  --num-shard 1

进行查询

# pip install text-generation
from text_generation import Client

client = Client("http://127.0.0.1:8080")
prompt = "Funniest joke ever:"
print(client.generate(prompt, max_new_tokens=17, temperature=0.95).generated_text)

3. CTranslate2

CTranslate2 是一个 C++ 和 Python 库，用于使用 Transformer 模型进行高效推理。在 CPU 和 GPU 上快速高效地执行，支持多种 CPU 架构，一些优化技术：layer fusion, padding removal, batch reordering, in-place operations, caching mechanism。支持并行和异步执行。缺乏对适配器（LoRA、QLoRA 等）的支持。

pip install -qqq transformers ctranslate2

# The model should be first converted into the CTranslate2 model format:
ct2-transformers-converter --model huggyllama/llama-13b --output_dir llama-13b-ct2 --force

进行查询

import ctranslate2
import transformers

generator = ctranslate2.Generator("llama-13b-ct2", device="cuda", compute_type="float16")
tokenizer = transformers.AutoTokenizer.from_pretrained("huggyllama/llama-13b")

prompt = "Funniest joke ever:"
tokens = tokenizer.convert_ids_to_tokens(tokenizer.encode(prompt))
results = generator.generate_batch(
    [tokens], 
    sampling_topk=1, 
    max_length=200, 
)
tokens = results[0].sequences_ids[0]
output = tokenizer.decode(tokens)
print(output)

4. DeepSpeed-MII

MII 使低延迟和高吞吐量推理成为可能，由 DeepSpeed 提供支持。跨多个副本的负载平衡，用于处理大量用户的非常有用的工具。原生和 Azure 集成、缺乏对适配器（LoRA、QLoRA 等）的支持。

# DON'T INSTALL USING pip install deepspeed-mii
# git clone https://github.com/microsoft/DeepSpeed-MII.git
# git reset --hard 60a85dc3da5bac3bcefa8824175f8646a0f12203
# cd DeepSpeed-MII && pip install .
# pip3 install -U deepspeed

# ... and make sure that you have same CUDA versions:
# python -c "import torch;print(torch.version.cuda)" == nvcc --version

import mii

mii_configs = {
    "dtype": "fp16",
    'max_tokens': 200,
    'tensor_parallel': 1,
    "enable_load_balancing": False
}
mii.deploy(task="text-generation",
           model="huggyllama/llama-13b",
           deployment_name="llama_13b_deployment",
           mii_config=mii_configs)

进行查询

import mii

generator = mii.mii_query_handle("llama_13b_deployment")
result = generator.query(  
  {"query": ["Funniest joke ever:"]}, 
  do_sample=True,
  max_new_tokens=200
)
print(result)

5. OpenLLM

在生产中操作大型语言模型（LLM）的开放平台。OpenLLM 支持使用 bitsandbytes 和 gptQ 进行量化。LangChain 集成。缺乏批处理支持、缺乏内置的分布式推理。

官方库

pip install openllm scipy
openllm start llama --model-id huggyllama/llama-13b \
  --max-new-tokens 200 \
  --temperature 0.95 \
  --api-workers 1 \
  --workers-per-resource 1

进行查询

import openllm

client = openllm.client.HTTPClient('http://localhost:3000')
print(client.query("Funniest joke ever:"))

6. Ray Serve

Ray Serve 是一个可扩展的模型服务库，用于构建在线推理 API。Serve 与框架无关，因此您可以使用单个工具包来提供深度学习模型中的所有内容。可以使用 Ray 控制面板获取 Ray 集群和 Ray Serve 应用程序状态的高级概述。可以跨多个副本自动缩放和动态请求批处理。Ray Serve并不专注于LLM，它是一个更广泛的框架，用于部署任何ML模型。最适合可用性、可伸缩性和可观测性非常重要的企业。

# pip install ray[serve] accelerate>=0.16.0 transformers>=4.26.0 torch starlette pandas
# ray_serve.py
import pandas as pd

import ray
from ray import serve
from starlette.requests import Request

@serve.deployment(ray_actor_options={"num_gpus": 1})
class PredictDeployment:
    def __init__(self, model_id: str):
        from transformers import AutoModelForCausalLM, AutoTokenizer
        import torch

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

    def generate(self, text: str) -> pd.DataFrame:
        input_ids = self.tokenizer(text, return_tensors="pt").input_ids.to(
            self.model.device
        )
        gen_tokens = self.model.generate(
            input_ids,
            temperature=0.9,
            max_length=200,
        )
        return pd.DataFrame(
            self.tokenizer.batch_decode(gen_tokens), columns=["responses"]
        )

    async def __call__(self, http_request: Request) -> str:
        json_request: str = await http_request.json()
        # Note: Prompt key might vary depending on request structure
        prompt = json_request.get("text", "")
        return self.generate(prompt)

deployment = PredictDeployment.bind(model_id="huggyllama/llama-13b")

# then run from CLI command:
# serve run ray_serve:deployment

进行查询

import requests

sample_input = {"text": "Funniest joke ever:"}
output = requests.post("http://localhost:8000/", json=[sample_input]).json()
print(output)

7. MLC LLM

机器学习编译 LLM（MLC LLM）是一种通用部署解决方案，使 LLM 能够利用本机硬件加速在消费者设备上高效运行。该库主要专注于为不同设备编译模型。支持分组量化。

# 1. Make sure that you have python >= 3.9
# 2. You have to run it using conda:
conda create -n mlc-chat-venv -c mlc-ai -c conda-forge mlc-chat-nightly
conda activate mlc-chat-venv

# 3. Then install package:
pip install --pre --force-reinstall mlc-ai-nightly-cu118 \
  mlc-chat-nightly-cu118 \
  -f https://mlc.ai/wheels

# 4. Download the model weights from HuggingFace and binary libraries:
git lfs install && mkdir -p dist/prebuilt && \
  git clone https://github.com/mlc-ai/binary-mlc-llm-libs.git dist/prebuilt/lib && \
  cd dist/prebuilt && \
  git clone https://huggingface.co/huggyllama/llama-13b dist/ && \
  cd ../..

运行服务器

python -m mlc_chat.rest --device-name cuda --artifact-path dist

进行查询

import requests

payload = {
   "model": "lama-30b",
   "messages": [{"role": "user", "content": "Funniest joke ever:"}],
   "stream": False
}
r = requests.post("http://127.0.0.1:8000/v1/chat/completions", json=payload)
print(r.json()['choices'][0]['message']['content'])

8. LightLLM

LightLLM 是一个基于 Python 的 LLM（大型语言模型）推理和服务框架，以其轻量级设计、易扩展性和高速性能而著称。LightLLM 利用了众多广受赞誉的开源实现，包括但不限于 FasterTransformer、TGI、vLLM 和 FlashAttention。

Python 脚本访问

import time
import requests
import json

url = 'http://localhost:8000/generate'
headers = {'Content-Type': 'application/json'}
data = {
    'inputs': 'What is AI?',
    "parameters": {
        'do_sample': False,
        'ignore_eos': False,
        'max_new_tokens': 1024,
    }
}
response = requests.post(url, headers=headers, data=json.dumps(data))
if response.status_code == 200:
    print(response.json())
else:
    print('Error:', response.status_code, response.text)

python -m lightllm.server.api_server --model_dir /path/llama-7B --tp 1 --max_total_token_num 120000

curl 127.0.0.1:8000/generate \
    -X POST \
    -d '{"inputs":"What is AI?","parameters":{"max_new_tokens":17, "frequency_penalty":1}}' \
    -H 'Content-Type: application/json'

其他

为 LLM 推理配置必要的环境并使用单个命令启动：dstack run . -f vllm/serve.dstack.yml

type: task

env:
  - MODEL=huggyllama/llama-13b
  # (Optional) Specify your Hugging Face token
  - HUGGING_FACE_HUB_TOKEN=

ports:
  - 8000

commands:
  - conda install cuda # Required since vLLM will rebuild the CUDA kernel
  - pip install vllm
  - python -m vllm.entrypoints.openai.api_server --model $MODEL --port 8000

结论

1. Batched prompt 需要最大速度时，使用 vLLM。
2. 需要使用 HuggingFace 并且不打算使用多个适配器，选择 Text generation inference。
3. 想在 CPU 上运行推理，选 CTranslate2。
4. 想将适配器连接到核心模型并使用 HuggingFace Agents，选择 OpenLLM。
5. 想获得稳定的管道和灵活的部署，使用 Ray Serve，项目比较成熟。
6. 想在客户端（边缘计算）上本地部署 LLM，例如在 Android 或 iPhone 平台上，使用 MLC LLM。
7. 有使用 DeepSpeed 库的经验并希望继续使用它来部署 LLM，使用 DeepSpeed-MII。

部署建议

在选择具体的部署框架时，除了考虑上述的性能和功能特性外，还应结合团队的技术栈储备、现有的基础设施以及未来的维护成本。例如，如果团队已经深度集成了 Ray 生态，那么 Ray Serve 可能是平滑过渡的最佳选择；若关注移动端或边缘端部署，MLC LLM 则是目前较为成熟的方案。此外，对于生产环境，务必关注各框架的版本稳定性及社区活跃度，确保长期可获得技术支持。