Gemini Enterprise के एजेंट प्लैटफ़ॉर्म पर Gemini को बेहतर बनाना

1. परिचय

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

आपको Gemini 3.5 Flash का इस्तेमाल करना होगा. यह एक हल्का और किफ़ायती मॉडल है. साथ ही, Gemini Enterprise Agent Platform का इस्तेमाल करके, फ़ाइन-ट्यूनिंग करनी होगी.

आर्किटेक्चर के बारे में खास जानकारी

हम यहां यह बनाएंगे:

  • Cloud Shell: यह आपका डेवलपमेंट एनवायरमेंट है.
  • Cloud Storage: यह ट्रेनिंग/वैलिडेशन डेटा को JSONL फ़ॉर्मैट में सेव करता है.
  • Gemini Enterprise का एजेंट प्लैटफ़ॉर्म ट्रेनिंग: यह फ़ाइन-ट्यूनिंग के काम को मैनेज करता है.
  • Gemini Enterprise का एजेंट प्लैटफ़ॉर्म एंडपॉइंट: यह आपके फ़ाइन-ट्यून किए गए मॉडल को होस्ट करता है.

आपको क्या सीखने को मिलेगा

  • निगरानी में रखकर फ़ाइन-ट्यूनिंग करने के लिए, अच्छी क्वालिटी के डेटासेट तैयार करें.
  • Gemini Enterprise Agent Platform SDK for Python का इस्तेमाल करके, फ़ाइन-ट्यूनिंग के जॉब कॉन्फ़िगर और लॉन्च करें.
  • ऑटोमेटेड मेट्रिक (आरओयूजी स्कोर) का इस्तेमाल करके मॉडल का आकलन करें.
  • बेहतर नतीजों का आकलन करने के लिए, बुनियादी मॉडल और फ़ाइन-ट्यून किए गए मॉडल की तुलना करें.

2. प्रोजेक्ट सेटअप करना

Google खाता

अगर आपके पास पहले से कोई निजी Google खाता नहीं है, तो आपको Google खाता बनाना होगा.

ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.

Google Cloud Console में साइन इन करना

किसी निजी Google खाते का इस्तेमाल करके, Google Cloud Console में साइन इन करें.

बिलिंग चालू करें

Google Cloud क्रेडिट रिडीम करना (ज़रूरी नहीं है)

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

प्रोजेक्ट बनाना (ज़रूरी नहीं)

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

3. Cloud Shell Editor खोलें

  1. Cloud Shell Editor पर सीधे जाने के लिए, इस लिंक पर क्लिक करें
  2. अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें. Cloud Shell को अनुमति देने के लिए क्लिक करें
  3. अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
    • देखें पर क्लिक करें
    • टर्मिनलCloud Shell Editor में नया टर्मिनल खोलें पर क्लिक करें
  4. टर्मिनल में, इस निर्देश का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:
    gcloud config set project [PROJECT_ID]
    
    • उदाहरण:
      gcloud config set project lab-project-id-example
      
    • अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो इन कमांड का इस्तेमाल करके अपने सभी प्रोजेक्ट आईडी की सूची बनाई जा सकती है:
      gcloud projects list
      
      Cloud Shell Editor के टर्मिनल में प्रोजेक्ट आईडी सेट करना
  5. आपको यह मैसेज दिखेगा:
    Updated property [core/project].
    

4. एपीआई चालू करें

Gemini Enterprise Agent Platform और अन्य सेवाओं का इस्तेमाल करने के लिए, आपको अपने Google Cloud प्रोजेक्ट में ज़रूरी एपीआई चालू करने होंगे.

  1. टर्मिनल में, इन एपीआई को चालू करें:
    • Vertex AI API (aiplatform.googleapis.com): इसकी मदद से, मॉडल को फ़ाइन-ट्यून करने और उन्हें डिप्लॉय करने के लिए Vertex AI का इस्तेमाल किया जा सकता है.
    • Cloud Storage API (storage.googleapis.com): यह डेटासेट और मॉडल आर्टफ़ैक्ट को सेव करने की सुविधा चालू करता है.
    gcloud services enable aiplatform.googleapis.com \
        storage.googleapis.com
    

5. प्रोजेक्ट एनवायरमेंट सेट अप करना

वर्किंग डायरेक्ट्री बनाना

  1. टर्मिनल में, अपने प्रोजेक्ट के लिए एक डायरेक्ट्री बनाएं और उसमें नेविगेट करें.
    mkdir gemini-finetuning
    cd gemini-finetuning
    

