TensorRT-LLM: Un ghid cuprinzător pentru optimizarea inferenței modelului de limbă mare pentru performanță maximă

Pe măsură ce cererea de modele lingvistice mari (LLM) continuă să crească, asigurarea unei inferențe rapide, eficiente și scalabile a devenit mai crucială ca niciodată. NVIDIA TensorRT-LLM face un pas pentru a aborda această provocare oferind un set de instrumente puternice și optimizări concepute special pentru inferența LLM. TensorRT-LLM oferă o gamă impresionantă de îmbunătățiri ale performanței, cum ar fi cuantificarea, fuziunea nucleului, loturi în timpul zborului și suport pentru mai multe GPU. Aceste progrese fac posibilă obținerea unor viteze de inferență de până la 8 ori mai rapide decât metodele tradiționale bazate pe CPU, transformând modul în care implementăm LLM-urile în producție.

Acest ghid cuprinzător va explora toate aspectele TensorRT-LLM, de la arhitectura și caracteristicile cheie până la exemple practice pentru implementarea modelelor. Indiferent dacă sunteți inginer AI, dezvoltator de software sau cercetător, acest ghid vă va oferi cunoștințele necesare pentru a utiliza TensorRT-LLM pentru optimizarea inferenței LLM pe GPU-urile NVIDIA.

Accelerarea inferenței LLM cu TensorRT-LLM

TensorRT-LLM oferă îmbunătățiri dramatice ale performanței inferenței LLM. Conform testelor NVIDIA, aplicațiile bazate pe TensorRT apar la 8x mai rapid viteze de inferență în comparație cu platformele numai cu CPU. Acesta este un progres crucial în aplicațiile în timp real, cum ar fi chatbot-urile, sistemele de recomandare și sistemele autonome care necesită răspunsuri rapide.

Cum funcționează

TensorRT-LLM accelerează inferența prin optimizarea rețelelor neuronale în timpul implementării utilizând tehnici precum:

• Eºantionare: Reduce precizia greutăților și activărilor, micșorând dimensiunea modelului și îmbunătățind viteza de inferență.
• Fuziunea stratului și tensorului: Îmbină operațiuni precum funcțiile de activare și înmulțirile de matrice într-o singură operație.
• Tuning Kernel: Selectează nucleele CUDA optime pentru calculul GPU, reducând timpul de execuție.

Aceste optimizări asigură că modelele dvs. LLM funcționează eficient pe o gamă largă de platforme de implementare, de la centre de date la scară largă până la sisteme încorporate.

Optimizarea performanței inferenței cu TensorRT

Construit pe modelul de programare paralelă CUDA de la NVIDIA, TensorRT oferă optimizări foarte specializate pentru inferența asupra GPU-urilor NVIDIA. Prin eficientizarea proceselor precum cuantizarea, reglarea nucleului și fuziunea operațiunilor tensorului, TensorRT asigură că LLM-urile pot rula cu o latență minimă.

Unele dintre cele mai eficiente tehnici includ:

• Eºantionare: Acest lucru reduce precizia numerică a parametrilor modelului, menținând în același timp o precizie ridicată, accelerând efectiv inferența.
• Tensor Fusion: Prin fuzionarea mai multor operațiuni într-un singur nucleu CUDA, TensorRT minimizează supraîncărcarea memoriei și crește debitul.
• Reglare automată a nucleului: TensorRT selectează automat cel mai bun nucleu pentru fiecare operațiune, optimizând inferența pentru un anumit GPU.

Aceste tehnici permit TensorRT-LLM să optimizeze performanța de inferență pentru sarcini de învățare profundă, cum ar fi procesarea limbajului natural, motoarele de recomandare și analiza video în timp real.

Accelerarea sarcinilor de lucru AI cu TensorRT

