DashInfer-VLM, desempenho de inferência SOTA multimodal, ultra-vLLM!

introdutório

O DashInfer-VLM é uma arquitetura de inferência para grandes modelos VLMs multimodais visuais, especialmente otimizada para a aceleração da inferência dos modelos VL da Qwen. A maior diferença entre o DashInfer-VLM e outras estruturas de aceleração de inferência para VLMs é que ele separa a parte VIT da parte LLM, e a VIT e a LLM são executadas em paralelo sem interferir uma na outra. sem interferir um no outro.

Isso é caracterizado pelo fato de que o pré-processamento de imagem e vídeo no VLM, bem como a parte de extração de recursos do VIT, não interromperá a geração do LLM, e também pode ser uma arquitetura separada de VIT/LLM, que é a primeira estrutura de serviço VLM na comunidade de código aberto a usar essa arquitetura.

Em uma implementação com várias placas, ele tem uma unidade de processamento ViT em cada placa, o que proporciona uma vantagem de desempenho muito significativa em cenários de vídeo e de várias imagens.

Além disso, para a parte ViT, ele oferece suporte ao armazenamento em cache na memória para que não haja necessidade de recalcular o ViT repetidamente em várias rodadas de diálogo.

Abaixo está um diagrama de sua arquitetura e sua configuração de acordo com a parte de 4 cartões 72B.

O diagrama de arquitetura descreve o processo e a arquitetura:

• Na parte ViT, muitas elicitações de inferência podem ser usadas para inferência, como TensorRT ou onnxruntime (a exportação do modelo onnx será realizada na parte ViT do modelo dentro da estrutura).
• Na seção LLM, o DashInfer é usado para inferência.
• Parte do cache, suporte ao resultado do ViT Cache de memória, parte do LLM Cache de prefixo, parte do LLM Cache de prefixo multimodal (não ativado por padrão)

Endereço do código:

https://github.com/modelscope/dash-infer

Endereço do documento: 

https://dashinfer.readthedocs.io/en/latest/vlm/vlm_offline_inference_en.html

melhores práticas

Experimente o DashInfer na aritmética de GPU gratuita da comunidade Magic Hitch:

首先是dashinfer-vlm和TensorRT的安装。

# 首先安装所需的 package
import os

# 下载并安装 dashinfer 2.0.0rc2 版本
# 如果需要，可以使用 wget 下载并解压 TensorRT 包
# pip 安装 dashinfer 2.0.0rc2
#!pip install https://github.com/modelscope/dash-infer/releases/download/v2.0.0-rc2/dashinfer-2.0.0rc2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
#!wget https://modelscope.oss-cn-beijing.aliyuncs.com/releases/TensorRT-10.6.0.26.Linux.x86_64-gnu.cuda-12.6.tar.gz
#!tar -xvzf TensorRT-10.6.0.26.Linux.x86_64-gnu.cuda-12.6.tar.gz

# 下载到本地并替换为 modelscope 对应的 URL
# 安装 dashinfer，因 package 较大，推荐下载到本地后安装
#!wget https://modelscope.oss-cn-beijing.aliyuncs.com/releases/dashinfer-2.0.0rc3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
#!pip install ./dashinfer-2.0.0rc3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

# 安装 dashinfer vlm
#!pip install dashinfer-vlm

# 安装 OpenAI 客户端
#!pip install openai==1.56.2

# 安装 TensorRT 的 Python 包，从下载的包中打开安装
#!pip install TensorRT-10.6.0.26/python/tensorrt-10.6.0-cp310-none-linux_x86_64.whl

O TensorRT requer a configuração de variáveis de ambiente:

import os

# 获取 TensorRT 运行时库的路径
trt_runtime_path = os.getcwd() + "/TensorRT-10.6.0.26/lib/"

# 获取当前的 LD_LIBRARY_PATH 环境变量值
current_ld_library_path = os.environ.get('LD_LIBRARY_PATH', '')

# 将新路径添加到现有值中
if current_ld_library_path:
# 如果 LD

Depois que o ambiente estiver instalado, inicie o dashinfer vlm para raciocinar sobre os modelos e formar um servidor compatível com openai, onde os modelos podem ser alterados para 7B, 72B, etc.

Toda a memória da GPU no ambiente é usada por padrão.

!dashinfer_vlm_serve --model qwen/Qwen2-VL-2B-Instruct --port 8000 --host 127.0.0.1

Esse processo inicializa o DashInfer, bem como o mecanismo externo usado pelo ViT (nesse caso, o TensorRT), e inicia um serviço openai.

A visualização desses registros indica que o TRT foi inicializado com êxito:

A visualização desses registros indica que o DashInfer foi inicializado com êxito:

A visualização desses registros indica que o serviço openai foi inicializado com êxito:

Quando toda a inicialização for bem-sucedida, você poderá abrir outro notebook para o cliente e o benchmarking.