एनवायरमेंट वैरिएबल सेट अप करना

  1. टर्मिनल में, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल सेट करें. हम इन वैरिएबल को सेव करने के लिए, एक env.sh फ़ाइल बनाएंगे. इससे, सेशन बंद होने पर इन्हें आसानी से फिर से लोड किया जा सकेगा.
    cat <<EOF > env.sh
    export PROJECT_ID=\$(gcloud config get-value project)
    export REGION="us-central1"
    export LOCATION="global"
    export BUCKET_NAME="\${PROJECT_ID}-gemini-tuning"
    EOF
    
    source env.sh
    

Cloud Storage बकेट बनाना

  1. टर्मिनल में, अपने डेटासेट और मॉडल आर्टफ़ैक्ट को सेव करने के लिए एक बकेट बनाएं.
    gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID --location=$REGION
    

वर्चुअल एनवायरमेंट सेट अप करना

  1. हम अपने Python एनवायरमेंट को मैनेज करने के लिए, uv का इस्तेमाल करेंगे. टर्मिनल में, यह कमांड चलाएं:
    uv venv .venv
    source .venv/bin/activate
    
  2. टर्मिनल में, ज़रूरी Python पैकेज इंस्टॉल करें.
    uv pip install google-cloud-aiplatform rouge-score matplotlib pandas tqdm
    

6. ट्रेनिंग डेटा तैयार करना

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

  1. टर्मिनल में, prepare_data.py नाम की एक फ़ाइल बनाएं.
    cloudshell edit prepare_data.py
    
  2. नीचे दिए गए कोड को prepare_data.py में चिपकाएं.
    import json
    import os
    import pandas as pd
    from google.cloud import storage
    import subprocess
    
    # Configuration
    BUCKET_NAME = os.environ["BUCKET_NAME"]
    PROJECT_ID = os.environ["PROJECT_ID"]
    
    def download_data():
        print("Downloading WikiLingua dataset...")
        # Using gsutil to copy from public bucket
        subprocess.run(["gsutil", "cp", "gs://github-repo/generative-ai/gemini/tuning/summarization/wikilingua/*", "."], check=True)
    
    def convert_to_gemini_format(input_file, output_file, max_samples=1000):
        print(f"Converting {input_file} to Gemini format (first {max_samples} samples)...")
        converted_data = []
        with open(input_file, 'r') as f:
            for i, line in enumerate(f):
                if i >= max_samples:
                    break
                obj = json.loads(line)
                messages = obj.get("messages", [])
    
                # Convert messages to Gemini format
                # Input: {"messages": [{"role": "user", "content": "..."}, {"role": "model", "content": "..."}]}
                # Output: {"contents": [{"role": "user", "parts": [{"text": "..."}]}, {"role": "model", "parts": [{"text": "..."}]}]}
    
                contents = []
                for msg in messages:
                    role = msg["role"]
                    content = msg["content"]
                    contents.append({
                        "role": role,
                        "parts": [{"text": content}]
                    })
    
                converted_data.append({"contents": contents})
    
        with open(output_file, 'w') as f:
            for item in converted_data:
                f.write(json.dumps(item) + "\n")
    
        print(f"Saved {len(converted_data)} examples to {output_file}")
    
    def upload_to_gcs(local_file, destination_blob_name):
        print(f"Uploading {local_file} to gs://{BUCKET_NAME}/{destination_blob_name}...")
        storage_client = storage.Client(project=PROJECT_ID)
        bucket = storage_client.bucket(BUCKET_NAME)
        blob = bucket.blob(destination_blob_name)
        blob.upload_from_filename(local_file)
        print("Upload complete.")
    
    def main():
        download_data()
    
        # Process Training Data
        convert_to_gemini_format("sft_train_samples.jsonl", "train_gemini.jsonl")
        upload_to_gcs("train_gemini.jsonl", "datasets/train/train_gemini.jsonl")
    
        # Process Validation Data
        convert_to_gemini_format("sft_val_samples.jsonl", "val_gemini.jsonl")
        upload_to_gcs("val_gemini.jsonl", "datasets/val/val_gemini.jsonl")
    
        print("Data preparation complete!")
    
    if __name__ == "__main__":
        main()
    
  3. टर्मिनल में, डेटा तैयार करने वाली स्क्रिप्ट चलाएं.
    python prepare_data.py
    

7. बेसलाइन परफ़ॉर्मेंस सेट अप करना

