जनरेटिव एआई के बारे में जानकारी

Google Colab में चलाएं

GitHub पर सोर्स देखें

कोडलैब में जानें

शुरुआती जानकारी

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

लर्निंग इंटरप्रेटेबिलिटी टूल (LIT; वेबसाइट, GitHub) एक ऐसा प्लैटफ़ॉर्म है जिसकी मदद से, एमएल मॉडल को डीबग किया जा सकता है और उनका विश्लेषण किया जा सकता है. इससे यह समझने में मदद मिलती है कि वे ऐसा क्यों और कैसे करते हैं.

इस कोडलैब में, आपको Google के Gemma मॉडल का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए, LIT का इस्तेमाल करने का तरीका पता चलेगा. इस कोडलैब से पता चलता है कि प्रॉम्प्ट इंजीनियरिंग के अलग-अलग तरीकों का विश्लेषण करने के लिए, सीक्वेंस सेलियन का इस्तेमाल कैसे किया जाता है. यह तकनीक, इसे समझने में आसान है.

सीखने के मकसद:

1. मॉडल विश्लेषण में क्रम की तुलना और इसके इस्तेमाल को समझना.
2. प्रॉम्प्ट आउटपुट और क्रम के समय की जानकारी का हिसाब लगाने के लिए, Gemma के लिए LIT सेट अप करना.
3. मॉडल आउटपुट पर प्रॉम्प्ट डिज़ाइन के असर को समझने के लिए, एलएम सेलियन मॉड्यूल की मदद से सिलसिलेवार तरीके से दिखाए जाने वाले टूल का इस्तेमाल करना.
4. LIT में, प्रॉम्प्ट में सुधार की परिकल्पना की जा रही है और उसका असर पता किया जा रहा है.

ध्यान दें: यह कोडलैब, Gemma के KerasNLP को लागू करने और बैकएंड के लिए, TensorFlow v2 का इस्तेमाल करता है. हमारा सुझाव है कि आप जीपीयू कर्नेल का इस्तेमाल करके, बेहतर तरीके से काम करें.

मॉडल विश्लेषण में क्रम का डेटा और इसके इस्तेमाल

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

सेलियन के तरीके, जानकारी देने वाली एआई (XAI) तकनीकों की एक क्लास हैं. इनसे आपको यह पता चल सकता है कि इनपुट के कौनसे हिस्से, आउटपुट के अलग-अलग हिस्सों के लिए मॉडल के लिए अहम हैं. LIT अलग-अलग कैटगरी के टास्क के लिए, विश्लेषण के तरीकों के साथ काम करता है. इससे, अनुमानित लेबल पर इनपुट टोकन के क्रम के असर के बारे में पता चलता है. क्रम चुने जाने की वजह से, इन तरीकों को टेक्स्ट-टू-टेक्स्ट जनरेटिव मॉडल के हिसाब से तय किया जाता है. साथ ही, जनरेट किए गए टोकन पर पहले से चल रहे टोकन के असर की जानकारी मिलती है.

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

ग्रेडिएंट पर आधारित बेहतर तरीकों में ग्रेड ⋅ इनपुट और इंटिग्रेट किए गए ग्रेडिएंट शामिल हैं. एब्लेशन-आधारित तरीके भी उपलब्ध हैं, जैसे कि LIME और SHAP, जो ज़्यादा मज़बूत हो सकते हैं, लेकिन उसका हिसाब लगाना काफ़ी महंगा हो सकता है. अलग-अलग तरह के विकल्पों की तुलना के बारे में ज़्यादा जानकारी के लिए, यह लेख पढ़ें.

इस शुरुआती इंटरैक्टिव इंटरैक्टिव एक्सप्लोरेशन से सॉलिएंस के तरीकों के विज्ञान के बारे में ज़्यादा जानें.

इंपोर्ट, एनवायरमेंट, और अन्य सेटअप कोड

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
bigframes 0.21.0 requires scikit-learn>=1.2.2, but you have scikit-learn 1.0.2 which is incompatible.
google-colab 1.0.0 requires ipython==7.34.0, but you have ipython 8.14.0 which is incompatible.

