Software 2.0

本地运行大模型的5个工具

TOOL Dec 14, 2024

在快速发展的人工智能领域，有效地服务大型语言模型 (LLM) 和视觉语言模型 (VLM) 对于充分发挥其潜力至关重要。随着这些模型变得越来越复杂，找到强大且可扩展的服务解决方案变得越来越重要。

在本指南中，我们将重点介绍5个在这一领域取得进展的著名项目：VLLM、LLAMA CPP Server 、SGLang、Ollama和TGI。

1、VLLM

VLLM 是一个高性能库，专为高效的 LLM 推理和服务而设计。它在吞吐量和灵活性方面表现出色，具有最先进的服务功能、通过 PagedAttention 实现的高效内存管理以及持续请求批处理等功能。 CUDA/HIP 图形执行和优化的 CUDA 内核提高了其性能。VLLM 支持各种量化方法，并与流行的 HuggingFace 模型无缝集成。它还提供高吞吐量服务，具有多种解码算法、张量和管道并行性、流式输出，并与 NVIDIA 和 AMD GPU 兼容。实验性功能包括前缀缓存和多 lora 支持。

1.1 使用说明

要安装 VLLM，请运行以下命令：

pip install vllm

安装后，你可以使用以下命令提供 LLM：

vllm serve Qwen/Qwen2-1.5B-Instruct --dtype auto --api-key token-abc123

基本 vllm 参数：

  • --host HOSTNAME：服务器主机名（默认值：localhost）
  • --port PORT：服务器端口号（默认值：8000）
  • --api-key KEY：用于服务器访问的 API 密钥（如果提供，服务器需要此密钥在标头中）
  • --model MODEL：要使用的 HuggingFace 模型的名称或路径（例如，Qwen/Qwen2-1.5B-Instruct）
  • --tokenizer TOKENIZER：要使用的标记器的名称或路径（例如，Qwen/Qwen2-1.5B-Instruct）
  • --quantization METHOD：量化方法模型权重（例如，aqlm、awq、fp8、bitsandbytes、None）
  • --dtype TYPE：模型权重和激活的数据类型（例如，auto、half、float16、bfloat16、float32）
  • --device DEVICE：执行设备类型（例如，auto、cuda、cpu、tpu）
  • --lora-modules MODULES：LoRA 模块配置（名称=路径对列表）

1.2 使用 Docker 部署

要使用 Docker 部署 VLLM，请运行以下命令：

docker pull vllm/vllm-openai:v0.5.4

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HUGGING_FACE_HUB_TOKEN=<secret>" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model Qwen/Qwen2-1.5B-Instruct

要将端点与 openai 库一起使用：

from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="token-abc123",
)

completion = client.chat.completions.create(
  model="Qwen/Qwen2-1.5B-Instruct",
  messages=[
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message)

2、LLaMA.cpp HTTP 服务器

LLaMA.cpp HTTP 服务器是一个轻量级且快速的基于 C/C++ 的 HTTP 服务器，利用 httplib、nlohmann::json 和 llama.cpp。它提供了一组 LLM REST API 和一个简单的 Web 界面，用于与 llama.cpp 交互。主要功能包括支持 GPU 和 CPU 上的 F16 和量化模型、OpenAI API 兼容性、并行解码、连续批处理和监控端点。它还支持架构约束的 JSON 响应，并且正在开发多模式功能。

2.1 使用说明

要安装 LLaMA.cpp，请运行以下命令：

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make

安装后，我们应该从 Hugging Face hub 下载 gguf 模型 (Mistral-7B-Instruct-v0.2-GGUF) 作为示例：

cd models && wget https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q2_K.gguf

要启动服务器，请运行以下命令：

cd .. 
./llama-server -m models/mistral-7b-instruct-v0.2.Q2_K.gguf -c 2048

2.2 基本 vllm 参数

常规：

  • -h、--help、--usage：打印使用情况并退出
  • --version：显示版本和构建信息
  • -v，--verbose：打印详细信息
  • --verbosity N：设置特定详细程度（默认值：0）
  • --color：为输出着色（默认值：false）
  • -s，--seed SEED：RNG 种子（默认值：-1，小于 0 时使用随机种子）
  • -t，--threads N：线程数（默认值：8）
  • --ctx-size N：提示上下文的大小（默认值：0，0 = 从模型加载）
  • -n，--predict N：要预测的标记数（默认值：-1，-1 = 无穷大，-2 = 直到上下文填满）
  • --prompt PROMPT：开始生成的提示（默认值：''）
  • --interactive：以交互模式运行（默认值：false）

采样：

  • --temp N：温度（默认值：0.8）
  • --top-k N：Top-k 采样（默认值：40，0 = 禁用）
  • --top-p N：Top-p 采样（默认值：0.9，1.0 = 禁用）
  • --mirostat N：使用 Mirostat 采样（默认值：0，0 = 禁用，1 = Mirostat，2 = Mirostat 2.0）

模型：

  • -m，--model FNAME：模型路径（默认值：models/$filename）
  • --lora FNAME：应用 LoRA 适配器（隐含 --no-mmap）
  • --control-vector FNAME：添加控制向量
  • --check-tensors：检查模型张量数据中是否存在无效值（默认值：false）

服务器：

  • --host HOST：要监听的 IP 地址（默认值：127.0.0.1）
  • --port PORT：要监听的端口（默认值：8080）
  • --timeout N：服务器读写超时（秒）（默认值： 600)

