एलएलएम का अनुमान लगाने वाली गाइड

LLM Inference API की मदद से, लार्ज लैंग्वेज मॉडल (एलएलएम) को डिवाइस पर ही चलाया जा सकता है. इसका इस्तेमाल कई तरह के कामों के लिए किया जा सकता है. जैसे, टेक्स्ट जनरेट करना, सामान्य भाषा में जानकारी हासिल करना, और दस्तावेज़ों की खास जानकारी पाना. इस टास्क में, टेक्स्ट से टेक्स्ट में बदलने वाले कई लार्ज लैंग्वेज मॉडल के लिए, पहले से ही सहायता उपलब्ध होती है. इससे, डिवाइस पर मौजूद जनरेटिव एआई मॉडल को अपने ऐप्लिकेशन और प्रॉडक्ट में लागू किया जा सकता है.

इसे आज़माएं!arrow_forward

यह टास्क, Gemma के इन वैरिएंट के साथ काम करता है: Gemma-3 1B, Gemma-2 2B, Gemma 2B, और Gemma 7B. Gemma एक लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. यह इन एक्सटर्नल मॉडल के साथ भी काम करता है: Phi-2, Falcon-RW-1B, और StableLM-3B.

काम करने वाले मॉडल के अलावा, Google के AI Edge Torch का इस्तेमाल करके, PyTorch मॉडल को कई हस्ताक्षर वाले LiteRT (tflite) मॉडल में एक्सपोर्ट किया जा सकता है. ये मॉडल, tokenizer पैरामीटर के साथ बंडल किए जाते हैं, ताकि LLM इंफ़रेंस एपीआई के साथ काम करने वाले टास्क बंडल बनाए जा सकें. एआई Edge Torch की मदद से बदले गए मॉडल, सिर्फ़ सीपीयू बैकएंड पर चल सकते हैं. इसलिए, ये मॉडल सिर्फ़ Android और iOS पर काम करते हैं.

शुरू करें

अपने टारगेट प्लैटफ़ॉर्म के लिए, लागू करने से जुड़ी इनमें से किसी एक गाइड का पालन करके, इस टास्क का इस्तेमाल शुरू करें. प्लैटफ़ॉर्म के हिसाब से बनाई गई ये गाइड, इस टास्क को लागू करने के बुनियादी तरीके के बारे में बताती हैं. इनमें, उपलब्ध मॉडल और सुझाए गए कॉन्फ़िगरेशन के विकल्पों का इस्तेमाल करने वाले कोड के उदाहरण दिए गए हैं:

• वेब:

  • गाइड
  • कोड का उदाहरण

• Android:

  • गाइड
  • कोड का उदाहरण

• iOS

  • गाइड
  • कोड का उदाहरण

टास्क की जानकारी

इस सेक्शन में, इस टास्क की सुविधाओं, इनपुट, आउटपुट, और कॉन्फ़िगरेशन के विकल्पों के बारे में बताया गया है.

सुविधाएं

LLM Inference API में ये मुख्य सुविधाएं शामिल हैं:

1. टेक्स्ट से टेक्स्ट जनरेट करना - इनपुट टेक्स्ट प्रॉम्प्ट के आधार पर टेक्स्ट जनरेट करना.
2. एलएलएम चुनना - ऐप्लिकेशन को अपने खास इस्तेमाल के उदाहरणों के हिसाब से बनाने के लिए, एक से ज़्यादा मॉडल लागू करें. मॉडल को फिर से ट्रेन किया जा सकता है और उस पर पसंद के मुताबिक वेट लागू किए जा सकते हैं.
3. LoRA मॉडल के साथ काम करना - अपने सभी डेटासेट पर ट्रेनिंग देकर या ओपन-सोर्स कम्यूनिटी से पहले से तैयार LoRA मॉडल का इस्तेमाल करके, LoRA मॉडल की मदद से एलएलएम की सुविधा को बढ़ाएं और उसे पसंद के मुताबिक बनाएं. यह सुविधा, AI Edge Torch Generative API की मदद से बदले गए मॉडल के साथ काम नहीं करती.

कॉन्फ़िगरेशन के विकल्प

इस टास्क के लिए, कॉन्फ़िगरेशन के ये विकल्प उपलब्ध हैं:

मॉडल

