How do I install and set up TensorRT-LLM the right way?

Use a container with matching CUDA/TensorRT or follow the official quick start and support matrix to avoid version drift. Verify GPU drivers and build tools before compiling engines.

How to use TensorRT-LLM with Hugging Face models?

Download the model and tokenizer, confirm support, and convert as needed before building the engine. If serving with TGI, compile engines for your GPU and point the backend to the engine directory.

Should I choose FP16, FP8, or INT8 for TensorRT-LLM?

Start with FP16 for stability, then try FP8/INT8 to increase throughput. Always validate task accuracy after quantization.

Can I serve TensorRT-LLM over HTTP?

Yes. You can use Python/C++ directly or serve via Hugging Face TGI’s TRT-LLM backend for scalable, production-ready APIs with streaming.

What are common performance bottlenecks when using TensorRT-LLM?

Tokenizer overhead, suboptimal batching, and lack of paged KV cache are common issues. Tune batch sizes, enable CUDA graphs, and monitor TTFT versus overall tokens-per-second.

TensorRT-LLM എങ്ങനെ ഉപയോഗിക്കാം: ഒരു സമ്പൂർണ്ണ ഹാൻഡ്‌സ്-ഓൺ ഗൈഡ്

ആമുഖം: എന്തുകൊണ്ട് TensorRT-LLM നിങ്ങളുടെ വാരാന്ത്യത്തിലെ നിർമ്മാണത്തിന് പ്രയോജനകരമാണ് നിങ്ങളുടെ LLM ഇഴഞ്ഞുനീങ്ങുമ്പോൾ GPU 60% ഉപയോഗത്തിൽ ഇരിക്കുന്നത് നിങ്ങൾ എപ്പോഴെങ്കിലും ശ്രദ്ധിച്ചിട്ടുണ്ടെങ്കിൽ, അവിടെ കൂടുതൽ കാര്യക്ഷമത നേടാൻ സാധിക്കുമെന്ന് നിങ്ങൾക്കറിയാം. TensorRT-LLM ആ സാധ്യതയെ ഉപയോഗിച്ച് കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നു: ലയിപ്പിച്ച കേർണലുകൾ, പേജ്ഡ് അറ്റൻഷൻ, ക്വാಂಟൈസേഷൻ, ഗ്രാഫ്-ലെവൽ ഒപ്റ്റിമൈസേഷനുകൾ എന്നിവ ലേറ്റൻസി കുറയ്ക്കുകയും ഒരു സെക്കൻഡിൽ കൂടുതൽ ടോക്കണുകൾ നൽകുകയും ചെയ്യുന്നു. ഈ ഗൈഡിൽ, ഇൻസ്റ്റാൾ ചെയ്യുന്നത് മുതൽ എഞ്ചിൻ നിർമ്മിക്കുന്നതും നൽകുന്നതും വരെയുള്ള എല്ലാ കാര്യങ്ങളും വിശദീകരിക്കുന്നു—അതിലൂടെ NVIDIA GPU-കളിൽ വേഗത്തിലും കുറഞ്ഞ ചിലവിലും ഇൻഫെറൻസ് വിന്യസിക്കാൻ നിങ്ങൾക്ക് കഴിയും.

ഈ ട്യൂട്ടോറിയൽ ഒരു പ്രായോഗികവും പ്രശ്നപരിഹാരത്തിന് ഊന്നൽ നൽകുന്നതുമായ ശൈലിയിലാണ് എഴുതിയിരിക്കുന്നത്. പകർത്താൻ കഴിയുന്ന കമാൻഡുകൾ, സാധാരണ പ്രശ്നങ്ങൾ, FP16 vs INT8, ബാച്ചിംഗ്, KV കാഷെ തന്ത്രങ്ങൾ എന്നിവയ്ക്കുള്ള തീരുമാന പോയിന്റുകൾ എന്നിവ ഉൾപ്പെടെ ചോദ്യോത്തര രൂപത്തിലാണ് ഇത് തയ്യാറാക്കിയിരിക്കുന്നത്. ആവശ്യമുള്ളപ്പോൾ കൂടുതൽ വിവരങ്ങൾക്കായി ഔദ്യോഗിക ഉറവിടങ്ങളെക്കുറിച്ചും പരാമർശിക്കും.

നിങ്ങൾ എന്തൊക്കെ പഠിക്കും

TensorRT-LLM-നുള്ള පරිസ്ഥിതി എങ്ങനെ സജ്ജീകരിക്കാം

എഞ്ചിൻ നിർമ്മാണത്തിനായി ഒരു മോഡൽ എങ്ങനെ തയ്യാറാക്കാം (Hugging Face അല്ലെങ്കിൽ ചെക്ക്പോയിന്റുകളിൽ നിന്ന്)

