AirLLM: कमज़ोर ग्राफ़िक्स कार्ड पर बड़े भाषा मॉडल

आमतौर पर, 70 अरब मापदंडों के साथ एक बड़े भाषा मॉडल को चलाने के लिए कई दसियों गीगाबाइट वीडियो मेमोरी की आवश्यकता होती है। AirLLM इस समस्या को अधिक शांति से देखता है और एक अलग तरीका पेश करता है: ऐसे मॉडल को वीडियो कार्ड पर केवल 4 जीबी मेमोरी के साथ, और बिना परिमाणीकरण, आसवन और ट्रिमिंग के चलाया जा सकता है। इस नोट में, मैं आपको बिना किसी जल्दबाजी के यह बताने की कोशिश करूंगा कि एयरएलएलएम कैसे काम करता है, इसका उपयोग कैसे करें, और मैं अपना छोटा प्रोजेक्ट एयरएलएलएम-प्रयोग साझा करूंगा, जो इस लाइब्रेरी के साथ काम करना थोड़ा और सुविधाजनक बनाता है।

एयरएलएलएम क्या है

एयरएलएलएम गेविन ली द्वारा लिखित बड़े भाषा मॉडल अनुमान के लिए एक खुला स्रोत पुस्तकालय है। इसका विचार सरल और सुरुचिपूर्ण है: वीडियो मेमोरी में सभी मॉडल भार को एक साथ संग्रहीत करने के बजाय, लाइब्रेरी एक समय में केवल एक परत को GPU पर लोड करती है। वज़न को परतों में काटे गए टुकड़ों के रूप में डिस्क पर संग्रहीत किया जाता है, और पीढ़ी के दौरान, प्रत्येक परत को बारी-बारी से लोड, संसाधित और अनलोड किया जाता है।

इससे यह पता चलता है कि आवश्यक वीडियो मेमोरी की मात्रा मॉडल के समग्र आकार पर निर्भर नहीं करती है, बल्कि इसकी परतों में से एक के आकार पर निर्भर करती है। इसीलिए 70बी मॉडल 4 जीबी में फिट बैठता है, 671बी पर डीपसीक-वी3 लगभग 12 जीबी में फिट बैठता है, और क्यूवेन3-235बी लगभग 3 जीबी में फिट बैठता है। लेकिन मॉडल का आकार मुख्य रूप से डिस्क स्थान द्वारा सीमित है, न कि वीडियो कार्ड की क्षमताओं द्वारा।

ये मेमोरी बचत गति की कीमत पर आती है: प्रत्येक टोकन उत्पन्न होने पर प्रत्येक परत को डिस्क से पढ़ा जाता है, इसलिए आउटपुट धीमा होता है, प्रति टोकन लगभग सेकंड। इसलिए AirLLM एक त्वरित इंटरैक्टिव चैट के बारे में कम और एक ऐसे मॉडल को लॉन्च करने की क्षमता के बारे में अधिक है जो अन्यथा हार्डवेयर में फिट नहीं होगा।

स्थापना

लाइब्रेरी को सामान्य कमांड का उपयोग करके PyPI से स्थापित किया गया है:

pip install airllm

जब आप पहली बार लॉन्च करेंगे, तो मॉडल हगिंग फेस से डाउनलोड किया जाएगा और परतों में विघटित हो जाएगा। यह प्रक्रिया धीमी है और बहुत अधिक डिस्क स्थान लेती है, इसलिए आपको खाली स्थान पहले से तैयार करना चाहिए। यदि वांछित है, तो आप 4 बिट या 8 बिट संपीड़न को सक्षम कर सकते हैं – फिर ब्लॉक क्वांटाइजेशन को वजन पर लागू किया जाएगा, जो डिस्क से परतों को लोड करने की गति लगभग तीन गुना बढ़ा देता है, और सटीकता काफी कम हो जाती है।

मूल उदाहरण

आप एयरएलएलएम के साथ लगभग उसी तरह काम कर सकते हैं जैसे ट्रांसफार्मर के एक नियमित मॉडल के साथ। हगिंग फेस पर एक बार मॉडल आईडी दर्ज करना पर्याप्त है, और फिर सब कुछ परिचित हो जाएगा:

from airllm import AutoModel

MAX_LENGTH = 128
model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

input_text = ['What is the capital of United States?']

input_tokens = model.tokenizer(
    input_text,
    return_tensors="pt",
    return_attention_mask=False,
    truncation=True,
    max_length=MAX_LENGTH,
    padding=False)

generation_output = model.generate(
    input_tokens['input_ids'].cuda(),
    max_new_tokens=20,
    use_cache=True,
    return_dict_in_generate=True)

