1. 量化

量化 LLM 是一种降低现有模型精度的技术, 从而在略微降低"智能"的同时提高性能。这种方法在管理成本方面特别有效, 同时仍能保持许多应用程序可接受的性能水平。通过量化 LLM, 您可以在性能和准确性之间实现更具成本效益的平衡。

模型量化是一种技术, 用于通过使用较少的位数表示 AI 模型的参数来减小 AI 模型的大小。在传统的机器学习模型中, 每个参数(例如, 神经网络中的权重和偏差)通常存储为 32 位浮点数, 这可能需要大量的内存和计算资源, 尤其是对于大型模型。

量化旨在通过降低这些参数的精度来缓解这种情况。例如, 可以使用较少的位(例如 8 位整数)来表示它们, 而不是将每个参数存储为 32 位浮点数。这种压缩减少了模型的内存占用, 使其部署和执行效率更高, 尤其是在移动设备或边缘设备等资源受限的环境中。

量化 bitsandbytes、GPTQ 和 AWQ 等方法使得使用大型模型成为可能, 例如 作为流行的 Llama-2, 内存明显减少, 使机器学习社区能够 进行 使用单个消费级 GPU 的卓越研究。

1.1 常用方案

1.1.1 Legacy quants (Q4_0, Q4_1, Q8_0, …)

• 非常直接、基本和快速的量化方法;
• 每一层被分成 256 个权重的块, 每个块变成 256 个量化值和一个 (_0) 或两个 (_1) 额外的常量(我相信, 额外的常量是Q4_1最终平均每个权重 4.0625 位的原因);
• 使用位移、AND 和乘法(以及 _1 变体中的加法)可以轻松解压缩量化权重;
• IIRC, 一些较旧的特斯拉卡可能会使用这些传统量化器运行得更快, 但除此之外, 您最好使用 K-quants。

1.1.2 K-quants (Q3_K_S, Q5_K_M, …)

• llama.cpp里介的绍 #1684;
• 比特的分配方式比传统量化更智能, 尽管我不确定这是主要的还是唯一的区别(也许每个区块的常量也被量化了, 而以前没有？
• Q3_K 或 Q4_K 是指文件中使用的流行量化类型(以及它使用这种混合"K"格式的事实), 而后缀(如 _XS、_S 或 _M)是引用文件中使用的特定量化类型组合的别名(某些层更重要, 因此每个权重为它们提供更多位可能是有益的);
• 无论如何, 单个权重的存储方式与传统量化非常相似, 因此它们可以很容易地解包(或者通过一些额外的班次/AND来解包每个区块的常量);
• 因此, K-Quants 与传统 Quants 一样快, 甚至更快*, 并且鉴于它们还具有较低的量化误差, 在大多数情况下, 它们显然是更好的选择。*) 不能 100% 确定这是事实还是只是我的测量误差。

1.1.3 I-quants (IQ2_XXS, IQ3_S, …)

• 引入的一种新的 SOTA* 量化方法公关 #4773;
• 从本质上讲, 它仍然使用基于块的量化, 但有一些受 QuIP#启发的新奇功能, 这有点超出了我的理解;
• 一个区别是它使用查找表来存储解码过程中所需的一些特殊酱汁值;
• 对查找表的额外内存访问似乎足以使去量化步骤比传统和 K-quants 要求更高——以至于您可能会受到 CPU 而不是内存带宽的限制;
• 苹果芯片似乎对此特别敏感, 它也发生在我身上, 旧的 Xeon E5-2667 v2(内存带宽不错, 但难以跟上额外的负载, 最终运行速度比 k-quants 慢 ~50%);
• 另一方面: 如果您有足够的计算能力, 则通过缓解内存带宽瓶颈, 减小的模型大小可能会提高 K-Quants 的整体性能。
• 目前, 它仅在 4 bpw 时是 SOTA: 在较低的 bpw 值下, AQLM 方法目前占据主导地位。查看llama.cpp 讨论 #5063.

1.1.4 可能

• 常驻llama.cpp量化专家 Ikawarakow 还提到了其他一些未来可能的改进, 例如:
• 每行常量(因此 2 个常量可以涵盖比一个 256 块更多的权重),
• 非线性量化(使用比简单权重 = 量化 * 规模 + 最小值更复杂的公式),
• k-means 聚类量化(不要与上面描述的 k-quants 混淆;另一种我不明白的特殊酱汁方法);
• 查看llama.cpp讨论 #5063 了解详情。

