LLM ಇನ್‌ಫರೆನ್ಸ್ ಎಂಜಿನ್‌ಗಳ ವಿವರಣೆ: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch ಮತ್ತು LiteRT-LM

ಒಂದು ಮಾಡೆಲ್ ಫೈಲ್ ತನ್ನಷ್ಟಕ್ಕೆ ತಾನೇ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ. ಅದು ಸಂಖ್ಯೆಗಳ ಒಂದು ದೊಡ್ಡ ರಾಶಿಯಷ್ಟೇ, ಮತ್ತು ಬೇರೊಂದು ಪ್ರೋಗ್ರಾಂ ಆ ಸಂಖ್ಯೆಗಳನ್ನು ಲೋಡ್ ಮಾಡಬೇಕು, ಅದಕ್ಕೆ ಪಠ್ಯವನ್ನು ಒದಗಿಸಿ ಉತ್ತರಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಬೇಕು. ಆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಇನ್‌ಫರೆನ್ಸ್ ಎಂಜಿನ್ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಸರಿಯಾದ ಒಂದನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಮಾಡೆಲ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವಷ್ಟೇ ಮುಖ್ಯವಾಗಿರುತ್ತದೆ.

ಇಂದು ನವೆಂಬರ್ 12, 2026. ಮುಕ್ತ (ಓಪನ್) ಮಾಡೆಲ್‌ಗಳು ಈಗ ಪಾವತಿಸಿದ AI ಸೇವೆಗಳು ಮಾಡಬಹುದಾದ ಕೆಲಸಕ್ಕೆ ಸನಿಹವಾಗಿವೆ, ಮತ್ತು ಅನೇಕ ತಂಡಗಳು ಗೌಪ್ಯತೆ, ವೆಚ್ಚ ಅಥವಾ ಆಫ್‌ಲೈನ್ ಬಳಕೆಗಾಗಿ ಅವುಗಳನ್ನು ತಮ್ಮದೇ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಲು ಬಯಸುತ್ತವೆ. ಆಗ ಅವು ವಿಚಿತ್ರ ಹೆಸರುಗಳ ಪಟ್ಟಿಯನ್ನು ಎದುರಿಸುತ್ತವೆ: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM. ಈ ಪೋಸ್ಟ್ ಈ ಟೂಲ್‌ಗಳ ಗುಂಪನ್ನು ಏನೆಂದು ಕರೆಯುತ್ತಾರೆ, ಪ್ರತಿಯೊಂದೂ ಏಕೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ಮತ್ತು ನಮ್ಮ ಉದಾಹರಣೆ ಇಂಜಿನಿಯರ್ ರೋಹಿತ್ ಯಾವುದನ್ನು ಯಾವಾಗ ಆರಿಸಿಕೊಳ್ಳುತ್ತಾನೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.

ನಾವು ಈ ಟೂಲ್‌ಗಳನ್ನು ಏನೆಂದು ಕರೆಯುತ್ತೇವೆ

ಇದರ ಸಾಮಾನ್ಯ ಹೆಸರು LLM ಇನ್‌ಫರೆನ್ಸ್ ಎಂಜಿನ್‌ಗಳು. ನೀವು ಇವುಗಳನ್ನು ಮಾಡೆಲ್ ರನ್‌ಟೈಮ್‌ಗಳು, ಸರ್ವಿಂಗ್ ಎಂಜಿನ್‌ಗಳು ಅಥವಾ ಸರ್ವಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಎಂದೂ ಕರೆಯುವುದನ್ನು ಕಾಣಬಹುದು. ಕೆಲವು ತ್ವರಿತ ವ್ಯಾಖ್ಯಾನಗಳು ಇಲ್ಲಿವೆ:

• ಇನ್‌ಫರೆನ್ಸ್ ಎಂದರೆ ಉತ್ತರಗಳನ್ನು ನೀಡಲು ತರಬೇತಿ ಪಡೆದ ಮಾಡೆಲ್ ಅನ್ನು ಬಳಸುವುದು. ಟ್ರೈನಿಂಗ್ ಮಾಡೆಲ್‌ಗೆ ಕಲಿಸುತ್ತದೆ; ಇನ್‌ಫರೆನ್ಸ್ ಎಂದರೆ ಅದಕ್ಕೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುವುದು.
• ಸರ್ವಿಂಗ್ ಎಂದರೆ ಮಾಡೆಲ್ ಅನ್ನು ಒಂದು ಸೇವೆಯಾಗಿ, ಸಾಮಾನ್ಯವಾಗಿ HTTP API ಆಗಿ ರನ್ ಮಾಡುವುದು, ಇದರಿಂದ ಹಲವು ಬಳಕೆದಾರರು ಅಥವಾ ಆ್ಯಪ್‌ಗಳು ಒಂದೇ ಬಾರಿಗೆ ಅದನ್ನು ಕಾಲ್ ಮಾಡಬಹುದು.
• ರನ್‌ಟೈಮ್ ಎನ್ನುವುದು CPU, GPU ಅಥವಾ ಫೋನ್ ಚಿಪ್‌ನಲ್ಲಿ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡುವ ಲೋ-ಲೆವೆಲ್ ಕೋಡ್ ಆಗಿದೆ.