फ़ाइन-ट्यूनिंग से पहले, आपको एक बेंचमार्क की ज़रूरत होती है. ROUGE स्कोर का इस्तेमाल करके, यह मेज़र किया जाएगा कि जवाब देने के टास्क में, बेस gemini-3.5-flash मॉडल कैसा परफ़ॉर्म करता है.

  1. टर्मिनल में, evaluate.py नाम की एक फ़ाइल बनाएं.
    cloudshell edit evaluate.py
    
  2. नीचे दिए गए कोड को evaluate.py में चिपकाएं.
    import argparse
    import json
    import os
    import pandas as pd
    from google import genai
    from google.genai import types
    from rouge_score import rouge_scorer
    from tqdm import tqdm
    import matplotlib.pyplot as plt
    import time
    
    # Configuration for Google Gen AI SDK
    PROJECT_ID = os.environ.get("PROJECT_ID", "")
    
    def get_client(model_name):
        os.environ["GOOGLE_GENAI_USE_ENTERPRISE"] = "true"
        os.environ["GOOGLE_CLOUD_PROJECT"] = PROJECT_ID
        if "locations/" in model_name:
            parts = model_name.split("/")
            loc = parts[parts.index("locations") + 1]
            if loc == "us":
                loc = "us-central1"
        else:
            loc = os.environ.get("LOCATION", "global")
        os.environ["GOOGLE_CLOUD_LOCATION"] = loc
        return genai.Client()
    
    def evaluate(model_name, test_file, max_samples=50, output_json="results.json"):
        print(f"Evaluating model: {model_name}")
        client = get_client(model_name)
    
        # Load Test Data
        test_df = pd.read_csv(test_file)
        test_df = test_df.head(max_samples)
    
        config = types.GenerateContentConfig(
            temperature=0.1,
            max_output_tokens=1024,
        )
    
        scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
        results = []
    
        for index, row in tqdm(test_df.iterrows(), total=len(test_df)):
            input_text = row['input_text']
            reference_summary = row['output_text']
    
            try:
                response = client.models.generate_content(
                    model=model_name,
                    contents=input_text,
                    config=config,
                )
                generated_summary = response.text
    
                scores = scorer.score(reference_summary, generated_summary)
    
                results.append({
                    "generated": generated_summary,
                    "reference": reference_summary,
                    "rouge1": scores['rouge1'].fmeasure,
                    "rouge2": scores['rouge2'].fmeasure,
                    "rougeL": scores['rougeL'].fmeasure
                })
            except Exception as e:
                print(f"Error processing example {index}: {e}")
                # Sleep briefly to avoid quota issues if hitting limits
                time.sleep(1)
    
        # Save results
        with open(output_json, 'w') as f:
            json.dump(results, f, indent=2)
    
        return pd.DataFrame(results)
    
    def plot_results(df, title, filename):
        os.makedirs("plots", exist_ok=True)
    
        metrics = ['rouge1', 'rouge2', 'rougeL']
        fig, axes = plt.subplots(1, 3, figsize=(15, 5))
    
        for i, metric in enumerate(metrics):
            axes[i].hist(df[metric], bins=10, alpha=0.7, color='skyblue', edgecolor='black')
            axes[i].set_title(f'{metric} Distribution')
            axes[i].set_xlabel('Score')
            axes[i].set_ylabel('Count')
    
        plt.suptitle(title)
        plt.tight_layout()
        plt.savefig(f"plots/{filename}")
        print(f"Plot saved to plots/{filename}")
    
    def compare_results(baseline_file, tuned_file):
        with open(baseline_file, 'r') as f:
            baseline_data = pd.DataFrame(json.load(f))
        with open(tuned_file, 'r') as f:
            tuned_data = pd.DataFrame(json.load(f))
    
        print("\n--- Comparison ---")
        metrics = ['rouge1', 'rouge2', 'rougeL']
        for metric in metrics:
            base_mean = baseline_data[metric].mean()
            tuned_mean = tuned_data[metric].mean()
            diff = tuned_mean - base_mean
            print(f"{metric}: Base={base_mean:.4f}, Tuned={tuned_mean:.4f}, Diff={diff:+.4f}")
    
        # Comparative Plot
        os.makedirs("plots", exist_ok=True)
        comparison_df = pd.DataFrame({
            'Metric': metrics,
            'Baseline': [baseline_data[m].mean() for m in metrics],
            'Tuned': [tuned_data[m].mean() for m in metrics]
        })
    
        comparison_df.plot(x='Metric', y=['Baseline', 'Tuned'], kind='bar', figsize=(10, 6))
        plt.title('Baseline vs Tuned Model Performance')
        plt.ylabel('Average Score')
        plt.xticks(rotation=0)
        plt.tight_layout()
        plt.savefig("plots/comparison.png")
        print("Comparison plot saved to plots/comparison.png")
    
    def main():
        parser = argparse.ArgumentParser()
        parser.add_argument("--model", type=str, default="gemini-3.5-flash", help="Model resource name")
        parser.add_argument("--baseline", type=str, help="Path to baseline results json for comparison")
        parser.add_argument("--output", type=str, default="results.json", help="Output file for results")
        args = parser.parse_args()
    
        # Ensure test data exists (it was downloaded in prepare_data step)
        if not os.path.exists("sft_test_samples.csv"):
            # Fallback download if needed
            subprocess.run(["gsutil", "cp", "gs://github-repo/generative-ai/gemini/tuning/summarization/wikilingua/sft_test_samples.csv", "."], check=True)
    
        df = evaluate(args.model, "sft_test_samples.csv", output_json=args.output)
    
        print("\n--- Results Summary ---")
        print(df.describe())
    
        plot_filename = "baseline_dist.png" if not args.baseline else "tuned_dist.png"
        plot_results(df, f"ROUGE Scores - {args.model}", plot_filename)
    
        if args.baseline:
            compare_results(args.baseline, args.output)
    
    if __name__ == "__main__":
        main()
    
  3. टर्मिनल में, बेसलाइन का आकलन करें.
    python evaluate.py --model "gemini-3.5-flash" --output "baseline.json"
    
    इससे baseline.json फ़ाइल और plots/baseline_dist.png में एक प्लॉट जनरेट होगा.

