DashInfer-VLM, multimodale SOTA-Inferenzleistung, ultra-vLLM!

Einführung

DashInfer-VLM ist eine Inferenzarchitektur für visuelle multimodale VLMs mit großen Modellen, die speziell für die Inferenzbeschleunigung von Qwen-VL-Modellen optimiert wurde. Der größte Unterschied zwischen DashInfer-VLM und anderen Inferenzbeschleunigungs-Frameworks für VLMs besteht darin, dass es den VIT-Teil vom LLM-Teil trennt und VIT und LLM parallel laufen, ohne sich gegenseitig zu behindern. ohne sich gegenseitig zu behindern.

Diese zeichnet sich dadurch aus, dass die Bild- und Videovorverarbeitung in VLM sowie die Merkmalsextraktion in VIT die LLM-Erzeugung nicht unterbrechen. Außerdem kann es sich um eine von VIT/LLM getrennte Architektur handeln, die als erstes VLM-Service-Framework in der Open-Source-Gemeinschaft diese Architektur verwendet.

Bei einem Einsatz mit mehreren Karten verfügt er über eine ViT-Verarbeitungseinheit auf jeder Karte, was einen erheblichen Leistungsvorteil bei Video- und Multibildszenarien bietet.

Darüber hinaus unterstützt es für den ViT-Teil die Zwischenspeicherung im Speicher, so dass ViT bei mehreren Dialogrunden nicht wiederholt neu berechnet werden muss.

Nachstehend finden Sie ein Diagramm seiner Architektur und seiner Konfiguration gemäß dem 4-Karten-Teil 72B.

Das Architekturdiagramm beschreibt den Prozess und die Architektur:

• Im ViT-Teil können viele Inferenzerhebungen für die Inferenz verwendet werden, wie z.B. TensorRT oder onnxruntime (onnx-Modellexport wird auf dem ViT-Teil des Modells innerhalb des Frameworks durchgeführt). TensorRT wird derzeit standardmäßig im Framework unterstützt.
• Im LLM-Abschnitt wird DashInfer für die Inferenz verwendet.
• Cache-Teil, unterstützt ViT-Ergebnis-Speicher-Cache, LLM-Teil-Präfix-Cache, LLM-Teil-multimodaler Präfix-Cache (standardmäßig nicht aktiviert)

Code Adresse:

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

Adresse des Dokuments: 

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

bestes Verfahren

Erleben Sie DashInfer auf der freien GPU-Arithmetik der Magic Hitch Community:

Der erste Schritt ist die Installation von dashinfer-vlm und TensorRT.

# Installieren Sie zuerst die benötigten Pakete
os importieren

# Downloaden und installieren Sie dashinfer Version 2.0.0rc2
# Laden Sie die TensorRT Pakete herunter und entpacken Sie sie mit wget, falls nötig.
# pip install 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

# Laden Sie die Datei lokal herunter und ersetzen Sie sie durch die URL, die modelscope entspricht
# install dashinfer, wir empfehlen, es lokal zu installieren, da das Paket sehr groß ist.
#!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

# install dashinfer vlm
#!pip install dashinfer-vlm

#!pip installieren OpenAI-Client
#!pip install openai==1.56.2

# Installieren Sie das Python-Paket für TensorRT, öffnen Sie es aus dem Download und installieren Sie es.
#!pip install TensorRT-10.6.0.26/python/tensorrt-10.6.0-cp310-none-linux_x86_64.whl

TensorRT erfordert die Konfiguration von Umgebungsvariablen:

importieren os

# Ermittelt den Pfad zur TensorRT-Laufzeitbibliothek
trt_runtime_path = os.getcwd() + "/TensorRT-10.6.0.26/lib/"

# Den aktuellen Wert der Umgebungsvariablen LD_LIBRARY_PATH ermitteln
current_ld_library_path = os.environ.get('LD_LIBRARY_PATH', '')

# Fügen Sie den neuen Pfad zu dem vorhandenen Wert hinzu
if current_ld_library_path.
# wenn LD