इन्हें नज़रअंदाज़ किया जा सकता है.

LIT और Keras NLP को इंस्टॉल करें

इस कोडलैब का बेस मॉडल डाउनलोड करने के लिए, आपके पास keras (3) keras-nlp (0.8.0) और lit-nlp (1.1) का नया वर्शन और Kaggle खाते का होना ज़रूरी है.

pip install -q -U lit-nlp
pip uninstall -y umap-learn
pip install -q -U keras-nlp
pip install -q -U keras

Kaggle ऐक्सेस

Kaggle में लॉगिन करने के लिए, अपनी kaggle.json क्रेडेंशियल फ़ाइल को ~/.kaggle/kaggle.json पर सेव करें या Colab के एनवायरमेंट में यह चलाएं. ज़्यादा जानकारी के लिए, kagglehub पैकेज के दस्तावेज़ देखें.

import kagglehub

kagglehub.login()

Gemma के लाइसेंस का कानूनी समझौता भी स्वीकार करना न भूलें.

Gemma के लिए LIT सेट अप करना

LIT मॉडल सेट अप करना

import os

os.environ["KERAS_BACKEND"] = "tensorflow"

import keras
import keras_nlp

# Run at half precision.
keras.config.set_floatx("bfloat16")

model_name = 'gemma_instruct_2b_en'
gemma_model = keras_nlp.models.GemmaCausalLM.from_preset(model_name)

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

from lit_nlp.examples.models import instrumented_keras_lms

batch_size = 1
max_sequence_length = 512
init_models = instrumented_keras_lms.initialize_model_group_for_salience
models = init_models(model_name, gemma_model,
                     batch_size=batch_size,
                     max_length=max_sequence_length)

LIT डेटासेट सेट अप करना

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

• prompt: KerasGenerationModel के लिए इनपुट.
• target: वैकल्पिक टारगेट क्रम, जैसे कि "ग्राउंड ट्रुथ" (गोल्ड) जवाब या मॉडल से पहले से जनरेट किया गया जवाब.

LIT में sample_prompts का एक छोटा सेट शामिल होता है, जिसमें अलग-अलग सोर्स के उदाहरण शामिल होते हैं, जैसे:

• [GSM8K][GSM8K]: कुछ उदाहरणों की मदद से, स्कूल के ग्रेड की गणित के सवालों को हल करना.
• [Gigaword बेंचमार्क][gigaword]: छोटे लेखों के संग्रह के लिए हेडलाइन बनाना.
• [संविधान के तहत निर्देश देना][कॉन्स्टिट्यूशनल-प्रॉम्पटिंग]: दिशा-निर्देशों/सीमाओं वाली चीज़ों का इस्तेमाल कैसे करें, इस बारे में नए आइडिया जनरेट करना

अपना डेटा आसानी से लोड किया जा सकता है. डेटा को .jsonl फ़ाइल के तौर पर लोड किया जा सकता है, जिसमें prompt फ़ील्ड वाले रिकॉर्ड शामिल हैं. साथ ही, target ([example][jsonl-example]) डेटा या किसी भी फ़ॉर्मैट में डेटा लोड किया जा सकता है. इसके लिए, LIT के डेटासेट एपीआई का इस्तेमाल करें.

सैंपल प्रॉम्प्ट लोड करने के लिए, नीचे दिया गया सेल चलाएं.

from lit_nlp.examples.datasets import lm as lm_data

datasets = {
  'sample_prompts': lm_data.PromptExamples(
      lm_data.PromptExamples.SAMPLE_DATA_PATH
  ),
}

LIT यूज़र इंटरफ़ेस (यूआई) सेट अप करना

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

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

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

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

from lit_nlp.api import layout
modules = layout.LitModuleName

