python系列&deep_study系列：大模型的N种高效部署方法：以LLama2为例
大模型的N种高效部署方法：以LLama2为例
大模型的N种高效部署方法：以LLama2为例
通过部署LLama2示例，比较不同LLM开源推理服务框架的优缺点。
本文没介绍深度学习模型推理服务的传统库，如TorchServe，KServe或Triton Inference Server。
1. vLLM
它的吞吐量比huggingface transformers （HF） 高 14 倍到24 倍，吞吐量比文本生成推理 （TGI） 高 2.2 倍。有连续批处理Continuous batching 和PagedAttention功能，集成各种解码算法，包括并行采样、波束搜索等。但缺乏对适配器（LoRA、QLoRA 等）的支持。
后期功能迭代可以追踪官方库：https://github.com/vllm-project/vllm
本地推理服务：
# pip install vllm
from vllm import LLM, SamplingParams
prompts = [
"Funniest joke ever:",
"The capital of France is",
"The future of AI is",
]
sampling_params = SamplingParams(temperature=0.95, top_p=0.95, max_tokens=200)
llm = LLM(model="huggyllama/llama-13b")
outputs = llm.generate(prompts, sampling_params)
for output in outputs:
prompt = output.prompt
generated_text = output.outputs[0].text
print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")
API 服务：
# Start the server:
Python -m vllm.entrypoints.api_server --env MODEL_NAME=huggyllama/llama-13b
# Query the model in shell:
curl http://localhost:8000/generate \
-d '{
"prompt": "Funniest joke ever:",
"n": 1,
"temperature": 0.95,
"max_tokens": 200
}'
2. Text generation inference
用于文本生成推理的 Rust、Python 和 gRPC 服务框架。在HuggingFace的生产中使用，为LLM的API推理小部件提供支持。内置 Prometheus metrics，可以监控服务器负载和性能，可以使用Flashattention和PagedAttention。所有依赖项都安装在 Docker 中，支持HuggingFace模型，有很多选项来管理模型推理，包括精度调整、量化、张量并行性、重复惩罚等。适合了解Rust编程的人。
官方库地址： https://github.com/huggingface/text-generation-inference
使用 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 集成。缺乏批处理支持、缺乏内置的分布式推理。
官方库： https://github.com/bentoml/OpenLLM
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模型。最适合可用性、可伸缩性和可观测性非常重要的企业。
https://github.com/ray-project
# 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()
return self.generate(prompt["text"])
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 ../..
5. Run server:
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 脚本访问：【官方代码库】https://github.com/ModelTC/lightllm
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'
官方给出对比：
其他
dstack 为 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。
