स्वतः पूर्ण

TensorFlow.org पर देखें Google Colab में चलाएँ

परिचय

बड़े भाषा मॉडल (एलएलएम) मशीन लर्निंग मॉडल का एक वर्ग है जिसे बड़े डेटासेट के आधार पर टेक्स्ट उत्पन्न करने के लिए प्रशिक्षित किया जाता है। उनका उपयोग प्राकृतिक भाषा प्रसंस्करण (एनएलपी) कार्यों के लिए किया जा सकता है, जिसमें पाठ निर्माण, प्रश्न उत्तर और मशीन अनुवाद शामिल हैं। वे ट्रांसफॉर्मर आर्किटेक्चर पर आधारित हैं और भारी मात्रा में टेक्स्ट डेटा पर प्रशिक्षित होते हैं, जिसमें अक्सर अरबों शब्द शामिल होते हैं। यहां तक ​​कि जीपीटी-2 जैसे छोटे पैमाने के एलएलएम भी प्रभावशाली प्रदर्शन कर सकते हैं। TensorFlow मॉडल को हल्के, तेज़ और कम-शक्ति वाले मॉडल में परिवर्तित करने से हमें बेहतर उपयोगकर्ता सुरक्षा के लाभ के साथ डिवाइस पर जेनरेटिव AI मॉडल चलाने की अनुमति मिलती है क्योंकि डेटा कभी भी आपके डिवाइस को नहीं छोड़ेगा।

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

हमने अपना एंड्रॉइड ऐप फ्रेमवर्क ओपन सोर्स किया है जिसे कोई भी संगत टीएफलाइट एलएलएम प्लग इन कर सकता है। यहां दो डेमो हैं:

  • चित्र 1 में, हमने डिवाइस पर पाठ पूरा करने के कार्य करने के लिए केरस जीपीटी-2 मॉडल का उपयोग किया।
  • चित्र 2 में, हमने निर्देश-ट्यून किए गए PaLM मॉडल (1.5 बिलियन पैरामीटर) के एक संस्करण को TFLite में परिवर्तित किया और TFLite रनटाइम के माध्यम से निष्पादित किया।

PaLM के साथ स्वतः पूर्ण
चित्र 1: पिक्सेल 7 पर पाठ पूरा करने के लिए डिवाइस पर केरस जीपीटी-2 मॉडल (इस कोडेलैब से परिवर्तित) चलाने का उदाहरण। डेमो बिना किसी स्पीडअप के वास्तविक विलंबता दिखाता है।

PaLM के साथ स्वतः पूर्ण

चित्र 2: 1.5 बिलियन मापदंडों के साथ PaLM मॉडल का एक संस्करण चलाने का उदाहरण। प्लेबैक स्पीडअप के बिना Pixel 7 Pro पर डेमो रिकॉर्ड किया गया है।

गाइड

मॉडल संलेखन

इस प्रदर्शन के लिए, हम GPT-2 मॉडल प्राप्त करने के लिए KerasNLP का उपयोग करेंगे। केरसएनएलपी एक पुस्तकालय है जिसमें प्राकृतिक भाषा प्रसंस्करण कार्यों के लिए अत्याधुनिक पूर्व-प्रशिक्षित मॉडल शामिल हैं, और यह उपयोगकर्ताओं को उनके संपूर्ण विकास चक्र के दौरान समर्थन दे सकता है। आप KerasNLP रिपॉजिटरी में उपलब्ध मॉडलों की सूची देख सकते हैं। वर्कफ़्लो मॉड्यूलर घटकों से निर्मित होते हैं जिनमें आउट-ऑफ़-द-बॉक्स उपयोग किए जाने पर अत्याधुनिक प्रीसेट वज़न और आर्किटेक्चर होते हैं और अधिक नियंत्रण की आवश्यकता होने पर आसानी से अनुकूलन योग्य होते हैं। GPT-2 मॉडल का निर्माण निम्नलिखित चरणों से किया जा सकता है:

gpt2_tokenizer = keras_nlp.models.GPT2Tokenizer.from_preset("gpt2_base_en")

gpt2_preprocessor = keras_nlp.models.GPT2CausalLMPreprocessor.from_preset(
    "gpt2_base_en",
    sequence_length=256,
    add_end_token=True,
)

gpt2_lm =
keras_nlp.models.GPT2CausalLM.from_preset(
"gpt2_base_en",
preprocessor=gpt2_preprocessor
)

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

  1. टोकननाइज़र : एक कच्चे स्ट्रिंग इनपुट को केरस एंबेडिंग परत के लिए उपयुक्त पूर्णांक टोकन आईडी में परिवर्तित करता है। GPT-2 विशेष रूप से बाइट-जोड़ी एन्कोडिंग (BPE) टोकननाइज़र का उपयोग करता है।

  2. प्रीप्रोसेसर : केरस मॉडल में इनपुट को टोकनाइज़ करने और पैक करने के लिए परत। यहां, प्रीप्रोसेसर टोकनाइजेशन के बाद टोकन आईडी के टेंसर को एक निर्दिष्ट लंबाई (256) तक पैड कर देगा।

  3. बैकबोन : केरस मॉडल जो SoTA ट्रांसफार्मर बैकबोन आर्किटेक्चर का अनुसरण करता है और इसमें पूर्व निर्धारित वजन होता है।

