ಪರಿಚಯ: TensorRT-LLM ನಿಮ್ಮ ವಾರಾಂತ್ಯದ ನಿರ್ಮಾಣಕ್ಕೆ ಏಕೆ ಯೋಗ್ಯವಾಗಿದೆ
ನಿಮ್ಮ LLM ನಿಧಾನವಾಗಿ ಚಲಿಸುವಾಗ ನಿಮ್ಮ GPU 60% ಬಳಕೆಯಲ್ಲಿ ಕುಳಿತಿರುವದನ್ನು ನೀವು ಎಂದಾದರೂ ಗಮನಿಸಿದರೆ, ಟೇಬಲ್ ಮೇಲೆ ಉಚಿತ ಕಾರ್ಯಕ್ಷಮತೆ ಉಳಿದಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ. TensorRT-LLM ಆ ಜಾಗವನ್ನು ಥ್ರೂಪುಟ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ: ಫ್ಯೂಸ್ಡ್ ಕರ್ನಲ್ಸ್, ಪೇಜ್ಡ್ ಅಟೆನ್ಶನ್, ಕ್ವಾಂಟೈಸೇಶನ್ ಮತ್ತು ಗ್ರಾಫ್-ಲೆವೆಲ್ ಆಪ್ಟಿಮೈಸೇಶನ್ಗಳು ಲೇಟೆನ್ಸಿಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಟೋಕನ್ಗಳನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಈ ಹೇಗೆ-ಮಾಡಬೇಕೆಂದು ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ನಾವು ಅನುಸ್ಥಾಪನೆಯಿಂದ ಎಂಜಿನ್ ಬಿಲ್ಡ್ನಿಂದ ಸರ್ವಿಂಗ್ವರೆಗೆ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಳ್ಳುತ್ತೇವೆ - ಇದರಿಂದ ನೀವು NVIDIA GPU ಗಳಲ್ಲಿ ವೇಗವಾಗಿ, ಅಗ್ಗದ ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ವಿಶ್ವಾಸದಿಂದ ನಿಯೋಜಿಸಬಹುದು.
ಈ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಪ್ರಾಯೋಗಿಕ ಮತ್ತು ಪರಿಹಾರ-ಆಧಾರಿತ ಶೈಲಿಯಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ನಾವು ಪ್ರಶ್ನೆ-ನೇತೃತ್ವದ ರಚನೆಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದರಲ್ಲಿ ನಕಲಿಸಬಹುದಾದ ಕಮಾಂಡ್ಗಳು, ಸಾಮಾನ್ಯ ತೊಂದರೆಗಳು ಮತ್ತು FP16 vs INT8, ಬ್ಯಾಚಿಂಗ್ ಮತ್ತು KV ಕ್ಯಾಶ್ ತಂತ್ರಗಳಿಗಾಗಿ ನಿರ್ಧಾರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಸೂಕ್ತವಾದ ಕಡೆಗಳಲ್ಲಿ ಆಳವಾದ ಅಧ್ಯಯನಕ್ಕಾಗಿ ಅಧಿಕೃತ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಹ ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ.
ನೀವು ಏನು ಕಲಿಯುವಿರಿ
- TensorRT-LLM ಗಾಗಿ ಪರಿಸರವನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು
- ಎಂಜಿನ್ ನಿರ್ಮಾಣಕ್ಕಾಗಿ ಮಾಡೆಲ್ ಅನ್ನು ಹೇಗೆ ಸಿದ್ಧಪಡಿಸುವುದು (Hugging Face ಅಥವಾ ಚೆಕ್ಪಾಯಿಂಟ್ಗಳಿಂದ)
- FP16/INT8 ಎಂಜಿನ್ಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೇಗೆ ಟ್ಯೂನ್ ಮಾಡುವುದು
- Python/C++ ಮತ್ತು HTTP ಸರ್ವಿಂಗ್ ಮೂಲಕ ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸುವುದು
- ಬೆಂಚ್ಮಾರ್ಕ್, ಬ್ಯಾಚ್ ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವುದು ಹೇಗೆ
ಇದು ಯಾರಿಗೆ
- ML ಇಂಜಿನಿಯರ್ಗಳು NVIDIA GPU ಗಳಲ್ಲಿ LLM ಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತಿದ್ದಾರೆ
- ಉತ್ಪಾದನೆಯಲ್ಲಿ ವೆಚ್ಚ/ವಿಳಂಬವನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸುವ ತಜ್ಞರು
- PyTorch ಟ್ರಾನ್ಸ್ಫಾರ್ಮರ್ಗಳಿಂದ ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ಡ್ ಇನ್ಫರೆನ್ಸ್ಗೆ ಚಲಿಸುವ ಬಿಲ್ಡರ್ಗಳು
- TensorRT-LLM ಎಂದರೇನು ಮತ್ತು ನೀವು ಅದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು?
TensorRT-LLM ಒಂದು ಇನ್ಫರೆನ್ಸ್ ಸ್ಟಾಕ್ ಆಗಿದ್ದು ಅದು ಟ್ರಾನ್ಸ್ಫಾರ್ಮರ್ ಮಾದರಿಗಳನ್ನು ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ಡ್ GPU “ಎಂಜಿನ್”ಗಳಾಗಿ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ. ಕಚ್ಚಾ 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 ಬೆಂಬಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಮತ್ತು ಬಿಡುಗಡೆ ಟಿಪ್ಪಣಿಗಳನ್ನು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಿ.
ತ್ವರಿತ-ಪ್ರಾರಂಭದ ಆಯ್ಕೆಗಳು
- ಕಂಟೈನರೈಸ್ಡ್: ಮೊದಲೇ ಸ್ಥಾಪಿಸಲಾದ CUDA/TensorRT ಯೊಂದಿಗೆ NVIDIA ಯ ಕಂಟೈನರ್ಗಳನ್ನು ಬಳಸಿ - ಆವೃತ್ತಿಯ ಹೊಂದಾಣಿಕೆ ತಪ್ಪಿಸಲು ವೇಗವಾದ ಮಾರ್ಗವಾಗಿದೆ.
- ಸ್ಥಳೀಯ ಅನುಸ್ಥಾಪನೆ: ಬೇಸ್ TensorRT ಗಾಗಿ ಅಧಿಕೃತ ತ್ವರಿತ ಪ್ರಾರಂಭವನ್ನು ಅನುಸರಿಸಿ, ನಂತರ ಅದರ ಮೇಲೆ TensorRT-LLM ಅನ್ನು ಲೇಯರ್ ಮಾಡಿ.
- ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಸಿದ್ಧಗೊಳಿಸುವುದು (Hugging Face → TensorRT-LLM)
ಸಾಮಾನ್ಯ ಮೂಲಗಳು
- Hugging Face: Llama/Mistral/BLOOM ರೂಪಾಂತರಗಳು
- ಸ್ಥಳೀಯ ಚೆಕ್ಪಾಯಿಂಟ್ಗಳು: ಕಸ್ಟಮ್ ಫೈನ್-ಟ್ಯೂನ್ಗಳು
ತಯಾರಿ ಪರಿಶೀಲನಾಪಟ್ಟಿ
- ಮಾದರಿ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು TensorRT-LLM ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿ.
- ಮಾದರಿ ತೂಕ ಮತ್ತು ಟೋಕನೈಜರ್ ಅನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಿ.
- ಅಗತ್ಯವಿದ್ದರೆ, ಸೇಫ್ಟೆನ್ಸರ್ಗಳನ್ನು ನಿರೀಕ್ಷಿತ ಸ್ವರೂಪಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ ಅಥವಾ ಯೋಜನೆಯ ಸ್ಕ್ರಿಪ್ಟ್ಗಳ ಮೂಲಕ ONNX ಗೆ ರಫ್ತು ಮಾಡಿ.
ಸಲಹೆ: ಅಧಿಕೃತ ತ್ವರಿತ ಪ್ರಾರಂಭವು ಮಾದರಿಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಲು ಮತ್ತು ಸರಿಯಾದ ಮಧ್ಯಂತರ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. BLOOM ಉದಾಹರಣೆಯೊಂದಿಗೆ ಟ್ಯುಟೋರಿಯಲ್-ಶೈಲಿಯ ವಾಕ್ಥ್ರೂಗಾಗಿ, Hugging Face LLM ಗಳನ್ನು TensorRT-LLM ಗೆ ಪರಿವರ್ತಿಸುವ ಕುರಿತು Dell ನ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ನೋಡಿ.
- TensorRT-LLM ಎಂಜಿನ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು (ವರ್ಕ್ಫ್ಲೋದ ಹೃದಯ)
ನೀವು ತಿಳಿದಿರಬೇಕಾದ ಪರಿಕಲ್ಪನೆಗಳು
- ಎಂಜಿನ್: ಇನ್ಫರೆನ್ಸ್ಗಾಗಿ ನೀವು ಲೋಡ್ ಮಾಡುವ ಕಂಪೈಲ್ಡ್, ಹಾರ್ಡ್ವೇರ್-ಆಪ್ಟಿಮೈಸ್ಡ್ ಕಲಾಕೃತಿ.
- ನಿಖರತೆ: ಬಲವಾದ ಬೇಸ್ಲೈನ್ಗಾಗಿ FP16/BF16; ನಿಖರತೆ ಉಳಿದರೆ ಹೆಚ್ಚಿನ ಥ್ರೂಪುಟ್ಗಾಗಿ INT8 ಅಥವಾ FP8.
- KV ಕ್ಯಾಶ್: ಪೇಜ್ಡ್ KV ಕ್ಯಾಶ್ ಮೆಮೊರಿ ವಿಘಟನೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ದೀರ್ಘ-ಸಂದರ್ಭದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
ಉನ್ನತ-ಮಟ್ಟದ ಹಂತಗಳು
- ಬಿಲ್ಡ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ: ಗರಿಷ್ಠ ಬ್ಯಾಚ್, ಸೀಕ್ವೆನ್ಸ್ ಉದ್ದಗಳು, ನಿಖರತೆ, ಕ್ವಾಂಟೈಸೇಶನ್ ಮತ್ತು GPU ಆರ್ಕಿಟೆಕ್ಚರ್.
- ನಿಮ್ಮ ಮಾದರಿ ಚೆಕ್ಪಾಯಿಂಟ್ಗಳು ಮತ್ತು ಟೋಕನೈಜರ್ಗೆ ಪಾಯಿಂಟ್ ಮಾಡಿ.
- ನಿಮ್ಮ ಗುರಿ GPU (ಗಳಿಗಾಗಿ) ಎಂಜಿನ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ.
ಉಲ್ಲೇಖ: ಅಧಿಕೃತ ಡಾಕ್ಸ್ ಮತ್ತು ಕಾನ್ಫಿಗ್ಗಳೊಂದಿಗೆ ಎಂಜಿನ್ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು. ನೀವು Hugging Face Text Generation Inference (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 ಓವರ್ಹೆಡ್ ಮತ್ತು ಕರ್ನಲ್ ಲಾಂಚ್ ಲೇಟೆನ್ಸಿಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತವೆ.
- ಬಹು-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 ಸಾಮಾನ್ಯವಾಗಿ ಟೋಕನ್ಗೆ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
- ಸರಿಯಾದ-ಗಾತ್ರದ ಎಂಜಿನ್ಗಳು: ಹೆಡ್ರೂಮ್ ತ್ಯಾಜ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಣ್ಣ-ರೂಪ ಮತ್ತು ದೀರ್ಘ-ರೂಪಕ್ಕಾಗಿ ಪ್ರತ್ಯೇಕ ಎಂಜಿನ್ಗಳನ್ನು ನಿರ್ಮಿಸಿ.
- ಮಾರ್ಗದರ್ಶಿಯ ಒಳಗಿರುವ FAQ ಗಳು
ಪ್ರಶ್ನೆ: ಪ್ರತಿ GPU ಪ್ರಕಾರಕ್ಕೂ ನಾನು ಎಂಜಿನ್ಗಳನ್ನು ಪುನರ್ನಿರ್ಮಿಸಬೇಕೇ?
ಉ: ಹೌದು. ಎಂಜಿನ್ಗಳು ಹಾರ್ಡ್ವೇರ್-ನಿರ್ದಿಷ್ಟವಾಗಿವೆ. ನೀವು ನಿಯೋಜಿಸುವ ಪ್ರತಿ GPU ಆರ್ಕಿಟೆಕ್ಚರ್ಗಾಗಿ ನಿರ್ಮಿಸಿ.
ಪ್ರಶ್ನೆ: INT8 ಗುಣಮಟ್ಟವನ್ನು ಎಷ್ಟು ಪರಿಣಾಮ ಬೀರುತ್ತದೆ?
ಉ: ಇದು ಮಾದರಿ ಮತ್ತು ಕಾರ್ಯವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಉತ್ತಮ ಮಾಪನಾಂಕ ನಿರ್ಣಯ ಡೇಟಾದೊಂದಿಗೆ, ಅನೇಕ ಮಾದರಿಗಳು ಗಣನೀಯ ವೇಗವರ್ಧನೆಗಳನ್ನು ನೀಡುವಾಗ ಹತ್ತಿರದ-FP16 ಗುಣಮಟ್ಟವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ.
ಪ್ರಶ್ನೆ: ನಾನು ದೀರ್ಘ ಸಂದರ್ಭಗಳನ್ನು (ಉದಾ., 32K) ಚಲಾಯಿಸಬಹುದೇ?
ಉ: ಹೌದು, ಆದರೆ ಮೆಮೊರಿಯನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಯೋಜಿಸಿ. ಪೇಜ್ಡ್ KV ಕ್ಯಾಶ್ ಬಳಸಿ ಮತ್ತು ಬ್ಲಾಕ್ ಗಾತ್ರಗಳನ್ನು ಟ್ಯೂನ್ ಮಾಡಿ; ದೀರ್ಘ ಸಂದರ್ಭಗಳು ಎಂಜಿನ್ ಹೆಜ್ಜೆಗುರುತನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ ಮತ್ತು ವೆಚ್ಚವನ್ನು ಡಿಕೋಡ್ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಪ್ರಶ್ನೆ: TGI ಅಗತ್ಯವಿದೆಯೇ?
ಉ: ಇಲ್ಲ. ನೀವು Python/C++ ಅನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸಬಹುದು. ಆಟೋಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ಲಾಗಿಂಗ್ನೊಂದಿಗೆ ಉತ್ಪಾದನಾ-ದರ್ಜೆಯ HTTP API ಗಳಿಗಾಗಿ TGI ಅನುಕೂಲಕರವಾಗಿದೆ.
ವರ್ಕ್ಫ್ಲೋ ವೇಗವರ್ಧನೆಗೆ ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು
ನೀವು ಪದೇ ಪದೇ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಪುನರಾವರ್ತಿಸಿದರೆ, ಎಂಜಿನ್ಗಳಾದ್ಯಂತ ಔಟ್ಪುಟ್ಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ ಅಥವಾ ಪ್ರಯೋಗಗಳನ್ನು ದಾಖಲಿಸಿದರೆ, ತ್ವರಿತ ಮರುಪ್ರಯತ್ನಗಳು, ಕೋಡ್ ಬ್ಲಾಕ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಮತ್ತು ವೆಬ್ ಸ್ನಿಪ್ಪೆಟ್ಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಪಕ್ಕ-ಪಕ್ಕದ AI ಸಹಾಯಕವು ನಿಮ್ಮ ಲೂಪ್ ಅನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ. ಮೂಲಕ, Sider.AI ಇಂಜಿನಿಯರ್ಗಳಿಗಾಗಿ ಟ್ಯೂನ್ ಮಾಡಲಾದ ಡೆಸ್ಕ್ಟಾಪ್ ಅನುಭವವನ್ನು ನೀಡುತ್ತದೆ - ಬೆಂಚ್ಮಾರ್ಕ್ಗಳನ್ನು ಸೆರೆಹಿಡಿಯಲು, ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿಮ್ಮ TensorRT-LLM ಪೈಪ್ಲೈನ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವಾಗ ನಿಮ್ಮ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸಂಘಟಿಸಲು ಸೂಕ್ತವಾಗಿದೆ. ಮುಂದಿನ ಹಂತಗಳ ಪರಿಶೀಲನಾಪಟ್ಟಿ
- ನಿಮ್ಮ ಪರಿಸರವನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಅಧಿಕೃತ ತ್ವರಿತ ಪ್ರಾರಂಭವನ್ನು ಓದಿ.
- ಬೆಂಬಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ನಲ್ಲಿ CUDA/TensorRT ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿ.
- ಎಂಜಿನ್-ಬಿಲ್ಡಿಂಗ್ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಅನುಸರಿಸಿ ಮತ್ತು ಮೊದಲು FP16 ಅನ್ನು ಆರಿಸಿ.
- TGI ಮೂಲಕ ಸೇವೆ ಸಲ್ಲಿಸುತ್ತಿದ್ದರೆ, ಎಂಜಿನ್ಗಳನ್ನು ಪ್ರಿಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು TRT-LLM ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ.
- ಐಚ್ಛಿಕವಾಗಿ, BLOOM ನಂತಹ Hugging Face ಮಾದರಿಗಳಿಗಾಗಿ ಟ್ಯುಟೋರಿಯಲ್-ಶೈಲಿಯ ವಾಕ್ಥ್ರೂ ಅನ್ನು ಪರಿಶೀಲಿಸಿ.
ಪ್ರಮುಖ ಅಂಶಗಳು
- TensorRT-LLM ನಿಮ್ಮ ಟ್ರಾನ್ಸ್ಫಾರ್ಮರ್ ಅನ್ನು ಗರಿಷ್ಠ ಥ್ರೂಪುಟ್ ಮತ್ತು ಕಡಿಮೆ ಲೇಟೆನ್ಸಿಗಾಗಿ GPU-ಸ್ಥಳೀಯ ಎಂಜಿನ್ಗೆ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ.
- FP16 ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ, ಪೇಜ್ಡ್ KV ಕ್ಯಾಶ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ಮತ್ತು ಅಳೆಯಿರಿ. ನಂತರ ಹೆಚ್ಚಿನ ವೇಗಕ್ಕಾಗಿ INT8/FP8 ಅನ್ನು ಅನ್ವೇಷಿಸಿ.
- ಎಂಜಿನ್ಗಳು GPU- ಮತ್ತು ಕಾನ್ಫಿಗ್-ನಿರ್ದಿಷ್ಟವಾಗಿವೆ; ನಿಯೋಜನೆ ಗುರಿಯ ಪ್ರಕಾರ ನಿರ್ಮಿಸಿ.
- ಉತ್ಪಾದನೆಗಾಗಿ, ಎಂಜಿನ್ಗಳನ್ನು ದೃಢವಾದ ಸರ್ವಿಂಗ್ ಲೇಯರ್ನೊಂದಿಗೆ ಜೋಡಿಸಿ (ಉದಾ., TGI) ಮತ್ತು TTFT, ಥ್ರೂಪುಟ್ ಮತ್ತು ಗುಣಮಟ್ಟವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ.
FAQ
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 ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ.
