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

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

इसे आज़माएं!

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

डिफ़ॉल्ट रूप से काम करने वाले मॉडल के अलावा, उपयोगकर्ता Google के एआई एज की सुविधाओं का इस्तेमाल करके, दूसरे मॉडल भी मैप कर सकते हैं. इनमें PyTorch मॉडल को मैप करना भी शामिल है. इससे, उपयोगकर्ताओं को मैप किए गए मॉडल को कई हस्ताक्षर वाले TensorFlow Lite मॉडल में एक्सपोर्ट करने की सुविधा मिलती है. ये मॉडल, टास्क बंडल बनाने के लिए टोकनेटर पैरामीटर के साथ बंडल किए जाते हैं.

शुरू करें

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

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

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

सुविधाएं

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

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

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

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

विकल्प का नाम ब्यौरा मान की सीमा डिफ़ॉल्ट मान
modelPath प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने का पाथ. पाथ लागू नहीं
maxTokens मॉडल, ज़्यादा से ज़्यादा कितने टोकन (इनपुट टोकन + आउटपुट टोकन) हैंडल कर सकता है. पूर्णांक 512
topK जनरेट करने के हर चरण में, मॉडल जिन टोकन को ध्यान में रखता है उनकी संख्या. सबसे ज़्यादा संभावित टोकन के लिए, अनुमान लगाने की सुविधा को सीमित करता है. पूर्णांक 40
temperature जनरेट करने के दौरान, रैंडम तरीके से जोड़े गए एलिमेंट की संख्या. ज़्यादा तापमान होने पर, जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखाई जाती है. वहीं दूसरी ओर, तापमान कम रखने से टेक्स्ट जनरेट होने का बेहतर अनुमान लगाया जा सकता है. फ़्लोट 0.8
randomSeed टेक्स्ट जनरेट करने के दौरान इस्तेमाल किया गया रैंडम सीड. पूर्णांक 0
loraPath डिवाइस पर स्थानीय तौर पर LoRA मॉडल का ऐब्सलूट पाथ. ध्यान दें: यह सुविधा सिर्फ़ GPU मॉडल के साथ काम करती है. पाथ लागू नहीं
resultListener नतीजे असींक्रोनस तरीके से पाने के लिए, नतीजा सुनने वाले को सेट करता है. सिर्फ़ तब लागू होता है, जब एक साथ काम नहीं करने वाली प्रोसेस जनरेट करने का तरीका इस्तेमाल किया जा रहा हो. लागू नहीं लागू नहीं
errorListener गड़बड़ी सुनने वाले को वैकल्पिक तौर पर सेट करता है. लागू नहीं लागू नहीं

मॉडल

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

LLM Inference API को शुरू करने से पहले, काम करने वाले किसी मॉडल को डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें.

जेमा-2 2बी

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 को डाउनलोड करने के बाद, यह मॉडल 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 मॉडल से Gemma को डाउनलोड करने के बाद, यह मॉडल 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 डाउनलोड करने के बाद, यह मॉडल MediaPipe के साथ इस्तेमाल करने के लिए पहले से ही सही फ़ॉर्मैट में होता है.

Falcon 1B

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

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

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

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

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

StableLM 3B

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

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

एलएलएम इन्फ़्रेंस एपीआई के लिए ज़रूरी है कि इन फ़ाइलों को लोकल तौर पर डाउनलोड और सेव किया जाए:

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

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

Phi-2

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

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

एलएलएम इन्फ़्रेंस एपीआई के लिए ज़रूरी है कि इन फ़ाइलों को लोकल तौर पर डाउनलोड और सेव किया जाए:

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

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

एआई (AI) एज से एक्सपोर्ट किए गए मॉडल

एआई एज, Google की एक सेवा है. इसकी मदद से, उपयोगकर्ता के मैप किए गए मॉडल को कई हस्ताक्षर वाले TensorFlow Lite मॉडल में बदला जा सकता है. मॉडल को मैप करने और एक्सपोर्ट करने के बारे में ज़्यादा जानकारी के लिए, AI Edge Torch के GitHub पेज पर जाएं.

मॉडल को TFLite फ़ॉर्मैट में एक्सपोर्ट करने के बाद, मॉडल को MediaPipe फ़ॉर्मैट में बदला जा सकता है. ज़्यादा जानकारी के लिए, मॉडल को MediaPipe फ़ॉर्मैट में बदलना देखें.

मॉडल को MediaPipe फ़ॉर्मैट में बदलना

नेटिव मॉडल कन्वर्ज़न

अगर किसी बाहरी एलएलएम (Phi-2, Falcon या StableLM) या Gemma के ऐसे वर्शन का इस्तेमाल किया जा रहा है जो Kaggle पर उपलब्ध नहीं है, तो मॉडल को MediaPipe के साथ काम करने लायक बनाने के लिए, हमारी कन्वर्ज़न स्क्रिप्ट का इस्तेमाल करें.