इसके अतिरिक्त, आप GitHub पर पूर्ण GPT-2 मॉडल कार्यान्वयन की जांच कर सकते हैं।

मॉडल रूपांतरण

TensorFlow Lite मोबाइल, माइक्रोकंट्रोलर और अन्य एज डिवाइसों पर तरीकों को तैनात करने के लिए एक मोबाइल लाइब्रेरी है। पहला कदम TensorFlow Lite कनवर्टर का उपयोग करके केरस मॉडल को अधिक कॉम्पैक्ट TensorFlow Lite प्रारूप में परिवर्तित करना है, और फिर परिवर्तित मॉडल को चलाने के लिए TensorFlow Lite दुभाषिया का उपयोग करना है, जो मोबाइल उपकरणों के लिए अत्यधिक अनुकूलित है।

GPT2CausalLM से generate() फ़ंक्शन से प्रारंभ करें जो रूपांतरण करता है। एक ठोस TensorFlow फ़ंक्शन बनाने के लिए generate() फ़ंक्शन को लपेटें:

@tf.function
def generate(prompt, max_length):
    """
    Args:
        prompt: input prompt to the LLM in string format
        max_length: the max length of the generated tokens
    """
    return gpt2_lm.generate(prompt, max_length)

concrete_func = generate.get_concrete_function(tf.TensorSpec([], tf.string), 100)

ध्यान दें कि रूपांतरण करने के लिए आप TFLiteConverter से from_keras_model() भी उपयोग कर सकते हैं।

अब एक सहायक फ़ंक्शन को परिभाषित करें जो एक इनपुट और एक TFLite मॉडल के साथ अनुमान चलाएगा। TFLite रनटाइम में TensorFlow टेक्स्ट ऑप्स बिल्ट-इन ऑप्स नहीं हैं, इसलिए दुभाषिया के लिए इस मॉडल पर अनुमान लगाने के लिए आपको इन कस्टम ऑप्स को जोड़ने की आवश्यकता होगी। यह सहायक फ़ंक्शन एक इनपुट और एक फ़ंक्शन स्वीकार करता है जो रूपांतरण करता है, अर्थात् ऊपर परिभाषित generator() फ़ंक्शन।

def run_inference(input, generate_tflite):
    interp = interpreter.InterpreterWithCustomOps(
        model_content=generate_tflite,
        custom_op_registerers=
            tf_text.tflite_registrar.SELECT_TFTEXT_OPS
    )

    interp.get_signature_list()

    generator = interp.get_signature_runner('serving_default')
    output = generator(prompt=np.array([input]))

अब आप मॉडल को परिवर्तित कर सकते हैं:

gpt2_lm.jit_compile = False
converter = tf.lite.TFLiteConverter.from_concrete_functions(
    [concrete_func],
    gpt2_lm)

converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS, # enable TFLite ops
    tf.lite.OpsSet.SELECT_TF_OPS, # enable TF ops
]
converter.allow_custom_ops = True
converter.target_spec.experimental_select_user_tf_ops = [
    "UnsortedSegmentJoin",
    "UpperBound"
]
converter._experimental_guarantee_all_funcs_one_use = True
generate_tflite = converter.convert()
run_inference("I'm enjoying a", generate_tflite)

परिमाणीकरण

TensorFlow Lite ने क्वांटाइजेशन नामक एक अनुकूलन तकनीक लागू की है जो मॉडल आकार को कम कर सकती है और अनुमान में तेजी ला सकती है। परिमाणीकरण प्रक्रिया के माध्यम से, 32-बिट फ्लोट्स को छोटे 8-बिट पूर्णांकों में मैप किया जाता है, इसलिए आधुनिक हार्डवेयर पर अधिक कुशल निष्पादन के लिए मॉडल आकार को 4 गुना कम कर दिया जाता है। TensorFlow में परिमाणीकरण करने के कई तरीके हैं। अधिक जानकारी के लिए आप TFLite मॉडल ऑप्टिमाइज़ेशन और TensorFlow मॉडल ऑप्टिमाइज़ेशन टूलकिट पेज पर जा सकते हैं। परिमाणीकरण के प्रकारों को नीचे संक्षेप में समझाया गया है।

