LLM Inference Engines விளக்கம்: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch மற்றும் LiteRT-LM

ஒரு மாடல் கோப்பு தானாகவே எதையும் செய்வதில்லை. அது எண்களின் ஒரு பெரிய குவியல்; மற்றொரு புரோகிராம்தான் அந்த எண்களை ஏற்றி, உரையை உள்ளீடாக வழங்கி, விடைகளைப் பெற வேண்டும். அந்த புரோகிராம் அழைக்கப்படுவது ஒரு inference engine, மேலும் சரியான ஒன்றைத் தேர்ந்தெடுப்பது மாடலைத் தேர்ந்தெடுப்பதைப் போலவே முக்கியமானது.

இன்று நவம்பர் 12, 2026. கட்டண AI சேவைகள் செய்யக்கூடிய அளவிற்கு திறந்தநிலை மாடல்கள் (open models) இப்போது நெருங்கி வந்துவிட்டன, மேலும் தனியுரிமை, செலவு அல்லது ஆஃப்லைன் பயன்பாட்டிற்காக பல குழுக்கள் அவற்றை தங்கள் சொந்த வன்பொருளில் இயக்க விரும்புகின்றன. அப்போது அவர்கள் விசித்திரமான பெயர்களின் பட்டியலை எதிர்கொள்கிறார்கள்: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM. இந்தக் கருவிக் குடும்பம் எவ்வாறு அழைக்கப்படுகிறது, ஒவ்வொன்றும் ஏன் உருவாக்கப்பட்டது, மற்றும் நமது உதாரணப் பொறியாளரான Rohit எப்போது எதைத் தேர்ந்தெடுப்பார் என்பதை இந்தப் பதிவு விளக்குகிறது.

இந்தக் கருவிகளை நாம் எவ்வாறு அழைக்கிறோம்

இதன் பொதுவான பெயர் LLM inference engines. இவை model runtimes, serving engines அல்லது serving frameworks என்றும் அழைக்கப்படுவதை நீங்கள் காண்பீர்கள். சில விரைவான விளக்கங்கள்:

• Inference என்பது பதில்களை உருவாக்க ஒரு பயிற்றுவிக்கப்பட்ட மாடலைப் பயன்படுத்துவதைக் குறிக்கிறது. Training என்பது மாடலுக்குக் கற்றுக்கொடுக்கிறது; inference என்பது அதனிடம் கேள்விகள் கேட்பதாகும்.
• Serving என்பது ஒரு மாடலை ஒரு சேவையாக, பொதுவாக ஒரு HTTP API ஆக இயக்குவதைக் குறிக்கிறது; இதன் மூலம் பல பயனர்கள் அல்லது செயலிகள் அதை ஒரே நேரத்தில் அழைக்க முடியும்.
• Runtime என்பது CPU, GPU அல்லது போன் சிப்பில் கணக்கீடுகளைச் செய்யும் அடிமட்டக் குறியீடு (low-level code) ஆகும்.

பட்டியலில் உள்ள ஆறு கருவிகளும் ஒரே மாடல் எடைகளை (model weights) எடுத்துக்கொண்டு அவற்றை விடைகளாக மாற்றுகின்றன. அவை எங்கு சிறப்பாக இயங்குகின்றன (லேப்டாப், பெரிய GPU சர்வர் அல்லது போன்), ஒரே நேரத்தில் எத்தனை பயனர்களைக் கையாள்கின்றன, மற்றும் அவற்றுக்கு எவ்வளவு நினைவகம் தேவைப்படுகிறது என்பதில் வேறுபடுகின்றன.

என்ஜின் ஏன் இவ்வளவு முக்கியமானது

பயன்படுத்தப்படும் என்ஜினைப் பொறுத்து, அதே மாடல் மிக வேகமாகவோ அல்லது வேதனை தரும் அளவுக்கு மெதுவாகவோ செயல்படலாம். அதை மூன்று விஷயங்கள் தீர்மானிக்கின்றன:

1. Memory. ஒரு மாடல் RAM அல்லது GPU நினைவகத்தில் பொருந்த வேண்டும். சில என்ஜின்கள் quantization-ஐ ஆதரிக்கின்றன; இது எண்களைக் குறைந்த பிட்களில் சேமிக்கிறது (உதாரணமாக 16 பிட்டுகளுக்குப் பதிலாக 4 பிட்கள்). மாடல் சுமார் மூன்று முதல் நான்கு மடங்கு சிறியதாகி, தரத்தில் சிறிய இழப்புடன் குறைந்த விலையுள்ள வன்பொருளில் இயங்குகிறது.
2. Throughput. பல பயனர்களுக்கு ஒரே நேரத்தில் என்ஜினால் ஒரு வினாடிக்கு எத்தனை பதில்களை உருவாக்க முடியும் என்பதே இதுவாகும். சர்வர் என்ஜின்கள் continuous batching (புதிய கோரிக்கைகள் தங்கள் முறைக்காகக் காத்திருக்காமல், இயங்கிக் கொண்டிருக்கும் தொகுப்பில் இணைந்துகொள்வது) போன்ற உத்திகளைப் பயன்படுத்தி GPU-வை சுறுசுறுப்பாக வைத்திருக்கின்றன.
3. Latency. ஒரு பயனர் முதல் வார்த்தையை எவ்வளவு விரைவாகப் பார்க்கிறார் என்பதே இதுவாகும். உரையாடலுக்கு (chat) வெறும் throughput-ஐ விட இதுவே மிகவும் முக்கியமானது.

தவறான தேர்வு அதிக செலவை ஏற்படுத்தும். Rohit அதிக விலையுள்ள GPU-வை வாடகைக்கு எடுத்து சில பயனர்களுக்கு மட்டுமே சேவை செய்ய நேரிடலாம், அல்லது லேப்டாப்பில் ஒருபோதும் பொருந்தாத ஒரு மாடலை ஏற்ற முயற்சித்துக் கொண்டிருக்கலாம்.

ஆறு என்ஜின்கள், ஒவ்வொன்றாக

llama.cpp: கிட்டத்தட்ட எங்கு வேண்டுமானாலும் இயங்கும்

llama.cpp என்பது சாதாரண வன்பொருளில் மாடல்களை இயக்குவதற்காக உருவாக்கப்பட்ட ஒரு C மற்றும் C++ என்ஜின் ஆகும். இது தனக்கென சொந்தமான ஒரு கோப்பு வடிவத்தைப் பயன்படுத்துகிறது, அதுவே GGUFஆகும்; இது ஒரு குவாண்டைஸ் செய்யப்பட்ட மாடலை ஒரே கோப்பில் அடைக்கிறது. இது சாதாரண CPU-க்கள், Apple Silicon, NVIDIA மற்றும் AMD GPU-க்கள் உள்ளிட்ட பலவற்றில் இயங்குகிறது. Ollama மற்றும் LM Studio போன்ற பிரபலமான டெஸ்க்டாப் கருவிகள் இதன் மேல் கட்டமைக்கப்பட்டுள்ளன.

Practical example. Rohit வாடிக்கையாளர்களின் ஒப்பந்தங்களை மதிப்பாய்வு செய்யும் ஒரு ஆலோசகர்; அவற்றை ஒரு பொது சாட்போட்டில் அவரால் ஒட்ட முடியாது. llama.cpp மூலம் அவர் தனது லேப்டாப்பில் முற்றிலும் ஆஃப்லைனில் ஒரு சிறிய குவாண்டைஸ் செய்யப்பட்ட மாடலை இயக்குகிறார், மேலும் எந்த உரையும் கணினியை விட்டு வெளியேறாமல் ஆவணங்களைச் சுருக்கமாகத் தொகுக்கிறார்.

# Start a local OpenAI-compatible server on port 8080
llama-server -m ./models/example-model-Q4_K_M.gguf --port 8080

vLLM: the workhorse for GPU servers