LM_SALIENCE_LAYOUT = layout.LitCanonicalLayout(
    left={
        'Data Table': [modules.DataTableModule],
        'Datapoint Editor': [modules.DatapointEditorModule],
    },
    upper={  # if 'lower' not specified, this fills the right side
        'Salience': [modules.LMSalienceModule],
    },
    layoutSettings=layout.LayoutSettings(leftWidth=40),
    description='Custom layout for language model salience.',
)

यह सेल, LIT सर्वर को शुरू करता है. इसमें कुछ सेकंड लग सकते हैं, क्योंकि यह सैंपल प्रॉम्प्ट पर मॉडल को भी चलाता है और नतीजे को कैश मेमोरी में सेव करता है.

from lit_nlp import notebook as lit_notebook

lit_widget = lit_notebook.LitWidget(
    models=models,
    datasets=datasets,
    layouts={'default': LM_SALIENCE_LAYOUT},
    default_layout='default',
)

अब यूज़र इंटरफ़ेस (यूआई) को दिखाया जा सकता है:

lit_widget.render(height=800)

<IPython.core.display.Javascript object>

LIT को नए टैब में पूरे पेज के तौर पर भी खोला जा सकता है. इस सेल को चलाएं और उसमें दिखने वाले लिंक पर क्लिक करें:

lit_widget.render(open_in_new_tab=True)

<IPython.core.display.Javascript object>

एलआईटी में जेमा के लिए कुछ शॉट प्रॉम्प्ट का विश्लेषण

प्रॉम्प्ट करना, आज जितनी कला है उतना ही विज्ञान है. LIT, जेम्मा जैसे बड़े लैंग्वेज मॉडल के प्रॉम्प्ट को बेहतर बनाने में आपकी मदद कर सकता है. आगे आपको एक उदाहरण दिखेगा. से पता चलेगा कि जेम्मा की गतिविधियों का पता लगाने, संभावित समस्याओं का अनुमान करने, और उसकी सुरक्षा को बेहतर बनाने के लिए LIT का इस्तेमाल कैसे किया जा सकता है.

जटिल प्रॉम्प्ट में गड़बड़ियों की पहचान करना

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

एक उदाहरण के ज़रिए, किसी व्यक्ति को यह आकलन करने में मदद करें कि उसे अपनी पसंद के हिसाब से खाना पसंद है या नहीं. शुरुआती प्रोटोटाइप चेन-ऑफ़-विचार का प्रॉम्प्ट-टेंप्लेट ऐसा दिख सकता है:

def analyze_menu_item_template(food_likes, food_dislikes, menu_item):
  return f"""Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: {food_likes}
Taste-dislikes: {food_dislikes}
Suggestion: {menu_item}
Analysis:"""

क्या आपको इस प्रॉम्प्ट में कोई समस्या दिखा? LIT की मदद से, LM Salience मॉड्यूल का इस्तेमाल करके, प्रॉम्प्ट की जांच की जा सकती है.

डीबग करने के लिए, क्रम के विकल्प का इस्तेमाल करें

यह मॉड्यूल, प्रॉम्प्ट के उन हिस्सों को हाइलाइट करता है जिनका जवाब मॉडल जनरेट करते समय देखता है. सैलियंस का हिसाब, हर इनपुट टोकन के लिए छोटे से छोटे लेवल पर किया जाता है. हालांकि, LIT टोकन के हिसाब से, ज़्यादा जानकारी देने वाले कई बड़े वाक्यों को इकट्ठा कर सकता है, जैसे कि लाइन, वाक्य या शब्द. हमारे Saliency Explorable में आपको इस बारे में ज़्यादा जानकारी मिल सकती है कि कैसे बेहतर है और इसका इस्तेमाल करके अनजाने में होने वाले पूर्वाग्रहों का पता कैसे लगाया जा सकता है.

सबसे पहले प्रॉम्प्ट-टेंप्लेट वैरिएबल के लिए, प्रॉम्प्ट में एक नया इनपुट इनपुट देकर शुरुआत करते हैं:

food_likes = """Cheese"""
food_dislikes = """Can't eat eggs"""
menu_item = """Quiche Lorraine"""