ಪಟ್ಟಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಆರು ಟೂಲ್‌ಗಳು ಒಂದೇ ರೀತಿಯ ಮಾಡೆಲ್ ತೂಕಗಳನ್ನು (weights) ತೆಗೆದುಕೊಂಡು ಅವುಗಳನ್ನು ಉತ್ತರಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತವೆ. ಅವು ಎಲ್ಲಿ ಉತ್ತಮವಾಗಿ ರನ್ ಆಗುತ್ತವೆ (ಲ್ಯಾಪ್‌ಟಾಪ್, ದೊಡ್ಡ GPU ಸರ್ವರ್ ಅಥವಾ ಫೋನ್), ಒಂದೇ ಬಾರಿಗೆ ಎಷ್ಟು ಬಳಕೆದಾರರನ್ನು ನಿಭಾಯಿಸುತ್ತವೆ ಮತ್ತು ಅವುಗಳಿಗೆ ಎಷ್ಟು ಮೆಮೊರಿ ಬೇಕಾಗುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಭಿನ್ನವಾಗಿವೆ.

ಎಂಜಿನ್ ಏಕೆ ಅಷ್ಟೊಂದು ಮುಖ್ಯ

ಎಂಜಿನ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಅದೇ ಮಾಡೆಲ್ ವೇಗವಾಗಿ ಅಥವಾ ಅತ್ಯಂತ ನಿಧಾನವಾಗಿ ಭಾಸವಾಗಬಹುದು. ಮೂರು ಅಂಶಗಳು ಅದನ್ನು ನಿರ್ಧರಿಸುತ್ತವೆ:

1. ಮೆಮೊರಿ. ಒಂದು ಮಾಡೆಲ್ RAM ಅಥವಾ GPU ಮೆಮೊರಿಯಲ್ಲಿ ಹೊಂದಿಕೊಳ್ಳಬೇಕು. ಕೆಲವು ಎಂಜಿನ್‌ಗಳು ಕ್ವಾಂಟೈಸೇಶನ್ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ, ಇದು ಸಂಖ್ಯೆಗಳನ್ನು ಕಡಿಮೆ ಬಿಟ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ 16 ಬಿಟ್‌ಗಳ ಬದಲಿಗೆ 4 ಬಿಟ್‌ಗಳು). ಮಾಡೆಲ್ ಸರಿಸುಮಾರು ಮೂರರಿಂದ ನಾಲ್ಕು ಪಟ್ಟು ಚಿಕ್ಕದಾಗುತ್ತದೆ ಮತ್ತು ಗುಣಮಟ್ಟದಲ್ಲಿ ಸಣ್ಣ ನಷ್ಟದೊಂದಿಗೆ ಕಡಿಮೆ ಬೆಲೆಯ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ರನ್ ಆಗುತ್ತದೆ.
2. ಥ್ರೂಪುಟ್. ಇದು ಎಂಜಿನ್ ಒಟ್ಟಾಗಿ ಹಲವು ಬಳಕೆದಾರರಿಗೆ ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಎಷ್ಟು ಉತ್ತರಗಳನ್ನು ನೀಡಬಲ್ಲದು ಎಂಬುದಾಗಿದೆ. ಸರ್ವರ್ ಎಂಜಿನ್‌ಗಳು GPU ಅನ್ನು ಕಾರ್ಯನಿರತವಾಗಿರಿಸಲು ಕಂಟಿನ್ಯೂವಸ್ ಬ್ಯಾಚಿಂಗ್ (ಹೊಸ ವಿನಂತಿಗಳು ತಮ್ಮ ಸರದಿಗಾಗಿ ಕಾಯುವ ಬದಲು ಚಾಲನೆಯಲ್ಲಿರುವ ಬ್ಯಾಚ್‌ಗೆ ಸೇರಿಕೊಳ್ಳುತ್ತವೆ) ನಂತಹ ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತವೆ.
3. ಲೇಟೆನ್ಸಿ. ಇದು ಒಬ್ಬ ಬಳಕೆದಾರ ಮೊದಲ ಪದವನ್ನು ಎಷ್ಟು ವೇಗವಾಗಿ ನೋಡುತ್ತಾನೆ ಎಂಬುದಾಗಿದೆ. ಚಾಟ್‌ಗಾಗಿ ಇದು ಕಚ್ಚಾ ಥ್ರೂಪುಟ್‌ಗಿಂತ ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿರುತ್ತದೆ.