日志记录：

  • -ld，--logdir LOGDIR：保存 YAML 日志的路径（如果未设置则不记录）
  • --log-enable：启用跟踪日志

上下文：

  • --rope-scaling {none,linear,yarn}：RoPE 频率缩放方法（默认值：线性）

并行：

  • -np，--parallel N：要解码的并行序列数（默认值：1）
    嵌入：
  • --embd-normalize：嵌入的规范化（默认值：2）

2.3 使用 Docker 部署

要使用 Docker 部署 LLaMA.cpp，请运行以下命令：

docker run -p 8080:8080 -v /path/to/models:/models ghcr.io/ggerganov/llama.cpp:server 
            -m models/mistral-7b-instruct-v0.2.Q2_K.gguf 
            -c 512 
            --host 0.0.0.0 
            --port 8080

# or, with CUDA:
docker run -p 8080:8080 
            -v /path/to/models:/models 
            --gpus all ghcr.io/ggerganov/llama.cpp:server-cuda 
            -m models/mistral-7b-instruct-v0.2.Q2_K.gguf
            -c 512 
            --host 0.0.0.0 
            --port 8080 
            --n-gpu-layers 99

要将端点与 openai 库一起使用：

from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8081/v1",
    api_key="token-abc123",
)

completion = client.chat.completions.create(
  model="Mistral-7B-Instruct-v0.2-GGUF",
  messages=[
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message)

3、SGLang

SGLang 是一个专为 LLM 和 VLM 设计的快速服务框架，专注于提高交互速度和控制。它具有高效的后端运行时，使用 RadixAttention 进行前缀缓存、前跳约束解码和各种量化技术。SGLang 还支持张量并行和高级内核以提高性能。灵活的前端语言允许轻松编程复杂的 LLM 应用程序，包括链式生成调用、高级提示和并行性，以及与多种模态和外部交互的集成。

3.1 使用说明

要安装 SGLang，请运行以下命令：

pip install --upgrade pip
pip install "sglang[all]"

# Install FlashInfer CUDA kernels
pip install flashinfer -i https://flashinfer.ai/whl/cu121/torch2.3/

要启动服务器，请运行以下命令：

! python -m sglang.launch_server --model-path Qwen/Qwen2-1.5B-Instruct --port 30000

3.2 基本 vllm 参数

必需选项

  • --model-path MODEL_PATH：模型权重路径（必需）。

可选关键选项

  • --tokenizer-path TOKENIZER_PATH：tokenizer 路径。
  • --host HOST：服务器主机（默认为 localhost）。
  • --port PORT：服务器端口（默认为 8000 或其他常用端口）。
  • --tokenizer-mode {auto,slow}：默认可能为自动。
  • --load-format {auto,pt,safetensors,npcache,dummy}：默认可能为自动。
  • --dtype {auto,half,float16,bfloat16,float,float32}：默认可能为自动。
  • --context-length CONTEXT_LENGTH：默认为 None，使用模型的配置值。

性能和资源选项

  • --mem-fraction-static MEM_FRACTION_STATIC：静态分配的内存分数。
  • --max-prefill-tokens MAX_PREFILL_TOKENS：预填充批次中的最大令牌数。
  • --max-running-requests MAX_RUNNING_REQUESTS：最大运行请求数。
  • --max-num-reqs MAX_NUM_REQS：内存池中的最大请求数。
  • --max-total-tokens MAX_TOTAL_TOKENS：内存池中的最大 token 数。

调度和并行性

  • --schedule-policy {lpm,random,fcfs,dfs-weight}：调度策略，默认为 fcfs（先到先得）。
  • --tp-size TP_SIZE：张量并行性大小。
  • --dp-size DP_SIZE：数据并行性大小。

日志记录和调试

  • --log-level LOG_LEVEL：日志记录级别。
  • --log-requests：日志请求。
  • --show-time-cost：显示自定义标记的时间成本。

高级选项

  • --quantization {awq,fp8,gptq,marlin,gptq_marlin,awq_marlin,squeezellm,bitsandbytes}：量化方法。
  • --load-balance-method {round_robin,shortest_queue}：负载平衡策略。
    实验性或可选功能
  • --enable-torch-compile：实验性优化功能。
  • --disable-disk-cache：禁用磁盘缓存。

3.3 使用 Docker 部署

要使用 Docker 部署 SGLang，请运行以下命令：

docker pull lmsysorg/sglang:v0.2.10-cu124

docker run --gpus all \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server --model-path Qwen/Qwen2-1.5B-Instruct --host 0.0.0.0 --port 30000

使用openai库访问端点：

import openai
client = openai.Client(
    base_url="http://127.0.0.1:30000/v1", api_key="EMPTY")

# Text completion
response = client.completions.create(
    model="default",
    prompt="The capital of France is",
    temperature=0,
    max_tokens=32,
)
print(response)

4、Ollama：简化本地 LLM 部署

Ollama 是一个开源平台，旨在简化在本地机器上部署大型语言模型的过程。它充当了 LLM 通常所需的复杂基础设施与寻求更易于访问和可定制的 AI 体验的用户之间的桥梁。凭借其与 OpenAI 兼容的 API，Ollama 可与现有工具和工作流程无缝集成。

该平台强调对量化模型的支持，这对于减少内存使用和提高性能至关重要。Ollama 提供了一个不断增长的预训练模型库，从多功能通用选项到用于小众任务的专用模型。可用的著名模型包括 Llama 3.1、Qwen、Mistral 和 deepseek-coder-v2 等专用变体。

Ollama 的用户友好型设置过程和直观的模型管理由其统一的 Modelfile 格式提供。它的跨平台支持（包括 Windows、macOS 和 Linux）进一步增强了可访问性。通过提供具有与 OpenAI 兼容的接口的本地模型服务，Ollama 是寻求本地部署灵活性以及标准 API 集成便利性的开发人员的强大选择。

4.1 安装依赖项和 Ollama

首先，我们需要安装 openai Python 包。该库提供了一个简单的接口来与任何 OpenAI 兼容的 API 进行交互，这在我们稍后连接到 Ollama 服务器时将至关重要。

pip install openai

接下来，我们使用单个命令安装 Ollama（适用于 Linux）。Ollama 旨在简化运行本地 LLM 的过程，因此设置起来既快速又简单。

curl -fsSL https://ollama.com/install.sh | sh

4.2 使用 Ollama 拉取和提供模型

安装 Ollama 后，我们拉取 qwen2:1.5b 模型。该模型是 Ollama 支持的众多模型之一，它展示了该工具在本地管理和运行各种大型语言模型的能力。

ollama pull qwen2:1.5b

拉取模型后，我们启动 Ollama 服务器。这使我们能够在本地提供模型并通过 API 访问它。

4.3 使用 OpenAI 客户端向 Ollama 发出简单请求

在这里，我们设置 OpenAI 客户端与 Ollama 服务器进行通信。base_url 指向本地服务器，而 api_key 是必需的，但 Ollama 未使用。

ollama serve

然后，我们向 qwen2:1.5b 模型（即我们上面拉取的模型）发送聊天完成请求。

from openai import OpenAI

client = OpenAI(
    base_url = 'http://127.0.0.1:11434/v1',
    api_key='ollama', 
)

response = client.chat.completions.create(
  model="qwen2:1.5b",
  messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ]
)
print(response.choices[0].message.content)