FP16/INT8 എഞ്ചിനുകൾ എങ്ങനെ നിർമ്മിക്കാം, പ്രകടനം എങ്ങനെ മെച്ചപ്പെടുത്താം

Python/C++ , HTTP എന്നിവ ഉപയോഗിച്ച് ഇൻഫെറൻസ് എങ്ങനെ പ്രവർത്തിപ്പിക്കാം

എങ്ങനെ ബെഞ്ച്മാർക്ക് ചെയ്യാം, ബാച്ച് ചെയ്യാം, ഡീബഗ് ചെയ്യാം

ആർക്കുവേണ്ടിയുള്ളതാണ് ഇത്

NVIDIA GPU-കളിൽ LLM-കൾ വിന്യസിക്കുന്ന ML എഞ്ചിനീയർമാർക്ക്

പ്രൊഡക്ഷനിൽ ചിലവ്/ലേറ്റൻസി എന്നിവ ഒപ്റ്റിമൈസ് ചെയ്യുന്നവർക്ക്

PyTorch ട്രാൻസ്ഫോർമറുകളിൽ നിന്ന് ഉയർന്ന ഒപ്റ്റിമൈസ്ഡ് ഇൻഫെറൻസിലേക്ക് മാറുന്നവർക്ക്

എന്താണ് TensorRT-LLM, നിങ്ങൾ ഇത് എప్పుడు ഉപയോഗിക്കണം? Transformer മോഡലുകളെ വളരെ ഒപ്റ്റിമൈസ് ചെയ്ത GPU “എഞ്ചിനുകളിലേക്ക്” കംപൈൽ ചെയ്യുന്ന ഒരു ഇൻഫെറൻസ് സ്റ്റാക്കാണ് TensorRT-LLM. സാധാരണ PyTorch അല്ലെങ്കിൽ മറ്റ് റൺടൈമുകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, നിങ്ങൾക്ക് സാധാരണയായി ലഭിക്കുന്നത്:

ഓരോ ടോക്കണുകൾക്കുമുള്ള കുറഞ്ഞ ലേറ്റൻസി

വലിയ ബാച്ച് സൈസുകളിൽ ഉയർന്ന ത്രൂപുട്ട്

പേജ്ഡ് KV കാഷെ, ക്വാണ്ടിസേഷൻ എന്നിവ ഉപയോഗിച്ച് മികച്ച മെമ്മറി കാര്യക്ഷമത നിങ്ങൾ NVIDIA GPU-കളിൽ പ്രവർത്തിക്കുകയും പ്രൊഡക്ഷൻ-ഗ്രേഡ് പ്രകടനത്തെക്കുറിച്ച് ശ്രദ്ധിക്കുകയും ചെയ്യുമ്പോൾ ഇത് ഉപയോഗിക്കുക. ഡീകോഡർ-മാത്രമുള്ള LLM-കൾക്ക് (ഉദാഹരണത്തിന്, Llama, Mistral, Phi, BLOOM) ചാറ്റ്ബോട്ടുകൾ, RAG, ഉയർന്ന QPS API സേവനങ്ങൾ തുടങ്ങിയ സാഹചര്യങ്ങളിലും ഇത് വളരെ പ്രയോജനകരമാണ്.

ആവശ്യകതകളും പരിസ്ഥിതി സജ്ജീകരണവും പ്രധാന ആവശ്യകതകൾ

പുതിയ കമ്പ്യൂട്ട് ശേഷിയുള്ള NVIDIA GPU (ഉദാഹരണത്തിന്, Ampere, Ada, Hopper)

യോജിച്ച CUDA, TensorRT പതിപ്പുകൾ, കൂടാതെ അനുയോജ്യമായ ഡ്രൈവറുകൾ

Python 3.8+ കൂടാതെ സോഴ്സിൽ നിന്ന് കംപൈൽ ചെയ്യുകയാണെങ്കിൽ, അതിനായുള്ള ടൂളുകൾ

പതിപ്പ് ശ്രദ്ധിക്കുക: ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുമ്പ് അനുയോജ്യമായ CUDA/TensorRT പതിപ്പുകൾക്കും ഫീച്ചറുകൾക്കുമായി ഔദ്യോഗിക TensorRT പിന്തുണാ മാട്രിക്സും റിലീസ് കുറിപ്പുകളും എപ്പോഴും പരിശോധിക്കുക.

Quick-start ഓപ്ഷനുകൾ

കണ്ടെയ്‌നറൈസ്ഡ്: പ്രീഇൻസ്റ്റാൾ ചെയ്ത CUDA/TensorRT-യുള്ള NVIDIA-യുടെ കണ്ടെയ്‌നറുകൾ ഉപയോഗിക്കുക—പതിപ്പ് പൊരുത്തക്കേടുകൾ ഒഴിവാക്കാനുള്ള ഏറ്റവും വേഗതയേറിയ മാർഗ്ഗം.