ತಪ್ಪಾದ ಆಯ್ಕೆಯು ದುಬಾರಿಯಾಗುತ್ತದೆ. ರೋಹಿತ್ ದುಬಾರಿ GPU ಅನ್ನು ಬಾಡಿಗೆಗೆ ಪಡೆದು ಕೇವಲ ಕೆಲವೇ ಬಳಕೆದಾರರಿಗೆ ಮಾತ್ರ ಸೇವೆ ನೀಡಬಹುದು, ಅಥವಾ ಲ್ಯಾಪ್‌ಟಾಪ್‌ನಲ್ಲಿ ಎಂದಿಗೂ ಹೊಂದಿಕೊಳ್ಳದ ಮಾಡೆಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಬಹುದು.

ಆರು ಎಂಜಿನ್‌ಗಳು, ಒಂದೊಂದಾಗಿ

llama.cpp: ಬಹುತೇಕ ಎಲ್ಲಿ ಬೇಕಾದರೂ ರನ್ ಆಗುತ್ತದೆ

llama.cpp ಎನ್ನುವುದು ಸಾಮಾನ್ಯ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಮಾಡೆಲ್‌ಗಳನ್ನು ರನ್ ಮಾಡಲು ನಿರ್ಮಿಸಲಾದ C ಮತ್ತು C++ ಎಂಜಿನ್ ಆಗಿದೆ. ಇದು ತನ್ನದೇ ಆದ ಫೈಲ್ ಫಾರ್ಮ್ಯಾಟ್ ಆದ 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 ಸರ್ವರ್‌ಗಳಿಗೆ ವರ್ಕ್‌ಹಾರ್ಸ್

vLLM ಎನ್ನುವುದು GPUಗಳಲ್ಲಿ ಒಂದೇ ಬಾರಿಗೆ ಅನೇಕ ಬಳಕೆದಾರರಿಗೆ ಮಾಡೆಲ್‌ಗಳನ್ನು ಸರ್ವ್ ಮಾಡಲು ಬಳಸುವ Python ಎಂಜಿನ್ ಆಗಿದೆ. ಇದರ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆ PagedAttentionಆಗಿದೆ. ಉತ್ತರಿಸುವಾಗ, ಮಾಡೆಲ್ ಹಿಂದಿನ ಟೋಕನ್‌ಗಳ ಸ್ಕ್ರ್ಯಾಚ್‌ಪ್ಯಾಡ್ ಅನ್ನು ಇರಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಇದನ್ನು KV cacheಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸುವ ರೀತಿಯಲ್ಲೇ vLLM ಆ ಸ್ಕ್ರ್ಯಾಚ್‌ಪ್ಯಾಡ್ ಅನ್ನು ಸಣ್ಣ ಪುಟಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ GPU ಮೆಮೊರಿ ಬಹಳ ಕಡಿಮೆ ವ್ಯರ್ಥವಾಗುತ್ತದೆ ಮತ್ತು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ವಿನಂತಿಗಳು ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ. ಕಂಟಿನ್ಯೂವಸ್ ಬ್ಯಾಚಿಂಗ್ ಜೊತೆಗೆ, ಇದು ಒಂದೇ GPU ಅನೇಕ ಬಳಕೆದಾರರಿಗೆ ಸೇವೆ ನೀಡಲು ಅನುಮತಿಸುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ. ರೋಹಿತ್‌ನ ಕಂಪನಿಯಾದ Acme, ತನ್ನ 300 ಸಿಬ್ಬಂದಿಗಾಗಿ ಆಂತರಿಕ ಸಹಾಯಕರನ್ನು ಬಯಸುತ್ತದೆ. ಪ್ರತಿ ಪ್ರಶ್ನೆಗೂ ಪಾವತಿಸಿದ API ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದು ದುಬಾರಿಯಾಗುತ್ತಿದೆ, ಮತ್ತು ಕೆಲವು ಡೇಟಾ ಸಂಸ್ಥೆಯ ಒಳಗಡೆಯೇ ಇರಬೇಕಾಗುತ್ತದೆ. ರೋಹಿತ್ ಒಂದು GPU ಸರ್ವರ್‌ನಲ್ಲಿ vLLM ಅನ್ನು ಇರಿಸುತ್ತಾನೆ, ಮತ್ತು ಅದು OpenAI-ಹೊಂದಾಣಿಕೆಯಾಗುವ API ಅನ್ನು ಒದಗಿಸುವುದರಿಂದ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಚಾಟ್ ಆ್ಯಪ್‌ಗೆ ಕೇವಲ ಹೊಸ ಬೇಸ್ URL ಮಾತ್ರ ಬೇಕಾಗುತ್ತದೆ.

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

