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

ai.google.dev पर देखें Google Colab में चलाएं GitHub पर सोर्स देखें

इस notebook में बताया गया है कि Gemini API को कॉल करने के लिए, CURL कमांड का इस्तेमाल करके Gemini API की ट्यूनिंग सेवा या Python request API का इस्तेमाल कैसे किया जाता है. यहां आपको Gemini API की टेक्स्ट जनरेट करने वाली सेवा के टेक्स्ट मॉडल को ट्यून करने का तरीका पता चलेगा.

पुष्टि करने की सुविधा सेट अप करें

Gemini API की मदद से, अपने डेटा का इस्तेमाल करके मॉडल को ट्यून किया जा सकता है. यह आपका डेटा और आपके ट्यून किए गए मॉडल हैं. इसलिए, एपीआई पासकोड से मिलने वाले कंट्रोल की तुलना में, ज़्यादा सख्त ऐक्सेस कंट्रोल की ज़रूरत होती है.

इस ट्यूटोरियल को चलाने से पहले, आपको अपने प्रोजेक्ट के लिए OAuth सेट अप करना होगा.

Colab को सबसे आसानी से सेटअप करने के लिए, अपनी client_secret.json फ़ाइल के कॉन्टेंट को Colab के "सीक्रेट्स मैनेजर" (बाएं पैनल में कुंजी आइकॉन के नीचे) में सीक्रेट नाम CLIENT_SECRET के साथ कॉपी करें.

यह gcloud कमांड client_secret.json फ़ाइल को क्रेडेंशियल में बदल देता है. इसका इस्तेमाल सेवा में पुष्टि के लिए किया जा सकता है.

try:
  from google.colab import userdata
  import pathlib
  pathlib.Path('client_secret.json').write_text(userdata.get('CLIENT_SECRET'))

  # Use `--no-browser` in colab
  !gcloud auth application-default login --no-browser --client-id-file client_secret.json --scopes='https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/generative-language.tuning'
except ImportError:
  !gcloud auth application-default login --client-id-file client_secret.json --scopes='https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/generative-language.tuning'
You are authorizing client libraries without access to a web browser. Please run the following command on a machine with a web browser and copy its output back here. Make sure the installed gcloud version is 372.0.0 or newer.

gcloud auth application-default login --remote-bootstrap="https://accounts.google.com/o/oauth2/auth?response_type=code&client_id=87071151422-n1a3cb6c7fvkfg4gmhdtmn5ulol2l4be.apps.googleusercontent.com&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcloud-platform+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgenerative-language.tuning&state=QIyNibWSaTIsozjmvZEkVBo6EcoW0G&access_type=offline&code_challenge=76c1ZiGvKN8cvlYfj3BmbCwE4e7tvrlwaX3REUX25gY&code_challenge_method=S256&token_usage=remote"

Enter the output of the above command: https://localhost:8085/?state=QIyNibWSaTIsozjmvZEkVBo6EcoW0G&code=4/0AeaYSHBKrY911S466QjKQIFODoOPXlO1mWyTYYdrbELIDV6Hw2DKRAyro62BugroSvIWsA&scope=https://www.googleapis.com/auth/cloud-platform%20https://www.googleapis.com/auth/generative-language.tuning

Credentials saved to file: [/content/.config/application_default_credentials.json]

These credentials will be used by any library that requests Application Default Credentials (ADC).

वैरिएबल सेट करें

कर्ल

REST API के बाकी कॉल के लिए, बार-बार इस्तेमाल होने वाली वैल्यू के वैरिएबल सेट करें. यह कोड, Python os लाइब्रेरी का इस्तेमाल करके ऐसे एनवायरमेंट वैरिएबल सेट करता है जिन्हें सभी कोड सेल से ऐक्सेस किया जा सकता है.

यह खास तौर पर Colab notebook के एनवायरमेंट के लिए है. अगले कोड सेल का कोड, बैश टर्मिनल में इन निर्देशों को चलाने के बराबर है.

export access_token=$(gcloud auth application-default print-access-token)
export project_id=my-project-id
export base_url=https://generativelanguage.googleapis.com
import os

access_token = !gcloud auth application-default print-access-token
access_token = '\n'.join(access_token)

os.environ['access_token'] = access_token
os.environ['project_id'] = "[Enter your project-id here]"
os.environ['base_url'] = "https://generativelanguage.googleapis.com"