vLLM என்பது ஒரே நேரத்தில் பல பயனர்களுக்கு GPU-களில் மாடல்களை வழங்குவதற்கான ஒரு Python என்ஜின் ஆகும். இதன் முக்கிய யோசனை PagedAttentionஆகும். பதிலளிக்கும் போது, ஒரு மாடல் முந்தைய டோக்கன்களின் தற்காலிகப் பதிவேடு ஒன்றை வைத்திருக்கிறது, இது KV cacheஎன்று அழைக்கப்படுகிறது. ஓர் இயங்குதளம் நினைவகத்தை நிர்வகிப்பது போலவே vLLM அந்தத் தற்காலிகப் பதிவேட்டைச் சிறிய பக்கங்களாகச் சேமிக்கிறது; இதனால் மிகக் குறைந்த GPU நினைவகமே வீணாகிறது மற்றும் ஒரே நேரத்தில் மிக அதிகமான கோரிக்கைகளுக்கு இடமளிக்க முடிகிறது. continuous batching உடன் இணைந்து, இது ஒரு GPU பல பயனர்களுக்குச் சேவை செய்ய அனுமதிக்கிறது.

Practical example. Rohit-இன் நிறுவனமான Acme, 300 பணியாளர்களுக்காக ஒரு உள்நாட்டு உதவியாளரை (internal assistant) விரும்புகிறது. ஒவ்வொரு கேள்விக்கும் கட்டண API-ஐ அழைப்பது அதிக செலவை ஏற்படுத்துகிறது, மேலும் சில தரவுகள் நிறுவனத்திற்குள்ளேயே இருக்க வேண்டும். Rohit ஒரு GPU சர்வரில் vLLM-ஐ நிறுவுகிறார், மேலும் அது OpenAI-க்கு இணக்கமான API-ஐ வழங்குவதால், ஏற்கனவே உள்ள சாட் செயலிக்கு ஒரு புதிய base URL மட்டுமே தேவைப்படுகிறது.

vllm serve example-org/example-model --port 8000

SGLang: fast for agents and repeated prompts

SGLang என்பது மற்றொரு உயர் செயல்திறன் கொண்ட serving என்ஜின் ஆகும். ஒரு நீண்ட system prompt, பகிரப்பட்ட ஆவணம் அல்லது ஒரு உரையாடலின் முந்தைய பகுதிகள் என பல கோரிக்கைகள் ஒரே தொடக்கத்தைப் பகிர்ந்து கொள்ளும்போது இது சிறப்பாகச் செயல்படுகிறது. இதன் RadixAttention அந்தப் பகிரப்பட்ட பகுதிகளை கேச் செய்து வைத்துக்கொண்டு, அவற்றை மீண்டும் கணக்கிடுவதற்குப் பதிலாக மறுபயன்பாடு செய்கிறது. மேலும் இது structured output-க்கான வலுவான ஆதரவையும் கொண்டுள்ளது, அதாவது விடைகள் செல்லுபடியாகும் JSON அல்லது ஒரு நிலையான வடிவத்திற்குள் அமையுமாறு கட்டாயப்படுத்தப்படுகின்றன.

Practical example. Rohit ஆதரவு டிக்கெட்டுகளை வகைப்படுத்தும் ஒரு ஏஜென்ட்டை உருவாக்குகிறார். ஒவ்வொரு டிக்கெட்டும் அதே 3,000 வார்த்தைகள் கொண்ட கொள்கை ஆவணத்துடன் அனுப்பப்படுகிறது, மேலும் மாடல் வகை (category) மற்றும் முன்னுரிமை (priority) போன்ற JSON புலங்களுடன் பதிலளிக்க வேண்டும். SGLang டிக்கெட்டுகளுக்கு இடையே கேச் செய்யப்பட்ட கொள்கைப் பகுதியை மறுபயன்பாடு செய்கிறது மற்றும் அவரது குறியீடு பாகுபடுத்தக்கூடிய (parse) வடிவத்தில் வெளியீட்டை வைத்திருக்கிறது.

python -m sglang.launch_server --model-path example-org/example-model --port 30000

mistral.rs: a Rust engine for Rust shops