SGLang: ಏಜೆಂಟ್‌ಗಳು ಮತ್ತು ಪುನರಾವರ್ತಿತ ಪ್ರಾಂಪ್ಟ್‌ಗಳಿಗೆ ವೇಗವಾದದ್ದು

SGLang ಮತ್ತೊಂದು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸರ್ವಿಂಗ್ ಎಂಜಿನ್ ಆಗಿದೆ. ದೀರ್ಘ ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್, ಹಂಚಿಕೊಂಡ ಡಾಕ್ಯುಮೆಂಟ್ ಅಥವಾ ಚಾಟ್‌ನ ಹಿಂದಿನ ಸಂಭಾಷಣೆಗಳಂತಹ ಒಂದೇ ಆರಂಭಿಕ ಭಾಗವನ್ನು ಅನೇಕ ವಿನಂತಿಗಳು ಹಂಚಿಕೊಂಡಾಗ ಇದು ಅತ್ಯುತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇದರ RadixAttention ಆ ಹಂಚಿಕೆಯಾದ ಭಾಗಗಳನ್ನು ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಪುನಃ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಬದಲು ಮರುಬಳಕೆ ಮಾಡುತ್ತದೆ. ಇದು ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಔಟ್‌ಪುಟ್ಅನ್ನು ಬಲವಾಗಿ ಬೆಂಬಲಿಸುತ್ತದೆ, ಅಂದರೆ ಉತ್ತರಗಳನ್ನು ಮಾನ್ಯವಾದ JSON ಅಥವಾ ನಿಗದಿತ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಸೀಮಿತಗೊಳಿಸುವುದು.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ. ರೋಹಿತ್ ಸಪೋರ್ಟ್-ಟಿಕೆಟ್ ಟ್ರಯಾಜ್ ಏಜೆಂಟ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಾನೆ. ಪ್ರತಿಯೊಂದು ಟಿಕೆಟ್ ಅನ್ನು ಅದೇ 3,000 ಪದಗಳ ಪಾಲಿಸಿ ಡಾಕ್ಯುಮೆಂಟ್‌ನೊಂದಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಮಾಡೆಲ್ category ಹಾಗೂ priority ಯಂತಹ JSON ಫೀಲ್ಡ್‌ಗಳೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಬೇಕು. SGLang ಟಿಕೆಟ್‌ಗಳಾದ್ಯಂತ ಕ್ಯಾಶ್ ಮಾಡಲಾದ ಪಾಲಿಸಿ ಭಾಗವನ್ನು ಮರುಬಳಕೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಅವನ ಕೋಡ್ ಪಾರ್ಸ್ ಮಾಡಬಹುದಾದ ಆಕಾರದಲ್ಲಿ ಇರಿಸುತ್ತದೆ.

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

mistral.rs: Rust ಪರಿಸರಗಳಿಗಾಗಿ ಒಂದು Rust ಎಂಜಿನ್