LLM Inference API, टेक्स्ट-टू-टेक्स्ट के कई बड़े लैंग्वेज मॉडल के साथ काम करता है. इसमें ब्राउज़र और मोबाइल डिवाइसों पर चलने के लिए ऑप्टिमाइज़ किए गए कई मॉडल के लिए, पहले से मौजूद सहायता भी शामिल है. इन छोटे मॉडल का इस्तेमाल, पूरी तरह से डिवाइस पर अनुमान लगाने के लिए किया जा सकता है.

LLM Inference API को शुरू करने से पहले, कोई मॉडल डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें. पहले से बदले गए मॉडल का इस्तेमाल किया जा सकता है या किसी मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है.

LLM Inference API, इन टाइप के मॉडल के साथ काम करता है. इनमें से कुछ मॉडल के लिए, मॉडल को बदलना ज़रूरी होता है. अपने मॉडल के लिए ज़रूरी चरणों के तरीके की पहचान करने के लिए, टेबल का इस्तेमाल करें.

अन्य मॉडल को बदलने का तरीका जानने के लिए, मॉडल बदलना सेक्शन देखें.

Gemma-3 1B

Gemma-3 1B, Gemma फ़ैमिली का सबसे नया मॉडल है. यह लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. इस मॉडल में 10 करोड़ पैरामीटर और ओपन वेट शामिल हैं. 1B वैरिएंट, Gemma फ़ैमिली का सबसे छोटा मॉडल है. इसलिए, इसे डिवाइस पर इस्तेमाल करने के कई उदाहरणों के लिए आदर्श माना जाता है.

Gemma-3 1B डाउनलोड करें

HuggingFace का Gemma-3 1B मॉडल, .task फ़ॉर्मैट में उपलब्ध है. साथ ही, यह Android और वेब ऐप्लिकेशन के लिए एलएलएम इंफ़रेंस एपीआई के साथ इस्तेमाल के लिए तैयार है.

LLM Inference API के साथ Gemma-3 1B को चलाते समय, इन विकल्पों को इस हिसाब से कॉन्फ़िगर करें:

• preferredBackend: CPU या GPU के बीच से किसी एक बैकएंड को चुनने के लिए, इस विकल्प का इस्तेमाल करें. यह विकल्प सिर्फ़ Android के लिए उपलब्ध है.
• supportedLoraRanks: LLM Inference API को Gemma-3 1B मॉडल के साथ, कम रैंक वाले अडैप्टेशन (LoRA) के साथ काम करने के लिए कॉन्फ़िगर नहीं किया जा सकता. supportedLoraRanks या loraRanks विकल्पों का इस्तेमाल न करें.
• maxTokens: maxTokens की वैल्यू, मॉडल में बनाए गए कॉन्टेक्स्ट साइज़ से मेल खानी चाहिए. इसे की-वैल्यू (KV) कैश या कॉन्टेक्स्ट की लंबाई भी कहा जा सकता है.
• numResponses: यह हमेशा 1 होना चाहिए. यह विकल्प सिर्फ़ वेब के लिए उपलब्ध है.

वेब ऐप्लिकेशन पर Gemma-3 1B को चलाने पर, शुरू करने की प्रोसेस की वजह से मौजूदा थ्रेड में लंबे समय तक ब्लॉक हो सकता है. अगर हो सके, तो मॉडल को हमेशा वर्कर्स थ्रेड से चलाएं.

जेमा-2 2B

Gemma-2 2B, Gemma फ़ैमिली का एक मॉडल है. यह लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. इस मॉडल में 2B पैरामीटर और ओपन वेट शामिल हैं. Gemma-2 2B, अपनी क्लास के मॉडल के लिए, बेहतरीन तरीके से तर्क करने की सुविधाओं के लिए जाना जाता है.

Gemma-2 2B डाउनलोड करें

Gemma-2 2B मॉडल इन वैरिएंट में उपलब्ध हैं:

• gemma2-2b-it-cpu-int8: Gemma-2 2B 8-बिट मॉडल, जो सीपीयू के साथ काम करता है.
• gemma2-2b-it-gpu-int8: Gemma-2 2B 8-बिट मॉडल, जो जीपीयू के साथ काम करता है.

मॉडल को ऐप्लिकेशन में जोड़ने से पहले, उसे ट्यून किया जा सकता है और उसमें नए वेट जोड़े जा सकते हैं. Gemma को ट्यून करने और उसे पसंद के मुताबिक बनाने के बारे में ज़्यादा जानने के लिए, Gemma को ट्यून करना लेख पढ़ें. Kaggle मॉडल से Gemma-22B डाउनलोड करने के बाद, यह मॉडल पहले से ही MediaPipe Tasks के साथ इस्तेमाल करने के लिए सही फ़ॉर्मैट में होता है.

