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

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

इसे आज़माएं!

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

नेटिव मॉडल के अलावा, उपयोगकर्ता Google के AI Edge ऑफ़र का इस्तेमाल करके, दूसरे मॉडल मैप कर सकते हैं. इसमें PyTorch मॉडल को मैप करना भी शामिल है. इससे उपयोगकर्ता, मैप किए गए मॉडल को मल्टी-सिग्नेचर TensorFlow Lite मॉडल में एक्सपोर्ट कर सकते हैं. जिन्हें टोकनाइज़र पैरामीटर के साथ बंडल करके टास्क बंडल बनाया जाता है.

शुरू करें

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

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

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

सुविधाएं

एलएलएम अनुमान एपीआई में ये मुख्य सुविधाएं शामिल होती हैं:

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

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

इस टास्क में कॉन्फ़िगरेशन के ये विकल्प हैं:

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

मॉडल

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

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

जेम्मा 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-बिट मॉडल, जिसमें जीपीयू के साथ काम करने की सुविधा है.
  • gemma-2b-it-gpu-int8: Gemma 2B 8-बिट मॉडल, जिसमें जीपीयू के साथ काम करने की सुविधा है.

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

हगिंग फ़ेस से Gemma 2B को डाउनलोड करने पर, आपको मॉडल को MediaPipe-फ़्रेंडली फ़ॉर्मैट में बदलना होगा. एलएलएम अनुमान एपीआई के लिए, इन फ़ाइलों को डाउनलोड और कन्वर्ट करने की ज़रूरत होती है:

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

जेम्मा 7B

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

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

Gemma 7B मॉडल, एक ही वैरिएंट में आता है:

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

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

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

फ़ाल्कन 1B

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

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

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

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

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

स्टेबलएलएम 3B

StableLM-3B 300 करोड़ पैरामीटर डिकोडर सिर्फ़ भाषा का मॉडल है. इसे अंग्रेज़ी के अलग-अलग 10 खरब टोकन और चार पीरियड के कोड डेटासेट के साथ पहले से ट्रेनिंग दी गई है.

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 Edge के एक्सपोर्ट किए गए मॉडल

AI Edge, 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 के अन्य विकल्प भी बताए जाने चाहिए. ध्यान दें कि एपीआई, जीपीयू के साथ सिर्फ़ 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. PATH
ckpt_format मॉडल फ़ाइल का फ़ॉर्मैट. {"safetensors", "pytorch"}
model_type एलएलएम को बदला जा रहा है. {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
backend मॉडल को चलाने के लिए इस्तेमाल किया जाने वाला प्रोसेसर (प्रतिनिधि). {"cpu", "gpu"}
output_dir हर लेयर की वेट फ़ाइलों को होस्ट करने वाली आउटपुट डायरेक्ट्री का पाथ. PATH
output_tflite_file आउटपुट फ़ाइल का पाथ. उदाहरण के लिए, "model_cpu.bin" या "model_gpu.bin". यह फ़ाइल सिर्फ़ एलएलएम अनुमान एपीआई के साथ काम करती है. इसे सामान्य `tflite` फ़ाइल के तौर पर इस्तेमाल नहीं किया जा सकता. PATH
vocab_model_file उस डायरेक्ट्री का पाथ जिसमें tokenizer.json और tokenizer_config.json फ़ाइलें सेव की जाती हैं. जेम्मा के लिए, एक tokenizer.model फ़ाइल पर कर्सर ले जाएं. PATH
lora_ckpt सेफ़टेंसर फ़ाइल के LoRA ckpt का पाथ, जिसमें LoRA अडैप्टर का वज़न सेव होता है. PATH
lora_rank LoRA ckpt की रैंक दिखाने वाला पूर्णांक. लॉरा वेट को बदलने के लिए ज़रूरी है. अगर यह पैरामीटर उपलब्ध नहीं कराया जाता, तो कन्वर्टर को यह लगता है कि कोई LoRA वेट नहीं है. ध्यान दें: सिर्फ़ जीपीयू बैकएंड में, LoRA के साथ काम किया जा सकता है. पूरी संख्या
lora_output_tflite_file LoRA वज़न के लिए आउटपुट फ़ाइल का tflite फ़ाइल नाम. PATH

AI Edge मॉडल का कन्वर्ज़न

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

मॉडल बंडलिंग प्रोसेस के लिए 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 AI Edge से एक्सपोर्ट किए गए TFLite मॉडल का पाथ. PATH
tokenizer_model StencePiece के टोकनाइज़र मॉडल का पाथ. PATH
start_token मॉडल के लिए खास स्टार्ट टोकन. दिए गए टोकनाइज़र मॉडल में, स्टार्ट टोकन मौजूद होना चाहिए. स्ट्रिंग
stop_tokens मॉडल के हिसाब से खास स्टॉप टोकन. दिए गए टोकनाइज़र मॉडल में, स्टॉप टोकन मौजूद होना चाहिए. सूची[STRING]
output_filename आउटपुट टास्क बंडल फ़ाइल का नाम. PATH

LoRA कस्टमाइज़ेशन

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

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

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

अपने डेटासेट वाले बेहतर ट्यून किए गए LoRA मॉडल को Gemma-2B या Phi-2 पर, काम करने वाले मॉडल के साथ ट्रेनिंग देने के लिए, HggingFace पर दिए गए निर्देशों का पालन करें. Gemma-2B और Phi-2 मॉडल, HuggingFace पर सेफ़ेंसर फ़ॉर्मैट में उपलब्ध हैं. एलएलएम अनुमान एपीआई, ध्यान खींचने वाली लेयर पर सिर्फ़ 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 पर उपलब्ध एलएलएम इंफ़रेंस एपीआई के हिसाब से उपलब्ध हैं. उदाहरण के लिए, Gemma-2B के लिए monsterapi/gemma-2b-lora-maths-orca-200k और Phi-2 के लिए lole25/phi-2-sft-ultrachat-lora.

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

अगले चरण में, आपको MediaPipe Python पैकेज का इस्तेमाल करके मॉडल वेट को TensorFlow Lite फ़्लैटबफ़र में बदलना होगा. 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 एलएलएम इंफ़रेंस एपीआई को अपडेट किया गया है. वेब, डाइनैमिक LoRA के साथ काम करता है. यह रनटाइम के दौरान, अलग-अलग LoRA मॉडल को स्विच कर सकता है. Android और iOS, स्टैटिक LoRA के साथ काम करते हैं. इसमें, टास्क के पूरे समय के दौरान, एक ही LoRA वेट का इस्तेमाल किया जाता है.

शुरू करने के दौरान, Android में स्टैटिक LoRA की सुविधा दी जाती है. LoRA मॉडल को लोड करने के लिए, उपयोगकर्ता 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() तरीकों का इस्तेमाल करें जिन्हें बेस मॉडल में इस्तेमाल किया गया था.