Keras में Gemma मॉडल का विश्लेषण करने के लिए LIT का इस्तेमाल करना

1. परिचय

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

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

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

सीखने के लिए लक्ष्य:

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

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

LIT के यूज़र इंटरफ़ेस (यूआई) का डेमो

2. मॉडल विश्लेषण में सीक्वेंस सलिएंस और इसके इस्तेमाल

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

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

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

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

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

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

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

ध्यान दें: आपको फ़ॉर्म से जुड़ी कुछ चेतावनियां दिख सकती हैं

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 के लिए लाइसेंस का कानूनी समझौता भी स्वीकार करना न भूलें.

4. 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_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)

5. LIT डेटासेट सेट अप किए जा रहे हैं

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

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

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

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

इसके अलावा, अपना डेटा आसानी से लोड किया जा सकता है. ऐसा .jsonl फ़ाइल के तौर पर किया जा सकता है जिसमें prompt फ़ील्ड वाले रिकॉर्ड हों और विकल्प के तौर पर target (उदाहरण) शामिल हो. इसके अलावा, LIT के Dataset API का इस्तेमाल करके ऐसा किया जा सकता है.

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

from lit_nlp.examples.datasets import lm as lm_data

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

6. 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)

LIT के यूज़र इंटरफ़ेस (यूआई) का डेमो

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

lit_widget.render(open_in_new_tab=True)

ध्यान दें: अगर सामान्य .py स्क्रिप्ट में LIT का इस्तेमाल किया जा रहा है, तो एक स्टैंडअलोन सर्वर बनाने के लिए, LitWidget के बजाय lit_nlp.dev_server.Server() का इस्तेमाल करें. ज़्यादा जानकारी के लिए, LIT दस्तावेज़ देखें.

7. LIT में Gemma के लिए, कुछ शॉट प्रॉम्प्ट का विश्लेषण किया जा रहा है

आज के समय में प्रॉम्प्ट देना, विज्ञान जितना ही कला है. जेमा जैसे बड़े लैंग्वेज मॉडल के लिए, प्रॉम्प्ट को बेहतर बनाने में, 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 मॉड्यूल की मदद से प्रॉम्प्ट की जांच करने में आपकी मदद करेगा.

8. डीबग करने के लिए क्रम का इस्तेमाल करें

बैटरी के इस्तेमाल का हिसाब सबसे छोटे लेवल पर लगाया जाता है. जैसे, हर इनपुट टोकन के लिए. हालांकि, LIT, टोकन की संभावना को बड़े लेवल में इकट्ठा कर सकता है. जैसे, लाइनें, वाक्य या शब्द. Salincy 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 डेटापॉइंट एडिटर

इसके अलावा, बैज को सीधे दिलचस्पी दिखाने वाले प्रॉम्प्ट के साथ फिर से रेंडर करना भी है:

lit_widget.render(data=[fewshot_mistake_example])

शानदार मॉडल की समाप्ति पर ध्यान दें:

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')}])

अब मॉडल पूरा होने की प्रोसेस यह होती है:

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 में देखी जा सकती है.

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

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

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')}])

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

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

इसके बाद, यह समझने में मदद करने के लिए कि यह बदलाव क्यों हो रहा है, प्रॉम्प्ट जवाब की फिर से जांच की जा सकती है:

एलआईटी सैलियंस

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

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

इंटरप्रेटेड लैंग्वेज का मतलब है, टीम की कोशिश. इसमें XAI, नीति, कानून वगैरह के क्षेत्र में विशेषज्ञता हासिल करना शामिल है.

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

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

11. रीकैप

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

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

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

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