जेमा 2B

Gemma 2B, लाइटवेट और बेहतरीन ओपन मॉडल के परिवार का हिस्सा है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और टेक्नोलॉजी का इस्तेमाल करके बनाया गया है. इस मॉडल में 2B पैरामीटर और ओपन वेट शामिल हैं. यह मॉडल, टेक्स्ट जनरेट करने से जुड़े कई कामों के लिए बेहतर है. जैसे, सवालों के जवाब देना, खास जानकारी देना, और तर्क देना.

Gemma 2B डाउनलोड करें

Gemma 2B मॉडल इन वैरिएंट में उपलब्ध हैं:

• gemma-2b-it-cpu-int4: सीपीयू के साथ काम करने वाला Gemma 2B 4-बिट मॉडल.
• gemma-2b-it-cpu-int8: सीपीयू के साथ काम करने वाला Gemma 2B 8-बिट मॉडल.
• gemma-2b-it-gpu-int4: Gemma 2B 4-बिट मॉडल, जो GPU के साथ काम करता है.
• gemma-2b-it-gpu-int8: Gemma 2B का 8-बिट मॉडल, जो जीपीयू के साथ काम करता है.

मॉडल को ऐप्लिकेशन में जोड़ने से पहले, उसे ट्यून किया जा सकता है और उसमें नए वेट जोड़े जा सकते हैं. Gemma को ट्यून करने और उसे पसंद के मुताबिक बनाने के बारे में ज़्यादा जानने के लिए, Gemma को ट्यून करना लेख पढ़ें. Kaggle Models से Gemma 2B को डाउनलोड करने के बाद, यह मॉडल MediaPipe Tasks के साथ इस्तेमाल करने के लिए सही फ़ॉर्मैट में पहले से ही मौजूद होता है.

Gemma 7B

Gemma 7B, Gemma का एक बड़ा मॉडल है. इसमें 7B पैरामीटर और ओपन वेट हैं. यह मॉडल, टेक्स्ट जनरेट करने से जुड़े कई टास्क के लिए ज़्यादा बेहतर है. जैसे, सवालों के जवाब देना, खास जानकारी देना, और तर्क देना. Gemma 7B सिर्फ़ वेब पर काम करता है.

Gemma 7B डाउनलोड करें

Gemma 7B मॉडल एक वैरिएंट में उपलब्ध है:

• gemma-1.1-7b-it-gpu-int8: Gemma 7B 8-बिट मॉडल, जो जीपीयू के साथ काम करता है.

Kaggle के मॉडल से Gemma 7B डाउनलोड करने के बाद, यह मॉडल MediaPipe के साथ इस्तेमाल करने के लिए पहले से ही सही फ़ॉर्मैट में होता है.

Falcon 1B

Falcon-1B, एक अरब पैरामीटर वाला सिर्फ़ कैज़ल डिकोडर मॉडल है. इसे RefinedWeb के 350 अरब टोकन पर ट्रेन किया गया है.

Falcon 1B डाउनलोड करें

LLM Inference API के लिए, इन फ़ाइलों को डाउनलोड करके स्थानीय स्टोरेज में सेव करना ज़रूरी है:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

Falcon मॉडल की फ़ाइलें डाउनलोड करने के बाद, मॉडल को कन्वर्ज़न स्क्रिप्ट की मदद से MediaPipe फ़ॉर्मैट में बदला जा सकता है. काम करने वाले मॉडल के लिए कन्वर्ज़न स्क्रिप्ट सेक्शन में दिया गया तरीका अपनाएं.

StableLM 3B

StableLM-3B, सिर्फ़ डिकोडर वाला 3 अरब पैरामीटर वाला लैंग्वेज मॉडल है. इसे चार युगों के लिए, अंग्रेज़ी और कोड के अलग-अलग डेटासेट के 1 ट्रिलियन टोकन पर ट्रेन किया गया है.

StableLM 3B डाउनलोड करें

LLM Inference API के लिए, इन फ़ाइलों को डाउनलोड करके स्थानीय स्टोरेज में सेव करना ज़रूरी है:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

