LLM ഇൻഫറൻസ് എഞ്ചിനുകൾ വിശദീകരിക്കുന്നു: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM

ഒരു മോഡൽ ഫയലിന് സ്വന്തമായി ഒന്നും ചെയ്യാൻ കഴിയില്ല. അതൊരു വലിയ സംഖ്യകളുടെ കൂട്ടമാണ്, ആ നമ്പറുകൾ ലോഡ് ചെയ്യാനും ടെക്സ്റ്റ് നൽകി ഉത്തരങ്ങൾ നേടാനും മറ്റൊരു പ്രോഗ്രാം ആവശ്യമാണ്. ആ പ്രോഗ്രാമിനെ വിളിക്കുന്നത് ഒരു ഇൻഫറൻസ് എഞ്ചിൻഎന്നാണ്, കൂടാതെ ശരിയായ ഒന്ന് തിരഞ്ഞെടുക്കുന്നത് മോഡൽ തിരഞ്ഞെടുക്കുന്നത് പോലെ തന്നെ പ്രധാനമാണ്.

ഇന്ന് 2026 നവംബർ 12 ആണ്. പണമടച്ച് ഉപയോഗിക്കുന്ന AI സേവനങ്ങൾക്ക് തുല്യമായ പ്രകടനം കാഴ്ചവെക്കാൻ ഇന്ന് ഓപ്പൺ മോഡലുകൾക്ക് കഴിയുന്നുണ്ട്, കൂടാതെ സ്വകാര്യത, ചെലവ് അല്ലെങ്കിൽ ഓഫ്‌ലൈൻ ഉപയോഗം എന്നിവയ്ക്കായി പല ടീമുകളും അവ സ്വന്തം ഹാർഡ്‌വെയറിൽ പ്രവർത്തിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു. എന്നാൽ അപ്പോഴാണ് അവർ വിചിത്രമായ ചില പേരുകൾ കാണുന്നത്: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM. ഈ ടൂളുകളുടെ വിഭാഗത്തെ എന്താണ് വിളിക്കുന്നത്, ഓരോന്നും എന്തിനാണ് നിലനിൽക്കുന്നത്, നമ്മുടെ ഉദാഹരണ എഞ്ചിനീയറായ രോഹിത് ഇവയിൽ ഓരോന്നും എപ്പോഴാണ് തിരഞ്ഞെടുക്കുന്നത് എന്ന് ഈ പോസ്റ്റ് വിശദീകരിക്കുന്നു.

ഈ ടൂളുകളെ നമ്മൾ എന്താണ് വിളിക്കുന്നത്

ഇവയുടെ പൊതുവായ പേര് LLM ഇൻഫറൻസ് എഞ്ചിനുകൾഎന്നാണ്. മോഡൽ റൺടൈമുകൾ, സെർവിംഗ് എഞ്ചിനുകൾ അല്ലെങ്കിൽ സെർവിംഗ് ഫ്രെയിംവർക്കുകൾ എന്നും ഇവ അറിയപ്പെടുന്നത് നിങ്ങൾക്ക് കാണാം. ചില ലളിതമായ നിർവചനങ്ങൾ:

• ഇൻഫറൻസ് എന്നാൽ ഉത്തരങ്ങൾ നൽകാൻ പരിശീലിപ്പിച്ച ഒരു മോഡൽ ഉപയോഗിക്കുക എന്നാണ് അർത്ഥമാക്കുന്നത്. ട്രെയിനിംഗ് മോഡലിനെ പഠിപ്പിക്കുന്നു; ഇൻഫറൻസ് എന്നത് അതിനോട് കാര്യങ്ങൾ ചോദിക്കുന്നതാണ്.
• സെർവിംഗ് എന്നാൽ ഒരേസമയം നിരവധി ഉപയോക്താക്കൾക്കോ ആപ്പുകൾക്കോ വിളിക്കാൻ കഴിയുന്ന തരത്തിൽ സാധാരണയായി ഒരു HTTP API ആയി മോഡൽ പ്രവർത്തിപ്പിക്കുന്നതാണ്.
• റൺടൈം എന്നത് CPU, GPU അല്ലെങ്കിൽ ഫോൺ ചിപ്പിൽ കണക്കുകൂട്ടലുകൾ നടത്തുന്ന ലോ-ലെവൽ കോഡാണ്.

പട്ടികയിലുള്ള ആറ് ടൂളുകളും ഒരേ മോഡൽ വെയ്റ്റുകൾ സ്വീകരിച്ച് അവയെ ഉത്തരങ്ങളാക്കി മാറ്റുന്നു. എവിടെയാണ് അവ ഏറ്റവും നന്നായി പ്രവർത്തിക്കുന്നത് (ലാപ്‌ടോപ്പ്, വലിയ GPU സെർവർ അല്ലെങ്കിൽ ഫോൺ), ഒരേസമയം എത്ര ഉപയോക്താക്കളെ കൈകാര്യം ചെയ്യുന്നു, എത്ര മെമ്മറി ആവശ്യമാണ് എന്നിവയിലാണ് അവ വ്യത്യാസപ്പെട്ടിരിക്കുന്നത്.