1.2 AQLM

aqlm 的主要问题是量化过程非常困难
量化时间 AQLM 量化比 GPTQ 等更简单的量化方法需要更长的时间来校准。这只会影响量化时间, 而不会影响推理时间。
AQLM只是量化的另一种形式, 是压缩的一种形式, 所以说它“更”是一种压缩方法是没有意义的。

1.3 HQQ(Half-Q uadratic Quantization)

特别注重最小化权重误差, 而不是层激活。此外, 通过合并 稀疏性促进损失, 例如lₚ<1 -norm, 我们通过以下方式有效地对异常值进行建模 超拉普拉斯分布。这种分布可以更准确地捕获重尾 与平方误差相比, 异常误差的性质, 导致更细微 误差分布的表示。

1.4 GPTQ

1.5 AWQ

gptq 和 awq(awq 更聪明但速度稍慢)以获得 4 位选项, 以及 fp8 支持

1.6 BNB

2. LLM 推理与部署框架

部署方式	CPU	GPU	Function Call	OpenAI API	Vision	HF	GGUF	EXL2	AQLM	Distributed	备注
vllm	Y	FA v2*	-	Y	Y↓	Y	-	-	Y	with Ray	aqlm,awq,fp8,gptq,squeezellm,gptq_marlin,marlin
FastChat	-	Y	-	-	Y	Y	-	-	Y		vllm
llama.cpp	Y	Y	Y↓	Y	Y↓	-	Y	-		分布式推理,FP16	可以直接训练已经量化的 gguf 模型
Ollama	Y	Y	Y	Y	Y↓	-	Y	-			llama.cpp
Text Generate Interface	-	FA v2	Y	Y	Y↓	Y	-	Y	Y
ExLlamaV2	-		Y	Y	Y	Y	-	Y			专为4位GPTQ量化(与 GPTQ-for-LLaMA、AutoGPTQ 兼容)而构建
Text Embedding Interface	Y	FA v2↓	-	-	-	-	-	-	-		compute capabilities < 7.5 are not supported (V100, Titan V, GTX 1000 series, …).

说明:

• ↓: 表示部分支持
• FA v2: Flash Attention v2, 对GPU有要求
• torchrun: 分布式部署(nccl + 网卡)
• 分布式部署需要考虑对 NVLink 功能
• llama.cpp现在支持分布式推理, 目前仅限于 FP16, 尚无量化支持。另外, 无法让它与 Vulkan 一起使用。推理受网络带宽限制。使用 1 Gb 以太网连接比使用较慢的 wifi 连接更快。而且整体速度似乎受到最慢机器的限制。
• LocalAI v2.16.0: 分布式推理和 P2P 功能, 可让您在自己的 CPU 和 GPU 上本地运行 AI 模型!

2.1 vLLM

Github: https://github.com/vllm-project/vllm
Doc: https://docs.vllm.ai/en/latest/

适用于大批量Prompt输入, 并对推理速度要求高的场景。
vLLM的吞吐量比HuggingFace Transformers(HF)高14x-24倍, 比HuggingFace Text Generation Inference(TGI)高2.2x-2.5倍。

**功能: **

• Continuous batching[9]: 有iteration-level的调度机制, 每次迭代batch大小都有所变化, 因此vLLM在大量查询下仍可以很好的工作。
• PagedAttention[10]: 受操作系统中虚拟内存和分页的经典思想启发的注意力算法, 这就是模型加速的秘诀。

**优点: **

• 文本生成的速度: 实验多次, 发现vLLM的推理速度是最快的;
• 高吞吐量服务: 支持各种解码算法, 比如parallel sampling, beam search等;
• 与OpenAI API兼容: 如果使用OpenAI API, 只需要替换端点的URL即可;

**缺点: **