Endereço do notebook:https://modelscope.cn/notebook/share/ipynb/6ea987c5/vl-start-server.ipynb

Demonstração de compreensão de imagens

Demonstrar uma demonstração para compreensão de imagens com várias imagens:

# Install the required OpenAI client version
!pip install openai==1.56.2 # VL support requires a recent OpenAI client.

from openai import OpenAI

# Initialize the OpenAI client
client = OpenAI(
base_url="http://localhost:8000/v1", 
api_key="EMPTY"
)

# Prepare the API call for a chat completion
response = client.chat.completions.create(
model="model",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Are these images different?"},
{
"type": "image_url",
"image_url": {
"url": "https://farm4.staticflickr.com/3075/3168662394_7d7103de7d_z_d.jpg",
}
},
{
"type": "image_url",
"image_url": {
"url": "https://farm2.staticflickr.com/1533/26541536141_41abe98db3_z_d.jpg",
}
},
],
}
],
stream=True,
max_completion_tokens=1024,
temperature=0.1,
)

# Process the streamed response
full_response = ""
for chunk in response:
# Append the delta content to the full response
full_response += chunk.choices[0].delta.content
print(".", end="") # Print a dot for each chunk received

# Print the full response
print(f"\nImage: Full Response:\n{full_response}")

Demonstração de compreensão de vídeo

Como o openai não define uma interface de vídeo padrão, este documento fornece um tipo video_url, que faz o download automático, extrai quadros e analisa o vídeo.

# video example
!pip install openai==1.56.2 # Ensure the OpenAI client supports video link features.

from openai import OpenAI

# Initialize the OpenAI client
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY"
)

# Create a chat completion request with a video URL
response = client.chat.completions.create(
model="model",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Generate a compelling description that I can upload along with the video."
},
{
"type": "video_url",
"video_url": {
"url": "https://cloud.video.taobao.com/vod/JCM2awgFE2C2vsACpDESXZ3h5_iQ5yCZCypmjtEs2Ck.mp4",
"fps": 2
}
}
]
}
],
max_completion_tokens=1024,
top_p=0.5,
temperature=0.1,
frequency_penalty=1.05,
stream=True,
)

# Process the streaming response
full_response = ""
for chunk in response:
# Append the delta content from the chunk to the full response
full_response += chunk.choices[0].delta.content
print(".", end="") # Indicate progress with dots

# Print the complete response
print(f"\nFull Response: \n{full_response}")

referência

Use a imagem acima para entender o EXEMPLO e simplesmente faça um teste multicorrente para testar a taxa de transferência.

# benchmark!pip install openai==1.56.2
import time
import concurrent.futures
from openai import OpenAI

# 初始化 OpenAI 客户端
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY"
)

# 请求参数
model = "model"
messages = [
{
"role": "user",
"content": [
{"type": "text", "text": "Are these images different?"},
{
"type": "image_url",
"image_url": {
"url": "https://farm4.staticflickr.com/3075/3168662394_7d7103de7d_z_d.jpg",
}
},
{
"type": "image_url",
"image_url": {
"url": "https://farm2.staticflickr.com/1533/26541536141_41abe98db3_z_d.jpg",
}
},
],
}
]

# 并发请求函数
def send_request():
start_time = time.time()
response = client.chat.completions.create(
model=model,
messages=messages,
stream=False,
max_completion_tokens=1024,
temperature=0.1,
)
end_time = time.time()
latency = end_time - start_time
return latency

# 基准测试函数
def benchmark(num_requests, num_workers):
latencies = []
start_time = time.time()

with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
futures = [executor.submit(send_request) for _ in range(num_requests)]
for future in concurrent.futures.as_completed(futures):
latencies.append(future.result())

end_time = time.time()
total_time = end_time - start_time
qps = num_requests / total_time
average_latency = sum(latencies) / len(latencies)
throughput = num_requests * 1024 / total_time # 假设每个请求的响应大小为 1024 字节

print(f"Total Time: {total_time:.2f} seconds")
print(f"QPS: {qps:.2f}")
print(f"Average Latency: {average_latency:.2f} seconds")

# 主程序入口
if __name__ == "__main__":
num_requests = 100 # 总请求数
num_workers = 10 # 并发工作线程数
benchmark(num_requests, num_workers)

Resultados do teste:

Endereço do notebook:https://modelscope.cn/notebook/share/ipynb/5560603a/vl-test-and-benchmark.ipynb

Comparação de desempenho abrangente e vLLM:

Para comparar e contrastar o desempenho do vLLM de forma mais abrangente e precisa, usamos o OpenGVLab/InternVL-Chat-V1-2-SFT-Data para comparar conversas simultâneas simples, múltiplas e de várias rodadas em diferentes tamanhos de modelos, e os scripts de reprodução detalhados são mostrados no link, e os resultados são os seguintes:

É possível observar que o DashInfer tem algumas vantagens de desempenho em todos os casos, especialmente no diálogo de várias rodadas.