എഞ്ചിൻ എന്തുകൊണ്ട് ഇത്രയധികം പ്രാധാന്യമർഹിക്കുന്നു

ഉപയോഗിക്കുന്ന എഞ്ചിനെ ആശ്രയിച്ച് ഒരേ മോഡൽ തന്നെ വേഗതയേറിയതോ അല്ലെങ്കിൽ അസഹനീയമായ വിധം മന്ദഗതിയിലുള്ളതോ ആയി അനുഭവപ്പെടാം. മൂന്ന് കാര്യങ്ങളാണ് അത് തീരുമാനിക്കുന്നത്:

1. മെമ്മറി. ഒരു മോഡൽ RAM അല്ലെങ്കിൽ GPU മെമ്മറിയിൽ ഉൾക്കൊള്ളേണ്ടതുണ്ട്. ചില എഞ്ചിനുകൾ ക്വാണ്ടൈസേഷൻപിന്തുണയ്ക്കുന്നു, ഇത് കുറഞ്ഞ ബിറ്റുകളിൽ സംഖ്യകൾ സൂക്ഷിക്കുന്നു (ഉദാഹരണത്തിന് 16 ബിറ്റുകൾക്ക് പകരം 4 ബിറ്റുകൾ). മോഡൽ ഏകദേശം മൂന്ന് മുതൽ നാല് മടങ്ങ് വരെ ചെറുതാവുകയും ഗുണനിലവാരത്തിൽ ചെറിയ വ്യത്യാസത്തോടെ കുറഞ്ഞ ചെലവിലുള്ള ഹാർഡ്‌വെയറിൽ പ്രവർത്തിക്കുകയും ചെയ്യുന്നു.
2. ത്രൂപുട്ട്. നിരവധി ഉപയോക്താക്കൾക്കായി ഒന്നിച്ച് എഞ്ചിന് ഒരു സെക്കൻഡിൽ എത്ര ഉത്തരങ്ങൾ നൽകാൻ കഴിയും എന്നതിനെയാണിത് സൂചിപ്പിക്കുന്നത്. GPU പൂർണ്ണമായും ഉപയോഗപ്പെടുത്താൻ സെർവർ എഞ്ചിനുകൾ കണ്ടിന്യൂവസ് ബാച്ചിംഗ് (പുതിയ അഭ്യർത്ഥനകൾ ഊഴത്തിനായി കാത്തിരിക്കുന്നതിന് പകരം നിലവിൽ പ്രവർത്തിക്കുന്ന ബാച്ചിനൊപ്പം ചേരുന്നു) പോലുള്ള വിദ്യകൾ ഉപയോഗിക്കുന്നു.
3. ലേറ്റൻസി. ഒരു ഉപയോക്താവിന് ആദ്യ വാക്ക് എത്ര വേഗത്തിൽ കാണാൻ കഴിയുന്നു എന്നതിനെയാണിത് സൂചിപ്പിക്കുന്നത്. ചാറ്റിന്റെ കാര്യത്തിൽ റോ ത്രൂപുട്ടിനേക്കാൾ പ്രധാനം ഇതാണ്.

തെറ്റായ ഒരു തിരഞ്ഞെടുപ്പ് വലിയ ചെലവുണ്ടാക്കും. രോഹിത്തിന് വിലകൂടിയ ഒരു GPU വാടകയ്‌ക്കെടുത്തിട്ടും ചുരുക്കം ഉപയോക്താക്കൾക്ക് മാത്രമേ സേവനം നൽകാൻ കഴിഞ്ഞേക്കൂ, അല്ലെങ്കിൽ ലാപ്‌ടോപ്പിൽ ഒരിക്കലും ഒതുങ്ങാത്ത ഒരു മോഡൽ ലോഡ് ചെയ്യാൻ ശ്രമിക്കേണ്ടി വന്നേക്കാം.

ആറ് എഞ്ചിനുകൾ, ഓരോന്നായി

llama.cpp: മിക്കവാറും എവിടെയും പ്രവർത്തിക്കുന്നു