നേറ്റീവ് ഇൻസ്റ്റാൾ: അടിസ്ഥാന TensorRT-യ്‌ക്കായുള്ള ഔദ്യോഗിക ക്വിക്ക് സ്റ്റാർട്ട് പിന്തുടരുക, തുടർന്ന് TensorRT-LLM മുകളിൽ ലെയർ ചെയ്യുക.

നിങ്ങളുടെ മോഡൽ തയ്യാറാക്കുന്നു (Hugging Face → TensorRT-LLM) സാധാരണ ഉറവിടങ്ങൾ

Hugging Face: Llama/Mistral/BLOOM വേരിയന്റുകൾ

പ്രാദേശിക ചെക്ക്പോയിന്റുകൾ: ഇഷ്ടമുള്ള ഫൈൻ-ട്യൂണുകൾ

തയ്യാറാക്കാനുള്ള കാര്യങ്ങൾ

TensorRT-LLM മോഡൽ ആർക്കിടെക്ചറിനെ പിന്തുണയ്ക്കുന്നുണ്ടോയെന്ന് സ്ഥിരീകരിക്കുക.

മോഡൽ വെയ്റ്റുകളും ടോക്കണൈസറും ഡൗൺലോഡ് ചെയ്യുക.

ആവശ്യമെങ്കിൽ, safetensor-കളെ പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റുകളിലേക്ക് മാറ്റുക അല്ലെങ്കിൽ പ്രോജക്റ്റിന്റെ സ്ക്രിപ്റ്റുകൾ വഴി ONNX-ലേക്ക് എക്സ്പോർട്ട് ചെയ്യുക.

നുറുങ്ങ്: മോഡലുകൾ നേടുന്നതിനും ശരിയായ ഇന്റർമീഡിയറ്റ് ഫോമിലേക്ക് മാറ്റുന്നതിനും ഔദ്യോഗിക ക്വിക്ക് സ്റ്റാർട്ടിൽ പലപ്പോഴും സ്ക്രിപ്റ്റുകൾ ഉൾപ്പെടുന്നു. BLOOM ഉദാഹരണത്തോടുകൂടിയ ട്യൂട്ടോറിയൽ-ശൈലിയിലുള്ള വിശദീകരണത്തിനായി, Hugging Face LLM-കളെ TensorRT-LLM-ലേക്ക് മാറ്റുന്നതിനെക്കുറിച്ചുള്ള Dell-ൻ്റെ ഗൈഡ് കാണുക.

TensorRT-LLM എഞ്ചിൻ നിർമ്മിക്കുന്നു (വർക്ക്ഫ്ലോയുടെ ഹൃദയം) നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട ആശയങ്ങൾ

എഞ്ചിൻ: ഇൻഫെറൻസിനായി നിങ്ങൾ ലോഡ് ചെയ്യുന്ന കംപൈൽ ചെയ്ത, ഹാർഡ്‌വെയർ-ഒപ്റ്റിമൈസ്ഡ് ആർട്ടിഫാക്റ്റ്.

കൃത്യത: ശക്തമായ അടിസ്ഥാനത്തിനായി FP16/BF16; കൃത്യത നിലനിർത്തുകയാണെങ്കിൽ ഉയർന്ന ത്രൂപുട്ടിനായി INT8 അല്ലെങ്കിൽ FP8.

KV കാഷെ: പേജ്ഡ് KV കാഷെ മെമ്മറി ഫ്രാഗ്മെൻ്റേഷൻ കുറയ്ക്കുകയും ലോംഗ്-കോൺടെക്സ്റ്റ് പ്രകടനം വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.

ഉയർന്ന തലത്തിലുള്ള ഘട്ടങ്ങൾ

നിർമ്മാണ കോൺഫിഗറേഷൻ നിർവചിക്കുക: പരമാവധി ബാച്ച്, സീക്വൻസ് ലെങ്ത്, കൃത്യത, ക്വാണ്ടിസേഷൻ, GPU ആർക്കിടെക്ചർ.

നിങ്ങളുടെ മോഡൽ ചെക്ക്പോയിന്റുകളും ടോക്കണൈസറും ചൂണ്ടിക്കാണിക്കുക.

നിങ്ങളുടെ ടാർഗെറ്റ് GPU-കൾക്കായി എഞ്ചിൻ കംപൈൽ ചെയ്യുക.

റഫറൻസ്: ഔദ്യോഗിക ഡോക്യുമെൻ്റുകളും കോൺഫിഗറേഷനുകളും ഉപയോഗിച്ച് എഞ്ചിനുകൾ നിർമ്മിക്കുക. നിങ്ങൾ Hugging Face ടെക്സ്റ്റ് ജനറേഷൻ ഇൻഫെറൻസ് (TGI) വഴി നൽകാൻ പദ്ധതിയിടുകയാണെങ്കിൽ, GPU ആർക്കിടെക്ചറിനും കോൺഫിഗറേഷനും അനുസരിച്ച് മുൻകൂട്ടി കംപൈൽ ചെയ്യുന്ന എഞ്ചിനുകളെക്കുറിച്ചുള്ള TRT-LLM ബാക്കെൻഡ് കുറിപ്പുകൾ കാണുക.

