TensorRT-LLM: Átfogó útmutató a nagy nyelvi modellek következtetéseinek optimalizálásához a maximális teljesítmény érdekében

Mivel a nagy nyelvi modellek (LLM) iránti kereslet folyamatosan növekszik, a gyors, hatékony és méretezhető következtetések biztosítása minden eddiginél fontosabbá vált. NVIDIA-k TensorRT-LLM lépéseket tesz ennek a kihívásnak a megoldása érdekében azáltal, hogy hatékony eszközöket és optimalizálásokat kínál, amelyeket kifejezetten az LLM következtetésekhez terveztek. A TensorRT-LLM a teljesítményjavítások lenyűgöző sorát kínálja, mint például a kvantálás, a kernelfúzió, a repülés közbeni kötegelés és a több GPU támogatása. Ezek a fejlesztések a hagyományos CPU-alapú módszereknél akár 8-szor gyorsabb következtetési sebesség elérését teszik lehetővé, átalakítva az LLM-ek éles üzembe helyezésének módját.

Ez az átfogó útmutató a TensorRT-LLM minden aspektusát feltárja, az architektúrától és a kulcsfontosságú jellemzőktől a modellek telepítésének gyakorlati példáiig. Legyen Ön MI-mérnök, szoftverfejlesztő vagy kutató, ez az útmutató megadja a tudást a TensorRT-LLM-nek az LLM-következtetések optimalizálásához az NVIDIA GPU-kon.

Az LLM-következtetés felgyorsítása a TensorRT-LLM segítségével

A TensorRT-LLM drámai javulást biztosít az LLM következtetési teljesítményében. Az NVIDIA tesztjei szerint a TensorRT-n alapuló alkalmazások egészen a 8x gyorsabb következtetési sebesség a csak CPU-t használó platformokhoz képest. Ez döntő előrelépés a valós idejű alkalmazásokban, például a chatbotokban, az ajánlórendszerekben és az autonóm rendszerekben, amelyek gyors reagálást igényelnek.

Hogyan működik

A TensorRT-LLM felgyorsítja a következtetést azáltal, hogy optimalizálja a neurális hálózatokat a telepítés során, olyan technikákkal, mint:

• kvantálási: Csökkenti a súlyozások és aktiválások pontosságát, csökkenti a modell méretét és javítja a következtetési sebességet.
• Réteg és tenzor fúzió: A műveleteket, például az aktiválási függvényeket és a mátrixszorzásokat egyetlen műveletté egyesíti.
• Kernel Tuning: Az optimális CUDA-kerneleket választja ki a GPU-számításhoz, csökkentve a végrehajtási időt.

Ezek az optimalizálások biztosítják, hogy LLM-modellei hatékonyan működjenek a telepítési platformok széles skáláján – a hiperskálájú adatközpontoktól a beágyazott rendszerekig.

A következtetési teljesítmény optimalizálása a TensorRT segítségével

Az NVIDIA CUDA párhuzamos programozási modelljére épülő TensorRT rendkívül speciális optimalizálásokat kínál az NVIDIA GPU-kra vonatkozó következtetésekhez. Az olyan folyamatok egyszerűsítésével, mint a kvantálás, a kernelhangolás és a tenzorműveletek egyesítése, a TensorRT biztosítja, hogy az LLM-ek minimális késleltetéssel futhassanak.

A leghatékonyabb technikák közül néhány:

• kvantálási: Ez csökkenti a modellparaméterek numerikus pontosságát, miközben megőrzi a nagy pontosságot, hatékonyan felgyorsítva a következtetést.
• Tensor Fusion: Azáltal, hogy több műveletet egyetlen CUDA kernelbe egyesít, a TensorRT minimalizálja a memória többletterhelését és növeli az átviteli sebességet.
• Kernel automatikus hangolása: A TensorRT automatikusan kiválasztja a legjobb kernelt minden egyes művelethez, optimalizálva a következtetést egy adott GPU-hoz.

Ezek a technikák lehetővé teszik a TensorRT-LLM számára, hogy optimalizálja a következtetési teljesítményt olyan mély tanulási feladatokhoz, mint a természetes nyelvi feldolgozás, az ajánlómotorok és a valós idejű videóelemzés.

A mesterséges intelligencia munkaterhelésének felgyorsítása a TensorRT segítségével

A TensorRT felgyorsítja a mély tanulási munkaterhelést azáltal, hogy olyan precíziós optimalizálásokat tartalmaz, mint pl INT8 és a FP16. Ezek a csökkentett pontosságú formátumok lényegesen gyorsabb következtetést tesznek lehetővé a pontosság megőrzése mellett. Ez különösen értékes a valós idejű alkalmazásokban, ahol az alacsony késleltetés kritikus követelmény.

INT8 és a FP16 Az optimalizálás különösen hatékony:

• Videó Streaming: A mesterséges intelligencia alapú videofeldolgozási feladatok, például az objektumészlelés, profitálnak ezekből az optimalizálásokból, mivel csökkentik a képkockák feldolgozásához szükséges időt.
• Ajánlórendszerek: A nagy mennyiségű felhasználói adatot feldolgozó modellek következtetéseinek felgyorsításával a TensorRT lehetővé teszi a valós idejű, nagyszabású személyre szabást.
• Természetes nyelvi feldolgozás (NLP): A TensorRT javítja az NLP-feladatok (például szöveggenerálás, fordítás és összegzés) sebességét, így alkalmassá teszi őket valós idejű alkalmazásokhoz.

Üzembe helyezés, futtatás és méretezés az NVIDIA Triton segítségével