സാധാരണ ഹാർഡ്‌വെയറുകളിൽ മോഡലുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനായി നിർമ്മിച്ച ഒരു C, C++ എഞ്ചിനാണ് llama.cpp. ഇത് സ്വന്തം ഫയൽ ഫോർമാറ്റായ GGUFആണ് ഉപയോഗിക്കുന്നത്, ഇത് ഒരു ക്വാണ്ടൈസ്ഡ് മോഡലിനെ ഒരൊറ്റ ഫയലിലേക്ക് ചുരുക്കുന്നു. സാധാരണ CPU-കൾ, Apple Silicon, NVIDIA, AMD GPU-കൾ എന്നിവയിലും അതിലേറെ കാര്യങ്ങളിലും ഇത് പ്രവർത്തിക്കുന്നു. Ollama, LM Studio പോലുള്ള പ്രശസ്തമായ ഡെസ്ക്ടോപ്പ് ടൂളുകൾ ഇതിനെ അടിസ്ഥാനമാക്കിയാണ് നിർമ്മിച്ചിരിക്കുന്നത്.

പ്രായോഗിക ഉദാഹരണം. ക്ലയന്റ് കരാറുകൾ പരിശോധിക്കുന്ന ഒരു കൺസൾട്ടന്റാണ് രോഹിത്, അവ ഒരു പൊതു ചാറ്റ്ബോട്ടിലേക്ക് പേസ്റ്റ് ചെയ്യാൻ അദ്ദേഹത്തിന് കഴിയില്ല. llama.cpp ഉപയോഗിച്ച് അദ്ദേഹം തന്റെ ലാപ്‌ടോപ്പിൽ പൂർണ്ണമായും ഓഫ്‌ലൈനായി ഒരു ചെറിയ ക്വാണ്ടൈസ്ഡ് മോഡൽ പ്രവർത്തിപ്പിക്കുകയും, മെഷീനിൽ നിന്ന് ഒരു വിവരവും പുറത്തുപോകാതെ തന്നെ രേഖകൾ സംഗ്രഹിക്കുകയും ചെയ്യുന്നു.

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

vLLM: GPU സെർവറുകൾക്കായുള്ള വർക്ക്ഹോഴ്സ്

ഒരേസമയം നിരവധി ഉപയോക്താക്കൾക്കായി GPU-കളിൽ മോഡലുകൾ സെർവ് ചെയ്യുന്നതിനുള്ള ഒരു Python എഞ്ചിനാണ് vLLM. ഇതിന്റെ പ്രധാന ആശയം PagedAttentionആണ്. മറുപടി നൽകുമ്പോൾ, മോഡൽ മുൻ ടോക്കണുകളുടെ വിവരങ്ങൾ ഒരു സ്ക്രാച്ച്പാഡായി സൂക്ഷിക്കുന്നു, ഇതിനെ KV cacheഎന്ന് വിളിക്കുന്നു. ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മെമ്മറി കൈകാര്യം ചെയ്യുന്നത് പോലെ, vLLM ആ സ്ക്രാച്ച്പാഡിനെ ചെറിയ പേജുകളായി സൂക്ഷിക്കുന്നു; അതിനാൽ വളരെ കുറഞ്ഞ GPU മെമ്മറി മാത്രമേ പാഴാകൂ, ഒപ്പം ഒരേസമയം കൂടുതൽ അഭ്യർത്ഥനകൾ ഉൾക്കൊള്ളാനും സാധിക്കും. കണ്ടിന്യൂവസ് ബാച്ചിംഗിനൊപ്പം, ഇത് ഒരൊറ്റ GPU-ന് നിരവധി ഉപയോക്താക്കൾക്ക് സേവനം നൽകാൻ അവസരമൊരുക്കുന്നു.

പ്രായോഗിക ഉദാഹരണം. രോഹിത്തിന്റെ കമ്പനിയായ Acme-യ്ക്ക് 300 ജീവനക്കാർക്കായി ഒരു ആന്തരിക അസിസ്റ്റന്റിനെ ആവശ്യമുണ്ട്. ഓരോ ചോദ്യത്തിനും പണമടച്ചുള്ള API ഉപയോഗിക്കുന്നത് ചെലവേറിയതായി മാറുന്നു, കൂടാതെ ചില വിവരങ്ങൾ കമ്പനിക്കുള്ളിൽ തന്നെ സൂക്ഷിക്കേണ്ടതുമുണ്ട്. രോഹിത് ഒരു GPU സെർവറിൽ vLLM സജ്ജീകരിക്കുന്നു; ഇത് OpenAI-യുമായി പൊരുത്തപ്പെടുന്ന API നൽകുന്നതിനാൽ, നിലവിലുള്ള ചാറ്റ് ആപ്പിൽ പുതിയൊരു ബേസ് URL (base URL) മാത്രം നൽകിയാൽ മതിയാകും.

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

SGLang: ഏജന്റുകൾക്കും ആവർത്തിച്ചുള്ള പ്രോംപ്റ്റുകൾക്കും വേഗതയേറിയത്

