बेहतर बनाने का ट्यूटोरियल

इस ट्यूटोरियल की मदद से, curl का इस्तेमाल करके, Python SDK या REST API में से किसी एक का इस्तेमाल करके, Gemini API ट्यूनिंग सेवा का इस्तेमाल शुरू किया जा सकता है. इन उदाहरणों में, Gemini API की टेक्स्ट जनरेशन सेवा के पीछे मौजूद टेक्स्ट मॉडल को ट्यून करने का तरीका बताया गया है.

ai.google.dev पर देखें Colab notebook आज़माएं GitHub पर नोटबुक देखना

सीमाएं

किसी मॉडल को ट्यून करने से पहले, आपको इन सीमाओं के बारे में पता होना चाहिए:

डेटासेट को फ़ाइन-ट्यून करना

Gemini 1.5 Flash के लिए डेटासेट को बेहतर बनाने की सुविधा में ये सीमाएं हैं:

  • हर उदाहरण के लिए, इनपुट का ज़्यादा से ज़्यादा साइज़ 40,000 वर्ण हो सकता है.
  • हर उदाहरण के लिए, आउटपुट का ज़्यादा से ज़्यादा साइज़ 5,000 वर्ण हो सकता है.
  • सिर्फ़ इनपुट-आउटपुट पेयर के उदाहरण काम करते हैं. चैट-स्टाइल वाली एक से ज़्यादा बार की जाने वाली बातचीत की सुविधा काम नहीं करती.

ट्यून किए गए मॉडल

ट्यून किए गए मॉडल की ये सीमाएं हैं:

  • ट्यून किए गए Gemini 1.5 Flash मॉडल के लिए, इनपुट की सीमा 40,000 वर्ण है.
  • ट्यून किए गए मॉडल के साथ JSON मोड काम नहीं करता.
  • सिर्फ़ टेक्स्ट इनपुट का इस्तेमाल किया जा सकता है.

शुरू करने से पहले: अपना प्रोजेक्ट और एपीआई पासकोड सेट अप करना

Gemini API को कॉल करने से पहले, आपको अपना प्रोजेक्ट सेट अप करना होगा और अपनी एपीआई पासकोड को कॉन्फ़िगर करना होगा.

ट्यून किए गए मॉडल की सूची

tunedModels.list तरीके से, ट्यून किए गए अपने मौजूदा मॉडल देखे जा सकते हैं.

# Sending a page_size is optional
curl -X GET https://generativelanguage.googleapis.com/v1beta/tunedModels?page_size=5 \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${access_token}" \
    -H "x-goog-user-project: ${project_id}" > tuned_models.json

jq .tunedModels[].name < tuned_models.json

# Send the nextPageToken to get the next page.
page_token=$(jq .nextPageToken < tuned_models.json | tr -d '"')

if [[ "$page_token" != "null"" ]]; then
curl -X GET https://generativelanguage.googleapis.com/v1beta/tunedModels?page_size=5\&page_token=${page_token}?key=$GOOGLE_API_KEY \
    -H "Content-Type: application/json"  > tuned_models2.json
jq .tunedModels[].name < tuned_models.json
fi
tuned_models.sh

ट्यून किया गया मॉडल बनाना

ट्यून किया गया मॉडल बनाने के लिए, आपको tunedModels.create के तरीके से मॉडल में अपना डेटासेट पास करना होगा.

इस उदाहरण में, आपको क्रम में अगला नंबर जनरेट करने के लिए, मॉडल को ट्यून करना होगा. उदाहरण के लिए, अगर इनपुट 1 है, तो मॉडल को 2 आउटपुट देना चाहिए. अगर इनपुट one hundred है, तो आउटपुट one hundred one होना चाहिए.

curl -X POST "https://generativelanguage.googleapis.com/v1beta/tunedModels?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -d '
      {
        "display_name": "number generator model",
        "base_model": "models/gemini-1.5-flash-001-tuning",
        "tuning_task": {
          "hyperparameters": {
            "batch_size": 2,
            "learning_rate": 0.001,
            "epoch_count":5,
          },
          "training_data": {
            "examples": {
              "examples": [
                {
                    "text_input": "1",
                    "output": "2",
                },{
                    "text_input": "3",
                    "output": "4",
                },{
                    "text_input": "-3",
                    "output": "-2",
                },{
                    "text_input": "twenty two",
                    "output": "twenty three",
                },{
                    "text_input": "two hundred",
                    "output": "two hundred one",
                },{
                    "text_input": "ninety nine",
                    "output": "one hundred",
                },{
                    "text_input": "8",
                    "output": "9",
                },{
                    "text_input": "-98",
                    "output": "-97",
                },{
                    "text_input": "1,000",
                    "output": "1,001",
                },{
                    "text_input": "10,100,000",
                    "output": "10,100,001",
                },{
                    "text_input": "thirteen",
                    "output": "fourteen",
                },{
                    "text_input": "eighty",
                    "output": "eighty one",
                },{
                    "text_input": "one",
                    "output": "two",
                },{
                    "text_input": "three",
                    "output": "four",
                },{
                    "text_input": "seven",
                    "output": "eight",
                }
              ]
            }
          }
        }
      }' | tee tunemodel.json

# Check the operation for status updates during training.
# Note: you can only check the operation on v1/
operation=$(cat tunemodel.json | jq ".name" | tr -d '"')
tuning_done=false

while [[ "$tuning_done" != "true" ]];
do
  sleep 5
  curl -X GET "https://generativelanguage.googleapis.com/v1/${operation}?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
     2> /dev/null > tuning_operation.json

  complete=$(jq .metadata.completedPercent < tuning_operation.json)
  tput cuu1
  tput el
  echo "Tuning...${complete}%"
  tuning_done=$(jq .done < tuning_operation.json)
done

# Or get the TunedModel and check it's state. The model is ready to use if the state is active.
modelname=$(cat tunemodel.json | jq ".metadata.tunedModel" | tr -d '"')
curl -X GET  https://generativelanguage.googleapis.com/v1beta/${modelname}?key=$GOOGLE_API_KEY \
    -H 'Content-Type: application/json' > tuned_model.json

cat tuned_model.json | jq ".state"
tuned_models.sh

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

ट्यून किया गया मॉडल, ट्यून किए गए मॉडल की सूची में तुरंत जुड़ जाता है. हालांकि, मॉडल ट्यून होने के दौरान, इसकी स्थिति "बनाया जा रहा है" पर सेट होती है.

मॉडल आज़माना

tunedModels.generateContent के तरीके का इस्तेमाल करके, ट्यून किए गए मॉडल की परफ़ॉर्मेंस की जांच की जा सकती है. इसके लिए, मॉडल का नाम बताना होगा.

curl -X POST https://generativelanguage.googleapis.com/v1beta/$modelname:generateContent?key=$GOOGLE_API_KEY \
    -H 'Content-Type: application/json' \
    -d '{
        "contents": [{
        "parts": [{
          "text": "LXIII"
          }]
        }]
        }' 2> /dev/null
tuned_models.sh

मॉडल मिटाना

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

curl -X DELETE https://generativelanguage.googleapis.com/v1beta/${modelname}?key=$GOOGLE_API_KEY \
    -H 'Content-Type: application/json' 
tuned_models.sh