• 添加自定义模型: 虽然可以合并自己的模型, 但如果模型没有使用与vLLM中现有模型类似的架构, 则过程会变得更加复杂。例如, 增加Falcon的支持, 这似乎很有挑战性;
• 缺乏对适配器(LoRA、QLoRA等)的支持: 当针对特定任务进行微调时, 开源LLM具有重要价值。然而, 在当前的实现中, 没有单独使用模型和适配器权重的选项, 这限制了有效利用此类模型的灵活性。
• 缺少权重量化: 有时, LLM可能不需要使用GPU内存, 这对于减少GPU内存消耗至关重要。

这是LLM推理最快的库。得益于其内部优化, 它显著优于竞争对手。尽管如此, 它在支持有限范围的模型方面确实存在弱点。

pip install -U vllm
export CUDA_VISIBLE_DEVICES=0,1
python -m vllm.entrypoints.openai.api_server --host 0.0.0.0 --port 8000 \
  --served-model-name codegemma-2b \ 
  --max-model-len 65536 --tensor-parallel-size 8 --gpu-memory-utilization 0.4 \
  --model E:/Learn/models/codegemma-2b

扩展到单台计算机之外:

pip install ray
ray start --head  # On head node

# On worker nodes
ray start --address=<ray-head-address>

# 在头节点上启动 vLLM 进程, 将 GPU 数设置为所有计算机上的 GPU 总数, 从而在多台计算机上运行推理和服务
python -m vllm.entrypoints.openai.api_server <...>

## VISION
python -m vllm.entrypoints.openai.api_server \
  --model llava-hf/llava-1.5-7b-hf \
  --image-input-type pixel_values \
  --image-token-id 32000 \
  --image-input-shape 1,3,336,336 \
  --image-feature-size 576 \
  --chat-template template_llava.jinja

2.1.1 主要参数

• –max-model-len: 模型上下文长度
• –tensor-parallel-size: 并行的GPU卡, 必须可以被32整除
• –gpu-memory-utilization: VRAM比例(0~1, Default 0.9)
• –served-model-name: 模型名称, 必须与接口传过来的保持一致

2.2 Text Generation Inference(TGI)

Text generation inference: 依赖HuggingFace模型, 并且不需要为核心模型增加多个adapter的场景; 是一个多功能工具包, 专为部署和服务大型语言模型而设计。它支持各种开源 LLM, 包括 Llama、Falcon、StarCoder、BLOOM、GPT-NeoX 和 T5。TGI 已经越来越受欢迎, 并且已经被 IBM、Grammarly 和 Open-Assistant 计划等著名组织使用。

2.2.1 Rust

# install
curl https://sh.rustup.rs -sSf | sh

# 内容 ~/.bash_profile
export RUSTUP_DIST_SERVER=https://rsproxy.cn
export RUSTUP_UPDATE_ROOT=https://rsproxy.cn/rustup

配置文件： ~/.cargo/config 中, 添加以下内容:

[source.crates-io]
replace-with = 'aliyun'
[source.aliyun]
registry = "sparse+https://mirrors.aliyun.com/crates.io-index/"

2.2.2 编译

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

sudo apt-get install libssl-dev gcc -y

conda create -n tgi python=3.11
conda activate tgi

export TORCH_CUDA_ARCH_LIST="8.6" # "8.0 8.6 8.9 9.0"
git clone https://github.com/huggingface/text-generation-inference.git && cd text-generation-inference
export CARGO_TARGET_DIR=/data/cargo
BUILD_EXTENSIONS=True make install

# Docker
model=teknium/OpenHermes-2.5-Mistral-7B
volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0.1 --model-id $model

# --model-id
# --port
# --hostname
# --master-addr
# --master-port
# --cuda-memory-fraction

2.2.3 Text Embeddings Inference(TEI)

# Build Depends:
wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \
| gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null && \
  echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | \
  sudo tee /etc/apt/sources.list.d/oneAPI.list
  
sudo apt-get update
sudo apt-get install -y intel-oneapi-mkl-devel
sudo apt-get install -y libomp-dev

# docker 
# onnx
optimum-cli export onnx --task sentence-similarity --model ./bge-reranker-v2-m3 ./bge-reranker-v2-m3/onnx/

docker run -p 8080:80 -v /mnt/hgfs/learn/models:/data ghcr.io/huggingface/text-embeddings-inference:cpu-1.5 --model-id /data/bge-reranker-v2-m3
docker run -p 8082:80 -v /mnt/hgfs/learn/models:/data ghcr.io/huggingface/text-embeddings-inference:cpu-1.5 --model-id /data/zpoint_large_embedding_zh