Python

access_token = !gcloud auth application-default print-access-token
access_token = '\n'.join(access_token)

project = '[Enter your project-id here]'
base_url = "https://generativelanguage.googleapis.com"

requests लाइब्रेरी इंपोर्ट करें.

import requests
import json

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

ट्यून किए जाने वाले उपलब्ध मॉडल की सूची देकर, पुष्टि करने के सेटअप की पुष्टि करें.

कर्ल


curl -X GET ${base_url}/v1beta/tunedModels \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${access_token}" \
    -H "x-goog-user-project: ${project_id}"

Python

headers={
  'Authorization': 'Bearer ' + access_token,
  'Content-Type': 'application/json',
  'x-goog-user-project': project
}

result = requests.get(
  url=f'{base_url}/v1beta/tunedModels',
  headers = headers,
)
result.json()

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

ट्यून किया जाने वाला मॉडल बनाने के लिए, आपको training_data फ़ील्ड में दिए गए मॉडल को अपना डेटासेट पास करना होगा.

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

कर्ल


curl -X POST $base_url/v1beta/tunedModels \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer ${access_token}" \
    -H "x-goog-user-project: ${project_id}" \
    -d '
      {
        "display_name": "number generator model",
        "base_model": "models/gemini-1.0-pro-001",
        "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
{
"name": "tunedModels/number-generator-model-dzlmi0gswwqb/operations/bvl8dymw0fhw",
"metadata": {
  "@type": "type.googleapis.com/google.ai.generativelanguage.v1beta.CreateTunedModelMetadata",
  "totalSteps": 38,
  "tunedModel": "tunedModels/number-generator-model-dzlmi0gswwqb"
}
}
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                              Dload  Upload   Total   Spent    Left  Speed
100  2280    0   296  100  1984    611   4098 --:--:-- --:--:-- --:--:--  4720

Python

operation = requests.post(
    url = f'{base_url}/v1beta/tunedModels',
    headers=headers,
    json= {
        "display_name": "number generator",
        "base_model": "models/gemini-1.0-pro-001",
        "tuning_task": {
          "hyperparameters": {
            "batch_size": 4,
            "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',
                }
              ]
            }
          }
        }
      }
)
operation
<Response [200]>
operation.json()
{'name': 'tunedModels/number-generator-wl1qr34x2py/operations/41vni3zk0a47',
'metadata': {'@type': 'type.googleapis.com/google.ai.generativelanguage.v1beta.CreateTunedModelMetadata',
  'totalSteps': 19,
  'tunedModel': 'tunedModels/number-generator-wl1qr34x2py'} }

बाकी कॉल के लिए इस्तेमाल करने के लिए, अपने ट्यून किए गए मॉडल के नाम के साथ एक वैरिएबल सेट करें.

name=operation.json()["metadata"]["tunedModel"]
name
'tunedModels/number-generator-wl1qr34x2py'

ट्यून किए गए मॉडल की स्थिति देखें

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

कर्ल

नीचे कुछ Python कोड दिया गया है, ताकि JSON के रिस्पॉन्स से जनरेट हुए मॉडल का नाम पार्स किया जा सके. अगर इसे किसी टर्मिनल में चलाया जा रहा है, तो रिस्पॉन्स को पार्स करने के लिए, bash JSON पार्सर का इस्तेमाल करके देखें.

import json

first_page = json.load(open('tunemodel.json'))
os.environ['modelname'] = first_page['metadata']['tunedModel']

print(os.environ['modelname'])
tunedModels/number-generator-model-dzlmi0gswwqb

राज्य फ़ील्ड वाला मॉडल मेटाडेटा पाने के लिए, मॉडल के नाम के साथ एक और GET अनुरोध करें.


curl -X GET ${base_url}/v1beta/${modelname} \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer ${access_token}" \
    -H "x-goog-user-project: ${project_id}" | grep state
"state": "ACTIVE",
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                              Dload  Upload   Total   Spent    Left  Speed
100  5921    0  5921    0     0  13164      0 --:--:-- --:--:-- --:--:-- 13157

Python

tuned_model = requests.get(
    url = f'{base_url}/v1beta/{name}',
    headers=headers,
)
tuned_model.json()

