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

इस ट्यूटोरियल में, Gemini API को ट्यून करने की सेवा का इस्तेमाल शुरू करने के बारे में बताया गया है फिर चाहे वह Python SDK टूल या REST API का इस्तेमाल करके, curl. इन उदाहरणों में, 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

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

ट्यून किया गया मॉडल बनाने के लिए, आपको 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"

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

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

मॉडल आज़माना

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

मॉडल मिटाना

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

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