print(model.tokenizer.decode(generation_output.sequences[0]))

ऑटोमॉडल वर्ग स्वयं मॉडल प्रकार निर्धारित करता है, इसलिए उसी लाइन का उपयोग लामा, क्वेन और डीपसीक के लिए किया जा सकता है। और यदि आप 671बी मापदंडों के साथ डीपसीक-वी3 जैसा मॉडल लेते हैं, तो यह लगभग 12 जीबी वीडियो मेमोरी में भी फिट होगा – यही काफी हद तक परियोजना को आकर्षक बनाता है।

macOS पर लॉन्च करें

AirLLM न केवल CUDA पर, बल्कि Apple सिलिकॉन पर भी चलता है। MacOS पर यह MLX बैकएंड का उपयोग करता है, इसलिए mlx और टॉर्च स्थापित करने की आवश्यकता होगी, और केवल Apple चिप्स का समर्थन करता है। एक छोटी सी सीमा भी है: एमएलएक्स कार्यान्वयन केवल लामा-जैसे आर्किटेक्चर का समर्थन करता है, इसलिए क्वेन और इसी तरह के मॉडल को मैकबुक पर इस तरह से लॉन्च नहीं किया जा सकता है।

उदाहरण का प्रयोग करें

AirLLM-प्रयोग स्थानीय स्तर पर बड़े भाषा मॉडल चलाने के लिए दो छोटी इंटरैक्टिव कंसोल उपयोगिताएँ हैं। वे मॉडल को लोड करने और चैट को व्यवस्थित करने के लिए हर बार एक ही कोड लिखने की आवश्यकता को समाप्त कर देते हैं।

पहला टूल, Airllm-lib-usage.py, AirLLM लाइब्रेरी को सीधे वर्तमान पायथन प्रक्रिया में चलाता है। यह सामान्य कैटलॉग से मॉडलों की एक क्रमांकित सूची दिखाता है, यदि आवश्यक हो, तो यह लापता निर्भरताएँ स्थापित करता है और एक चैट सत्र खोलता है। MLX रनटाइम का उपयोग macOS पर किया जाता है, टॉर्च का उपयोग अन्य प्लेटफ़ॉर्म पर किया जाता है।

दूसरा टूल, Airllm-openai-server-client.py, आपको Airllm-openai-server सर्वर के साथ काम करने में मदद करता है, जो डॉकर में चलता है और एक OpenAI-संगत एपीआई प्रदान करता है। जब आप इसे पहली बार लॉन्च करते हैं, तो उपयोगिता सेटिंग्स मांगती है, छवि एकत्र करती है, कंटेनर उठाती है और चल रहे सर्वर पर एक स्ट्रीमिंग चैट खोलती है। जब बार-बार लॉन्च किया जाता है, तो यह एक मौजूदा कंटेनर ढूंढता है और बस इसका पुन: उपयोग करता है, और मॉडल कैश को एक अलग डॉकर वॉल्यूम में संग्रहीत करता है ताकि मॉडल को दोबारा डाउनलोड न करना पड़े।

उपलब्ध मॉडलों की सूची सामान्य मॉड्यूल model_catalog.py में शामिल है, इसलिए दोनों उपकरण एक ही सेट के साथ काम करते हैं। चैट कमांड भी आम हैं: /help, /clear, /exit। स्रोत कोड और निर्देश भंडार में हैं:

https://github.com/zefir1990/AirLLM-experiments

किस बात पर ध्यान दें

पहली प्रतिक्रिया को तैयार होने में कई मिनट लग सकते हैं: सबसे पहले, AirLLM मॉडल को डाउनलोड करता है और उसे परतों में काटता है, और उसके बाद ही उत्पादन शुरू करता है। इसके अलावा, गति भी कम रहती है – यह स्मृति को बचाने के लिए एक जानबूझकर किया गया समझौता है। मेटा-लामा जैसे गेटेड मॉडल के लिए, आपको हगिंग फेस पर शर्तों को स्वीकार करना होगा और एक एक्सेस टोकन पास करना होगा। डाउनलोड किए गए मॉडलों और शार्डों के कैश को न हटाना सबसे अच्छा है, अन्यथा सब कुछ फिर से डाउनलोड करना होगा।

लिंक

https://github.com/lyogavin/airllm
https://github.com/mkamranr/airllm-openai-server
https://github.com/zefir1990/AirLLM-experiments
https://pypi.org/project/airllm/
https://huggingface.co/

स्रोत

https://github.com/lyogavin/airllm
https://github.com/zefir1990/AirLLM-experiments