തുടക്കക്കാർക്കുള്ള തീരുമാനമെടുക്കാനുള്ള ട്രീ

ആദ്യത്തെ നിർമ്മാണം: FP16, മീഡിയം മാക്സ് സീക്വൻസ് ലെങ്ത് (ഉദാഹരണത്തിന്, 4K–8K), മിതമായ ബാച്ച് (ഉദാഹരണത്തിന്, 4–8). കൃത്യത ഉറപ്പാക്കുക.

സ്കെയിലിംഗ്: പേജ്ഡ് KV കാഷെ പ്രവർത്തനക്ഷമമാക്കുക. പരമാവധി ബാച്ച്/ബീം വലുപ്പങ്ങൾ വർദ്ധിപ്പിക്കുക. FP8 അല്ലെങ്കിൽ INT8 ഉപയോഗിച്ച് പരീക്ഷിക്കുക.

പ്രൊഡക്ഷൻ: ലേറ്റൻസി/QPS SLO-കൾ പാലിക്കുന്ന കോൺഫിഗുകൾ പിൻ ചെയ്യുക; ഓരോ സാഹചര്യത്തിനും പ്രത്യേക എഞ്ചിനുകൾ ഉണ്ടാക്കുക (ചെറിയ പ്രോംപ്റ്റുകൾ vs ലോംഗ്-കോൺടെക്സ്റ്റ്).

ഇൻഫെറൻസ് പ്രവർത്തിപ്പിക്കുന്നു: Python, C++, HTTP നിങ്ങൾക്ക് മൂന്ന് പൊതുവായ വഴികളുണ്ട്:

Python: പെട്ടെന്നുള്ള പ്രോട്ടോടൈപ്പിംഗിന് അനുയോജ്യം, പൈപ്പ്ലൈനുകൾക്കും നോട്ട്ബുക്കുകൾക്കും ഉത്തമം.

C++: പരമാവധി പ്രകടനം, നേറ്റീവ് സേവനങ്ങളിലേക്ക് സംയോജിപ്പിക്കാൻ സാധിക്കുന്നു.

HTTP സെർവിംഗ്: സ്കെയിലബിൾ വിന്യാസത്തിനായി TRT-LLM ബാക്കെൻഡിനൊപ്പം TGI ഉപയോഗിക്കുക അല്ലെങ്കിൽ റൺടൈമിൻ്റെ സെർവിംഗ് ഉദാഹരണങ്ങൾ ഉപയോഗിക്കുക.

Hugging Face TGI ബാക്കെൻഡ്

നിങ്ങളുടെ GPU/കൃത്യത സജ്ജീകരണത്തിനായി എഞ്ചിനുകൾ മുൻകൂട്ടി കംപൈൽ ചെയ്യുക.

TRT-LLM ബാക്കെൻഡ് ഉപയോഗിച്ച് TGI സ്പിൻ അപ്പ് ചെയ്യുക, എഞ്ചിൻ ഡയറക്ടറിയിലേക്ക് പോയിന്റ് ചെയ്യുക.

/generate അല്ലെങ്കിൽ openai-അനുയോജ്യമായ റൂട്ടുകൾ വഴി അഭ്യർത്ഥനകൾ അയച്ച് റെപ്ലിക്കകൾ ഉപയോഗിച്ച് സ്കെയിൽ ചെയ്യുക.

പ്രകടനം മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്ന കാര്യങ്ങൾ എവിടെ തുടങ്ങണം

കൃത്യത: FP16 ആണ് നിങ്ങളുടെ വിശ്വസനീയമായ അടിസ്ഥാനം. INT8/FP8 ലേറ്റൻസി കൂടുതൽ കുറയ്ക്കാൻ സഹായിക്കും, പക്ഷേ ഗുണമേന്മ ഉറപ്പാക്കുക.

ബാച്ചിംഗ്: ഡൈനാമിക് ബാച്ചിംഗും അഭ്യർത്ഥന ഏകീകരണവും ത്രൂപുട്ട് ഗണ്യമായി വർദ്ധിപ്പിക്കുന്നു; ടെയിൽ ലേറ്റൻസി അളക്കുക.

പേജ്ഡ് KV കാഷെ: വലിയ പ്രോംപ്റ്റുകൾക്കും സ്ട്രീമിംഗിനും അത്യാവശ്യം; മെമ്മറി പ്രശ്നങ്ങൾ കുറയ്ക്കുന്നു.