यहां, आप कनवर्टर ऑप्टिमाइज़ेशन फ़्लैग को tf.lite.Optimize.DEFAULT ऑप्टिमाइज़.DEFAULT पर सेट करके GPT-2 मॉडल पर पोस्ट-ट्रेनिंग डायनेमिक रेंज क्वांटाइज़ेशन का उपयोग करेंगे, और बाकी रूपांतरण प्रक्रिया पहले बताए अनुसार ही है। हमने परीक्षण किया कि इस परिमाणीकरण तकनीक के साथ Pixel 7 पर विलंबता लगभग 6.7 सेकंड है और अधिकतम आउटपुट लंबाई 100 पर सेट है।

gpt2_lm.jit_compile = False
converter = tf.lite.TFLiteConverter.from_concrete_functions(
    [concrete_func],
    gpt2_lm)

converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS, # enable TFLite ops
    tf.lite.OpsSet.SELECT_TF_OPS, # enable TF ops
]
converter.allow_custom_ops = True
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.experimental_select_user_tf_ops = [
    "UnsortedSegmentJoin",
    "UpperBound"
]
converter._experimental_guarantee_all_funcs_one_use = True
quant_generate_tflite = converter.convert()
run_inference("I'm enjoying a", quant_generate_tflite)

डानामिक रेंज

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

एफपी16

फ्लोटिंग पॉइंट मॉडल को फ्लोट16 प्रकार के वजन को परिमाणित करके भी अनुकूलित किया जा सकता है। फ्लोट16 क्वांटाइजेशन के फायदे मॉडल के आकार को आधे तक कम कर रहे हैं (क्योंकि सभी वजन उनके आकार के आधे हो जाते हैं), जिससे सटीकता में न्यूनतम हानि होती है, और जीपीयू प्रतिनिधियों का समर्थन होता है जो सीधे फ्लोट16 डेटा पर काम कर सकते हैं (जिसके परिणामस्वरूप फ्लोट32 की तुलना में तेज गणना होती है) डेटा)। फ्लोट16 वेट में परिवर्तित मॉडल अभी भी अतिरिक्त संशोधनों के बिना सीपीयू पर चल सकता है। पहले अनुमान से पहले फ्लोट16 वज़न को फ्लोट32 में अपसैंपल किया जाता है, जो विलंबता और सटीकता पर न्यूनतम प्रभाव के बदले मॉडल आकार में कमी की अनुमति देता है।

पूर्ण पूर्णांक परिमाणीकरण

पूर्ण पूर्णांक परिमाणीकरण दोनों 32 बिट फ़्लोटिंग पॉइंट संख्याओं को, वजन और सक्रियण सहित, निकटतम 8 बिट पूर्णांक में परिवर्तित करता है। इस प्रकार के परिमाणीकरण के परिणामस्वरूप बढ़ी हुई अनुमान गति के साथ एक छोटा मॉडल प्राप्त होता है, जो माइक्रोकंट्रोलर का उपयोग करते समय अविश्वसनीय रूप से मूल्यवान होता है। इस मोड की अनुशंसा तब की जाती है जब सक्रियण परिमाणीकरण के प्रति संवेदनशील होते हैं।

एंड्रॉइड ऐप एकीकरण

आप अपने TFLite मॉडल को Android ऐप में एकीकृत करने के लिए इस Android उदाहरण का अनुसरण कर सकते हैं।

आवश्यक शर्तें

यदि आपने पहले से नहीं किया है, तो वेबसाइट पर दिए गए निर्देशों का पालन करते हुए एंड्रॉइड स्टूडियो इंस्टॉल करें।

  • एंड्रॉइड स्टूडियो 2022.2.1 या इसके बाद का संस्करण।
  • 4जी से अधिक मेमोरी वाला एंड्रॉइड डिवाइस या एंड्रॉइड एमुलेटर

एंड्रॉइड स्टूडियो के साथ निर्माण और संचालन

  • एंड्रॉइड स्टूडियो खोलें, और स्वागत स्क्रीन से, मौजूदा एंड्रॉइड स्टूडियो प्रोजेक्ट खोलें का चयन करें।
  • दिखाई देने वाली ओपन फ़ाइल या प्रोजेक्ट विंडो से, जहां भी आपने TensorFlow Lite नमूना GitHub रेपो क्लोन किया है, वहां से lite/examples/generative_ai/android निर्देशिका पर नेविगेट करें और उसका चयन करें।
  • आपको त्रुटि संदेशों के अनुसार विभिन्न प्लेटफ़ॉर्म और टूल इंस्टॉल करने की भी आवश्यकता हो सकती है।
  • परिवर्तित .tflite मॉडल का नाम बदलकर autocomplete.tflite और इसे app/src/main/assets/ फ़ोल्डर में कॉपी करें।
  • ऐप बनाने के लिए मेनू बिल्ड -> प्रोजेक्ट बनाएं का चयन करें। (Ctrl+F9, आपके संस्करण पर निर्भर करता है)।
  • मेनू रन -> रन 'ऐप' पर क्लिक करें। (Shift+F10, आपके संस्करण पर निर्भर करता है)