8. फ़ाइन-ट्यूनिंग को कॉन्फ़िगर करना और लॉन्च करना

अब आपको Gemini Enterprise के एजेंट प्लैटफ़ॉर्म पर, मैनेज की गई फ़ाइन-ट्यूनिंग का काम शुरू करना होगा.

  1. टर्मिनल में, tune.py नाम की एक फ़ाइल बनाएं.
    cloudshell edit tune.py
    
  2. नीचे दिए गए कोड को tune.py में चिपकाएं.
    import os
    import time
    from google import genai
    from google.genai import types
    
    # Configuration for Google Gen AI SDK
    os.environ["GOOGLE_GENAI_USE_ENTERPRISE"] = "true"
    os.environ["GOOGLE_CLOUD_PROJECT"] = os.environ.get("PROJECT_ID", "")
    os.environ["GOOGLE_CLOUD_LOCATION"] = os.environ.get("REGION", "us-central1")
    
    BUCKET_NAME = os.environ["BUCKET_NAME"]
    client = genai.Client()
    
    def train():
        print("Launching fine-tuning job...")
    
        training_dataset = types.TuningDataset(
            gcs_uri=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl"
        )
        validation_dataset = types.TuningValidationDataset(
            gcs_uri=f"gs://{BUCKET_NAME}/datasets/val/val_gemini.jsonl"
        )
    
        tuning_job = client.tunings.tune(
            base_model="gemini-3.5-flash",
            training_dataset=training_dataset,
            config=types.CreateTuningJobConfig(
                tuned_model_display_name="gemini-3.5-flash-wikilingua",
                validation_dataset=validation_dataset,
                adapter_size=types.AdapterSize.ADAPTER_SIZE_FOUR,
                epoch_count=1,
            ),
        )
    
        print(f"Job started: {tuning_job.name}")
        print("Waiting for job to complete... (this may take ~45 minutes)")
    
        running_states = {"JOB_STATE_PENDING", "JOB_STATE_RUNNING"}
        while tuning_job.state in running_states:
            time.sleep(60)
            tuning_job = client.tunings.get(name=tuning_job.name)
            print(f"Status: {tuning_job.state}")
    
        print("Job completed!")
        print(f"Tuned Model Endpoint: {tuning_job.tuned_model.endpoint}")
        return tuning_job.tuned_model.endpoint
    
    if __name__ == "__main__":
        train()
    
  3. टर्मिनल में, फ़ाइन-ट्यूनिंग स्क्रिप्ट चलाएं.
    python tune.py
    
    ध्यान दें: इस प्रोसेस में ~45 मिनट लग सकते हैं. Gemini Enterprise के एजेंट प्लैटफ़ॉर्म कंसोल में जाकर, इस काम को मॉनिटर किया जा सकता है.

9. ट्रेनिंग कोड के बारे में जानकारी

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

निगरानी में रखकर फ़ाइन-ट्यून करना

यह स्क्रिप्ट, मैनेज किए जा रहे ट्यूनिंग जॉब को सबमिट करने के लिए vertexai.tuning.sft.train तरीके का इस्तेमाल करती है. इससे इंफ़्रास्ट्रक्चर को उपलब्ध कराने, ट्रेनिंग को डिस्ट्रिब्यूट करने, और चेकपॉइंट मैनेज करने की जटिलता कम हो जाती है.