mistral.rs என்பது Rust மொழியில் எழுதப்பட்ட சமூகத்தால் உருவாக்கப்பட்ட ஒரு inference engine ஆகும். இந்தப் பெயர் இருந்தபோதிலும், இது Mistral AI நிறுவனத்தின் அதிகாரப்பூர்வ தயாரிப்பு அல்ல, மேலும் இது பல மாடல் குடும்பங்களை இயக்குகிறது. இது quantization, OpenAI-இணக்கமான சர்வர் ஆகியவற்றை ஆதரிக்கிறது, மேலும் ஒரு Rust நிரலுக்குள் ஒரு லைப்ரரியாகவும் பயன்படுத்தப்படலாம். Rust நினைவகப் பாதுகாப்பையும் (memory safety), நிர்வகிக்க எந்த Python சூழலும் தேவையில்லாத ஒற்றை தொகுக்கப்பட்ட பைனரியையும் (compiled binary) வழங்குகிறது.

Practical example. Rohit-இன் குழுவிடம் Rust-இல் எழுதப்பட்ட ஒரு பதிவு பகுப்பாய்வுக் கருவி (log-analysis tool) உள்ளது; இது Python-ஐ நிறுவ அனுமதிக்கப்படாத பாதுகாக்கப்பட்ட சர்வர்களில் இயங்குகிறது. mistral.rs மூலம் அவர்கள் "summarise this incident" என்ற அம்சத்தை நேரடியாக அதே பைனரிக்குள் சேர்க்கிறார்கள், எனவே வரிசைப்படுத்தவோ (deploy) அல்லது பேட்ச் செய்யவோ கூடுதல் சேவை எதுவும் தேவையில்லை.

Plain PyTorch: the reference, not the race car

பெரும்பாலான மாடல்கள் உருவாக்கப்பட்டு பயிற்றுவிக்கப்படும் கட்டமைப்பு PyTorch ஆகும். பெரும்பாலும் Hugging Face Transformers லைப்ரரி மற்றும் அதன் generate() function மூலமாக, நேரடி PyTorch கொண்டு ஒரு மாடலை இயக்குவது அதைப் பயன்படுத்துவதற்கான மிக நேரடியான வழியாகும். இதை மாற்றுவதும் பிழைதிருத்தம் (debug) செய்வதும் எளிது; மேலும் புதிய மாடல்கள் பொதுவாக முதலிலேயே அங்கு வேலை செய்கின்றன. இது பல பயனர்களுக்குச் சேவை செய்ய உகந்ததாக மாற்றப்படவில்லை என்பதால், மேலே உள்ள என்ஜின்களை விட இது மெதுவாகவும் அதிக நினைவகத்தைப் பயன்படுத்துவதாகவும் உள்ளது.

Practical example. ஒரு ஃபைன்-டியூன் செய்யப்பட்ட மாடல் சிறப்பாக உள்ளதா என்பதை Rohit சோதிக்கிறார். அவர் அதை நேரடி PyTorch உடன் ஒரு நோட்புக்கில் ஏற்றி, வெவ்வேறு பிராம்ப்டுகளை முயற்சி செய்து, குறியீட்டை மாற்றி முடிவுகளை ஒப்பிடுகிறார். திருப்தி அடைந்தவுடன், தயாரிப்புப் பயன்பாட்டிற்காக (production) அவர் அந்த மாடலை vLLM அல்லது SGLang-க்கு நகர்த்துகிறார்.

Google-இன் LiteRT-LM: போனில் இயங்கும் மாடல்கள்

LiteRT என்பது Google-இன் சாதனத்திலேயே இயங்கும் இயக்கநேரமாகும் (on-device runtime), இது TensorFlow Lite-இன் புதிய பெயராகும். LiteRT-LM என்பது Gemma போன்ற மொழி மாடல்களை போன்கள், உலாவிகள் மற்றும் சிறிய எட்ஜ் சாதனங்களில் இயக்குவதற்கான அதன் அடுக்கு ஆகும். இது குறைந்த நினைவகம், பேட்டரி ஆயுள் மற்றும் மொபைல் சிப்புகளுக்காக உருவாக்கப்பட்டுள்ளது, மேலும் நெட்வொர்க் இணைப்பு மற்றும் சர்வர் கட்டணம் எதுவுமின்றி ஒரு செயலி AI-ஐ இயக்க இது அனுமதிக்கிறது.