नीचे दिया गया कोड हर पांच सेकंड में राज्य फ़ील्ड की जांच करता है, जब तक कि यह CREATING स्थिति में न रह जाए.

import time
import pprint

op_json = operation.json()
response = op_json.get('response')
error = op_json.get('error')

while response is None and error is None:
    time.sleep(5)

    operation = requests.get(
        url = f'{base_url}/v1/{op_json["name"]}',
        headers=headers,
    )

    op_json = operation.json()
    response = op_json.get('response')
    error = op_json.get('error')

    percent = op_json['metadata'].get('completedPercent')
    if percent is not None:
      print(f"{percent:.2f}% - {op_json['metadata']['snapshots'][-1]}")
      print()

if error is not None:
    raise Exception(error)
100.00% - {'step': 19, 'epoch': 5, 'meanLoss': 1.402067, 'computeTime': '2024-03-14T15:11:23.766989274Z'}

रन का अनुमान

ट्यूनिंग का काम पूरा हो जाने पर, इसका इस्तेमाल टेक्स्ट सेवा की मदद से टेक्स्ट जनरेट करने के लिए किया जा सकता है.

कर्ल

एक रोमन संख्या डालें, जैसे कि 63 (LXIII):


curl -X POST $base_url/v1beta/$modelname:generateContent \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer ${access_token}" \
    -H "x-goog-user-project: ${project_id}" \
    -d '{
        "contents": [{
        "parts": [{
          "text": "LXIII"
          }]
        }]
        }' 2> /dev/null
{
"candidates": [
  {
    "content": {
      "parts": [
        {
          "text": "LXIV"
        }
      ],
      "role": "model"
    },
    "finishReason": "STOP",
    "index": 0,
    "safetyRatings": [
      {
        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
        "probability": "NEGLIGIBLE"
      },
      {
        "category": "HARM_CATEGORY_HATE_SPEECH",
        "probability": "NEGLIGIBLE"
      },
      {
        "category": "HARM_CATEGORY_HARASSMENT",
        "probability": "NEGLIGIBLE"
      },
      {
        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
        "probability": "NEGLIGIBLE"
      }
    ]
  }
],
"promptFeedback": {
  "safetyRatings": [
    {
      "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
      "probability": "NEGLIGIBLE"
    },
    {
      "category": "HARM_CATEGORY_HATE_SPEECH",
      "probability": "NEGLIGIBLE"
    },
    {
      "category": "HARM_CATEGORY_HARASSMENT",
      "probability": "NEGLIGIBLE"
    },
    {
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "probability": "NEGLIGIBLE"
    }
  ]
}
}

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

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

Python

एक जापानी संख्या डालने की कोशिश करें, जैसे कि 6 (六):

import time

m = requests.post(
    url = f'{base_url}/v1beta/{name}:generateContent',
    headers=headers,
    json= {
        "contents": [{
            "parts": [{
                "text": "六"
            }]
          }]
    })
import pprint
pprint.pprint(m.json())
{'candidates': [{'content': {'parts': [{'text': '七'}], 'role': 'model'},
                'finishReason': 'STOP',
                'index': 0,
                'safetyRatings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
                                    'probability': 'NEGLIGIBLE'},
                                  {'category': 'HARM_CATEGORY_HATE_SPEECH',
                                    'probability': 'NEGLIGIBLE'},
                                  {'category': 'HARM_CATEGORY_HARASSMENT',
                                    'probability': 'LOW'},
                                  {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',
                                    'probability': 'NEGLIGIBLE'}]}],
'promptFeedback': {'safetyRatings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
                                      'probability': 'NEGLIGIBLE'},
                                      {'category': 'HARM_CATEGORY_HATE_SPEECH',
                                      'probability': 'NEGLIGIBLE'},
                                      {'category': 'HARM_CATEGORY_HARASSMENT',
                                      'probability': 'NEGLIGIBLE'},
                                      {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',
                                      'probability': 'NEGLIGIBLE'}]} }

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

नतीजा

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

अगले चरण

Gemini API के लिए Python SDK टूल की मदद से ट्यूनिंग की सेवा का इस्तेमाल करने का तरीका जानने के लिए, Python की मदद से ट्यूनिंग क्विकस्टार्ट पर जाएं. Gemini API में अन्य सेवाओं का इस्तेमाल करने का तरीक़ा जानने के लिए, Python क्विकस्टार्ट पर जाएं.