Nachdem die Umgebung installiert ist, starten Sie dashinfer vlm, um über die Modelle nachzudenken und einen openai-kompatiblen Server zu bilden, auf dem die Modelle in 7B, 72B usw. geändert werden können.

Standardmäßig wird der gesamte GPU-Speicher in der Umgebung verwendet.

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

Dieser Prozess initialisiert DashInfer sowie die von ViT verwendete externe Engine (in diesem Fall TensorRT) und startet einen openai-Dienst.

Aus diesen Protokollen geht hervor, dass der TRT erfolgreich initialisiert wurde:

Die Anzeige dieser Protokolle zeigt, dass DashInfer erfolgreich initialisiert wurde:

Die Anzeige dieser Protokolle zeigt, dass der openai-Dienst erfolgreich initialisiert wurde:

Wenn die Initialisierung erfolgreich war, können Sie ein weiteres Notebook für den Client und den Benchmark öffnen.

Notebook-Adresse:https://modelscope.cn/notebook/share/ipynb/6ea987c5/vl-start-server.ipynb

Demo zum Bildverständnis

Demonstration einer Demo für das Verstehen von Bildern mit mehreren Bildern:

# Installieren Sie die erforderliche OpenAI-Client-Version
!pip install openai==1.56.2 # VL-Unterstützung erfordert einen aktuellen OpenAI-Client.

von openai importieren OpenAI

# Initialisieren Sie den OpenAI-Client
client = OpenAI(
base_url="http://localhost:8000/v1", api_key="EMPTY", api_key="EMPTY
api_key="EMPTY"
)