TensorRT accelerează sarcinile de lucru de deep learning prin încorporarea unor optimizări de precizie, cum ar fi INT8 si FP16. Aceste formate cu precizie redusă permit o inferență semnificativ mai rapidă, păstrând în același timp precizia. Acest lucru este deosebit de valoros în aplicațiile în timp real unde latența scăzută este o cerință critică.

INT8 si FP16 optimizările sunt deosebit de eficiente în:

• Video Streaming: sarcinile de procesare video bazate pe inteligență artificială, cum ar fi detectarea obiectelor, beneficiază de aceste optimizări prin reducerea timpului necesar procesării cadrelor.
• Sisteme de recomandare: Prin accelerarea inferenței pentru modelele care procesează cantități mari de date de utilizator, TensorRT permite personalizarea în timp real la scară.
• Procesarea limbajului natural (NLP): TensorRT îmbunătățește viteza sarcinilor NLP, cum ar fi generarea de text, traducerea și rezumarea, făcându-le potrivite pentru aplicații în timp real.

Implementați, rulați și scalați cu NVIDIA Triton

Odată ce modelul dvs. a fost optimizat cu TensorRT-LLM, îl puteți implementa, rula și scala cu ușurință folosind NVIDIA Triton Inference Server. Triton este un software open-source care acceptă loturi dinamice, ansambluri de modele și debit ridicat. Oferă un mediu flexibil pentru gestionarea modelelor AI la scară.

Unele dintre caracteristicile cheie includ:

• Execuție simultană a modelului: rulați mai multe modele simultan, maximizând utilizarea GPU-ului.
• Loturi dinamice: Combină solicitări multiple de inferență într-un singur lot, reducând latența și crescând debitul.
• Intrări audio/video în flux: Acceptă fluxuri de intrare în aplicații în timp real, cum ar fi analiza video în direct sau serviciile de transmitere a vorbirii în text.

Acest lucru face din Triton un instrument valoros pentru implementarea modelelor optimizate TensorRT-LLM în medii de producție, asigurând scalabilitate și eficiență ridicate.

Caracteristicile de bază ale TensorRT-LLM pentru LLM Inference

Open Source Python API

TensorRT-LLM oferă un sistem extrem de modular și API-ul Python cu sursă deschisă, simplificând procesul de definire, optimizare și execuție LLM. API-ul le permite dezvoltatorilor să creeze LLM-uri personalizate sau să le modifice pe cele pre-construite pentru a se potrivi nevoilor lor, fără a necesita cunoștințe aprofundate despre CUDA sau cadrele de învățare profundă.

Loturi în zbor și atenție paginată

Una dintre caracteristicile remarcabile ale TensorRT-LLM este Loturi în timpul zborului, care optimizează generarea de text prin procesarea simultană a mai multor solicitări. Această caracteristică minimizează timpul de așteptare și îmbunătățește utilizarea GPU-ului prin gruparea dinamică a secvențelor.

În plus, Atenție paginată asigură că utilizarea memoriei rămâne scăzută chiar și atunci când procesează secvențe de intrare lungi. În loc să aloce memorie adiacentă pentru toate jetoanele, atenția paginată împarte memoria în „pagini” care pot fi reutilizate dinamic, prevenind fragmentarea memoriei și îmbunătățind eficiența.

Inferență cu mai multe GPU și cu mai multe noduri

Pentru modele mai mari sau sarcini de lucru mai complexe, TensorRT-LLM acceptă multi-GPU si inferență cu mai multe noduri. Această capacitate permite distribuirea calculelor modelului pe mai multe GPU-uri sau noduri, îmbunătățind randamentul și reducând timpul general de inferență.

Suport FP8

Odată cu apariția lui FP8 (virgulă mobilă de 8 biți), TensorRT-LLM folosește GPU-urile H100 de la NVIDIA pentru a converti greutățile modelului în acest format pentru inferență optimizată. FP8 permite un consum redus de memorie și un calcul mai rapid, util în special în implementările la scară largă.

Arhitectura și componentele TensorRT-LLM