Miután a modell optimalizálva lett a TensorRT-LLM segítségével, egyszerűen telepítheti, futtathatja és méretezheti. NVIDIA Triton következtetés szerver. A Triton egy nyílt forráskódú szoftver, amely támogatja a dinamikus kötegelést, a modellegyütteseket és a nagy áteresztőképességet. Rugalmas környezetet biztosít az AI-modellek nagyszabású kezeléséhez.

Néhány kulcsfontosságú funkció a következők:

• Egyidejű modell végrehajtás: Több modell futtatása egyszerre, maximalizálva a GPU kihasználtságát.
• Dinamikus kötegelés: Több következtetési kérést egyesít egy kötegbe, csökkentve a késleltetést és növelve az átviteli sebességet.
• Streaming audio/video bemenetek: Támogatja a bemeneti adatfolyamokat valós idejű alkalmazásokban, például élő videóelemzésben vagy beszéd-szöveg szolgáltatásban.

Ez teszi a Tritont értékes eszközzé a TensorRT-LLM optimalizált modellek termelési környezetben való üzembe helyezéséhez, biztosítva ezzel a magas skálázhatóságot és hatékonyságot.

A TensorRT-LLM fő jellemzői az LLM-következtetéshez

Nyílt forráskódú Python API

A TensorRT-LLM rendkívül moduláris és nyílt forráskódú Python API, leegyszerűsíti az LLM-ek meghatározásának, optimalizálásának és végrehajtásának folyamatát. Az API lehetővé teszi a fejlesztők számára, hogy egyéni LLM-eket hozzanak létre, vagy az előre elkészítetteket igényeiknek megfelelően módosítsák anélkül, hogy a CUDA vagy a mély tanulási keretrendszerek mélyreható ismeretére lenne szükségük.

Repülés közbeni kötegelés és lapozott figyelem

A TensorRT-LLM egyik kiemelkedő tulajdonsága az Repülés közbeni kötegelés, amely több kérés egyidejű feldolgozásával optimalizálja a szöveggenerálást. Ez a funkció minimálisra csökkenti a várakozási időt és javítja a GPU kihasználtságát a sorozatok dinamikus kötegelése révén.

Emellett, Paged Figyelem biztosítja, hogy a memóriahasználat alacsony maradjon még hosszú bemeneti sorozatok feldolgozása esetén is. Ahelyett, hogy az összes token számára összefüggő memóriát rendelne, a lapozott figyelem a memóriát „oldalakra” bontja, amelyek dinamikusan újra felhasználhatók, megelőzve a memória töredezettségét és javítva a hatékonyságot.

Több GPU és több csomópont következtetése

Nagyobb modellek vagy összetettebb munkaterhelések esetén a TensorRT-LLM támogatja több GPU-s és a több csomópontos következtetés. Ez a képesség lehetővé teszi a modellszámítások elosztását több GPU-n vagy csomóponton keresztül, javítva az átviteli sebességet és csökkentve az általános következtetési időt.

FP8 támogatás

Az Advent a FP8 (8 bites lebegőpontos), a TensorRT-LLM az NVIDIA H100 GPU-it használja fel, hogy a modellsúlyokat ebbe a formátumba konvertálja az optimalizált következtetések érdekében. Az FP8 csökkentett memóriafelhasználást és gyorsabb számítást tesz lehetővé, különösen nagyméretű telepítéseknél.

TensorRT-LLM architektúra és komponensek

A TensorRT-LLM architektúrájának megértése segít jobban kihasználni a képességeit az LLM-következtetéshez. Bontsuk fel a legfontosabb összetevőket:

Modell meghatározása

A TensorRT-LLM lehetővé teszi az LLM-ek meghatározását egy egyszerű Python API segítségével. Az API konstruálja a grafikonos ábrázolás Ez megkönnyíti az LLM architektúrák, például a GPT vagy a BERT összetett rétegeinek kezelését.

Súlykötések

A modell összeállítása előtt a súlyokat (vagy paramétereket) a hálózathoz kell kötni. Ez a lépés biztosítja, hogy a súlyok beépüljenek a TensorRT motorba, lehetővé téve a gyors és hatékony következtetést. A TensorRT-LLM a fordítás utáni súlyfrissítéseket is lehetővé teszi, rugalmasságot biztosítva a gyakori frissítést igénylő modellek számára.

Mintaillesztés és fúzió

Fusion művelet a TensorRT-LLM másik hatékony funkciója. Több művelet (pl. mátrixszorzás aktiválási függvényekkel) egyetlen CUDA-kernelbe való egyesítése révén a TensorRT minimalizálja a több kernelindításhoz kapcsolódó többletterhelést. Ez csökkenti a memóriaátvitelt és felgyorsítja a következtetéseket.

Dugó

A TensorRT képességeinek bővítése érdekében a fejlesztők írhatnak Plugins– egyedi kernelek, amelyek speciális feladatokat hajtanak végre, például optimalizálják a többfejes figyelemblokkokat. Például a Flash-Figyelem plugin jelentősen javítja az LLM figyelemrétegek teljesítményét.

Benchmark: TensorRT-LLM teljesítménynövekedés

A TensorRT-LLM jelentős teljesítménynövekedést mutat az LLM-következtetések során a különböző GPU-k között. Íme a következtetési sebesség összehasonlítása (token per másodpercben) TensorRT-LLM használatával a különböző NVIDIA GPU-k között:

Ezek a referenciaértékek azt mutatják, hogy a TensorRT-LLM jelentős teljesítményjavulást biztosít, különösen hosszabb sorozatok esetén.

Praktikus gyakorlat: A TensorRT-LLM telepítése és felépítése

1. lépés: Hozzon létre egy tárolókörnyezetet

A könnyebb használat érdekében a TensorRT-LLM Docker-képeket biztosít, amelyek ellenőrzött környezetet hozhatnak létre a modellek felépítéséhez és futtatásához.

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]]}
  ]
}'