ഉയർന്ന പ്രകടനക്ഷമതയുള്ള മറ്റൊരു സെർവിംഗ് എഞ്ചിനാണ് SGLang. ഒരു നീണ്ട സിസ്റ്റം പ്രോംപ്റ്റ്, പങ്കിട്ട ഡോക്യുമെന്റ് അല്ലെങ്കിൽ ചാറ്റിലെ മുൻ സംഭാഷണങ്ങൾ പോലെ നിരവധി അഭ്യർത്ഥനകൾ ഒരേ തുടക്കം പങ്കിടുമ്പോൾ ഇത് മികച്ച രീതിയിൽ തിളങ്ങുന്നു. ഇതിന്റെ RadixAttention അത്തരം പങ്കിട്ട ഭാഗങ്ങൾ കാഷെ ചെയ്തു സൂക്ഷിക്കുകയും അവ വീണ്ടും കണക്കുകൂട്ടുന്നതിന് പകരം പുനരുപയോഗിക്കുകയും ചെയ്യുന്നു. കൂടാതെ ഇത് സ്ട്രക്ചേർഡ് ഔട്ട്പുട്ട്എന്നതിന് ശക്തമായ പിന്തുണ നൽകുന്നു, അതായത് ഉത്തരങ്ങൾ സാധുവായ JSON അല്ലെങ്കിൽ ഒരു നിശ്ചിത ഫോർമാറ്റിലേക്ക് പരിമിതപ്പെടുത്തുന്നു.

പ്രായോഗിക ഉദാഹരണം. രോഹിത് ഒരു സപ്പോർട്ട്-ടിക്കറ്റ് ട്രയാജ് ഏജന്റ് നിർമ്മിക്കുന്നു. ഓരോ ടിക്കറ്റും 3,000 വാക്കുകളുള്ള ഒരേ പോളിസി ഡോക്യുമെന്റിനൊപ്പമാണ് അയയ്ക്കുന്നത്, കൂടാതെ കാറ്റഗറി, പ്രയോറിറ്റി തുടങ്ങിയ JSON ഫീൽഡുകൾ ഉപയോഗിച്ച് മോഡൽ മറുപടി നൽകണം. ടിക്കറ്റുകളിലുടനീളം കാഷെ ചെയ്ത പോളിസി ഭാഗം SGLang പുനരുപയോഗിക്കുകയും, അദ്ദേഹത്തിന്റെ കോഡിന് പാഴ്‌സ് ചെയ്യാൻ കഴിയുന്ന രൂപത്തിൽ ഔട്ട്പുട്ട് നിലനിർത്തുകയും ചെയ്യുന്നു.

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

mistral.rs: Rust ഉപയോഗിക്കുന്നവർക്കായുള്ള ഒരു Rust എഞ്ചിൻ

Rust-ൽ എഴുതിയ, കമ്മ്യൂണിറ്റി വികസിപ്പിച്ചെടുത്ത ഒരു ഇൻഫറൻസ് എഞ്ചിനാണ് mistral.rs. പേര് അങ്ങനെയാണെങ്കിലും, ഇത് Mistral AI എന്ന കമ്പനിയുടെ ഔദ്യോഗിക ഉൽപ്പന്നമല്ല, കൂടാതെ നിരവധി മോഡൽ കുടുംബങ്ങളെ ഇത് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. ഇത് ക്വാണ്ടൈസേഷൻ, OpenAI-യുമായി പൊരുത്തപ്പെടുന്ന സെർവർ എന്നിവ പിന്തുണയ്ക്കുകയും ഒരു Rust പ്രോഗ്രാമിനുള്ളിൽ ലൈബ്രറിയായി ഉപയോഗിക്കാൻ കഴിയുകയും ചെയ്യുന്നു. മാനേജ് ചെയ്യാൻ പ്രത്യേക Python എൻവയോൺമെന്റ് ഇല്ലാതെ തന്നെ മെമ്മറി സുരക്ഷയും ഒരൊറ്റ കംപൈൽ ചെയ്ത ബൈനറിയും Rust നൽകുന്നു.

പ്രായോഗിക ഉദാഹരണം. Python ഇൻസ്റ്റാൾ ചെയ്യാൻ അനുവാദമില്ലാത്ത സുരക്ഷിതമായ സെർവറുകളിൽ പ്രവർത്തിക്കുന്ന, Rust-ൽ എഴുതിയ ഒരു ലോഗ് വിശകലന ടൂൾ രോഹിത്തിന്റെ ടീമിനുണ്ട്. mistral.rs ഉപയോഗിച്ച് അവർ ഒരേ ബൈനറിയിലേക്ക് നേരിട്ട് "ഈ സംഭവം സംഗ്രഹിക്കുക" എന്ന ഫീച്ചർ ചേർക്കുന്നു; അതിനാൽ വിന്യസിക്കാനോ പാച്ച് ചെയ്യാനോ അധിക സേവനമൊന്നും ആവശ്യമില്ല.