mistral.rs ಎನ್ನುವುದು Rust ನಲ್ಲಿ ಬರೆಯಲಾದ ಸಮುದಾಯ-ನಿರ್ಮಿತ ಇನ್‌ಫರೆನ್ಸ್ ಎಂಜಿನ್ ಆಗಿದೆ. ಹೆಸರಿದ್ದರೂ ಇದು Mistral AI ಕಂಪನಿಯ ಅಧಿಕೃತ ಉತ್ಪನ್ನವಲ್ಲ, ಮತ್ತು ಇದು ಅನೇಕ ಮಾಡೆಲ್ ಕುಟುಂಬಗಳನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಇದು ಕ್ವಾಂಟೈಸೇಶನ್, OpenAI-ಹೊಂದಾಣಿಕೆಯ ಸರ್ವರ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು Rust ಪ್ರೋಗ್ರಾಂನ ಒಳಗೆ ಲೈಬ್ರರಿಯಾಗಿ ಬಳಸಬಹುದು. Rust ಮೆಮೊರಿ ಸುರಕ್ಷತೆಯನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಯಾವುದೇ Python ಪರಿಸರವಿಲ್ಲದೆ ಒಂದೇ ಕಂಪೈಲ್ ಮಾಡಿದ ಬೈನರಿಯನ್ನು ನೀಡುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ. ರೋಹಿತ್‌ನ ತಂಡವು Rust ನಲ್ಲಿ ಬರೆಯಲಾದ ಲಾಗ್-ವಿಶ್ಲೇಷಣಾ ಸಾಧನವನ್ನು ಹೊಂದಿದೆ, ಅದು Python ಸ್ಥಾಪಿಸಲು ಅನುಮತಿಯಿಲ್ಲದ ಸುರಕ್ಷಿತ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ರನ್ ಆಗುತ್ತದೆ. mistral.rs ನೊಂದಿಗೆ ಅವರು "summarise this incident" ವೈಶಿಷ್ಟ್ಯವನ್ನು ನೇರವಾಗಿ ಅದೇ ಬೈನರಿಗೆ ಸೇರಿಸುತ್ತಾರೆ, ಆದ್ದರಿಂದ ನಿಯೋಜಿಸಲು ಅಥವಾ ಪ್ಯಾಚ್ ಮಾಡಲು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಸೇವೆ ಇರುವುದಿಲ್ಲ.

ಪ್ಲೇನ್ PyTorch: ರೆಫರೆನ್ಸ್, ರೇಸ್ ಕಾರ್ ಅಲ್ಲ

ಹೆಚ್ಚಿನ ಮಾಡೆಲ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ತರಬೇತಿ ನೀಡಲು ಬಳಸುವ ಫ್ರೇಮ್‌ವರ್ಕ್ PyTorch ಆಗಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ Hugging Face Transformers ಲೈಬ್ರರಿ ಮತ್ತು ಅದರ generate() ಫಂಕ್ಷನ್ ಮೂಲಕ ಪ್ಲೇನ್ PyTorch ನೊಂದಿಗೆ ಮಾಡೆಲ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು ಅದನ್ನು ಬಳಸಲು ಅತ್ಯಂತ ನೇರವಾದ ಮಾರ್ಗವಾಗಿದೆ. ಇದನ್ನು ಬದಲಾಯಿಸುವುದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವುದು ಸುಲಭ, ಮತ್ತು ಹೊಸ ಮಾಡೆಲ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಮೊದಲು ಇಲ್ಲಿಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಇದು ಅನೇಕ ಬಳಕೆದಾರರಿಗೆ ಸರ್ವ್ ಮಾಡಲು ಟ್ಯೂನ್ ಮಾಡಲಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ಮೇಲಿನ ಎಂಜಿನ್‌ಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಇದು ನಿಧಾನವಾಗಿರುತ್ತದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ. ರೋಹಿತ್ ಫೈನ್-ಟ್ಯೂನ್ ಮಾಡಿದ ಮಾಡೆಲ್ ಉತ್ತಮವಾಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದಾನೆ. ಅವನು ಅದನ್ನು ಪ್ಲೇನ್ PyTorch ನೊಂದಿಗೆ ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ ಲೋಡ್ ಮಾಡುತ್ತಾನೆ, ವಿಭಿನ್ನ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತಾನೆ, ಕೋಡ್ ಬದಲಾಯಿಸುತ್ತಾನೆ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಹೋಲಿಸುತ್ತಾನೆ. ತೃಪ್ತಿಯಾದ ನಂತರ, ಅವನು ಪ್ರೊಡಕ್ಷನ್‌ಗಾಗಿ ಮಾಡೆಲ್ ಅನ್ನು vLLM ಅಥವಾ SGLang ಗೆ ಸ್ಥಳಾಂತರಿಸುತ್ತಾನೆ.

Google ನ LiteRT-LM: ಫೋನ್‌ನಲ್ಲಿ ಮಾಡೆಲ್‌ಗಳು