StableLM मॉडल की फ़ाइलें डाउनलोड करने के बाद, मॉडल को कन्वर्ज़न स्क्रिप्ट की मदद से MediaPipe फ़ॉर्मैट में बदला जा सकता है. काम करने वाले मॉडल के लिए कन्वर्ज़न स्क्रिप्ट सेक्शन में दिया गया तरीका अपनाएं.

Phi-2

Phi-2, 2.7 बिलियन पैरामीटर वाला ट्रांसफ़ॉर्मर मॉडल है. इसे अलग-अलग एनएलपी सिंथेटिक टेक्स्ट और फ़िल्टर की गई वेबसाइटों का इस्तेमाल करके ट्रेन किया गया था. यह मॉडल, सवाल-जवाब, चैट, और कोड फ़ॉर्मैट का इस्तेमाल करने वाले प्रॉम्प्ट के लिए सबसे सही है.

Phi-2 डाउनलोड करें

LLM Inference API के लिए, इन फ़ाइलों को डाउनलोड करके स्थानीय स्टोरेज में सेव करना ज़रूरी है:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

Phi-2 मॉडल की फ़ाइलें डाउनलोड करने के बाद, मॉडल को कन्वर्ज़न स्क्रिप्ट की मदद से MediaPipe फ़ॉर्मैट में बदला जा सकता है. काम करने वाले मॉडल के लिए कन्वर्ज़न स्क्रिप्ट सेक्शन में दिया गया तरीका अपनाएं.

जनरेटिव PyTorch मॉडल

AI Edge Torch जनरेटिव एपीआई की मदद से, PyTorch जनरेटिव मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है. PyTorch मॉडल को मल्टी-सिग्नेचर LiteRT (TensorFlow Lite) मॉडल में बदलने के लिए, एपीआई का इस्तेमाल किया जा सकता है. मॉडल को मैप करने और एक्सपोर्ट करने के बारे में ज़्यादा जानकारी के लिए, AI Edge Torch के GitHub पेज पर जाएं.

अगर आपको PyTorch मॉडल को बदलने के लिए, एआई एज Torch जनरेटिव एपीआई का इस्तेमाल करना है, तो PyTorch मॉडल के लिए Torch जनरेटिव कन्वर्टर सेक्शन में दिए गए निर्देशों का पालन करें.

मॉडल कन्वर्ज़न

MediaPipe LLM Inference API की मदद से, डिवाइस पर कई तरह के लार्ज लैंग्वेज मॉडल चलाए जा सकते हैं. इसमें ऐसे मॉडल शामिल हैं जिन्हें पहले से MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदल दिया गया है. साथ ही, ऐसे अन्य मॉडल भी शामिल हैं जिन्हें कन्वर्ज़न स्क्रिप्ट या AI Edge Torch लाइब्रेरी की मदद से बदला जा सकता है.

LLM Inference API, .bin और .task फ़ाइल फ़ॉर्मैट में मॉडल स्वीकार करता है. आम तौर पर, पहले से बदले गए मॉडल और कन्वर्ज़न स्क्रिप्ट की मदद से बदले गए मॉडल, .bin फ़ाइलें होंगी. वहीं, एआई Edge Torch लाइब्रेरी की मदद से बदले गए मॉडल, .task फ़ाइलें होंगी. बदले गए मॉडल के फ़ाइल फ़ॉर्मैट में मैन्युअल तौर पर बदलाव न करें.

LLM इंफ़रेंस एपीआई में तीन मॉडल कन्वर्ज़न पाथ होते हैं:

• पहले से बदले गए मॉडल (Gemma-3 1B, Gemma-2 2B, Gemma 2B, Gemma 7B): बदलाव करने की ज़रूरत नहीं है.
• इस्तेमाल किए जा सकने वाले मॉडल (Phi-2, StableLM, Falcon): MediaPipe ट्रांसफ़ॉर्मेशन स्क्रिप्ट.
• अन्य PyTorch मॉडल (सभी PyTorch एलएलएम मॉडल): AI Edge Torch Generative API.

पहले से बदले गए मॉडल

Gemma-2 2B, Gemma 2B, और Gemma 7B मॉडल, MediaPipe फ़ॉर्मैट में पहले से बदले हुए मॉडल के तौर पर उपलब्ध हैं. इन मॉडल के लिए, उपयोगकर्ता को कन्वर्ज़न के लिए कोई अतिरिक्त चरण पूरा करने की ज़रूरत नहीं होती. साथ ही, इन्हें LLM Inference API के साथ वैसे ही चलाया जा सकता है जैसे वे हैं.