curl 127.0.0.1:8080/rerank \
    -X POST \
    -d '{"query":"What is Deep Learning?", "texts": ["Deep Learning is not...", "Deep learning is..."]}' \
    -H 'Content-Type: application/json'

2.3 FastChat

Github: https://github.com/lm-sys/FastChat
可以与LightLLM、Apple MLX 集成。

pip3 install "fschat[model_worker,webui]"

# or
git clone https://github.com/lm-sys/FastChat.git
cd FastChat

python -m fastchat.serve.cli --model-path <model_path> --num-gpus 2
# --device cpu
# --load-8bit
# --conv-template=raw
# -m fastchat.serve.controller
# -m fastchat.serve.gradio_web_server

# RESTful API Server
python -m fastchat.serve.controller
python -m fastchat.serve.model_worker --conv-template=raw --model-path ./gemma-1.1-7b-it
python -m fastchat.serve.openai_api_server --host localhost --port 8000

curl http://localhost:8000/v1/embeddings \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text2vec-bge-large-chinese",
    "input": "Hello world!"
  }'

2.4 llama.cpp

项目地址: https://github.com/ggerganov/llama.cpp

打开RTX优化

# sudo apt install nvidia-cuda-toolkit
# nvcc --version
# nvcc --list-gpu-arch
# export CUDA_DOCKER_ARCH=compute_86 # 3090
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

export LD_LIBRARY_PATH=/data/anaconda3/envs/delphai/lib/python3.10/site-packages/nvidia/nvjitlink/lib::$LD_LIBRARY_PATH
export CUDA_DOCKER_ARCH=compute_86
make LLAMA_CUBLAS=1 LLAMA_CUDA=1 LLAMA_CUDA_NVCC=/usr/bin/nvcc -j 8
make LLAMA_CUBLAS=1 LLAMA_CUDA=1 -j 8

2.4.1 使用 llama.cpp server 提供 API 服务

# -ngl 1024
./server -ngl 99 -c 4096 -t 4 --host 0.0.0.0 --port 8000 -m <gguf_file_path> 

curl --request POST \
    --url http://localhost:8080/completion \
    --header "Content-Type: application/json" \
    --data '{"prompt": "What color is the sun?","n_predict": 512}'

2.4.2 使用 llama-cpp-python 提供 API 服务

项目地址: https://github.com/abetlen/llama-cpp-python

# Linux
CMAKE_ARGS="-DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS" pip install -U llama-cpp-python -i https://mirrors.aliyun.com/pypi/simple

# Windows
set CMAKE_GENERATOR = "MinGW Makefiles"
set CMAKE_ARGS = "-DGGML_OPENBLAS=on -DCMAKE_C_COMPILER=D:/Tools/w64devkit/bin/gcc.exe -DCMAKE_CXX_COMPILER=D:/Tools/w64devkit/bin/g++.exe"

pip install -U --no-cache-dir llama-cpp-python -i https://mirrors.aliyun.com/pypi/simple

# Linux
export LLAMA_CUBLAS=1
CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip install llama-cpp-python --verbose --no-cache-dir -i https://mirrors.aliyun.com/pypi/simple

# pip install pydantic==2.7.0 -i https://mirrors.aliyun.com/pypi/simple
pip install click sse_starlette starlette_context pydantic_settings -i https://mirrors.aliyun.com/pypi/simple

# --n_gpu_layers -1 # 如果为 -1, 则卸载所有图层
# --main_gpu
# --n_ctx 2048
# --clip_model_path ./gguf/llava-1.6-mistral-7b-gguf
# --chat_format llava-1-5 # chatml-function-calling / functionary-v2 / functionary-v1
# --hf_pretrained_model_name_or_path 
python -m llama_cpp.server --n_gpu_layers 24 --n_ctx 2048 --model <gguf_file_path> --chat_format chatml-function-calling

curl -X 'POST' \
  'http://localhost:8000/v1/chat/completions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "messages": [
    {
      "content": "You are a helpful assistant.",
      "role": "system"
    },
    {
      "content": "Write a poem for Chinese?",
      "role": "user"
    }
  ]
}'