LiteRT ಎನ್ನುವುದು Google ನ ಆನ್-ಡಿವೈಸ್ ರನ್‌ಟೈಮ್ ಆಗಿದ್ದು, TensorFlow Lite ನ ಹೊಸ ಹೆಸರಾಗಿದೆ. LiteRT-LM ಎನ್ನುವುದು ಫೋನ್‌ಗಳು, ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು ಸಣ್ಣ ಎಡ್ಜ್ ಸಾಧನಗಳಲ್ಲಿ Gemma ನಂತಹ ಭಾಷಾ ಮಾಡೆಲ್‌ಗಳನ್ನು ರನ್ ಮಾಡಲು ಅದರ ಲೇಯರ್ ಆಗಿದೆ. ಇದು ಸೀಮಿತ ಮೆಮೊರಿ, ಬ್ಯಾಟರಿ ಬಾಳಿಕೆ ಮತ್ತು ಮೊಬೈಲ್ ಚಿಪ್‌ಗಳಿಗಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಮತ್ತು ಯಾವುದೇ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕ ಮತ್ತು ಸರ್ವರ್ ಬಿಲ್ ಇಲ್ಲದೆ 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, ಮಾಡೆಲ್ ಮತ್ತು ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತವೆ. ನಿರ್ಧರಿಸುವ ಮೊದಲು ಎರಡು ಸಂಭಾವ್ಯ ಎಂಜಿನ್‌ಗಳೊಂದಿಗೆ ನಿಮ್ಮ ಸ್ವಂತ ಗಣಕದಲ್ಲಿ ನಿಮ್ಮದೇ ಆದ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ರನ್ ಮಾಡಿ, ಮತ್ತು ಮೊದಲ ಪದಕ್ಕೆ ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯ, ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಪದಗಳು ಮತ್ತು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಅಳೆಯಿರಿ.

ಉಪಸಂಹಾರ

llama.cpp, vLLM, SGLang, mistral.rs, PyTorch ಮತ್ತು LiteRT-LM ಎಲ್ಲವೂ ಒಂದೇ ಮೂಲಭೂತ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತವೆ: ಅವು ತರಬೇತಿ ಪಡೆದ ಮಾಡೆಲ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತವೆ ಮತ್ತು ಇನ್‌ಪುಟ್ ಅನ್ನು ಉತ್ತರಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತವೆ. ಈ ಕುಟುಂಬವನ್ನು LLM ಇನ್‌ಫರೆನ್ಸ್ ಎಂಜಿನ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಅವುಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು ಅವು ಎಲ್ಲಿ ರನ್ ಆಗುತ್ತವೆ ಮತ್ತು ಯಾರಿಗೆ ಸೇವೆ ನೀಡುತ್ತವೆ ಎಂಬುದು: ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳು ಮತ್ತು ಸಣ್ಣ ಸರ್ವರ್‌ಗಳಿಗೆ llama.cpp, ಕಾರ್ಯನಿರತ GPU ಸರ್ವರ್‌ಗಳಿಗೆ vLLM ಮತ್ತು SGLang, Rust-ಸ್ಥಳೀಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ mistral.rs, ಪ್ರಯೋಗಗಳಿಗೆ PyTorch, ಮತ್ತು ಫೋನ್‌ಗಳು ಹಾಗೂ ಎಡ್ಜ್ ಸಾಧನಗಳಿಗೆ LiteRT-LM. ಮಾಡೆಲ್ ಅನ್ನು ಎಷ್ಟು ಎಚ್ಚರಿಕೆಯಿಂದ ಆಯ್ಕೆ ಮಾಡುತ್ತೀರೋ ಅಷ್ಟೇ ಎಚ್ಚರಿಕೆಯಿಂದ ಎಂಜಿನ್ ಅನ್ನು ಆರಿಸಿ.

ಪ್ರಯೋಜನಗಳು

• ಓಪನ್ ಮಾಡೆಲ್‌ಗಳನ್ನು ನೀವೇ ರನ್ ಮಾಡುವುದರಿಂದ ಸೂಕ್ಷ್ಮ ಡೇಟಾ ಸಂಸ್ಥೆಯ ಒಳಗಡೆಯೇ ಇರುತ್ತದೆ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು.
• llama.cpp ಮತ್ತು mistral.rs ನಲ್ಲಿನ ಕ್ವಾಂಟೈಸೇಶನ್ ಸಮರ್ಥ ಮಾಡೆಲ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯ ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳಲ್ಲಿ ರನ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.
• vLLM ಮತ್ತು SGLang ಒಂದೇ GPU ನಿಂದ ಅನೇಕ ಬಳಕೆದಾರರಿಗೆ ಸೇವೆ ನೀಡುತ್ತವೆ, ಇದು ಪ್ರತಿ ಉತ್ತರದ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• OpenAI-ಹೊಂದಾಣಿಕೆಯ APIಗಳು ಪಾವತಿಸಿದ ಸೇವೆಯಿಂದ ಬದಲಾಯಿಸುವುದನ್ನು ಕೇವಲ ಒಂದು ಸಣ್ಣ ಕೋಡ್ ಬದಲಾವಣೆಯನ್ನಾಗಿಸುತ್ತವೆ.
• LiteRT-LM ಯಾವುದೇ ಸರ್ವರ್ ಬಿಲ್ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಅಗತ್ಯವಿಲ್ಲದೆ ಫೋನ್‌ಗಳಿಗೆ AI ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ತರುತ್ತದೆ.