sft_tuning_job = sft.train(
    source_model="gemini-3.5-flash",
    train_dataset=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl",
    # ...
)

LoRA कॉन्फ़िगरेशन

ओपन-सोर्स फ़्रेमवर्क में, LoraConfig को मैन्युअल तरीके से तय करने के बजाय, Gemini Enterprise का एजेंट प्लैटफ़ॉर्म इसे कुछ मुख्य पैरामीटर में बांट देता है:

  • adapter_size: यह पैरामीटर (हमारी स्क्रिप्ट में 4 पर सेट है), LoRA अडैप्टर की रैंक को कंट्रोल करता है. बड़े साइज़ की वजह से, मॉडल ज़्यादा जटिल अडैप्टेशन सीख पाता है. हालांकि, इससे ट्रेनिंग दिए जा सकने वाले पैरामीटर की संख्या बढ़ जाती है.
  • epochs: हमने इस लैब के लिए इसे 1 पर सेट किया है, ताकि ट्रेनिंग का समय कम रहे (~20 मिनट). प्रोडक्शन के मामले में, इस वैल्यू को बढ़ाया जा सकता है, ताकि मॉडल आपके डेटा से ज़्यादा जानकारी पा सके. हालांकि, आपको ओवरफ़िटिंग पर ध्यान देना चाहिए.

मॉडल चुनना

हम source_model="gemini-3.5-flash" के बारे में साफ़ तौर पर बताते हैं. Gemini Enterprise का एजेंट प्लैटफ़ॉर्म, Gemini के अलग-अलग वर्शन के साथ काम करता है. किसी वर्शन को पिन करने से, यह पक्का किया जा सकता है कि आपकी पाइपलाइन स्थिर रहे और उसे दोहराया जा सके.

10. मॉडल की तुलना करें

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

  1. ट्यून किए गए मॉडल का एंडपॉइंट पाएं. इसे tune.py स्क्रिप्ट के आखिर में प्रिंट किया गया था. यह कुछ ऐसा दिखेगा: projects/.../locations/.../endpoints/....
  2. जांच करने वाली स्क्रिप्ट को फिर से चलाएं. इस बार, तुलना करने के लिए अपने बेहतर मॉडल और बेसलाइन के नतीजों को पास करें.
    # Replace [YOUR_TUNED_MODEL_ENDPOINT] with the actual endpoint name
    export TUNED_MODEL="projects/[YOUR_PROJECT_ID]/locations/[YOUR_REGION]/endpoints/[YOUR_ENDPOINT_ID]"
    
    python evaluate.py --model "$TUNED_MODEL" --baseline "baseline.json" --output "tuned.json"
    
  3. नतीजे देखें. स्क्रिप्ट, ROUGE स्कोर की तुलना का आउटपुट देगी. साथ ही, plots/comparison.png चार्ट जनरेट करेगी, जिसमें सुधार दिखेगा. Cloud Shell Editor में plots फ़ोल्डर खोलकर, प्लॉट देखे जा सकते हैं.

11. व्यवस्थित करें

शुल्क से बचने के लिए, बनाए गए संसाधनों को मिटाएं.

  1. टर्मिनल में, Cloud Storage बकेट और फ़ाइन-ट्यून किए गए मॉडल को मिटाएं.
    gcloud storage rm -r gs://$BUCKET_NAME
    # Note: You can delete the model endpoint from the Gemini Enterprise Agent Platform Console
    

12. बधाई हो!

आपने Gemini Enterprise के एजेंट प्लैटफ़ॉर्म पर, Gemini 3.5 Flash को फ़ाइन-ट्यून कर लिया है!

रीकैप

इस लैब में, आपको ये काम करने होंगे:

  • Gemini को बेहतर बनाने के लिए, JSONL फ़ॉर्मैट में डेटासेट तैयार किया.
  • Gemini 3.5 Flash के बेस मॉडल का इस्तेमाल करके, एक बेसलाइन तैयार की गई.
  • Gemini Enterprise Agent Platform पर, सुपरवाइज़्ड फ़ाइन-ट्यूनिंग का काम शुरू किया गया.
  • फ़ाइन-ट्यून किए गए मॉडल का आकलन किया गया और उसकी तुलना बेसलाइन से की गई.

आगे क्या करना है

यह लैब, Google Cloud के साथ प्रोडक्शन-रेडी एआई लर्निंग पाथ का हिस्सा है.

प्रोटोटाइप से लेकर प्रोडक्शन तक के पूरे पाठ्यक्रम के बारे में जानें.

#ProductionReadyAI हैशटैग का इस्तेमाल करके, अपनी प्रोग्रेस शेयर करें.