Practical example. அடிக்கடி சிக்னல் கிடைக்காத தொழில்நுட்ப வல்லுநர்களுக்காக Rohit ஒரு கள ஆய்வு (field-inspection) Android செயலியை உருவாக்குகிறார். போனில் LiteRT-LM மற்றும் ஒரு சிறிய Gemma மாடலைக் கொண்டு, அந்தச் செயலி பேசும் குறிப்புகளை ஆஃப்லைனில் ஒரு தெளிவான அறிக்கையாக மாற்றுகிறது, மேலும் அந்தத் தரவு ஒருபோதும் சாதனத்தை விட்டு வெளியேறாது.

Rohit எவ்வாறு ஒன்றைத் தேர்ந்தெடுக்கிறார்: ஒரு எளிய முடிவெடுக்கும் வழிகாட்டி

படி 1: மாடல் எங்கு இயங்கும் என்பதைத் தீர்மானிக்கவும்

ஒரு போன் அல்லது சிறிய சாதனத்தில், LiteRT-LM உடன் தொடங்குங்கள். ஒரு லேப்டாப் அல்லது CPU மட்டுமே உள்ள சர்வரில், llama.cpp உடன் தொடங்குங்கள். GPU சர்வர்களில், vLLM அல்லது SGLang-ஐப் பாருங்கள். ஒரு Rust நிரலுக்குள், mistral.rs-ஐக் கருத்தில் கொள்ளுங்கள்.

படி 2: பயனர்களின் எண்ணிக்கையைக் கணக்கிடுங்கள்

ஒரு நபர் அல்லது ஒரு சிலர் மட்டுமே என்றால்: llama.cpp எளிமையானது மற்றும் போதுமானது. ஒரே நேரத்தில் டஜன் கணக்கான அல்லது நூற்றுக்கணக்கான பயனர்கள் என்றால்: vLLM அல்லது SGLang, ஏனெனில் batching முறையே ஒரு பதிலுக்கான செலவைக் குறைவாக வைத்திருக்கிறது.

படி 3: பணிச்சுமையின் தன்மையைக் கவனியுங்கள்

பகிரப்பட்ட பல பிராம்ப்டுகள், ஏஜென்ட்கள் அல்லது துல்லியமான JSON வெளியீடு போன்றவை தேவைப்பட்டால் SGLang-ஐத் தேர்ந்தெடுக்கவும். பொதுவான சாட் மற்றும் API டிராஃபிக் என்றால் vLLM-ஐத் தேர்ந்தெடுக்கவும். சோதனைகள் மற்றும் ஆராய்ச்சிகளுக்கு நேரடி PyTorch-ஐப் பயன்படுத்தவும்.

படி 4: உங்கள் சொந்த வன்பொருளில் சோதிக்கவும்

வெளியிடப்பட்ட செயல்திறன் எண்கள் GPU, மாடல் மற்றும் அமைப்புகளைப் பொறுத்து மாறுபடும். தீர்மானிப்பதற்கு முன், பரிசீலனையில் உள்ள இரண்டு என்ஜின்களுடன் உங்கள் சொந்த கணினியில் உங்கள் சொந்த பிராம்ப்டுகளை இயக்கி, முதல் வார்த்தைக்கான நேரம், வினாடிக்கு வார்த்தைகள் மற்றும் நினைவக பயன்பாடு ஆகியவற்றை அளவிடுங்கள்.

முடிவுரை