ಅನನುಕೂಲಗಳು

• ಪ್ರತಿಯೊಂದು ಎಂಜಿನ್ ಕಲಿಯಲು ತನ್ನದೇ ಆದ ಸೆಟಪ್, ಫ್ಲ್ಯಾಗ್‌ಗಳು ಮತ್ತು ಮಾಡೆಲ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳನ್ನು ಹೊಂದಿದೆ.
• ಸರ್ವರ್ ಎಂಜಿನ್‌ಗಳಿಗೆ ಸಮರ್ಥ GPUಗಳು ಬೇಕಾಗುತ್ತವೆ, ಇವುಗಳನ್ನು ಖರೀದಿಸುವುದು ಅಥವಾ ಬಾಡಿಗೆಗೆ ಪಡೆಯುವುದು ದುಬಾರಿಯಾಗಿದೆ.
• ಕ್ವಾಂಟೈಸ್ ಮಾಡಿದ ಮಾಡೆಲ್‌ಗಳು ಸ್ವಲ್ಪ ಗುಣಮಟ್ಟವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತವೆ, ಮತ್ತು ಆ ನಷ್ಟವು ಮಾಡೆಲ್ ಹಾಗೂ ಕಾರ್ಯವನ್ನು ಆಧರಿಸಿ ಭಿನ್ನವಾಗಿರುತ್ತದೆ.
• ಪ್ರತಿಯೊಂದು ಎಂಜಿನ್ ಮೊದಲ ದಿನವೇ ಪ್ರತಿಯೊಂದು ಹೊಸ ಮಾಡೆಲ್ ಅನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.
• ಸ್ವಯಂ-ಹೋಸ್ಟಿಂಗ್ ಎಂದರೆ ನವೀಕರಣಗಳು, ಭದ್ರತಾ ಪ್ಯಾಚ್‌ಗಳು ಮತ್ತು ಮಾನಿಟರಿಂಗ್‌ಗೆ ನೀವೇ ಜವಾಬ್ದಾರರಾಗಿರುತ್ತೀರಿ.

ಎಚ್ಚರಿಕೆ

ಈ ಲೇಖನವು ಶೈಕ್ಷಣಿಕ ಉದ್ದೇಶಕ್ಕಾಗಿ ಮಾತ್ರ. ಉದಾಹರಣೆಗಳಲ್ಲಿನ ಮಾಡೆಲ್ ಹೆಸರುಗಳು, ಪೋರ್ಟ್‌ಗಳು ಮತ್ತು ಪಾತ್‌ಗಳು ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್‌ಗಳಾಗಿದ್ದು, ಅವುಗಳನ್ನು ನಿಮ್ಮದೇ ಆದವುಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಬೇಕು. ಈ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ತ್ವರಿತವಾಗಿ ಬದಲಾಗುತ್ತವೆ, ಆದ್ದರಿಂದ ನೀವು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವ ಆವೃತ್ತಿಯಲ್ಲಿ ವೈಶಿಷ್ಟ್ಯಗಳು, ಫ್ಲ್ಯಾಗ್‌ಗಳು ಮತ್ತು ಬೆಂಬಲಿತ ಹಾರ್ಡ್‌ವೇರ್ ಭಿನ್ನವಾಗಿರಬಹುದು. ಪ್ರೊಡಕ್ಷನ್ ನಿರ್ಧಾರಕ್ಕಾಗಿ ಇಲ್ಲಿನ ಯಾವುದೇ ಹೇಳಿಕೆಯನ್ನು ಅವಲಂಬಿಸುವ ಮೊದಲು ಅಧಿಕೃತ ದಾಖಲಾತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ನಿಮ್ಮದೇ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಪರೀಕ್ಷಿಸಿ.

ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

