当前位置:   article > 正文

第五节课《LMDeploy 量化部署 LLM 实践》

第五节课《LMDeploy 量化部署 LLM 实践》

LMDeploy 量化部署 LLM-VLM 实践_哔哩哔哩_bilibili

PDF链接:https://pan.baidu.com/s/1JFtvBWgEGFWJq8pHafvIUg?pwd=6666 
提取码:6666

https://github.com/InternLM/Tutorial/blob/camp2/lmdeploy/README.md

一、大模型部署背景

RAG范式开发大模型

Xtuner微调大模型

LMDeploy部署大模型

  •         服务端:CPU、GPU/TPU/NPU,多卡,集群
  • 移动端/边缘:机器人、手机

1、计算量巨大

2、内存开销巨大

 3、访存瓶颈和动态请求:batchsize访问

 二、大模型部署方法

1、模型剪枝(Pruning):移除模型中不必要或者多余组件

  • 非结构化剪枝:SparseGPT,LoRAPrune,Wanda(将低于阈值的参数置零)
  • 结构化剪枝:LLM-Pruner(一次性移除连接或分层整组权重)

2、知识蒸馏(Knowledge Distillation,KD):模型压缩,引导轻量化的学生模型

  • 上下文学习(ICL):ICL distillation
  • 思维链(CoT):MT-COT,Fine-tune-CoT等
  • 指令跟随(IF):LaMini-LM