llama.cpp, vLLM, SGLang, mistral.rs, PyTorch மற்றும் LiteRT-LM ஆகிய அனைத்தும் ஒரே அடிப்படை வேலையைச் செய்கின்றன: அவை ஒரு பயிற்றுவிக்கப்பட்ட மாடலை இயக்கி, உள்ளீட்டை பதில்களாக மாற்றுகின்றன. இந்தக் குடும்பம் LLM inference engines என்று அழைக்கப்படுகிறது. அவை எங்கு இயங்குகின்றன மற்றும் யாருக்குச் சேவை செய்கின்றன என்பதே அவற்றை வேறுபடுத்துகிறது: லேப்டாப்கள் மற்றும் சிறிய சர்வர்களுக்கு llama.cpp, அதிக பணிச்சுமை கொண்ட GPU சர்வர்களுக்கு vLLM மற்றும் SGLang, Rust சார்ந்த செயலிகளுக்கு mistral.rs, சோதனைகளுக்கு PyTorch, மற்றும் போன்கள் மற்றும் எட்ஜ் சாதனங்களுக்கு LiteRT-LM. மாடலைத் தேர்ந்தெடுப்பதைப் போலவே என்ஜினையும் கவனமாகத் தேர்ந்தெடுங்கள்.

நன்மைகள்

• திறந்தநிலை மாடல்களை நீங்களே இயக்குவது முக்கியமான தரவை நிறுவனத்திற்குள்ளேயே வைத்திருக்க உதவுகிறது மற்றும் முற்றிலும் ஆஃப்லைனிலும் செயல்பட முடிகிறது.
• llama.cpp மற்றும் mistral.rs ஆகியவற்றில் உள்ள Quantization திறன்மிக்க மாடல்களை சாதாரண லேப்டாப்களிலேயே இயக்க அனுமதிக்கிறது.
• vLLM மற்றும் SGLang ஆகியவை ஒரே GPU-விலிருந்து பல பயனர்களுக்குச் சேவை செய்து, ஒரு பதிலுக்கான செலவைக் குறைக்கின்றன.
• OpenAI-இணக்கமான API-கள் ஒரு கட்டணச் சேவையிலிருந்து மாறுவதை ஒரு சிறிய குறியீட்டு மாற்றமாக மாற்றுகின்றன.
• LiteRT-LM எந்தவித சர்வர் கட்டணமும் நெட்வொர்க் தேவையும் இன்றி AI அம்சங்களை போன்களுக்குக் கொண்டு வருகிறது.

குறைபாடுகள்

• ஒவ்வொரு என்ஜினுக்கும் கற்றுக் கொள்ள வேண்டிய தனித்தனி அமைப்புமுறை, கொடிகள் (flags) மற்றும் மாடல் வடிவங்கள் உள்ளன.
• சர்வர் என்ஜின்களுக்கு ஆற்றல்வாய்ந்த GPU-க்கள் தேவைப்படுகின்றன; அவற்றை வாங்குவது அல்லது வாடகைக்கு எடுப்பது அதிக செலவாகும்.
• குவாண்டைஸ் செய்யப்பட்ட மாடல்கள் தரத்தில் சிறிதளவு இழப்பைச் சந்திக்கின்றன, மேலும் இந்த இழப்பு மாடல் மற்றும் பணியைப் பொறுத்து மாறுபடும்.
• ஒவ்வொரு என்ஜினும் ஒவ்வொரு புதிய மாடலையும் முதல் நாளிலேயே ஆதரிப்பதில்லை.
• சுய-ஹோஸ்டிங் (Self-hosting) என்பது புதுப்பிப்புகள், பாதுகாப்பு இணைப்புகள் (security patches) மற்றும் கண்காணிப்பு ஆகியவற்றை நீங்களே சொந்தமாக நிர்வகிக்க வேண்டும் என்பதைக் குறிக்கிறது.

எச்சரிக்கை