# Bereiten Sie den API-Aufruf für einen Chat-Abschluss vor
response = client.chat.completions.create(
model="model",
messages=[
{
"Rolle": "Benutzer", "Inhalt": [
"content": [
{ "type": "text", "text": "Sind diese Bilder unterschiedlich?"}, { "role": "user", "content": [
{
"type": "image_url", "image_url": {"type": "content", "text": "Sind diese Bilder anders?"}, {"type": "image_url", "text": "Sind diese Bilder anders?
"image_url": {
"url": "https://farm4.staticflickr.com/3075/3168662394_7d7103de7d_z_d.jpg", {"type": "image_url", "image_url": {
}
},
{
"type": "image_url", {
"image_url": {
"url": "https://farm2.staticflickr.com/1533/26541536141_41abe98db3_z_d.jpg",
}
}
]
}
],
stream=True, max_completion_tokens=1024, }
max_completion_tokens=1024, }, ], stream=True, max_completion_tokens=1024, }
temperature=0.1, )
)

# Verarbeiten der gestreamten Antwort
full_response = ""
for chunk in response.
# Anhängen des Deltainhalts an die vollständige Antwort
full_response += chunk.choices[0].delta.content
print("." , end="") # Druckt einen Punkt für jeden empfangenen Chunk

# Druckt die vollständige Antwort
print(f"\nBild: Vollständige Antwort:\n{full_response}")

Demo zum Video-Verständnis

Da openai keine Standardschnittstelle für Videos definiert, bietet dieses Dokument einen video_url-Typ, der das Video automatisch herunterlädt, Bilder extrahiert und analysiert.

# Video-Beispiel
!pip install openai==1.56.2 # Stellen Sie sicher, dass der OpenAI-Client Video-Link-Funktionen unterstützt.

von openai importieren OpenAI

# Initialisieren Sie den OpenAI-Client
client = OpenAI(
base_url="http://localhost:8000/v1", api_key="EMPTY", api_key="EMPTY
api_key="EMPTY"
)

# Erstellen Sie eine Chatabschlussanfrage mit einer Video-URL
response = client.chat.completions.create(
model="model",
messages=[
{
"Rolle": "Benutzer", "Inhalt": [
"content": [
{
"type": "text", "text": "Erstelle eine aussagekräftige Beschreibung, die ich zusammen mit dem Video hochladen kann.
"text": "Generate a compelling description that I can upload along with the video."
},
" }, {
"type": "video_url", "text": "Erstelle eine aussagekräftige Beschreibung, die ich zusammen mit dem Video hochladen kann.
"video_url": {
"url": "https://cloud.video.taobao.com/vod/JCM2awgFE2C2vsACpDESXZ3h5_iQ5yCZCypmjtEs2Ck.mp4",
"fps": 2
}
}
]
}
],
max_completion_tokens=1024,
max_completion_tokens=1024, top_p=0.5,
top_p=0.5, temperature=0.1,
frequency_penalty=1.05,
stream=True, )
)

# Verarbeiten der Streaming-Antwort
full_response = ""
for chunk in response.
# Anhängen des Deltainhalts des Chunks an die vollständige Antwort
full_response += chunk.choices[0].delta.content
print("." , end="") # Fortschritt mit Punkten anzeigen

# Drucken der vollständigen Antwort
print(f"\nFull Response: \n{full_response}")

Benchmark

Verwenden Sie das obige Bild, um das BEISPIEL zu verstehen, und führen Sie einfach einen Multicurrent-Test für die Durchsatzprüfung durch.

# benchmark!pip install openai==1.56.2
importiere Zeit
importiere concurrent.futures
von openai importieren OpenAI

# initialisiert den OpenAI-Client.
client = OpenAI(
base_url="http://localhost:8000/v1", api_key="EMPTY", api_key="EMPTY
api_key="EMPTY", api_key="EMPTY"
)

#-Anfrageparameter
Modell = "Modell"
Nachrichten = [
{
"Rolle": "Benutzer", "Inhalt": [
"content": [
{ "type": "text", "text": "Sind diese Bilder unterschiedlich?"}, { "role": "user", "content": [ "type": "text", "text": "Sind diese Bilder unterschiedlich?
{
"type": "image_url", "image_url": {"type": "content", "text": "Sind diese Bilder anders?"}, {"type": "image_url", "text": "Sind diese Bilder anders?
"image_url": {
"url": "https://farm4.staticflickr.com/3075/3168662394_7d7103de7d_z_d.jpg", {"type": "image_url", "image_url": {
}
},
{
"type": "image_url", {
"image_url": {
"url": "https://farm2.staticflickr.com/1533/26541536141_41abe98db3_z_d.jpg",
}
}
]
}
]

# Funktion für gleichzeitige Anfragen
def send_request():
start_time = time.time()
response = client.chat.completions.create(
model=model,
messages=messages,
stream=False, max_completion_tokens
max_completion_tokens=1024,
temperature=0.1, )
)
end_time = time.time()
latency = end_time - start_time
Latenzzeit zurückgeben

#-Benchmark-Funktion
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): [executor.submit(send_request) for _ in range(num_requests)]
latencies.append(future.result())

end_time = time.time()
total_time = end_time - start_time
qps = num_requests / total_time
durchschnittliche_Latenz = sum(Latenzen) / len(Latenzen)
Durchsatz = num_requests * 1024 / total_time # Unter der Annahme einer Antwortgröße von 1024 Bytes pro Anfrage

print(f "Gesamtzeit: {total_time:.2f} Sekunden")
print(f "QPS: {qps:.2f}")
print(f "Durchschnittliche Latenzzeit: {average_latency:.2f} Sekunden")

# Hauptprogramm-Eintrag
if __name__ == "__main__": num_requests = 100
num_requests = 100 # Gesamtzahl der Anfragen.
num_workers = 10 # gleichzeitige Worker-Threads
benchmark(num_requests, num_workers)

Testergebnisse:

Notebook-Adresse:https://modelscope.cn/notebook/share/ipynb/5560603a/vl-test-and-benchmark.ipynb

Umfassender und vLLM-Leistungsvergleich:

Um die Leistung von vLLM umfassender und genauer vergleichen und gegenüberstellen zu können, haben wir OpenGVLab/InternVL-Chat-V1-2-SFT-Data zum Benchmarking von ein-, mehr- und mehrründigen Konversationen auf verschiedenen Modellgrößen verwendet. Detaillierte Reproduktionsskripte sind im Link enthalten:

Es zeigt sich, dass DashInfer in allen Fällen einige Leistungsvorteile hat, insbesondere beim Mehrrunden-Dialog.