3、量化(Quantization):浮点数转换为整数或者其他离散形式,访储降低。

  • 量化感知训练(QAT) LLM-QAT:
  • 量化感知微调(QAF) PEQA[,QLORA:
  • 训练后量化(PTQ) LLM.int8,AWQ:

三、LMDeploy

涵盖了 LLM 任务的全套轻量化、部署和服务解决方案,

  • 模型高效推理:lmdeploy chat -h。LLaMa 结构模型的支持(CUDA算子实现)、continuous batch推理模式(请求数量长度不确定)和可扩展的 KV 缓存管理器(不使用的从显存放到内存)。
  • 模型量化压缩:lmdeploy lite -h。KV8量化(INT8),W4A16量化(AWQ)  (INT4)。
  • 服务化部署:lmdeploy serve -h。HTTP API服务

 四、动手实践:安装、部署、量化

1、创建conda环境

conda create -n lmdeploy -y python=3.10

2、安装LMDeploy 

激活虚拟环境

conda activate lmdeploy

安装Imdeploy

pip install lmdeploy[all]==0.3.0

 

3.LMDeploy模型对话(chat)

3.1 Huggingface与TurboMind

HuggingFace:深度学习模型和数据集的在线托管社区,托管模型采用HF格式。modelscope(阿里)、openxlab(上海AI Lab)。

TurboMind:LMDeploy团队开发的LLM推理的高效推理引擎。LLaMa 结构模型的支持,continuous batch 推理模式和可扩展的 KV 缓存管理器。推理HF格式的模型时,会首先自动将HF格式模型转换为TurboMind格式的模型。

  • TurboMind与LMDeploy的关系:LMDeploy是涵盖了LLM 任务全套轻量化、部署和服务解决方案的集成功能包,TurboMind是LMDeploy的一个推理引擎,是一个子模块。LMDeploy也可以使用pytorch作为推理引擎。
  • TurboMind与TurboMind模型的关系:TurboMind是推理引擎的名字,TurboMind模型是一种模型存储格式,TurboMind引擎只能推理TurboMind格式的模型。

3.2 下载模型.

常用的预训练模型

ls /root/share/new_models/Shanghai_AI_Laboratory/

  1. cd ~
  2. ln -s /root/share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b /root/ #软连接
  3. # cp -r /root/share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b /root/ #拷贝
  4. ls

 

 3.3 使用transformer运行模型

Transformer库是Huggingface社区推出的用于运行HF模型的官方库。

新建pipeline_transformer.py

touch /root/pipeline_transformer.py
  1. import torch
  2. from transformers import AutoTokenizer, AutoModelForCausalLM
  3. tokenizer = AutoTokenizer.from_pretrained("/root/internlm2-chat-1_8b", trust_remote_code=True)
  4. # Set `torch_dtype=torch.float16` to load model in float16, otherwise it will be loaded as float32 and cause OOM Error.
  5. model = AutoModelForCausalLM.from_pretrained("/root/internlm2-chat-1_8b", torch_dtype=torch.float16, trust_remote_code=True).cuda()
  6. model = model.eval()
  7. inp = "hello"
  8. print("[INPUT]", inp)
  9. response, history = model.chat(tokenizer, inp, history=[])
  10. print("[OUTPUT]", response)
  11. inp = "please provide three suggestions about time management"
  12. print("[INPUT]", inp)
  13. response, history = model.chat(tokenizer, inp, history=history)
  14. print("[OUTPUT]", response)

运行python代码:

  1. conda activate lmdeploy
  2. python /root/pipeline_transformer.py

4.使用LMDeploy与模型对话

使用LMDeploy与模型进行对话的通用命令格式为:lmdeploy chat [HF格式模型路径/TurboMind格式模型路径]

lmdeploy chat /root/internlm2-chat-1_8b

lmdeploy chat -h

5.LMDeploy模型量化(lite)

量化是一种以参数或计算中间结果精度下降换空间节省(以及同时带来的性能提升)的策略。

  • 计算密集(compute-bound): 指推理过程中,绝大部分时间消耗在数值计算上;针对计算密集型场景,可以通过使用更快的硬件计算单元来提升计算速度。
  • 访存密集(memory-bound): 指推理过程中,绝大部分时间消耗在数据读取上;针对访存密集型场景,一般通过减少访存次数、提高计算访存比或降低访存量来优化。

LLM 模型由于 Decoder Only 架构的特性,实际推理时大多数的时间都消耗在了逐 Token 生成阶段(Decoding 阶段),是典型的访存密集型场景。

KV8量化:将逐 Token(Decoding)生成过程中的上下文 K 和 V 中间结果进行 INT8 量化(计算时再反量化),以降低生成过程中的显存占用。

W4A16量化:将 FP16 的模型权重量化为 INT4,Kernel 计算时,访存量直接降为 FP16 模型的 1/4,大幅降低了访存成本。

Weight Only: 是指仅量化权重,数值计算依然采用 FP16(需要将 INT4 权重反量化)。

6. 设置最大KV Cache缓存大小

KV Cache是一种缓存技术,通过存储键值对的形式来复用计算结果,以达到提高性能和降低内存消耗的目的。

在大规模训练和推理中,KV Cache可以显著减少重复计算量,从而提升模型的推理速度。

当显存空间不足时,也可以将KV Cache放在内存,通过缓存管理器控制将当前需要使用的数据放入显存。

模型在运行时的显存占用:模型参数本身占用的显存、KV Cache占用的显存,以及中间运算结果占用的显存。

--cache-max-entry-count参数,控制KV缓存占用剩余显存的最大比例。默认的比例为0.8

lmdeploy chat /root/internlm2-chat-1_8b

lmdeploy chat /root/internlm2-chat-1_8b --cache-max-entry-count 0.5

lmdeploy chat /root/internlm2-chat-1_8b --cache-max-entry-count 0.01

显存占用仅为4660MB,代价是会降低模型推理速度。

 7. 使用W4A16量化

LMDeploy使用AWQ算法,实现模型4bit权重量化。

推理引擎TurboMind提供了非常高效的4bit推理cuda kernel。它支持以下NVIDIA显卡:

  • 图灵架构(sm75):20系列、T4
  • 安培架构(sm80,sm86):30系列、A10、A16、A30、A100
  • Ada Lovelace架构(sm90):40 系列

安装依赖库

pip install einops==0.7.0

模型量化:HF模型被保存到internlm2-chat-1_8b-4bit目录

  1. lmdeploy lite auto_awq \
  2. /root/internlm2-chat-1_8b \
  3. --calib-dataset 'ptb' \
  4. --calib-samples 128 \
  5. --calib-seqlen 1024 \
  6. --w-bits 4 \
  7. --w-group-size 128 \
  8. --work-dir /root/internlm2-chat-1_8b-4bit

使用Chat功能运行W4A16量化

lmdeploy chat /root/internlm2-chat-1_8b-4bit --model-format awq

KV Cache比例再次调为0.01

lmdeploy chat /root/internlm2-chat-1_8b-4bit --model-format awq --cache-max-entry-count 0.01

LMDeploy的lite功能

lmdeploy lite -h

 

8. LMDeploy服务(serve)

  • 模型推理/服务:主要提供模型本身的推理,一般来说可以和具体业务解耦,专注模型推理本身性能的优化。可以以模块、API等多种方式提供。
  • API Server:中间协议层,把后端推理/服务通过HTTP,gRPC或其他形式的接口,供前端调用。
  • Client:可以理解为前端,与用户交互的地方。通过通过网页端/命令行去调用API接口,获取模型推理/服务。

实际中并不是绝对的划分。

8.1. 启动API服务器

  1. lmdeploy serve api_server \
  2. /root/internlm2-chat-1_8b \
  3. --model-format hf \
  4. --quant-policy 0 \
  5. --server-name 0.0.0.0 \
  6. --server-port 23333 \
  7. --tp 1

model-format、quant-policy这些参数是与第三章中量化推理模型一致的;

server-name和server-port表示API服务器的服务IP与服务端口;

tp参数表示并行数量(GPU数量)。

ssh -CNg -L 23333:127.0.0.1:23333 root@ssh.intern-ai.org.cn -p 43158

http://127.0.0.1:23333/

8.2 命令行客户端连接API服务器

lmdeploy serve api_client http://localhost:23333

 

 

8.3 网页客户端连接API服务器

  1. lmdeploy serve gradio http://localhost:23333 \
  2. --server-name 0.0.0.0 \
  3. --server-port 6006

http://127.0.0.1:6006/

 

9.Python代码集成

9.1 Python代码集成运行1.8B模型

新建Python源代码文件pipeline.py

touch /root/pipeline.py
  1. from lmdeploy import pipeline #引入lmdeploy的pipeline模块 \
  2. pipe = pipeline('/root/internlm2-chat-1_8b')#从目录“./internlm2-chat-1_8b”加载HF模型 \
  3. response = pipe(['Hi, pls intro yourself', '上海是'])#运行pipeline,这里采用了批处理的方式,用一个列表包含两个输入,lmdeploy同时推理两个输入,产生两个输出结果,结果返回给response \
  4. print(response)#输出response

9.2 向TurboMind后端传递参数

创建TurbomindEngineConfig,向lmdeploy传递参数。

新建python文件pipeline_kv.py

touch /root/pipeline_kv.py

设置KV Cache占用比例 

  1. from lmdeploy import pipeline, TurbomindEngineConfig
  2. # 调低 k/v cache内存占比调整为总显存的 20%
  3. backend_config = TurbomindEngineConfig(cache_max_entry_count=0.2)
  4. pipe = pipeline('/root/internlm2-chat-1_8b',
  5. backend_config=backend_config)
  6. response = pipe(['Hi, pls intro yourself', '上海是'])
  7. print(response)

10.拓展部分

10.1 使用LMDeploy运行视觉多模态大模型llava

使用pipeline推理llava-v1.6-7b

安装llava依赖库。

pip install git+https://github.com/haotian-liu/LLaVA.git@4e2277a060da264c4f21b364c867cc622c945874

 新建一个python文件

touch /root/pipeline_llava.py
  1. from lmdeploy.vl import load_image #引入用于载入图片的load_image函数
  2. from lmdeploy import pipeline, TurbomindEngineConfig#引入了lmdeploy的pipeline模块
  3. backend_config = TurbomindEngineConfig(session_len=8192) #图片分辨率较高时请调高session_len
  4. # pipe = pipeline('liuhaotian/llava-v1.6-vicuna-7b', backend_config=backend_config) 非开发机运行此命令
  5. pipe = pipeline('/share/new_models/liuhaotian/llava-v1.6-vicuna-7b', backend_config=backend_config)# 创建了pipeline实例
  6. image = load_image('https://raw.githubusercontent.com/open-mmlab/mmdeploy/main/tests/data/tiger.jpeg')#从github下载了一张关于老虎的图片
  7. response = pipe(('describe this image', image))#输入提示词“describe this image”,和图片,结果返回至response
  8. print(response)

 运行pipeline

python /root/pipeline_llava.py

Llava模型对中文支持性不好

通过Gradio来运行llava模型

touch /root/gradio_llava.py
  1. import gradio as gr
  2. from lmdeploy import pipeline, TurbomindEngineConfig
  3. backend_config = TurbomindEngineConfig(session_len=8192) # 图片分辨率较高时请调高session_len
  4. # pipe = pipeline('liuhaotian/llava-v1.6-vicuna-7b', backend_config=backend_config) 非开发机运行此命令
  5. pipe = pipeline('/share/new_models/liuhaotian/llava-v1.6-vicuna-7b', backend_config=backend_config)
  6. def model(image, text):
  7. if image is None:
  8. return [(text, "请上传一张图片。")]
  9. else:
  10. response = pipe((text, image)).text
  11. return [(text, response)]
  12. demo = gr.Interface(fn=model, inputs=[gr.Image(type="pil"), gr.Textbox()], outputs=gr.Chatbot())
  13. demo.launch()
ssh -CNg -L 7860:127.0.0.1:7860 root@ssh.intern-ai.org.cn -p 43158

10.2 使用LMDeploy运行第三方大模型

 

ModelSize
Llama7B - 65B
Llama27B - 70B
InternLM7B - 20B
InternLM27B - 20B
InternLM-XComposer7B
QWen7B - 72B
QWen-VL7B
QWen1.50.5B - 72B
QWen1.5-MoEA2.7B
Baichuan7B - 13B
Baichuan27B - 13B
Code Llama7B - 34B
ChatGLM26B
Falcon7B - 180B
YI6B - 34B
Mistral7B
DeepSeek-MoE16B
DeepSeek-VL7B
Mixtral8x7B
Gemma2B-7B
Dbrx132B

10.3 定量比较LMDeploy与Transformer库的推理速度差异

速度测试脚本

新建python文件,命名为benchmark_transformer.py

touch /root/benchmark_transformer.py

 

  1. import torch
  2. import datetime
  3. from transformers import AutoTokenizer, AutoModelForCausalLM
  4. tokenizer = AutoTokenizer.from_pretrained("/root/internlm2-chat-1_8b", trust_remote_code=True)
  5. # Set `torch_dtype=torch.float16` to load model in float16, otherwise it will be loaded as float32 and cause OOM Error.
  6. model = AutoModelForCausalLM.from_pretrained("/root/internlm2-chat-1_8b", torch_dtype=torch.float16, trust_remote_code=True).cuda()
  7. model = model.eval()
  8. # warmup
  9. inp = "hello"
  10. for i in range(5):
  11. print("Warm up...[{}/5]".format(i+1))
  12. response, history = model.chat(tokenizer, inp, history=[])
  13. # test speed
  14. inp = "请介绍一下你自己。"
  15. times = 10
  16. total_words = 0
  17. start_time = datetime.datetime.now()
  18. for i in range(times):
  19. response, history = model.chat(tokenizer, inp, history=history)
  20. total_words += len(response)
  21. end_time = datetime.datetime.now()
  22. delta_time = end_time - start_time
  23. delta_time = delta_time.seconds + delta_time.microseconds / 1000000.0
  24. speed = total_words / delta_time
  25. print("Speed: {:.3f} words/s".format(speed))
python benchmark_transformer.py

 

touch /root/benchmark_lmdeploy.py

 

  1. import datetime
  2. from lmdeploy import pipeline
  3. pipe = pipeline('/root/internlm2-chat-1_8b')
  4. # warmup
  5. inp = "hello"
  6. for i in range(5):
  7. print("Warm up...[{}/5]".format(i+1))
  8. response = pipe([inp])
  9. # test speed
  10. inp = "请介绍一下你自己。"
  11. times = 10
  12. total_words = 0
  13. start_time = datetime.datetime.now()
  14. for i in range(times):
  15. response = pipe([inp])
  16. total_words += len(response[0].text)
  17. end_time = datetime.datetime.now()
  18. delta_time = end_time - start_time
  19. delta_time = delta_time.seconds + delta_time.microseconds / 1000000.0
  20. speed = total_words / delta_time
  21. print("Speed: {:.3f} words/s".format(speed))
python benchmark_lmdeploy.py

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/543158?site
推荐阅读
相关标签
  

闽ICP备14008679号