• LLM ಇನ್‌ಫರೆನ್ಸ್ ಎಂಜಿನ್ ಎಂದರೇನು? — ಇದು ತರಬೇತಿ ಪಡೆದ ಭಾಷಾ ಮಾಡೆಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿ, ಉತ್ತರಗಳನ್ನು ಪಡೆಯಲು CPU, GPU ಅಥವಾ ಫೋನ್ ಚಿಪ್‌ನಲ್ಲಿ ಅದನ್ನು ರನ್ ಮಾಡುವ ಸಾಫ್ಟ್‌ವೇರ್ ಆಗಿದೆ.
• llama.cpp ಅಥವಾ vLLM ಇವುಗಳಲ್ಲಿ ಯಾವುದು ಉತ್ತಮ? — ಎಲ್ಲೆಡೆಯೂ ಯಾವುದೂ ಉತ್ತಮವಲ್ಲ: ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳು ಮತ್ತು ಸಣ್ಣ ಸರ್ವರ್‌ಗಳಿಗೆ llama.cpp ಅತ್ಯುತ್ತಮವಾಗಿದೆ, ಮತ್ತು GPU ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಅನೇಕ ಬಳಕೆದಾರರಿಗೆ ಸೇವೆ ನೀಡಲು vLLM ಅತ್ಯುತ್ತಮವಾಗಿದೆ.
• vLLM ಮತ್ತು SGLang ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? — ಎರಡೂ ವೇಗದ GPU ಸರ್ವಿಂಗ್ ಎಂಜಿನ್‌ಗಳಾಗಿವೆ; ವಿನಂತಿಗಳು ದೀರ್ಘ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಹಂಚಿಕೊಂಡಾಗ ಅಥವಾ JSON ನಂತಹ ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಔಟ್‌ಪುಟ್ ಅಗತ್ಯವಿದ್ದಾಗ SGLang ವಿಶೇಷವಾಗಿ ಪ್ರಬಲವಾಗಿದೆ.
• ನಾನು GPU ಇಲ್ಲದೆ LLM ಅನ್ನು ರನ್ ಮಾಡಬಹುದೇ? — ಹೌದು, GPU ಗಿಂತ ನಿಧಾನವಾಗಿದ್ದರೂ, llama.cpp ಸಾಮಾನ್ಯ CPUಗಳಲ್ಲಿ ಕ್ವಾಂಟೈಸ್ ಮಾಡಿದ ಮಾಡೆಲ್‌ಗಳನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.
• mistral.rs ಅನ್ನು Mistral AI ತಯಾರಿಸಿದೆಯೇ? — ಇಲ್ಲ, ಇದು ಅನೇಕ ಮಾಡೆಲ್ ಕುಟುಂಬಗಳನ್ನು ರನ್ ಮಾಡಬಲ್ಲ Rust ನಲ್ಲಿ ಬರೆಯಲಾದ ಪ್ರತ್ಯೇಕ ಸಮುದಾಯ ಯೋಜನೆಯಾಗಿದೆ.
• ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ಕೇವಲ PyTorch ಅನ್ನು ಏಕೆ ಬಳಸಬಾರದು? — ಪ್ಲೇನ್ PyTorch ಹೊಂದಿಕೊಳ್ಳುವಂತಹುದಾಗಿದೆ ಆದರೆ ಅನೇಕ ಬಳಕೆದಾರರಿಗಾಗಿ ಟ್ಯೂನ್ ಮಾಡಲಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ಮೀಸಲಾದ ಎಂಜಿನ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅದೇ ಹಾರ್ಡ್‌ವೇರ್‌ನಿಂದ ಹೆಚ್ಚಿನ ವೇಗವನ್ನು ನೀಡುತ್ತವೆ.
• LiteRT-LM ಅನ್ನು ಯಾವುದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ? — ಇದು ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ಫೋನ್‌ಗಳು ಮತ್ತು ಎಡ್ಜ್ ಸಾಧನಗಳಲ್ಲಿ ನೇರವಾಗಿ Gemma ನಂತಹ ಭಾಷಾ ಮಾಡೆಲ್‌ಗಳನ್ನು ರನ್ ಮಾಡಲು Google ನ ರನ್‌ಟೈಮ್ ಆಗಿದೆ.
• ಕ್ವಾಂಟೈಸೇಶನ್ ಏನು ಮಾಡುತ್ತದೆ? — ಇದು ಮಾಡೆಲ್ ಸಂಖ್ಯೆಗಳನ್ನು ಕಡಿಮೆ ಬಿಟ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಮಾಡೆಲ್ ಕಡಿಮೆ ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಗುಣಮಟ್ಟದಲ್ಲಿ ಸಣ್ಣ ನಷ್ಟದೊಂದಿಗೆ ಕಡಿಮೆ ವೆಚ್ಚದ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ರನ್ ಆಗುತ್ತದೆ.

ಟ್ಯಾಗ್‌ಗಳು

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