prompt = analyze_menu_item_template(food_likes, food_dislikes, menu_item)
print(prompt)

fewshot_mistake_example = {'prompt': prompt}  # you'll use this below

Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis:

अगर आपने ऊपर या किसी दूसरे टैब में LIT यूज़र इंटरफ़ेस (यूआई) खोला है, तो इस प्रॉम्प्ट को जोड़ने के लिए LIT के डेटापॉइंट एडिटर का इस्तेमाल किया जा सकता है:

दूसरा तरीका है कि विजेट को दिलचस्पी के संकेत के साथ फिर से रेंडर करें:

lit_widget.render(data=[fewshot_mistake_example])

<IPython.core.display.Javascript object>

इस हैरान करने वाले मॉडल की परफ़ॉर्मेंस पर ध्यान दें:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: A savoury tart with cheese and eggs
Recommendation: You might not like it, but it's worth trying.

मॉडल आपको कुछ ऐसा खाने का सुझाव क्यों दे रही है जिसके बारे में आपने साफ़ तौर पर कहा कि आप नहीं खा सकते?

सिलसिलेवार विज्ञापन से मूल समस्या को हाइलाइट करने में मदद मिल सकती है, जो हमारे कुछ उदाहरणों में बताया गया है. पहले उदाहरण में, विश्लेषण वाले सेक्शन it has cooked onions in it, which you don't like में मौजूद 'सोच-विचार करने की रीज़निंग', आखिरी सुझाव You have to try it से मेल नहीं खाती.

LM Salience मॉड्यूल में, "वाक्य" चुनें. इसके बाद, सुझाव की लाइन चुनें. यूज़र इंटरफ़ेस (यूआई) अब ऐसा दिखेगा:

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

def get_fewshot_example(source: str) -> str:
  for example in datasets['sample_prompts'].examples:
    if example['source'] == source:
      return example['prompt']
  raise ValueError(f'Source "{source}" not found in the dataset.')

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-fixed')}])

<IPython.core.display.Javascript object>

अब इस मॉडल को पूरा किया जाएगा:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish contains eggs and cheese, which you don't like.
Recommendation: Avoid.

इससे बचने के लिए एक ज़रूरी चीज़ यह है: शुरुआती तौर पर प्रोटोटाइप करने से उन जोखिमों का पता चलता है जिनके बारे में आपको पहले से नहीं लगता है. इसी तरह, भाषा के मॉडल में गड़बड़ी होने की आशंका है. इसका मतलब है कि आपको गड़बड़ियों के लिए खुद ही कुछ डिज़ाइन करना पड़ता है. इस बारे में ज़्यादा जानकारी, हमारी People + AI Guidebook में देखी जा सकती है, ताकि एआई की मदद से डिज़ाइन तैयार किया जा सके.

सही किए गए कुछ शॉट प्रॉम्प्ट बेहतर हैं, लेकिन अब भी यह सही नहीं है: यह उपयोगकर्ता को अंडे से बचने के सही तरीके से कहता है, लेकिन तर्क सही नहीं है. इसमें लिखा है कि उन्हें अंडे पसंद नहीं हैं, जबकि असल में उपयोगकर्ता ने कहा हो कि वह अंडे नहीं खा सकता. अगले सेक्शन में, आपको दिखेगा कि अपनी परफ़ॉर्मेंस को बेहतर कैसे किया जा सकता है.

मॉडल के व्यवहार को बेहतर बनाने के लिए, परिकल्पनाओं की जांच करना

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

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

Analyze a menu item in a restaurant.

* The analysis should be brief and to the point.
* The analysis and recommendation should both be clear about the suitability for someone with a specified dietary restriction.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: Avoid.

...

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-constitution')}])

<IPython.core.display.Javascript object>

इस अपडेट के बाद, उदाहरण को फिर से चलाया जा सकता है और इससे बहुत अलग आउटपुट मिल सकता है:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish containts eggs, which you can't eat.
Recommendation: Not suitable for you.