2.4.3 报错解决

[Windows]No CUDA toolset found解决方法
出现这个问题一般是因为安装CUDA时没有安装对应的Visual Studio Integration缺失。首先将CUDA的安装包当作一个压缩包, 用winRAR之类的工具打开, 然后找到中对应文件夹: CUDAVisualStudioIntegration\extras\visual_studio_integration\MSBuildExtensions。
在这个路径下共有4个文件, 把它们拷到你Windows机器上安装Visual Studio的对应路径下, 例如: C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Microsoft\VC\v160\BuildCustomizations

Check for working CUDA compiler: /usr/local/cuda/bin/nvcc - skipped
参考 https://github.com/ggerganov/llama.cpp/issues/1832 系统安装过程中没找到你的cuda在哪里, 所以在pip安装之前先设置一个环境变量,把/usr/local/cuda-x.y改成你的cuda路径

export CUDA_PATH=/usr/local/cuda-x.y

‘f16c’: expected a number
这是你的cuda版本太低了, 升级到较新版本(11.6可用)。
或者参考 https://github.com/ggerganov/llama.cpp/issues/1467 和 https://github.com/marella/ctransformers/issues/53 中提到的命令和构建(我没有尝试, 有谁试了可以请我结果)。

Value ‘sm_30’ is not defined for option ‘gpu-name’ Tesla T
先运行下面的命令

apt-cache policy nvidia-cuda-toolkit

# sudo apt remove nvidia-cuda-toolkit # 如果版本是1.0 那么请运行

2.5 其他

• CTranslate2: 可在CPU上进行推理
• OpenLLM: 为核心模型添加adapter并使用HuggingFace Agents, 尤其是不完全依赖PyTorch
• Ray Serve: 稳定的Pipeline和灵活的部署, 它最适合更成熟的项目
• MLC LLM: 可在客户端(边缘计算)(例如, 在Android或iPhone平台上)本地部署LLM
• DeepSpeed-MII: 使用DeepSpeed库来部署LLM
• EricLLM
• PowerInfer
• QMoE
• FasterTransformer
  NVIDIA FasterTransformer (FT) 是一个用于实现基于Transformer的神经网络推理的加速引擎。它包含Transformer块的高度优化版本的实现, 其中包含编码器和解码器部分。使用此模块, 您可以运行编码器-解码器架构模型(如: T5)、仅编码器架构模型(如: BERT)和仅解码器架构模型(如: GPT)的推理。
• FlexFlow Server: 是一个开源编译器和分布式系统, 用于低延迟、高性能 LLM 服务。
• LMDeploy: 由 MMDeploy 和 MMRazor 团队联合开发, 涵盖了 LLM 任务的全套轻量化、部署和服务解决方案。
• koboldcpp

2.5.1 ExLlamaV2

ExLlamaV2是一个旨在从 GPTQ 中榨取更多性能的库。得益于新内核, 它针对(极快)快速推理进行了优化。它还引入了一种新的量化格式 EXL2, 它为权重的存储方式带来了很大的灵活性。在底层, ExLlamaV2 利用 GPTQ 算法来降低权重的精度, 同时最大限度地减少对输出的影响。

git clone https://github.com/turboderp/exllamav2
pip install exllamav2

需要 GPU 来量化该模型。官方文档指出, 7B 型号大约需要 8 GB VRAM, 70B 型号大约需要 24 GB VRAM。

2.5.2 TensorRT-LLM

TensorRT-LLM 可加速和优化 NVIDIA GPU 上最新大型语言模型(LLM)的推理性能。此开源库可在 TensorRT-LLM GitHub 存储库上免费获得, 并作为 NVIDIA NeMo 框架的一部分。

2.5.3 Xinference

GitHub URL
Xinference 是一个专为大型语言模型(LLM)、语音识别模型和多模态模型设计的开源模型推理平台, 支持私有化部署。 它提供多种灵活的 API 和接口, 包括 RPC、与 OpenAI API 兼容的 RESTful API、CLI 和 WebUI, 并集成了 LangChain、LlamaIndex 和 Dify 等第三方开发者工具, 便于模型的集成和开发。Xinference 支持多种推理引擎(如 Transformers、vLLM 和 GGML), 并适用于不同硬件环境, Xinference 还支持分布式多机部署, 能够在多个设备或机器间高效分配模型推理任务, 满足多模型和高可用的部署需要。