4.4 使用 OpenAI API 流式传输响应

客户端的配置方式相同，但这次我们在生成响应时对其进行流式传输。这对于需要在令牌进入时对其进行处理的实时应用程序特别有用。

from openai import OpenAI

# init the client but point it to TGI
client = OpenAI(
    base_url="http://127.0.0.1:11434/v1",
    api_key="ollama"
)

chat_completion = client.chat.completions.create(
    model="qwen2:1.5b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ],
    stream=True
)

# iterate and print stream
for message in chat_completion:
    print(message.choices[0].delta.content)

5、TGI：高性能 LLM 服务

TGI (文本生成推理) 是一种可用于生产的用于部署和提供 LLM 的工具包，重点是高性能文本生成。与本系列中讨论的其他工具一样，TGI 提供了与 OpenAI 兼容的 API，可轻松将高级 LLM 集成到现有应用程序中。

TGI 支持流行的开源模型，如 gemma2、mistral-nemo、mistral-large、qwen 等，使其成为需要可扩展、高吞吐量 AI 解决方案的组织的诱人选择。主要功能包括张量并行性或跨多个 GPU 进行更快的推理、使用服务器发送事件 (SSE) 进行令牌流式传输以及连续批处理以最大化吞吐量。

除了这些功能之外，TGI 还实现了 Flash Attention 和 Paged Attention 等高级优化，这对于提高 Transformer 架构上的推理速度至关重要。它还通过 bitsandbytes 和 GPT-Q 等技术支持模型量化，从而实现高效部署，同时保持模型性能。对于定制任务，TGI 提供微调支持和指导功能，进一步增强输出的相关性和准确性。