പരമാവധി ലെങ്ത്: വലിയ മാക്സ് സീക്വൻസ് ലെങ്ത് എഞ്ചിൻ വലുപ്പം വർദ്ധിപ്പിക്കുകയും ക്ലോക്ക് കുറയ്ക്കുകയും ചെയ്യും; ആവശ്യത്തിനനുസരിച്ചുള്ള എഞ്ചിനുകൾ നിർമ്മിക്കുക.

പ്രായോഗികമായ ടിപ്പുകൾ

റിയലിസ്റ്റിക് പ്രോംപ്റ്റുകൾ ഉപയോഗിച്ച് ബെഞ്ച്മാർക്ക് ചെയ്യുക: പ്രീഫിൽ vs ഡീകോഡ് ഘട്ടങ്ങൾ പ്രത്യേകം അളക്കുക.

ടോക്കണൈസർ ത്രൂപുട്ട് പ്രധാനമാണ്: നിങ്ങളുടെ ഫ്രെയിംവർക്ക് പിന്തുണയ്ക്കുന്നുണ്ടെങ്കിൽ GPU-ൽ ചെയ്യുക.

CUDA ഗ്രാഫുകൾ/ഫ്യൂസ്ഡ് കേർണലുകൾ എന്നിവയിൽ ശ്രദ്ധിക്കുക: അവ CPU ഓവർഹെഡും കേർണൽ ലോഞ്ച് ലേറ്റൻസിയും കുറയ്ക്കുന്നു.

Multi-GPU-ക്കായി: നിങ്ങളുടെ മോഡൽ വലുപ്പത്തിനും ലേറ്റൻസി ആവശ്യകതകൾക്കും അനുസരിച്ച് ടെൻസർ പാരലൽ അല്ലെങ്കിൽ പൈപ്പ്ലൈൻ പാരലൽ തിരഞ്ഞെടുക്കുക.

ബെഞ്ച്മാർക്കിംഗ്: വിജയം തെളിയിക്കുക ചെയ്യേണ്ട കാര്യങ്ങൾ

ലക്ഷ്യമിടുന്ന ബാച്ച് സൈസുകളിലെ ടോക്കണുകൾ/സെക്കൻഡ് (ത്രൂപുട്ട്)

ആദ്യ ടോക്കണിലേക്കുള്ള സമയം (TTFT), ഓരോ അഭ്യർത്ഥനയുടെയും എൻഡ്-ടു-എൻഡ് ലേറ്റൻസി

പരമാവധി QPS-ന് കീഴിലുള്ള GPU ഉപയോഗവും മെമ്മറി ശേഷിയും

കൃത്യത: നിങ്ങൾ ക്വാണ്ടിസൈസ് ചെയ്യുകയാണെങ്കിൽ BLEU/പെർപ്ലെക്സിറ്റി അല്ലെങ്കിൽ ടാസ്‌ക്-സ്‌പെസിഫിക് ഇവാലുവേഷനുകൾ

കൃത്യതയും ഡെൽറ്റകളും സാധൂകരിക്കുന്നതിന്, ബേസ്‌ലൈനുകളിലുടനീളം (PyTorch vs TensorRT-LLM) സ്ഥിരമായ സീഡുകളും പ്രോംപ്റ്റ് സെറ്റുകളും ഉപയോഗിക്കുക.

ഡീബഗ്ഗിംഗും സാധാരണ പ്രശ്നങ്ങളും

പൊരുത്തമില്ലാത്ത പതിപ്പുകൾ: ഔദ്യോഗിക പിന്തുണാ മാട്രിക്സ് അനുസരിച്ച് CUDA, ഡ്രൈവറുകൾ, TensorRT പതിപ്പുകൾ എന്നിവ ക്രമീകരിക്കുക.

ഉപകരണത്തിന് അനുയോജ്യമല്ലാത്ത എഞ്ചിൻ: നിങ്ങളുടെ GPU ആർക്കിടെക്ചറിനായി പ്രത്യേകമായി എഞ്ചിനുകൾ വീണ്ടും നിർമ്മിക്കുക.

നിർമ്മാണ സമയത്ത് OOM: പരമാവധി സീക്വൻസ് ലെങ്ത് അല്ലെങ്കിൽ ബാച്ച് കുറയ്ക്കുക; പേജ്ഡ് KV പ്രവർത്തനക്ഷമമാക്കുക; ക്വാണ്ടിസേഷൻ പരിഗണിക്കുക.

INT8 ഉപയോഗിച്ച് കൃത്യത കുറയുന്നു: ഡൊമെയ്ൻ-പ്രതിനിധീകരിക്കുന്ന ഡാറ്റയിൽ കാലിബ്രേറ്റ് ചെയ്യുക; പെർ-ടെൻസർ ക്വാണ്ടിസേഷൻ പരീക്ഷിച്ച് ലെയർ തിരിച്ചുള്ള സെൻസിറ്റിവിറ്റി പരിശോധിക്കുക.

