DashInfer-VLM, performance d'inférence multimodale SOTA, ultra-vLLM !

introductif

DashInfer-VLM est une architecture d'inférence pour les grands modèles VLM multimodaux visuels, spécialement optimisée pour l'accélération de l'inférence des modèles VL Qwen. La plus grande différence entre DashInfer-VLM et d'autres cadres d'accélération de l'inférence pour les VLM est qu'il sépare la partie VIT de la partie LLM et que le VIT et le LLM fonctionnent en parallèle sans interférer l'un avec l'autre. sans interférer l'un avec l'autre.

Il se caractérise par le fait que le prétraitement de l'image et de la vidéo dans le VLM, ainsi que l'extraction des caractéristiques dans le VIT, n'interrompent pas la génération du LLM, et il peut également s'agir d'une architecture séparée VIT/LLM, qui est le premier cadre de service VLM de la communauté open-source à utiliser cette architecture.

Dans le cadre d'un déploiement multi-cartes, il dispose d'une unité de traitement ViT sur chaque carte, ce qui donne un avantage très significatif en termes de performances dans les scénarios vidéo et multi-images.

En outre, pour la partie ViT, il prend en charge la mise en cache de la mémoire afin qu'il ne soit pas nécessaire de recalculer ViT à plusieurs reprises dans le cadre de plusieurs cycles de dialogue.

Voici un schéma de son architecture, et de sa configuration selon la partie 72B à 4 cartes.

Le diagramme d'architecture décrit le processus et l'architecture :

• Dans la partie ViT, de nombreuses élicitations d'inférence peuvent être utilisées pour l'inférence, telles que TensorRT ou onnxruntime (l'exportation de modèle onnx sera effectuée sur la partie ViT du modèle dans le cadre,) TensorRT est actuellement pris en charge dans le cadre par défaut.
• Dans la section LLM, DashInfer est utilisé pour l'inférence.
• Partie cache, prise en charge du résultat ViT Cache mémoire, partie LLM Cache préfixe, partie LLM Cache préfixe multimodal (non activé par défaut)

Adresse du code :

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

Adresse du document : 

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

meilleures pratiques

Découvrez DashInfer sur l'arithmétique GPU gratuite de la communauté 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 nécessite la configuration de variables d'environnement :

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

Une fois l'environnement installé, lancez dashinfer vlm pour raisonner sur les modèles et former un serveur compatible avec openai, où les modèles peuvent être changés en 7B, 72B, etc.

Toute la mémoire du GPU dans l'environnement est utilisée par défaut.

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

Ce processus initialise DashInfer, ainsi que le moteur externe utilisé par ViT (dans ce cas TensorRT), et démarre un service openai.

L'affichage de ces journaux indique que le TRT a été initialisé avec succès :

La lecture de ces journaux indique que DashInfer a été initialisé avec succès :

La lecture de ces journaux indique que le service openai a été initialisé avec succès :

Une fois l'initialisation réussie, vous pouvez ouvrir un autre carnet pour le client et l'analyse comparative.

Adresse du carnet de notes :https://modelscope.cn/notebook/share/ipynb/6ea987c5/vl-start-server.ipynb

Démonstration de la compréhension des images

Démonstration d'une démo pour la compréhension d'images multiples :

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

Démonstration vidéo de la compréhension

Comme openai ne définit pas d'interface vidéo standard, ce document fournit un type video_url, qui télécharge, extrait des images et analyse automatiquement la vidéo.

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

repère

Utilisez l'image ci-dessus pour comprendre l'EXEMPLE et effectuez simplement un test multiconcurrent pour tester le débit.

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

Résultats des tests :

Adresse du carnet de notes :https://modelscope.cn/notebook/share/ipynb/5560603a/vl-test-and-benchmark.ipynb

Comparaison des performances de Comprehensive et de vLLM :

Afin de comparer les performances de vLLM de manière plus complète et plus précise, nous avons utilisé OpenGVLab/InternVL-Chat-V1-2-SFT-Data pour évaluer les conversations monoconcurrentes, multiconcurrentes et multirondes sur des modèles de différentes tailles ; les scripts de reproduction détaillés sont indiqués dans les liens, et les résultats sont les suivants :

On constate que DashInfer présente des avantages en termes de performances dans tous les cas, en particulier dans le cadre d'un dialogue à plusieurs tours.