凭借其强大的功能集，包括分布式跟踪和用于监控的 Prometheus 指标，TGI 是要求苛刻的生产环境中提供 LLM 的理想解决方案。

5.1 本地安装 TGI

首先，我们通过安装必要的依赖项（包括 libssl-dev 和 gcc）来设置环境。我们还下载并安装协议缓冲区 (protoc) 包，这对于编译 TGI 框架使用的 protobuf 文件至关重要。

sudo apt-get install libssl-dev gcc -y
PROTOC_ZIP=protoc-21.12-linux-x86_64.zip
curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v21.12/$PROTOC_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
rm -f $PROTOC_ZIP

5.2 在本地构建和运行 TGI

要安装和运行 TGI，需要构建启用扩展（CUDA 内核）的存储库，以便在 GPU 上获得最佳性能。之后，你可以使用 Hugging Face 生态系统支持的任何模型（如 Mistral）启动文本生成服务。

BUILD_EXTENSIONS=True make install 
text-generation-launcher --model-id mistralai/Mistral-Large-Instruct-2407

要运行不同的模型，只需更改 --model-id 参数：

text-generation-launcher --model-id Qwen/Qwen2-1.5B-Instruct

5.3 使用量化运行

可以通过运行预量化权重或使用 AWQ、GPTQ 或 bitsandbytes 等动态量化选项来减少 VRAM 使用量。这在有限硬件上处理大型模型时特别有用。

text-generation-launcher --model-id Qwen/Qwen2-72B-Instruct-GPTQ-Int8 --sharded true --num-shard 2 --quantize gptq

5.4 使用 Docker 进行 TGI 部署

如果你更喜欢使用 Docker，可以通过安装模型数据卷并公开服务器的端口来轻松部署 TGI：

model=Qwen/Qwen2-1.5B-Instruct
volume=$PWD/data

然后，运行具有 GPU 访问权限的 Docker 容器：

docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data \
    ghcr.io/huggingface/text-generation-inference:2.2.0 --model-id $model

你可以通过发送生成文本的请求来测试部署：

curl 127.0.0.1:8080/generate_stream \
    -X POST \
    -d '{"inputs":"What is Deep Learning?","parameters":{"max_new_tokens":20}}' \
    -H 'Content-Type: application/json'

5.5 OpenAI 兼容 API 支持

TGI 的一项重要功能（从 1.4.0 版开始）是它与 OpenAI Chat Completion API 兼容。这允许你使用 OpenAI 的客户端库或其他期望相同架构的库与 TGI 的消息 API 进行交互。

发出同步请求

在这里，我们设置 OpenAI 客户端，但将其指向 TGI 端点。然后，我们创建一个类似于你使用 OpenAI API 执行的聊天完成请求。

from openai import OpenAI

# init the client but point it to TGI
client = OpenAI(
    base_url="http://localhost:3000/v1",
    api_key="-"
)

chat_completion = client.chat.completions.create(
    model="tgi",
    messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ],
    stream=False
)

print(chat_completion.choices[0].message.content)
发出流式请求

对于实时应用程序，你可以在生成响应时对其进行流式传输。OpenAI 客户端通过迭代流的每个部分来处理此问题，使你能够动态处理和显示结果。

from openai import OpenAI

# init the client but point it to TGI
client = OpenAI(
    base_url="http://localhost:3000/v1",
    api_key="-"
)

chat_completion = client.chat.completions.create(
    model="tgi",
    messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ],
    stream=True
)

# iterate and print stream
for message in chat_completion:
    print(message)

原文链接：Serving Large models (part one): VLLM, LLAMA CPP Server, and SGLang

汇智网翻译整理，转载请标明出处

Tags

admin

Recommended for you