pip install "xinference[all]"
pip install "xinference[vllm]"

xinference --help
xinference launch -u my_qwen -n qwen-chat -s 14 -f pytorch

2.5.4 Ollama

项目地址: https://github.com/ollama/ollama
支持的模型列表: https://ollama.com/library

# 设置环境变量, 下载的模型文件保存地址
OLLAMA_MODELS=/data/ollama/models

• Ollama 复制了llama.cpp服务器并稍微更改它以仅具有他们需要的端点这里
• 没有将 llama.cpp 与 FFI 集成, 而是血腥寻找自由港和启动新服务器通常只需使用 shell 命令调用它, 并且填充参数喜欢模型
• 在generate 函数然后, 他们检查模型的服务器是否处于活动状态, 并通常像调用 OpenAI API 一样调用它

2.5.5 mistral.rs

Mistral.rs 是一个快速的 LLM 推理平台, 支持在各种设备上进行推理、量化和易于使用的应用程序, 具有兼容 Open-AI API 的 HTTP 服务器和 Python 绑定。

./mistralrs_server -i plain -m google/gemma-2-9b-it -a gemma2
./mistralrs_server --port 1234 vision-plain -m microsoft/Phi-3-vision-128k-instruct -a phi3v
./mistralrs_server --port 1234 --isq Q4K plain -m meta-llama/Meta-Llama-3.1-8B-Instruct -a llama

2.5.6 LMdeploy

LMDeploy 由 MMDeploy 和 MMRazor 团队联合开发, 是涵盖了 LLM 任务的全套轻量化、部署和服务解决方案。

2.5.7 Infinity

Infinity 是一个高吞吐量、低延迟的 REST API, 用于提供向量嵌入, 支持所有句子转换器模型和框架。

infinity_emb v2 --model-id BAAI/bge-small-en-v1.5


docker run -p 8083:7997 -v /data/infinity:/app/.cache -v /mnt/hgfs/learn/models:/data --name xiaobu-embedding-v2 michaelf34/infinity:latest  v2 --model-id /data/xiaobu-embedding-v2

2.5.8 SGLang Runtime

SGLang是一个用于大型语言模型和视觉语言模型的快速服务框架。 它通过共同设计后端运行时和前端语言, 使您与模型的交互更快、更可控。

核心功能包括：

• 快速后端运行时：使用 RadixAttention 实现高效服务, 用于前缀缓存、跳转约束解码、连续批处理、令牌注意（分页注意）、张量并行、flashinfer 内核和量化 （AWQ/FP8/GPTQ/Marlin）。
• 灵活的前端语言：通过链式生成调用、高级提示、控制流、多种模态、并行性和外部交互, 可以轻松对 LLM 应用程序进行编程。

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 meta-llama/Meta-Llama-3-8B-Instruct --port 8081 --dp 2 --tp 2

# --tp 2
# --dp 2
# --mem-fraction-static 0.9

# --nnodes 2 sgl-dev-0 50000 多节点（节点数量、主机名、可用端口）
# Node 0
python -m sglang.launch_server --model-path meta-llama/Meta-Llama-3-8B-Instruct --tp 4 --nccl-init sgl-dev-0:50000 --nnodes 2 --node-rank 0

# Node 1
python -m sglang.launch_server --model-path meta-llama/Meta-Llama-3-8B-Instruct --tp 4 --nccl-init sgl-dev-0:50000 --nnodes 2 --node-rank 1

2.5.9 分布式 mlx

源代码：

• https://github.com/mzbac/mlx_sharding
• https://github.com/mzbac/open-chat
• 演示视频

pip install mlx-sharding

# 分片节点：运行
mlx-sharding-server --model mlx-community/DeepSeek-Coder-V2-Lite-Instruct-4bit-mlx --start-layer 14 --end-layer 27

# 主节点：运行
mlx-sharding-api --model mlx-community/DeepSeek-Coder-V2-Lite-Instruct-4bit-mlx --start-layer 0 --end-layer 14 --llm-shard-addresses <您的分片节点地址>

