Gemini 1.5 Flash की कीमत में कमी, सभी डेवलपर के लिए बेहतर ऐक्सेस वगैरह! ज़्यादा जानें

इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

ai.google.dev पर देखें

Colab notebook को आज़माएं

GitHub पर notebook देखें

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

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

इस ट्यूटोरियल को चलाने से पहले, आपको अपने प्रोजेक्ट और फिर "OAuth क्लाइंट आईडी" "client_secret.json" के तौर पर जोड़ा जाएगा.

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

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'

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

कर्ल

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'

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

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

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

कर्ल

नीचे दिए गए टेंप्लेट से, जनरेट किए गए मॉडल का नाम पार्स करने के लिए, एक Python कोड दिया गया है जवाब JSON. अगर इसे किसी टर्मिनल में चलाया जा रहा है, तो बैश का इस्तेमाल करके देखें जवाब को पार्स करने के लिए 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()

नीचे दिया गया कोड हर 5 सेकंड में स्टेट फ़ील्ड की जांच करता है, जब तक कि यह 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'}]} }

नतीजा

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

अगले चरण

Python SDK टूल की मदद से, ट्यूनिंग सेवा इस्तेमाल करने का तरीका जानने के लिए Gemini API के साथ, ट्यूनिंग वाले क्विकस्टार्ट पेज पर जाएँ Python. इसका तरीका जानने के लिए Gemini API की अन्य सेवाओं का इस्तेमाल करने के लिए, शुरू करने के बारे में जानकारी पर जाएँ ट्यूटोरियल देखें.