പ്ലെയിൻ PyTorch: ഒരു റഫറൻസ്, അല്ലാതെ റേസ് കാറല്ല

മിക്ക മോഡലുകളും നിർമ്മിക്കുകയും പരിശീലിപ്പിക്കുകയും ചെയ്യുന്ന ഫ്രെയിംവർക്കാണ് PyTorch. പ്ലെയിൻ PyTorch ഉപയോഗിച്ച്, പലപ്പോഴും Hugging Face Transformers ലൈബ്രറിയും അതിന്റെ generate() ഫംഗ്ഷനും വഴി ഒരു മോഡൽ പ്രവർത്തിപ്പിക്കുന്നത് അത് ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും നേരിട്ടുള്ള മാർഗ്ഗമാണ്. മാറ്റങ്ങൾ വരുത്താനും ഡീബഗ്ഗ് ചെയ്യാനും ഇത് എളുപ്പമാണ്, കൂടാതെ പുതിയ മോഡലുകൾ സാധാരണയായി ആദ്യം പ്രവർത്തിക്കുന്നത് ഇവിടെയാണ്. എന്നാൽ നിരവധി ഉപയോക്താക്കൾക്ക് ഒരേസമയം സേവനം നൽകാൻ ഇത് ട്യൂൺ ചെയ്തിട്ടില്ലാത്തതിനാൽ, മുകളിൽ പറഞ്ഞ എഞ്ചിനുകളേക്കാൾ ഇത് വേഗത കുറഞ്ഞതും കൂടുതൽ മെമ്മറി ഉപയോഗിക്കുന്നതുമാണ്.

പ്രായോഗിക ഉദാഹരണം. ഫൈൻ-ട്യൂൺ ചെയ്ത ഒരു മോഡൽ എത്രത്തോളം മികച്ചതാണെന്ന് രോഹിത് പരീക്ഷിക്കുകയാണ്. പ്ലെയിൻ PyTorch ഉപയോഗിച്ച് അദ്ദേഹം അത് ഒരു നോട്ട്ബുക്കിൽ ലോഡ് ചെയ്യുന്നു, വ്യത്യസ്ത പ്രോംപ്റ്റുകൾ പരീക്ഷിക്കുന്നു, കോഡിൽ മാറ്റങ്ങൾ വരുത്തുന്നു, ഫലങ്ങൾ താരതമ്യം ചെയ്യുന്നു. തൃപ്തികരമാണെന്ന് ഉറപ്പായ ശേഷം, പ്രൊഡക്ഷനായി അദ്ദേഹം മോഡലിനെ vLLM അല്ലെങ്കിൽ SGLang-ലേക്ക് മാറ്റുന്നു.

Google-ന്റെ LiteRT-LM: ഫോണുകളിലെ മോഡലുകൾ

TensorFlow Lite-ന്റെ പുതിയ പേരായ LiteRT എന്നത് Google-ന്റെ ഓൺ-ഡിവൈസ് റൺടൈം ആണ്. ഫോണുകൾ, ബ്രൗസറുകൾ, ചെറിയ എഡ്ജ് ഉപകരണങ്ങൾ എന്നിവയിൽ Gemma പോലുള്ള ഭാഷാ മോഡലുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഇതിന്റെ ലെയറാണ് LiteRT-LM. പരിമിതമായ മെമ്മറി, ബാറ്ററി ലൈഫ്, മൊബൈൽ ചിപ്പുകൾ എന്നിവയ്ക്കായി നിർമ്മിച്ചിരിക്കുന്ന ഇത്, നെറ്റ്‌വർക്ക് കണക്ഷനോ സെർവർ ചെലവുകളോ ഇല്ലാതെ AI പ്രവർത്തിപ്പിക്കാൻ ഒരു ആപ്പിനെ അനുവദിക്കുന്നു.

പ്രായോഗിക ഉദാഹരണം. പലപ്പോഴും സിഗ്നൽ ലഭ്യമല്ലാത്ത സ്ഥലങ്ങളിൽ ജോലി ചെയ്യുന്ന ടെക്നീഷ്യൻമാർക്കായി രോഹിത് ഒരു ഫീൽഡ് ഇൻസ്പെക്ഷൻ Android ആപ്പ് നിർമ്മിക്കുന്നു. ഫോണിലെ LiteRT-LM, ഒരു ചെറിയ Gemma മോഡൽ എന്നിവ ഉപയോഗിച്ച്, സംസാരിച്ചു നൽകുന്ന കുറിപ്പുകളെ ആപ്പ് ഓഫ്‌ലൈനായി വൃത്തിയുള്ള റിപ്പോർട്ടാക്കി മാറ്റുന്നു, കൂടാതെ ഡാറ്റ ഒരിക്കലും ഉപകരണത്തിന് പുറത്തുപോകുന്നുമില്ല.