Înțelegerea arhitecturii TensorRT-LLM vă va ajuta să utilizați mai bine capacitățile sale pentru inferența LLM. Să defalcăm componentele cheie:

Definiția modelului

TensorRT-LLM vă permite să definiți LLM-uri folosind un simplu API Python. API-ul construiește a reprezentare grafică a modelului, facilitând gestionarea straturilor complexe implicate în arhitecturile LLM precum GPT sau BERT.

Legături de greutate

Înainte de compilarea modelului, greutățile (sau parametrii) trebuie să fie legați de rețea. Acest pas asigură că greutățile sunt încorporate în motorul TensorRT, permițând o inferență rapidă și eficientă. TensorRT-LLM permite, de asemenea, actualizări de greutate după compilare, adăugând flexibilitate pentru modelele care necesită actualizări frecvente.

Potrivirea modelelor și fuziunea

Operațiunea Fusion este o altă caracteristică puternică a TensorRT-LLM. Prin fuzionarea mai multor operațiuni (de exemplu, înmulțiri de matrice cu funcții de activare) într-un singur nucleu CUDA, TensorRT minimizează suprasarcina asociată cu lansările multiple de nucleu. Acest lucru reduce transferurile de memorie și accelerează inferența.

Plugin-uri

Pentru a extinde capacitățile TensorRT, dezvoltatorii pot scrie Plugin-uri— nuclee personalizate care îndeplinesc sarcini specifice, cum ar fi optimizarea blocurilor de atenție cu mai multe capete. De exemplu, cel Flash-Atenție pluginul îmbunătățește semnificativ performanța straturilor de atenție LLM.

Puncte de referință: câștiguri de performanță TensorRT-LLM

TensorRT-LLM demonstrează câștiguri semnificative de performanță pentru inferența LLM pe diferite GPU-uri. Iată o comparație a vitezei de inferență (măsurată în jetoane pe secundă) folosind TensorRT-LLM pe diferite GPU-uri NVIDIA:

Aceste repere arată că TensorRT-LLM oferă îmbunătățiri substanțiale ale performanței, în special pentru secvențe mai lungi.

Practic: instalarea și construirea TensorRT-LLM

Pasul 1: Creați un mediu container

Pentru ușurință în utilizare, TensorRT-LLM oferă imagini Docker pentru a crea un mediu controlat pentru construirea și rularea modelelor.

docker build --pull \
             --target devel \
             --file docker/Dockerfile.multi \
             --tag tensorrt_llm/devel:latest .

docker run --rm -it \
           --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 --gpus=all \
           --volume ${PWD}:/code/tensorrt_llm \
           --workdir /code/tensorrt_llm \
           tensorrt_llm/devel:latest

python3 ./scripts/build_wheel.py --trt_root /usr/local/tensorrt
pip install ./build/tensorrt_llm*.whl

include_directories(${TENSORRT_LLM_PATH}/cpp/include)
link_directories(${TENSORRT_LLM_PATH}/cpp/build/tensorrt_llm)
target_link_libraries(your_project tensorrt_llm)

mkdir -p model_repository/gpt2/1
cp ./trt_engine/gpt2_fp16.engine model_repository/gpt2/1/

name: "gpt2"
platform: "tensorrt_llm"
max_batch_size: 8
input [
  {
    name: "input_ids"
    data_type: TYPE_INT32
    dims: [-1]
  }
]
output [
  {
    name: "logits"
    data_type: TYPE_FP32
    dims: [-1, -1]
  }
]

docker run --rm --gpus all \
    -v $(pwd)/model_repository:/models \
    nvcr.io/nvidia/tritonserver:23.05-py3 \
    tritonserver --model-repository=/models

curl -X POST http://localhost:8000/v2/models/gpt2/infer -d '{
  "inputs": [
    {"name": "input_ids", "shape": [1, 128], "datatype": "INT32", "data": [[101, 234, 1243]]}
  ]
}'