2.5.10 KTransformers

KTransformers, 一个灵活的框架, 用于体验尖端的 LLM 推理优化! KTransformers 利用来自 llamafile 和 marlin 的最先进的内核, 无缝增强了 HuggingFace Transformers 的性能, 并使其能够以极快的速度在本地操作大型 MoE 模型。

3. Model Format

3.1 HF

3.2 GGUF

GGML(GPT生成的模型语言): GGML 由 Georgi Gerganov 开发, 是一个专为机器学习而设计的张量库, 可促进各种硬件(包括 Apple Silicon)上的大型模型和高性能。

GGUF(GPT 生成的统一格式)作为 GGML(GPT 生成的模型语言)的继任者推出, 于 2023 年 8 月 21 日发布。这种格式代表了语言模型文件格式领域向前迈出的重要一步, 促进了 GPT 等大型语言模型的增强存储和处理。

# 将模型转换为 gguf 的命令(8 位量化 / f16 / f32)
python llama.cpp/convert.py myllama-hf \
  --outfile myllama-7b-v0.1.gguf \
  --outtype q8_0

from ctransformers import AutoModelForCausalLM
llm = AutoModelForCausalLM.from_pretrained("TheBloke/OpenHermes-2.5-Mistral-7B-GGUF", model_file="openhermes-2.5-mistral-7b.Q2_K.gguf")
print(lm("AI is going to"))

3.2.1 特征矩阵(imatrix)

# Use convert-image-encoder-to-gguf.py to convert the LLaVA image encoder to GGUF
python ./examples/llava/convert-image-encoder-to-gguf.py -m ../clip-vit-large-patch14-336 --llava-projector ../llava-v1.5-7b/llava.projector --output-dir ../llava-v1.5-7b

3.4 GPTQ vs. GGUF vs. AWQ

3.4.1 GPTQ & EXL2

GPTQ 在 GPU 上提供了惊人的性能。与非量化模型相比, 该方法使用的 VRAM 几乎减少了 3 倍, 同时提供了相似的精度水平和更快的生成速度。它变得如此流行, 以至于最近被直接集成到Transformers 库中。
GPTQ 还需要一个校准数据集, 用于通过比较基本模型及其量化版本的输出来衡量量化过程的影响。

wget https://huggingface.co/datasets/wikitext/resolve/9a9e482b5987f9d25b3a9b2883fc6cc9fd8071b3/wikitext-103-v1/wikitext-test.parquetwget https://huggingface.co/datasets/wikitext/resolve/9a9e482b5987f9d25b3a9b2883fc6cc9fd8071b3/wikitext-103-v1/wikitext-test.parquet

mkdir quant
python python exllamav2/convert.py \
    -i <base_model> \
    -o quant \
    -c wikitext-test.parquet \
    -b 5.0

EXL2 具有一些新功能：

• 它支持不同级别的量化：不限于 4 位精度, 可以处理 2、3、4、5、6 和 8 位量化。
• 它可以在模型内和每个层内混合不同的精度, 以保留最重要的权重和具有更多位的层。

4. Other

4.1 VRAM 计算

\[M = \frac{(P∗4B)}{32 / Q} * 1.2 \]

例如:

\[\frac{70∗4bytes}{32/16} * 1.2 = 168GB \]

Symbol	Description
M	GPU memory expressed in Gigabyte
P	The amount of parameters in the model. E.g. a 7B model has 7 billion parameters.
4B	4 bytes, 表示用于每个参数的字节数
32	There are 32 bits in 4 bytes
Q	应用于加载模型的位数。例如 16 位、8 位或 4 位
1.2	表示在 GPU 内存中加载其他内容的 20% 开销。

4.2 KV Cache

Model Size	1k tokens	16k tokens	128k tokens
8B	0.125 GB	1.95 GB	15.62 GB
70B	0.313 GB	4.88 GB	39.06 GB
405B	0.984 GB	15.38	123.05 GB

参考:
Overview of GGUF quantization methods
Xinference 函数调用: Qwen 和 ChatGLM3 Function Calling 大测评
vLLM
Quantization Types
Quantization
Half-Quadratic Quantization of Large Machine Learning Models
Calculating GPU memory for serving LLMs
A Visual Guide to Quantization