ഉയർന്ന ത്രൂപുട്ട് ഉണ്ടായിരുന്നിട്ടും TTFT കുറവാണ്: പേജ്ഡ് KV കാഷെ ട്യൂൺ ചെയ്യുക, CUDA ഗ്രാഫുകൾ പ്രവർത്തനക്ഷമമാക്കുക, ടോക്കണൈസർ തടസ്സങ്ങൾ പരിശോധിക്കുക.

ഉദാഹരണ വർക്ക്ഫ്ലോ: Hugging Face മോഡലിൽ നിന്ന് പ്രൊഡക്ഷനിലേക്ക് സാഹചര്യം: നിങ്ങൾക്ക് A100-ൽ കുറഞ്ഞ ലേറ്റൻസിയുള്ള ഒരു ചാറ്റ് മോഡൽ വേണം.

മോഡൽ തിരഞ്ഞെടുക്കുക: 7B–13B Llama/Mistral വേരിയൻ്റ്.

തയ്യാറാക്കുക: വെയ്റ്റുകളും ടോക്കണൈസറും ഡൗൺലോഡ് ചെയ്യുക; ആർക്കിടെക്ചർ പിന്തുണയ്ക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക.

ആദ്യ എഞ്ചിൻ: FP16, പരമാവധി ഇൻപുട്ട് 4K, പരമാവധി ഔട്ട്പുട്ട് 1K, ബാച്ച് 4; പേജ്ഡ് KV ഓൺ ചെയ്യുക.

സാധൂകരിക്കുക: നിങ്ങളുടെ PyTorch അടിസ്ഥാനവുമായി ഔട്ട്പുട്ടുകൾ താരതമ്യം ചെയ്യുക.

ഒപ്റ്റിമൈസ് ചെയ്യുക: INT8 അല്ലെങ്കിൽ FP8 പരീക്ഷിക്കുക; TTFT, ത്രൂപുട്ട് എന്നിവ അളക്കുക. സെർവർ മോഡിനായി ബാച്ച് വർദ്ധിപ്പിക്കുക.

സേവനം നൽകുക: TGI TRT-LLM ബാക്കെൻഡ് ഉപയോഗിക്കുക; ലോഡ് ബാലൻസറിന് പിന്നിൽ റെപ്ലിക്കകൾ സ്കെയിൽ ചെയ്യുക; സ്ട്രീമിംഗ് ചേർക്കുക.

ചെലവും ശേഷിയും ആസൂത്രണം ചെയ്യുക

ഓരോ GPU-യുടെയും ത്രൂപുട്ട്: നിങ്ങളുടെ ലക്ഷ്യമിടുന്ന കോൺടെക്സ്റ്റിൽ ടോക്കണുകൾ/സെക്കൻഡ് അളക്കുക. അത് ഉപയോഗിച്ച് QPS ശേഷി കണക്കാക്കുക.

1M ടോക്കണുകൾക്കുള്ള വില: വേഗത്തിലുള്ള ഡീകോഡിംഗും ഉയർന്ന ബാച്ച് ഉപയോഗവും ഉള്ളതിനാൽ, TRT-LLM സാധാരണയായി ടോക്കൺ വില കുറയ്ക്കുന്നു.

ശരിയായ വലുപ്പത്തിലുള്ള എഞ്ചിനുകൾ: ഹ്രസ്വ രൂപത്തിനും ദീർഘ രൂപത്തിനുമായി പ്രത്യേക എഞ്ചിനുകൾ നിർമ്മിച്ച് ശേഷി കുറയ്ക്കുക.

ഗൈഡിനുള്ളിലെ പതിവ് ചോദ്യങ്ങൾ ചോദ്യം: എല്ലാ GPU തരത്തിനും ഞാൻ എഞ്ചിനുകൾ വീണ്ടും നിർമ്മിക്കേണ്ടതുണ്ടോ? ഉത്തരം: അതെ. എഞ്ചിനുകൾ ഹാർഡ്‌വെയർ-നിർദ്ദിഷ്ടമാണ്. നിങ്ങൾ വിന്യസിക്കുന്ന ഓരോ GPU ആർക്കിടെക്ചറിനുമായി നിർമ്മിക്കുക.

ചോദ്യം: INT8 ഗുണനിലവാരത്തെ എത്രത്തോളം ബാധിക്കും? ഉത്തരം: ഇത് മോഡലിനെയും ടാസ്‌ക്കിനെയും ആശ്രയിച്ചിരിക്കുന്നു. നല്ല കാലിബ്രേഷൻ ഡാറ്റ ഉപയോഗിച്ച്, പല മോഡലുകളും ഗണ്യമായ വേഗത കൈവരിക്കുമ്പോൾ തന്നെ FP16-നോടടുത്ത ഗുണനിലവാരം നിലനിർത്തുന്നു.