इसके बाद, मुख्य जानकारी की फिर से जांच की जा सकती है, ताकि यह पता लगाया जा सके कि यह बदलाव क्यों हो रहा है:

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

मॉडल की जांच और एक्सप्लोरेशन में गैर-तकनीकी टीमों को शामिल करना

समझ में आने की सुविधा का मतलब है, टीम के साथ मिलकर काम करना, जिसमें XAI, नीति, कानून, और अन्य चीज़ों के बारे में विशेषज्ञता शामिल हो.

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

LIT के ज़रिए, उसे उम्मीद है कि यह मिसाल बदल सकती है. जैसा कि आपने इस कोडलैब के ज़रिए देखा है, LIT की विज़ुअल मीडियम और इंटरैक्टिव क्षमता, दिलचस्पी को परखने और उदाहरण एक्सप्लोर करने की क्षमता से अलग-अलग हिस्सेदारों को जानकारी शेयर करने और शेयर करने में मदद कर सकती है. इससे आपको मॉडल एक्सप्लोरेशन, जांच, और डीबग करने के लिए, टीम के अलग-अलग सदस्यों को जोड़ने में मदद मिलती है. उन्हें इन तकनीकी तरीकों के बारे में बताने से, मॉडल के काम करने के तरीके के बारे में उनकी समझ बढ़ सकती है. इसके अलावा, शुरुआती मॉडल टेस्टिंग में विशेषज्ञता का अलग-अलग तरह से इस्तेमाल करने से अनचाहे नतीजों का पता लगाने में भी मदद मिल सकती है, जिन्हें बेहतर बनाया जा सकता है.

Recap

ज़रूरी बातों पर फिर से एक नज़र:

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

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

आखिर में: लिट लगातार बेहतर हो रहा है! हमारी सुविधाओं के बारे में ज़्यादा जानें और अपने सुझाव यहां शेयर करें.

अपेंडिक्स: LIT, क्रम चुने जाने की गतिविधि को कैसे मापता है

LIT कई चरणों वाली प्रोसेस में, क्रम की तुलना करता है.

1. इनपुट स्ट्रिंग (प्रॉम्प्ट और मॉडल की जनरेशन या "गोल्ड" टारगेट सीक्वेंस) दिए जाने पर, उसे मॉडल इनपुट के लिए टोकनाइज़ करें.
2. इनपुट टोकन को बाईं ओर एक पोज़िशन घुमाकर "टारगेट" क्रम तय करें.
3. जनरेशन और "टारगेट" सीक्वेंस के बीच एम्बेड किए गए डेटा को निकालें और हर टोकन के नुकसान का हिसाब लगाएं.
4. आपको जिन टोकन के बारे में जानकारी चाहिए उन्हें अलग करने के लिए, नुकसान को मास्क करें.
5. tf.GradientTape.gradient() फ़ंक्शन का इस्तेमाल करके, मास्क की गई परफ़ॉर्मेंस के आधार पर इनपुट एम्बेड करने के ग्रेडिएंट का पता लगाएं.
6. हर इनपुट टोकन का एक स्कोर देने के लिए ग्रेडिएंट को प्रोसेस करें. उदाहरण के लिए, हर पोज़िशन पर ग्रेडिएंट का L2 नॉर्मल लेकर.

अपेंडिक्स: प्रोग्राम के हिसाब से, ज़रूरी जानकारी की गणना करना

सीधे Python से, सैलियंस स्कोर को कैलकुलेट किया जा सकता है. इसके लिए, ऊपर दिए गए उन चरणों का इस्तेमाल करें जिन्हें LIT टूल अंदरूनी तौर पर चलाता है. आपको यह तीन चरणों में करना होगा:

1. एक उदाहरण तैयार करें और मॉडल टोकनाइज़र चलाएं,
2. एक ऐसा मास्क तैयार करें जिसमें यह बताया गया हो कि किस (अनुमानित) टोकन को समझाना है.
3. सॉल्ट रैपर को कॉल करें.

