¡DashInfer-VLM, rendimiento de inferencia SOTA multimodal, ultra-vLLM!

introducción

DashInfer-VLM es una arquitectura de inferencia para grandes modelos visuales multimodales VLM, especialmente optimizada para la aceleración de la inferencia de modelos Qwen VL. La mayor diferencia entre DashInfer-VLM y otros marcos de aceleración de la inferencia para VLM es que separa la parte VIT de la parte LLM y la VIT y LLM se ejecutan en paralelo sin interferir entre sí. sin interferir entre sí.

Se caracteriza por el hecho de que el preprocesamiento de imagen y vídeo en VLM, así como la parte de extracción de características de VIT, no interrumpirán la generación de LLM, y también puede ser una arquitectura separada VIT/LLM, que es el primer marco de servicio VLM en la comunidad de código abierto que utiliza esta arquitectura.

En un despliegue multitarjeta, dispone de una unidad de procesamiento ViT en cada tarjeta, lo que supone una ventaja de rendimiento muy significativa en escenarios de vídeo e imágenes múltiples.

Además, para la parte ViT, admite el almacenamiento en caché de memoria, de modo que no sea necesario recalcular ViT repetidamente en múltiples rondas de diálogo.

A continuación se muestra un diagrama de su arquitectura, y su configuración de acuerdo con la parte 72B de 4 tarjetas.

El diagrama de arquitectura describe el proceso y la arquitectura:

• En la parte ViT, muchas elicitaciones de inferencia pueden ser usadas para la inferencia, como TensorRT o onnxruntime (la exportación del modelo onnx será realizada en la parte ViT del modelo dentro del framework,) TensorRT es actualmente soportado en el framework por defecto.
• En la sección LLM, se utiliza DashInfer para la inferencia.
• Parte de caché, compatible con el resultado ViT Caché de memoria, parte de LLM Caché de prefijo, parte de LLM Caché de prefijo multimodal (no activada por defecto)

Código Dirección:

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

Dirección del documento: 

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

buenas prácticas

Experimenta DashInfer en la aritmética GPU gratuita de la comunidad 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

TensorRT requiere la configuración de variables de entorno:

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

Una vez instalado el entorno, inicie dashinfer vlm para razonar sobre los modelos y formar un servidor compatible con openai, donde los modelos pueden cambiarse a 7B, 72B, etc.

Por defecto, se utiliza toda la memoria GPU del entorno.

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

Este proceso inicializa DashInfer, así como el motor externo utilizado por ViT (en este caso TensorRT), e inicia un servicio openai.

Ver estos registros indica que el TRT se ha inicializado correctamente:

Ver estos registros indica que DashInfer se inicializó con éxito:

Ver estos registros indica que el servicio openai se inicializó correctamente:

Aquí toda la inicialización es exitosa, puedes abrir otro notebook para cliente y benchmarking.

Dirección del cuaderno:https://modelscope.cn/notebook/share/ipynb/6ea987c5/vl-start-server.ipynb

Demostración de comprensión de imágenes

Demostración de comprensión de imágenes con múltiples imágenes:

# 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}")

Vídeo de demostración de comprensión

Dado que openai no define una interfaz de vídeo estándar, este documento proporciona un tipo video_url, que descarga, extrae fotogramas y analiza el vídeo automáticamente.

# 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}")

referencia

Utilice la imagen de arriba para entender el EJEMPLO y simplemente haga una prueba multiconcurrente para la prueba de rendimiento.

# 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 de las pruebas:

Dirección del cuaderno:https://modelscope.cn/notebook/share/ipynb/5560603a/vl-test-and-benchmark.ipynb

Comparación del rendimiento de Comprehensive y vLLM:

Con el fin de comparar y contrastar el rendimiento de vLLM de forma más exhaustiva y precisa, hemos utilizado OpenGVLab/InternVL-Chat-V1-2-SFT-Data para comparar conversaciones monoconcurrentes, multiconcurrentes y multirronda en modelos de diferentes tamaños, y en el enlace se proporcionan scripts de reproducción detallados, y los resultados son los siguientes:

Puede verse que DashInfer tiene algunas ventajas de rendimiento en todos los casos, especialmente en el diálogo multirronda.