ചോദ്യം: എനിക്ക് വലിയ കോൺടെക്സ്റ്റുകൾ (ഉദാഹരണത്തിന്, 32K) പ്രവർത്തിപ്പിക്കാൻ കഴിയുമോ? ഉത്തരം: അതെ, പക്ഷേ മെമ്മറി ശ്രദ്ധാപൂർവ്വം ആസൂത്രണം ചെയ്യുക. പേജ്ഡ് KV കാഷെ ഉപയോഗിച്ച് ബ്ലോക്ക് വലുപ്പങ്ങൾ ട്യൂൺ ചെയ്യുക; വലിയ കോൺടെക്സ്റ്റുകൾ എഞ്ചിൻ്റെ വലുപ്പം കൂട്ടുകയും ഡീകോഡ് ചെലവ് വർദ്ധിപ്പിക്കുകയും ചെയ്യും.

ചോദ്യം: TGI ആവശ്യമാണോ? ഉത്തരം: ഇല്ല. നിങ്ങൾക്ക് Python/C++ നേരിട്ട് പ്രവർത്തിപ്പിക്കാൻ കഴിയും. ഓട്ടോസ്‌കെയിലിംഗും ലോഗിംഗുമുള്ള പ്രൊഡക്ഷൻ-ഗ്രേഡ് HTTP API-കൾക്ക് TGI സൗകര്യപ്രദമാണ്.

വർക്ക്ഫ്ലോ വേഗത്തിലാക്കാൻ ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങൾ നിങ്ങൾ പ്രോംപ്റ്റുകളിൽ പതിവായി മാറ്റങ്ങൾ വരുത്തുകയാണെങ്കിൽ, എഞ്ചിനുകളിലുടനീളം ഔട്ട്പുട്ടുകൾ താരതമ്യം ചെയ്യുകയാണെങ്കിൽ അല്ലെങ്കിൽ പരീക്ഷണങ്ങൾ രേഖപ്പെടുത്തുകയാണെങ്കിൽ, വേഗത്തിൽ വീണ്ടും ശ്രമിക്കാനും, കോഡ് ബ്ലോക്ക് എക്സിക്യൂഷനും, വെബ് സ്നിപ്പറ്റുകളും പിന്തുണയ്ക്കുന്ന ഒരു AI അസിസ്റ്റൻ്റ് നിങ്ങളുടെ ലൂപ്പ് വേഗത്തിലാക്കാൻ സഹായിക്കും. വഴിയിൽ, Sider.AI എഞ്ചിനീയർമാർക്കായി ട്യൂൺ ചെയ്ത ഒരു ഡെസ്‌ക്‌ടോപ്പ് അനുഭവം വാഗ്ദാനം ചെയ്യുന്നു—ബെഞ്ച്മാർക്കുകൾ എടുക്കുന്നതിനും, പ്രോംപ്റ്റുകൾ പരീക്ഷിക്കുന്നതിനും, നിങ്ങളുടെ TensorRT-LLM പൈപ്പ്‌ലൈൻ ഒപ്റ്റിമൈസ് ചെയ്യുമ്പോൾ നിങ്ങളുടെ കുറിപ്പുകൾ ഓർഗനൈസ് ചെയ്യുന്നതിനും ഇത് ഉപയോഗപ്രദമാണ്.

അടുത്ത ഘട്ടങ്ങൾ

നിങ്ങളുടെ പരിസ്ഥിതി സാധൂകരിക്കുന്നതിന് ഔദ്യോഗിക ക്വിക്ക് സ്റ്റാർട്ട് വായിക്കുക.

പിന്തുണാ മാട്രിക്സിൽ CUDA/TensorRT അനുയോജ്യത ഉറപ്പാക്കുക.

എഞ്ചിൻ നിർമ്മാണ ഗൈഡ് പിന്തുടർന്ന് ആദ്യം FP16 തിരഞ്ഞെടുക്കുക.

TGI വഴി സേവനം നൽകുകയാണെങ്കിൽ, എഞ്ചിനുകൾ മുൻകൂട്ടി കംപൈൽ ചെയ്ത് TRT-LLM ബാക്കെൻഡ് കോൺഫിഗർ ചെയ്യുക.

Hugging Face മോഡലുകൾക്കായുള്ള ട്യൂട്ടോറിയൽ-ശൈലിയിലുള്ള വിശദീകരണം BLOOM പോലെ തിരഞ്ഞെടുക്കുക.

പ്രധാന കാര്യങ്ങൾ

പരമാവധി ത്രൂപുട്ടിനും കുറഞ്ഞ ലേറ്റൻസിക്കും TensorRT-LLM നിങ്ങളുടെ Transformer-നെ GPU-നേറ്റീവ് എഞ്ചിനായി കംപൈൽ ചെയ്യുന്നു.