LIT के लिए इनपुट का उदाहरण बनाएं

example = {
    'prompt': 'Keras is a',
    'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'
}
example

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'}

कॉल करने के तरीकों के बारे में जानकारी: टोकनाइज़र और सैलियंस रैपर, दोनों में LIT के मॉडल एपीआई का इस्तेमाल किया जाता है. इसमें .predict() फ़ंक्शन, उदाहरणों (डिक्ट) की सूची लेता है और रिस्पॉन्स (डिक्ट) का जनरेटर दिखाता है. बड़े डेटासेट या धीमे मॉडल के साथ काम करते समय यह तरीका ज़्यादा सुविधाजनक है. हालांकि, इसका मतलब यह है कि अगर आपको सिर्फ़ एक उदाहरण पर अनुमान चाहिए, तो अब आपको उसे कुछ इस तरह से रैप करना होगा: list(model.predict([example])[0]

टोकन पाएं, ताकि आप एक्सप्लेनेशन टारगेट चुन सकें

tokenizer = models[f"_{model_name}_tokenizer"].predict
tokens = list(tokenizer([example]))[0]['tokens']
tokens

array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
       '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
       '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
       '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
       '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')

सॉल्ट को कैलकुलेट करने के लिए, आपको एक टारगेट मास्क बनाना होगा. इससे यह पता चलेगा कि किस (अनुमानित) टोकन के बारे में बताना है. टारगेट मास्क, टोकन की लंबाई के बराबर अरे होगा. इसमें उन टोकन की पोज़िशन में 1s होगा जिनके बारे में आपको जानकारी देनी है. आइए, ▁training और ▁evaluating को टारगेट के तौर पर इस्तेमाल करें:

टारगेट मास्क तैयार करें

import numpy as np

target_start = list(tokens).index("▁training")
target_end = list(tokens).index("▁evaluating")

# Prepare our mask
target_mask = np.zeros(len(tokens), dtype=np.float32)
target_mask[target_start:target_end+1] = 1
target_mask

# Add to our LIT input
example_for_salience = example | {'target_mask': target_mask}
example_for_salience

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**',
 'target_mask': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
       dtype=float32)}

सॉल्ट मॉडल को कॉल करें

compute_salience = models[f"_{model_name}_salience"].predict
salience = list(compute_salience([example_for_salience]))
salience[0]

{'grad_l2': array([45.75, 36.75, 61, 5.40625, 4.09375, 5.625, 6.46875, 7.3125, 3.375,
        5.03125, 3.23438, 4.5625, 2.375, 3.40625, 2.75, 1.97656, 3.95312,
        3.42188, 14.125, 4.53125, 11.375, 12.625, 18.5, 4.5625, 6.5, 0, 0,
        0, 0, 0, 0, 0], dtype=bfloat16),
 'grad_dot_input': array([-4.03125, 3.04688, -7.03125, -0.800781, 0.769531, -0.679688,
        -0.304688, 2.04688, 0.275391, -1.25781, -0.376953, -0.0664062,
        -0.0405273, -0.357422, 0.355469, -0.145508, -0.333984, 0.0181885,
        -5.0625, 0.235352, -0.470703, 2.25, 3.90625, -0.199219, 0.929688,
        0, 0, 0, 0, 0, 0, 0], dtype=bfloat16),
 'tokens': array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
        '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
        '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
        '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
        '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')}

और बस काम हो गया! grad_l2 और grad_dot_input फ़ील्ड के स्कोर को tokens के हिसाब से अलाइन किया जाता है. साथ ही, ये वही होते हैं जैसे आपको LIT यूज़र इंटरफ़ेस (यूआई) में दिखेंगे.

ध्यान दें कि आखिरी कुछ स्कोर 0 हैं: हमारा मॉडल, बाईं से दाईं ओर लिखी गई भाषा का मॉडल है. इसलिए, टारगेट स्पैन के दाईं ओर मौजूद टोकन का अनुमान पर कोई असर नहीं होता.