Kaggle मॉडल से Gemma-2 2B डाउनलोड किया जा सकता है:

• gemma2-2b-it-cpu-int8: Gemma-2 2B 8-बिट मॉडल, जो सीपीयू के साथ काम करता है.
• gemma2-2b-it-gpu-int8: Gemma-2 2B 8-बिट मॉडल, जो जीपीयू के साथ काम करता है.

Kaggle मॉडल से Gemma 2B के वैरिएंट डाउनलोड किए जा सकते हैं:

• gemma-2b-it-cpu-int4: सीपीयू के साथ काम करने वाला Gemma 2B 4-बिट मॉडल.
• gemma-2b-it-cpu-int8: सीपीयू के साथ काम करने वाला Gemma 2B 8-बिट मॉडल.
• gemma-2b-it-gpu-int4: Gemma 2B 4-बिट मॉडल, जो GPU के साथ काम करता है.
• gemma-2b-it-gpu-int8: Gemma 2B का 8-बिट मॉडल, जो जीपीयू के साथ काम करता है.

Gemma 7B को Kaggle Models से डाउनलोड किया जा सकता है:

• gemma-1.1-7b-it-gpu-int8: Gemma 7B 8-बिट मॉडल, जो जीपीयू के साथ काम करता है.

Gemma मॉडल के बारे में ज़्यादा जानने के लिए, Gemma-2 2B, Gemma 2B, और Gemma 7B के दस्तावेज़ देखें.

काम करने वाले मॉडल के लिए कन्वर्ज़न स्क्रिप्ट

MediaPipe पैकेज में, कन्वर्ज़न स्क्रिप्ट उपलब्ध होती है. इसकी मदद से, इन बाहरी मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है:

• Falcon 1B
• StableLM 3B
• Phi-2

काम करने वाले बाहरी मॉडल के बारे में ज़्यादा जानकारी के लिए, Falcon 1B, StableLM 3B, और Phi-2 के दस्तावेज़ देखें.

मॉडल को बदलने की प्रोसेस के लिए, MediaPipe PyPI पैकेज की ज़रूरत होती है. 0.10.11 के बाद, कन्वर्ज़न स्क्रिप्ट सभी MediaPipe पैकेज में उपलब्ध है.

इनके साथ डिपेंडेंसी इंस्टॉल और इंपोर्ट करें:

$ python3 -m pip install mediapipe

मॉडल को बदलने के लिए, genai.converter लाइब्रेरी का इस्तेमाल करें:

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

LoRA मॉडल को बदलने के लिए, ConversionConfig में बेस मॉडल के विकल्पों के साथ-साथ LoRA के अन्य विकल्पों की जानकारी होनी चाहिए. ध्यान दें कि एपीआई सिर्फ़ GPU के साथ LoRA इंफ़रेंस के साथ काम करता है. इसलिए, बैकएंड को 'gpu' पर सेट करना ज़रूरी है.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

कनवर्टर, दो TFLite फ़्लैटबफ़र फ़ाइलें आउटपुट करेगा. एक बेस मॉडल के लिए और दूसरी LoRA मॉडल के लिए.

PyTorch मॉडल के लिए Torch जनरेटिव कन्वर्टर

AI Edge Torch जनरेटिव एपीआई की मदद से, PyTorch जनरेटिव मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है. एपीआई का इस्तेमाल करके, PyTorch LLMs को लिखा, बदला, और क्वांटिज़ किया जा सकता है, ताकि उन्हें LLM Inference API के साथ इस्तेमाल किया जा सके. Torch Generative Converter सिर्फ़ सीपीयू के लिए बदलाव करता है. इसके लिए, कम से कम 64 जीबी रैम वाली Linux मशीन की ज़रूरत होती है.

AI Edge Torch जनरेटिव एपीआई की मदद से, PyTorch मॉडल को बदलने के लिए, ये काम करने होंगे:

1. PyTorch मॉडल के चेकपॉइंट डाउनलोड करना
2. मॉडल को लिखने, बदलने, और उसे MediaPipe के साथ काम करने वाले फ़ाइल फ़ॉर्मैट (.tflite) में बदलने के लिए, AI Edge Torch जनरेटिव एपीआई का इस्तेमाल करें.
3. tflite फ़ाइल और मॉडल टॉकेनेटर से टास्क बंडल (.task) बनाएं.