FP16-ൽ ആരംഭിച്ച്, പേജ്ഡ് KV കാഷെ പ്രവർത്തനക്ഷമമാക്കി അളക്കുക. കൂടുതൽ വേഗതയ്ക്കായി INT8/FP8 എന്നിവ പര്യവേക്ഷണം ചെയ്യുക.

എഞ്ചിനുകൾ GPU-യെയും കോൺഫിഗറേഷനെയും ആശ്രയിച്ചിരിക്കുന്നു; ഓരോ വിന്യാസ ലക്ഷ്യത്തിനും നിർമ്മിക്കുക.

പ്രൊഡക്ഷനായി, എഞ്ചിനുകളെ ശക്തമായ സെർവിംഗ് ലെയറുമായി (ഉദാഹരണത്തിന്, TGI) ജോടിയാക്കുക, TTFT, ത്രൂപുട്ട്, ഗുണനിലവാരം എന്നിവ നിരീക്ഷിക്കുക.

പതിവ് ചോദ്യങ്ങൾ

Q1: TensorRT-LLM ശരിയായ രീതിയിൽ എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്ത് സജ്ജീകരിക്കാം? യോജിച്ച CUDA/TensorRT ഉള്ള ഒരു കണ്ടെയ്നർ ഉപയോഗിക്കുക അല്ലെങ്കിൽ പതിപ്പ് വ്യതിയാനം ഒഴിവാക്കാൻ ഔദ്യോഗിക ക്വിക്ക് സ്റ്റാർട്ടും പിന്തുണാ മാട്രിക്സും പിന്തുടരുക. എഞ്ചിനുകൾ കംപൈൽ ചെയ്യുന്നതിന് മുമ്പ് GPU ഡ്രൈവറുകളും നിർമ്മാണ ഉപകരണങ്ങളും പരിശോധിക്കുക.

Q2: Hugging Face മോഡലുകൾക്കൊപ്പം TensorRT-LLM എങ്ങനെ ഉപയോഗിക്കാം? എഞ്ചിൻ നിർമ്മിക്കുന്നതിന് മുമ്പ് മോഡലും ടോക്കണൈസറും ഡൗൺലോഡ് ചെയ്യുക, പിന്തുണ ഉറപ്പാക്കുക, ആവശ്യമെങ്കിൽ മാറ്റുക. TGI ഉപയോഗിച്ച് സേവനം നൽകുകയാണെങ്കിൽ, നിങ്ങളുടെ GPU-യ്‌ക്കായി എഞ്ചിനുകൾ കംപൈൽ ചെയ്‌ത് ബാക്കെൻഡിനെ എഞ്ചിൻ ഡയറക്‌ടറിയിലേക്ക് പോയിന്റ് ചെയ്യുക.

Q3: TensorRT-LLM-നായി ഞാൻ FP16, FP8 അല്ലെങ്കിൽ INT8 തിരഞ്ഞെടുക്കേണ്ടതുണ്ടോ? സ്ഥിരതയ്ക്കായി FP16-ൽ ആരംഭിച്ച്, ത്രൂപുട്ട് വർദ്ധിപ്പിക്കുന്നതിന് FP8/INT8 പരീക്ഷിക്കുക. ക്വാണ്ടിസേഷന് ശേഷം ടാസ്‌ക് കൃത്യത എപ്പോഴും സാധൂകരിക്കുക.

Q4: എനിക്ക് HTTP വഴി TensorRT-LLM നൽകാൻ കഴിയുമോ? ഉത്തരം: അതെ. നിങ്ങൾക്ക് Python/C++ നേരിട്ട് ഉപയോഗിക്കാം അല്ലെങ്കിൽ സ്ട്രീമിംഗോടുകൂടിയ സ്കെയിലബിൾ, പ്രൊഡക്ഷൻ-റെഡി API-കൾക്കായി Hugging Face TGI-യുടെ TRT-LLM ബാക്കെൻഡ് വഴി നൽകാം.

Q5: TensorRT-LLM ഉപയോഗിക്കുമ്പോൾ സാധാരണയായി ഉണ്ടാകുന്ന പ്രകടന പ്രശ്നങ്ങൾ എന്തൊക്കെയാണ്? ടോക്കണൈസർ ഓവർഹെഡ്, ഒപ്റ്റിമൽ അല്ലാത്ത ബാച്ചിംഗ്, പേജ്ഡ് KV കാഷെയുടെ അഭാവം എന്നിവയാണ് സാധാരണ പ്രശ്നങ്ങൾ. ബാച്ച് വലുപ്പങ്ങൾ ട്യൂൺ ചെയ്യുക, CUDA ഗ്രാഫുകൾ പ്രവർത്തനക്ഷമമാക്കുക, മൊത്തത്തിലുള്ള ടോക്കണുകൾ-പെർ-സെക്കൻഡിനെ അപേക്ഷിച്ച് TTFT നിരീക്ഷിക്കുക.