രോഹിത് ഒരെണ്ണം എങ്ങനെ തിരഞ്ഞെടുക്കുന്നു: ഒരു ലളിതമായ തീരുമാന ഗൈഡ്

ഘട്ടം 1: മോഡൽ എവിടെയാണ് പ്രവർത്തിക്കേണ്ടതെന്ന് തീരുമാനിക്കുക

ഒരു ഫോണിലോ ചെറിയ ഉപകരണത്തിലോ ആണെങ്കിൽ LiteRT-LM ഉപയോഗിച്ച് ആരംഭിക്കുക. ഒരു ലാപ്‌ടോപ്പിലോ CPU മാത്രമുള്ള സെർവറിലോ ആണെങ്കിൽ llama.cpp ഉപയോഗിച്ച് തുടങ്ങുക. GPU സെർവറുകളിൽ vLLM അല്ലെങ്കിൽ SGLang പരിശോധിക്കുക. ഒരു Rust പ്രോഗ്രാമിനുള്ളിലാണെങ്കിൽ mistral.rs പരിഗണിക്കുക.

ഘട്ടം 2: ഉപയോക്താക്കളുടെ എണ്ണം കണക്കാക്കുക

ഒരാൾ അല്ലെങ്കിൽ ഏതാനും ആളുകൾ മാത്രമാണെങ്കിൽ: llama.cpp ലളിതവും തികച്ചും അനുയോജ്യവുമാണ്. ഒരേസമയം ഡസൻ കണക്കിന് അല്ലെങ്കിൽ നൂറുകണക്കിന് ആളുകളുണ്ടെങ്കിൽ: vLLM അല്ലെങ്കിൽ SGLang ഉപയോഗിക്കുക, കാരണം ബാച്ചിംഗ് ആണ് ഓരോ ഉത്തരത്തിനുമുള്ള ചെലവ് കുറച്ചു നിർത്തുന്നത്.

ഘട്ടം 3: വർക്ക്‌ലോഡിന്റെ സ്വഭാവം പരിശോധിക്കുക

ധാരാളം പങ്കിട്ട പ്രോംപ്റ്റുകൾ, ഏജന്റുകൾ അല്ലെങ്കിൽ കൃത്യമായ JSON ഔട്ട്പുട്ട് എന്നിവയ്ക്ക് SGLang അനുയോജ്യമാണ്. പൊതുവായ ചാറ്റുകൾക്കും API ട്രാഫിക്കിനും vLLM ഉചിതമാണ്. പരീക്ഷണങ്ങൾക്കും ഗവേഷണങ്ങൾക്കും പ്ലെയിൻ PyTorch തിരഞ്ഞെടുക്കുക.

ഘട്ടം 4: നിങ്ങളുടെ സ്വന്തം ഹാർഡ്‌വെയറിൽ പരീക്ഷിക്കുക

പ്രസിദ്ധീകരിക്കപ്പെട്ട കണക്കുകൾ GPU, മോഡൽ, സെറ്റിംഗ്സ് എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു. തിരഞ്ഞെടുക്കാൻ ഉദ്ദേശിക്കുന്ന രണ്ട് എഞ്ചിനുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം മെഷീനിൽ നിങ്ങളുടെ പ്രോംപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക, തീരുമാനമെടുക്കുന്നതിന് മുമ്പ് ആദ്യ വാക്കിനായുള്ള സമയം (time to first word), സെക്കൻഡിലെ വാക്കുകളുടെ എണ്ണം (words per second), മെമ്മറി ഉപയോഗം എന്നിവ അളക്കുക.

ഉപസംഹാരം

llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM എന്നിവയെല്ലാം ഒരേ അടിസ്ഥാന ജോലിയാണ് ചെയ്യുന്നത്: അവ പരിശീലിപ്പിച്ച ഒരു മോഡൽ പ്രവർത്തിപ്പിക്കുകയും ഇൻപുട്ടിനെ ഉത്തരങ്ങളാക്കി മാറ്റുകയും ചെയ്യുന്നു. ആ ടൂളുകളുടെ വിഭാഗത്തെ LLM ഇൻഫറൻസ് എഞ്ചിനുകൾ എന്ന് വിളിക്കുന്നു. അവ എവിടെ പ്രവർത്തിക്കുന്നു, ആർക്കൊക്കെ സേവനം നൽകുന്നു എന്നതിലാണ് അവ തമ്മിലുള്ള വ്യത്യാസം: ലാപ്‌ടോപ്പുകൾക്കും ചെറിയ സെർവറുകൾക്കും llama.cpp, തിരക്കേറിയ GPU സെർവറുകൾക്ക് vLLM, SGLang, റസ്റ്റ്-നേറ്റീവ് ആപ്പുകൾക്ക് mistral.rs, പരീക്ഷണങ്ങൾക്ക് PyTorch, ഫോണുകൾക്കും എഡ്ജ് ഉപകരണങ്ങൾക്കും LiteRT-LM. മോഡൽ തിരഞ്ഞെടുക്കുന്നത് പോലെ തന്നെ ശ്രദ്ധയോടെ എഞ്ചിനും തിരഞ്ഞെടുക്കുക.