वैकल्पिक रूप से, आप इसे कमांड लाइन में बनाने के लिए ग्रेडल रैपर का भी उपयोग कर सकते हैं। कृपया अधिक जानकारी के लिए ग्रैडल दस्तावेज़ देखें।

(वैकल्पिक) .aar फ़ाइल बनाना

डिफ़ॉल्ट रूप से ऐप स्वचालित रूप से आवश्यक .aar फ़ाइलें डाउनलोड करता है। लेकिन अगर आप अपना खुद का निर्माण करना चाहते हैं, तो app/libs/build_aar/ फ़ोल्डर रन ./build_aar.sh पर स्विच करें। यह स्क्रिप्ट TensorFlow टेक्स्ट से आवश्यक ऑप्स खींचेगी और चुनिंदा TF ऑपरेटरों के लिए aar का निर्माण करेगी।

संकलन के बाद, एक नई फ़ाइल tftext_tflite_flex.aar उत्पन्न होती है। .aar फ़ाइल को app/libs/ फ़ोल्डर में बदलें और ऐप को फिर से बनाएं।

ध्यान दें कि आपको अभी भी अपनी ग्रेडल फ़ाइल में मानक tensorflow-lite एआर शामिल करने की आवश्यकता है।

प्रसंग विंडो का आकार

ऐप में एक परिवर्तनीय पैरामीटर 'संदर्भ विंडो आकार' है, जिसकी आवश्यकता है क्योंकि एलएलएम में आज आम तौर पर एक निश्चित संदर्भ आकार होता है जो सीमित करता है कि मॉडल में कितने शब्द/टोकन को 'प्रॉम्प्ट' के रूप में फीड किया जा सकता है (ध्यान दें कि 'शब्द' जरूरी नहीं है) इस मामले में, विभिन्न टोकननाइजेशन विधियों के कारण 'टोकन' के बराबर)। यह संख्या महत्वपूर्ण है क्योंकि:

  • इसे बहुत छोटा सेट करने पर, मॉडल में सार्थक आउटपुट उत्पन्न करने के लिए पर्याप्त संदर्भ नहीं होगा
  • इसे बहुत बड़ा सेट करने पर, मॉडल में काम करने के लिए पर्याप्त जगह नहीं होगी (क्योंकि आउटपुट अनुक्रम में प्रॉम्प्ट शामिल है)

आप इसके साथ प्रयोग कर सकते हैं, लेकिन इसे आउटपुट अनुक्रम लंबाई के ~50% पर सेट करना एक अच्छी शुरुआत है।

सुरक्षा और जिम्मेदार एआई

जैसा कि मूल OpenAI GPT-2 घोषणा में बताया गया है, GPT-2 मॉडल के साथ उल्लेखनीय चेतावनियाँ और सीमाएँ हैं। वास्तव में, आज एलएलएम में आम तौर पर कुछ प्रसिद्ध चुनौतियाँ हैं जैसे मतिभ्रम, निष्पक्षता और पूर्वाग्रह; ऐसा इसलिए है क्योंकि इन मॉडलों को वास्तविक दुनिया के डेटा पर प्रशिक्षित किया जाता है, जो उन्हें वास्तविक दुनिया के मुद्दों को प्रतिबिंबित करने में सक्षम बनाता है।

यह कोडलैब केवल यह प्रदर्शित करने के लिए बनाया गया है कि TensorFlow टूलिंग के साथ LLM द्वारा संचालित ऐप कैसे बनाया जाए। इस कोडलैब में निर्मित मॉडल केवल शैक्षिक उद्देश्यों के लिए है और उत्पादन उपयोग के लिए नहीं है।

एलएलएम उत्पादन उपयोग के लिए प्रशिक्षण डेटासेट के विचारशील चयन और व्यापक सुरक्षा शमन की आवश्यकता होती है। इस एंड्रॉइड ऐप में पेश की गई ऐसी ही एक कार्यक्षमता अपवित्रता फ़िल्टर है, जो खराब उपयोगकर्ता इनपुट या मॉडल आउटपुट को अस्वीकार कर देती है। यदि कोई अनुचित भाषा पाई जाती है, तो ऐप बदले में उस कार्रवाई को अस्वीकार कर देगा। एलएलएम के संदर्भ में रिस्पॉन्सिबल एआई के बारे में अधिक जानने के लिए, Google I/O 2023 में जेनेरेटिव लैंग्वेज मॉडल के साथ सुरक्षित और जिम्मेदार विकास तकनीकी सत्र देखना सुनिश्चित करें और रिस्पॉन्सिबल एआई टूलकिट देखें।