இந்தக் கட்டுரை கல்வி நோக்கத்திற்கானது மட்டுமே. உதாரணங்களில் உள்ள மாடல் பெயர்கள், போர்ட்கள் (ports) மற்றும் பாதைகள் (paths) ஒதுக்கிடங்கள் (placeholders) மட்டுமே; அவற்றை உங்கள் சொந்த அமைப்புகளுடன் மாற்ற வேண்டும். இந்தத் திட்டங்கள் வேகமாக மாறிவருவதால், நீங்கள் நிறுவும் பதிப்பில் அம்சங்கள், flags மற்றும் ஆதரிக்கப்படும் வன்பொருள்கள் மாறுபடலாம். தயாரிப்பு முடிவுக்காக இங்குள்ள கூற்றுகளை நம்புவதற்கு முன் அதிகாரப்பூர்வ ஆவணங்களைச் சரிபார்த்து உங்கள் சொந்த வன்பொருளில் சோதிக்கவும்.

அடிக்கடி கேட்கப்படும் கேள்விகள்

• LLM inference engine என்றால் என்ன? — இது ஒரு பயிற்றுவிக்கப்பட்ட மொழி மாடலை ஏற்றி, CPU, GPU அல்லது போன் சிப்பில் பதில்களை உருவாக்குவதற்காக அதை இயக்கும் மென்பொருளாகும்.
• llama.cpp சிறந்ததா அல்லது vLLM சிறந்ததா? — இரண்டுமே எல்லா இடங்களிலும் சிறந்தது என்று கூறிவிட முடியாது: லேப்டாப்கள் மற்றும் சிறிய சர்வர்களுக்கு llama.cpp சிறந்தது; GPU சர்வர்களில் பல பயனர்களுக்குச் சேவை செய்வதற்கு vLLM சிறந்தது.
• vLLM மற்றும் SGLang ஆகியவற்றுக்கு இடையேயான வித்தியாசம் என்ன? — இரண்டுமே வேகமான GPU serving என்ஜின்கள் ஆகும்; நீண்ட பிராம்ப்டுகளைப் பகிர்ந்து கொள்ளும் கோரிக்கைகளுக்கு அல்லது JSON போன்ற structured output தேவைப்படும் போது SGLang மிகவும் ஆற்றல் வாய்ந்தது.
• GPU இல்லாமல் என்னால் ஒரு LLM-ஐ இயக்க முடியுமா? — ஆம், GPU-வை விட மெதுவாக இயங்கும் என்றாலும், llama.cpp சாதாரண CPU-களிலேயே குவாண்டைஸ் செய்யப்பட்ட மாடல்களை இயக்குகிறது.
• mistral.rs என்பது Mistral AI நிறுவனத்தால் உருவாக்கப்பட்டதா? — இல்லை, இது Rust மொழியில் எழுதப்பட்ட ஒரு தனிப்பட்ட சமூகத் திட்டம் ஆகும்; இது பல மாடல் குடும்பங்களை இயக்க வல்லது.
• தயாரிப்பில் (production) நேரடியாக PyTorch-ஐ ஏன் பயன்படுத்தக் கூடாது? — நேரடி PyTorch நெகிழ்வானது, ஆனால் பல பயனர்களுக்கு உகந்தவாறு மாற்றப்படவில்லை; எனவே பிரத்யேக என்ஜின்கள் வழக்கமாக அதே வன்பொருளிலிருந்து மிக அதிக வேகத்தை வழங்குகின்றன.
• LiteRT-LM எதற்காகப் பயன்படுத்தப்படுகிறது? — இது Gemma போன்ற மொழி மாடல்களை நேரடியாக போன்கள் மற்றும் எட்ஜ் சாதனங்களில் ஆஃப்லைனில் இயக்குவதற்கான Google-இன் runtime ஆகும்.
• Quantization என்ன செய்கிறது? — இது மாடல் எண்களைக் குறைந்த பிட்களில் சேமிக்கிறது, எனவே மாடல் மிகக் குறைந்த நினைவகத்தைப் பயன்படுத்துகிறது மற்றும் தரத்தில் சிறிய இழப்புடன் குறைந்த விலையுள்ள வன்பொருளில் இயங்குகிறது.

குறிச்சொற்கள்

#llm #inferenceengine #llamacpp #vllm #sglang #mistralrs #pytorch #litertlm #selfhostedai #aiengineering