നേട്ടങ്ങൾ

• ഓപ്പൺ മോഡലുകൾ സ്വയം പ്രവർത്തിപ്പിക്കുന്നത് സെൻസിറ്റീവ് വിവരങ്ങൾ നിങ്ങളുടെ സ്ഥാപനത്തിനുള്ളിൽ തന്നെ സുരക്ഷിതമായി സൂക്ഷിക്കാൻ സഹായിക്കുകയും പൂർണ്ണമായും ഓഫ്‌ലൈനായി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു.
• llama.cpp, mistral.rs എന്നിവയിലെ ക്വാണ്ടൈസേഷൻ മികച്ച ശേഷിയുള്ള മോഡലുകൾ സാധാരണ ലാപ്‌ടോപ്പുകളിലും പ്രവർത്തിപ്പിക്കാൻ സഹായിക്കുന്നു.
• vLLM, SGLang എന്നിവ ഒരൊറ്റ GPU-ൽ നിന്ന് നിരവധി ഉപയോക്താക്കൾക്ക് സേവനം നൽകുകയും ഓരോ ഉത്തരത്തിനുമുള്ള ചെലവ് കുറയ്ക്കുകയും ചെയ്യുന്നു.
• OpenAI-യുമായി പൊരുത്തപ്പെടുന്ന API-കൾ പണമടച്ചുള്ള സേവനത്തിൽ നിന്നുള്ള മാറ്റം ഒരു ചെറിയ കോഡ് മാറ്റം മാത്രമാക്കി മാറ്റുന്നു.
• സെർവർ ചെലവുകളോ നെറ്റ്‌വർക്കോ ഇല്ലാതെ ഫോണുകളിലേക്ക് AI ഫീച്ചറുകൾ എത്തിക്കാൻ LiteRT-LM സഹായിക്കുന്നു.

പോരായ്മകൾ

• ഓരോ എഞ്ചിനും പഠിച്ചെടുക്കാൻ അതിന്റേതായ സെറ്റപ്പും ഫ്ലാഗുകളും മോഡൽ ഫോർമാറ്റുകളുമുണ്ട്.
• സെർവർ എഞ്ചിനുകൾക്ക് ഉയർന്ന ശേഷിയുള്ള GPU-കൾ ആവശ്യമാണ്, അവ വാങ്ങുന്നതിനോ വാടകയ്‌ക്കെടുക്കുന്നതിനോ വലിയ ചെലവ് വരുന്നു.
• ക്വാണ്ടൈസ്ഡ് മോഡലുകളിൽ ഗുണനിലവാരത്തിൽ ചെറിയ കുറവുണ്ടാകുന്നു, കൂടാതെ മോഡലിനും ചുമതലയ്ക്കും അനുസരിച്ച് ഈ നഷ്ടം വ്യത്യാസപ്പെടുന്നു.
• പുറത്തിറങ്ങുന്ന ദിവസം തന്നെ എല്ലാ പുതിയ മോഡലുകളെയും എല്ലാ എഞ്ചിനുകളും പിന്തുണയ്ക്കണമെന്നില്ല.
• സ്വയം ഹോസ്റ്റ് ചെയ്യുക എന്നാൽ അപ്‌ഡേറ്റുകൾ, സെക്യൂരിറ്റി പാച്ചുകൾ, മോണിറ്ററിംഗ് എന്നിവയുടെ പൂർണ്ണ ഉത്തരവാദിത്തം നിങ്ങൾക്കായിരിക്കും എന്നാണ് അർത്ഥമാക്കുന്നത്.

മുന്നറിയിപ്പ്

ഈ ലേഖനം അറിവ് പകരുന്നതിനായി മാത്രമുള്ളതാണ്. ഉദാഹരണങ്ങളിലെ മോഡൽ പേരുകൾ, പോർട്ടുകൾ, പാതകൾ എന്നിവ പ്ലേസ്‌ഹോൾഡറുകളാണ്, അവ നിങ്ങളുടെ സ്വന്തം വിവരങ്ങൾ ഉപയോഗിച്ച് മാറ്റണം. ഈ പ്രോജക്റ്റുകൾ അതിവേഗം മാറിക്കൊണ്ടിരിക്കുന്നതിനാൽ, നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുന്ന പതിപ്പിൽ ഫീച്ചറുകൾ, ഫ്ലാഗുകൾ, പിന്തുണയ്ക്കുന്ന ഹാർഡ്‌വെയർ എന്നിവ വ്യത്യാസപ്പെടാം. പ്രൊഡക്ഷൻ സംബന്ധിച്ച തീരുമാനങ്ങൾക്കായി ഇവിടെയുള്ള കാര്യങ്ങളെ ആശ്രയിക്കുന്നതിന് മുമ്പ് ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ പരിശോധിക്കുകയും നിങ്ങളുടെ സ്വന്തം ഹാർഡ്‌വെയറിൽ പരീക്ഷിക്കുകയും ചെയ്യുക.

പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

• എന്താണ് ഒരു LLM ഇൻഫറൻസ് എഞ്ചിൻ? — പരിശീലനം ലഭിച്ച ഒരു ഭാഷാ മോഡൽ ലോഡ് ചെയ്യുകയും CPU, GPU അല്ലെങ്കിൽ ഫോൺ ചിപ്പിൽ ഉത്തരങ്ങൾ നൽകാനായി അത് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്ന സോഫ്റ്റ്‌വെയറാണ് ഇത്.
• llama.cpp ആണോ അതോ vLLM ആണോ കൂടുതൽ മികച്ചത്? — എല്ലായിടത്തും ഒരെണ്ണം മാത്രമായി മികച്ചതല്ല: ലാപ്‌ടോപ്പുകൾക്കും ചെറിയ സെർവറുകൾക്കും llama.cpp ഏറ്റവും മികച്ചതാണ്, GPU സെർവറുകളിൽ നിരവധി ഉപയോക്താക്കൾക്ക് സേവനം നൽകാൻ vLLM ആണ് ഏറ്റവും മികച്ചത്.
• vLLM-ഉം SGLang-ഉം തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? — രണ്ടും വേഗതയേറിയ GPU സെർവിംഗ് എഞ്ചിനുകളാണ്; അഭ്യർത്ഥനകൾ നീണ്ട പ്രോംപ്റ്റുകൾ പങ്കിടുമ്പോഴോ JSON പോലുള്ള സ്ട്രക്ചേർഡ് ഔട്ട്പുട്ട് ആവശ്യമുള്ളപ്പോഴോ SGLang പ്രത്യേകിച്ചും ശക്തമാണ്.
• GPU ഇല്ലാതെ എനിക്ക് ഒരു LLM പ്രവർത്തിപ്പിക്കാൻ കഴിയുമോ? — അതെ, GPU-നെ അപേക്ഷിച്ച് വേഗത കുറവാണെങ്കിലും സാധാരണ CPU-കളിൽ ക്വാണ്ടൈസ്ഡ് മോഡലുകൾ പ്രവർത്തിപ്പിക്കാൻ llama.cpp സഹായിക്കുന്നു.
• mistral.rs നിർമ്മിച്ചത് Mistral AI ആണോ? — അല്ല, നിരവധി മോഡൽ കുടുംബങ്ങളെ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന, Rust-ൽ എഴുതിയ ഒരു പ്രത്യേക കമ്മ്യൂണിറ്റി പ്രോജക്റ്റാണിത്.
• പ്രൊഡക്ഷനിൽ വെറുതെ PyTorch ഉപയോഗിച്ചാൽ പോരെ? — പ്ലെയിൻ PyTorch ഫ്ലെക്സിബിൾ ആണ്, എന്നാൽ നിരവധി ഉപയോക്താക്കൾക്കായി ട്യൂൺ ചെയ്തിട്ടില്ല; അതിനാൽ ഡെഡിക്കേറ്റഡ് എഞ്ചിനുകൾ സാധാരണയായി ഒരേ ഹാർഡ്‌വെയറിൽ നിന്ന് കൂടുതൽ വേഗത നൽകുന്നു.
• LiteRT-LM എന്തിനാണ് ഉപയോഗിക്കുന്നത്? — ഫോണുകളിലും എഡ്ജ് ഉപകരണങ്ങളിലും ഓഫ്‌ലൈനായി Gemma പോലുള്ള ഭാഷാ മോഡലുകൾ നേരിട്ട് പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള Google-ന്റെ റൺടൈം ആണിത്.
• ക്വാണ്ടൈസേഷൻ എന്താണ് ചെയ്യുന്നത്? — ഇത് മോഡൽ നമ്പറുകൾ കുറഞ്ഞ ബിറ്റുകളിൽ സൂക്ഷിക്കുന്നു, അതിനാൽ മോഡൽ വളരെ കുറഞ്ഞ മെമ്മറി മാത്രം ഉപയോഗിക്കുകയും ഗുണനിലവാരത്തിൽ ചെറിയ നഷ്ടത്തോടെ കുറഞ്ഞ നിരക്കിലുള്ള ഹാർഡ്‌വെയറിൽ പ്രവർത്തിക്കുകയും ചെയ്യുന്നു.

ടാഗുകൾ

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