टास्क बंडल बनाने के लिए, टास्क बंडल बनाने के लिए बंडलिंग स्क्रिप्ट का इस्तेमाल करें. बंडलिंग की प्रोसेस, मैप किए गए मॉडल को अतिरिक्त मेटाडेटा (उदाहरण के लिए, Tokenizer पैरामीटर) की ज़रूरत होती है.

मॉडल को बंडल करने की प्रोसेस के लिए, MediaPipe PyPI पैकेज की ज़रूरत होती है. 0.10.14 के बाद, कन्वर्ज़न स्क्रिप्ट सभी MediaPipe पैकेज में उपलब्ध है.

इनके साथ डिपेंडेंसी इंस्टॉल और इंपोर्ट करें:

$ python3 -m pip install mediapipe

मॉडल को बंडल करने के लिए, genai.bundler लाइब्रेरी का इस्तेमाल करें:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

LoRA को पसंद के मुताबिक बनाना

LLM इंफ़रेंस एपीआई के LoRA सपोर्ट की सुविधा, जीपीयू बैकएंड के लिए Gemma के सभी वैरिएंट और Phi-2 मॉडल के साथ काम करती है. इसमें LoRA वेट सिर्फ़ ध्यान देने वाली लेयर पर लागू होते हैं. शुरुआती तौर पर लागू किए गए इस एपीआई को, आने वाले समय में होने वाली नई सुविधाओं के लिए एक्सपेरिमेंट के तौर पर इस्तेमाल किया जाएगा. आने वाले अपडेट में, ज़्यादा मॉडल और अलग-अलग तरह की लेयर के साथ काम करने की सुविधाएं जोड़ी जाएंगी.

LoRA मॉडल तैयार करना

अपने डेटासेट पर बेहतर LoRA मॉडल को ट्रेन करने के लिए, HuggingFace पर दिए गए निर्देशों का पालन करें. इसके लिए, Gemma या Phi-2 जैसे काम करने वाले मॉडल टाइप का इस्तेमाल करें. Gemma-2 2B, Gemma 2B, और Phi-2 मॉडल, HuggingFace पर सुरक्षित टेंसर फ़ॉर्मैट में उपलब्ध हैं. LLM Inference API, सिर्फ़ ध्यान देने वाली लेयर पर LoRA का इस्तेमाल करता है. इसलिए, LoraConfig बनाते समय सिर्फ़ ध्यान देने वाली लेयर तय करें. इसके लिए, यह तरीका अपनाएं:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

जांच के लिए, सार्वजनिक तौर पर ऐक्सेस किए जा सकने वाले ऐसे LoRA मॉडल उपलब्ध हैं जिन्हें HuggingFace पर उपलब्ध LLM के अनुमान लगाने वाले API के साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए, Gemma-2B के लिए monsterapi/gemma-2b-lora-maths-orca-200k और Phi-2 के लिए lole25/phi-2-sft-ultrachat-lora.

तैयार किए गए डेटासेट पर ट्रेनिंग देने और मॉडल को सेव करने के बाद, आपको एक adapter_model.safetensors फ़ाइल मिलती है. इसमें, बेहतर बनाए गए LoRA मॉडल के वेट होते हैं. safetensors फ़ाइल, मॉडल कन्वर्ज़न में इस्तेमाल किया जाने वाला LoRA चेकपॉइंट है.

अगले चरण में, आपको MediaPipe Python पैकेज का इस्तेमाल करके, मॉडल के वेट को TensorFlow Lite Flatbuffer में बदलना होगा. ConversionConfig में, बेस मॉडल के विकल्पों के साथ-साथ LoRA के अन्य विकल्पों के बारे में जानकारी होनी चाहिए. ध्यान दें कि एपीआई सिर्फ़ जीपीयू के साथ LoRA इंफ़रेंस के साथ काम करता है. इसलिए, बैकएंड को 'gpu' पर सेट किया जाना चाहिए.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

कनवर्टर, दो TFLite फ़्लैटबफ़र फ़ाइलें आउटपुट करेगा. एक बेस मॉडल के लिए और दूसरी LoRA मॉडल के लिए.

LoRA मॉडल का अनुमान

वेब, Android, और iOS LLM इंफ़रेंस एपीआई को अपडेट किया गया है, ताकि LoRA मॉडल के इंफ़रेंस की सुविधा काम कर सके.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

LoRA के साथ एलएलएम इंफ़रेंस चलाने के लिए, बेस मॉडल के generateResponse() या generateResponseAsync() तरीकों का इस्तेमाल करें.