मॉडल को बदलने की प्रोसेस के लिए, 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 मॉडल के लिए.

पैरामीटर ब्यौरा स्वीकार की जा सकने वाली वैल्यू
input_ckpt model.safetensors या pytorch.bin फ़ाइल का पाथ. ध्यान दें कि कभी-कभी मॉडल सेफ़टेंसर फ़ॉर्मैट को कई फ़ाइलों में बांटा जाता है, जैसे कि model-00001-of-00003.safetensors, model-00001-of-00003.safetensors. आपके पास फ़ाइल का कोई पैटर्न तय करने का विकल्प होता है, जैसे कि model*.safetensors. पाथ
ckpt_format मॉडल का फ़ाइल फ़ॉर्मैट. {"safetensors", "pytorch"}
model_type एलएलएम को बदला जा रहा है. {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B", "GEMMA_7B", "GEMMA-2_2B"}
backend मॉडल को चलाने के लिए इस्तेमाल किया जाने वाला प्रोसेसर (डेलिगेट). {"cpu", "gpu"}
output_dir आउटपुट डायरेक्ट्री का पाथ, जिसमें हर लेयर की वेट फ़ाइलें होस्ट की जाती हैं. पाथ
output_tflite_file आउटपुट फ़ाइल का पाथ. उदाहरण के लिए, "model_cpu.bin" या "model_gpu.bin". यह फ़ाइल सिर्फ़ LLM Inference API के साथ काम करती है. इसका इस्तेमाल सामान्य `tflite` फ़ाइल के तौर पर नहीं किया जा सकता. पाथ
vocab_model_file tokenizer.json और tokenizer_config.json फ़ाइलों को सेव करने वाली डायरेक्ट्री का पाथ. जेमा के लिए, tokenizer.model फ़ाइल पर कर्सर ले जाएं. पाथ
lora_ckpt safetensors फ़ाइल के LoRA ckpt का पाथ, जो LoRA अडैप्टर का वज़न सेव करता है. पाथ
lora_rank LoRA ckpt की रैंक दिखाने वाला इंटीजर. लॉरा वेट को बदलने के लिए ज़रूरी है. अगर यह वैल्यू नहीं दी जाती है, तो कन्वर्टर यह मान लेता है कि कोई लोआरए वेट नहीं है. ध्यान दें: सिर्फ़ GPU बैकएंड, LoRA के साथ काम करता है. पूर्णांक
lora_output_tflite_file LoRA वज़न के लिए आउटपुट tflite फ़ाइल नाम. पाथ

एआई (AI) एज मॉडल कन्वर्ज़न

अगर एआई एज के ज़रिए, TFLite मॉडल पर मैप किए गए एलएलएम का इस्तेमाल किया जा रहा है, तो टास्क बंडल बनाने के लिए, बंडलिंग स्क्रिप्ट का इस्तेमाल करें. बंडलिंग की प्रोसेस, मैप किए गए मॉडल को अतिरिक्त मेटाडेटा के साथ पैक करती है. जैसे, 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)
पैरामीटर ब्यौरा स्वीकार की जा सकने वाली वैल्यू
tflite_model एआई एज से एक्सपोर्ट किए गए TFLite मॉडल का पाथ. पाथ
tokenizer_model SentencePiece टॉकेनेटर मॉडल का पाथ. पाथ
start_token मॉडल के हिसाब से शुरू होने का टोकन. स्टार्ट टोकन, दिए गए टोकनाइज़र मॉडल में मौजूद होना चाहिए. स्ट्रिंग
stop_tokens स्टॉप के लिए खास टोकन मॉडल करें. दिए गए टॉकेनेटर मॉडल में स्टॉप टोकन मौजूद होने चाहिए. LIST[STRING]
output_filename आउटपुट टास्क बंडल फ़ाइल का नाम. पाथ

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

Mediapipe LLM inference API को कॉन्फ़िगर करके, लार्ज लैंग्वेज मॉडल के लिए कम रैंक वाले अडैप्टेशन (LoRA) का इस्तेमाल किया जा सकता है. बेहतर बनाए गए LoRA मॉडल का इस्तेमाल करके, डेवलपर कम लागत वाली ट्रेनिंग प्रोसेस के ज़रिए, एलएलएम के व्यवहार को पसंद के मुताबिक बना सकते हैं.

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

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

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

# For Gemma-2B
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 इंफ़रेंस एपीआई के साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए, 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 मॉडल का अनुमान

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

Android, शुरू करने के दौरान स्टैटिक LoRA का इस्तेमाल करता है. LoRA मॉडल लोड करने के लिए, उपयोगकर्ता LoRA मॉडल पाथ के साथ-साथ बेस LLM भी तय करते हैं.

// 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() तरीकों का इस्तेमाल करें.