Vertex AI पर Gemini को फ़ाइन-ट्यून करना

1. परिचय

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

इस लैब में, Gemini 2.5 Flash का इस्तेमाल किया जाएगा. यह एक हल्का और किफ़ायती मॉडल है. साथ ही, Vertex AI का इस्तेमाल करके, फ़ाइन-ट्यूनिंग की जाएगी.

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

हम यहां बताई गई चीज़ें बनाएंगे:

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

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

  • निगरानी में रखकर फ़ाइन-ट्यूनिंग करने के लिए, अच्छी क्वालिटी के डेटासेट तैयार करना.
  • Python के लिए Vertex AI SDK टूल का इस्तेमाल करके, फ़ाइन-ट्यूनिंग के काम को कॉन्फ़िगर करना और उसे शुरू करना.
  • अपने-आप जनरेट होने वाली मेट्रिक (आरओयूजी स्कोर) का इस्तेमाल करके, मॉडल का आकलन करना.
  • बेहतर परफ़ॉर्मेंस का आकलन करने के लिए, बेस मॉडल और फ़ाइन-ट्यून किए गए मॉडल की तुलना करना.

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

Google खाता

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

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

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

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

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

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

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

  1. इस लिंक पर क्लिक करें और निजी Google खाते से साइन इन करें.आपको कुछ ऐसा दिखेगा:Cloud Shell को अनुमति देने के लिए क्लिक करें
  2. अपने क्रेडिट ऐक्सेस करने के लिए, यहां क्लिक करें बटन पर क्लिक करें.इससे आपको बिलिंग प्रोफ़ाइल सेट अप करने के लिए एक पेज दिखेगाCloud Shell को अनुमति देने के लिए क्लिक करें
  3. पुष्टि करें पर क्लिक करें

अब आपका खाता, Google Cloud Platform के ट्रायल बिलिंग खाते से कनेक्ट हो गया है.

बिलिंग की खास जानकारी देने वाले पेज का स्क्रीनशॉट

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

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

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. एपीआई चालू करना

Vertex AI और अन्य सेवाओं का इस्तेमाल करने के लिए, आपको अपने 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 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 2.5 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. बेसलाइन परफ़ॉर्मेंस सेट अप करना

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

  1. टर्मिनल में, evaluate.py नाम की फ़ाइल बनाएं.
    cloudshell edit evaluate.py
  2. evaluate.py में यह कोड चिपकाएं.
    import argparse
import json
import os
import pandas as pd
from google.cloud import aiplatform
import vertexai
from vertexai.generative_models import GenerativeModel, GenerationConfig, HarmCategory, HarmBlockThreshold
from rouge_score import rouge_scorer
from tqdm import tqdm
import matplotlib.pyplot as plt
import time

# Configuration
PROJECT_ID = os.environ["PROJECT_ID"]
REGION = os.environ["REGION"]

aiplatform.init(project=PROJECT_ID, location=REGION)

def evaluate(model_name, test_file, max_samples=50, output_json="results.json"):
    print(f"Evaluating model: {model_name}")

    # Load Test Data
    test_df = pd.read_csv(test_file)
    test_df = test_df.head(max_samples)

    model = GenerativeModel(model_name)

    safety_settings = {
        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    }

    generation_config = GenerationConfig(
        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 = model.generate_content(
                input_text,
                generation_config=generation_config,
                safety_settings=safety_settings
            )
            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-2.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-2.5-flash" --output "baseline.json"
    इससे baseline.json फ़ाइल और plots/baseline_dist.png में एक प्लॉट जनरेट होगा.

8. फ़ाइन-ट्यूनिंग को कॉन्फ़िगर करना और उसे शुरू करना

अब Vertex AI पर, मैनेज की गई फ़ाइन-ट्यूनिंग का काम शुरू किया जाएगा.

  1. टर्मिनल में, tune.py नाम की फ़ाइल बनाएं.
    cloudshell edit tune.py
  2. tune.py में यह कोड चिपकाएं.
    import os
import time
from google.cloud import aiplatform
import vertexai
from vertexai.preview.tuning import sft

# Configuration
PROJECT_ID = os.environ["PROJECT_ID"]
REGION = os.environ["REGION"]
BUCKET_NAME = os.environ["BUCKET_NAME"]

aiplatform.init(project=PROJECT_ID, location=REGION)

def train():
    print("Launching fine-tuning job...")

    sft_tuning_job = sft.train(
        source_model="gemini-2.5-flash", # Using specific version for stability
        train_dataset=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl",
        validation_dataset=f"gs://{BUCKET_NAME}/datasets/val/val_gemini.jsonl",
        epochs=1, # Keep it short for the lab
        adapter_size=4,
        learning_rate_multiplier=1.0,
        tuned_model_display_name="gemini-2.5-flash-wikilingua",
    )

    print(f"Job started: {sft_tuning_job.resource_name}")
    print("Waiting for job to complete... (this may take ~45 minutes)")

    # Wait for the job to complete
    while not sft_tuning_job.has_ended:
        time.sleep(60)
        sft_tuning_job.refresh()
        print(f"Status: {sft_tuning_job.state.name}")

    print("Job completed!")
    print(f"Tuned Model Endpoint: {sft_tuning_job.tuned_model_endpoint_name}")
    return sft_tuning_job.tuned_model_endpoint_name

if __name__ == "__main__":
    train()
  3. टर्मिनल में, फ़ाइन-ट्यूनिंग की स्क्रिप्ट चलाएं.
    python tune.py
    ध्यान दें: इस प्रोसेस में करीब 45 मिनट लग सकते हैं. Vertex AI Console में जाकर, इस काम की निगरानी की जा सकती है.

9. ट्रेनिंग के कोड को समझना

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

निगरानी में रखकर की जाने वाली मैनेज की गई फ़ाइन-ट्यूनिंग

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

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

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

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

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

मॉडल चुनना

हमने साफ़ तौर पर source_model="gemini-2.5-flash" तय किया है. Vertex AI, 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. नतीजे देखें. स्क्रिप्ट, आरओयूजी स्कोर की तुलना दिखाएगी और 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 Vertex AI Console

12. बधाई हो!

आपने Vertex AI पर, Gemini 2.5 Flash को फ़ाइन-ट्यून कर लिया है!

रीकैप

इस लैब में, आपने ये काम किए:

  • Gemini को फ़ाइन-ट्यून करने के लिए, JSONL फ़ॉर्मैट में डेटासेट तैयार किया.
  • Gemini 2.5 Flash के बेस मॉडल का इस्तेमाल करके, बेसलाइन सेट अप की.
  • Vertex AI पर, निगरानी में रखकर की जाने वाली फ़ाइन-ट्यूनिंग का काम शुरू किया.
  • फ़ाइन-ट्यून किए गए मॉडल का आकलन किया और उसकी तुलना बेसलाइन से की.

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

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

प्रोटोटाइप से प्रोडक्शन तक के गैप को भरने के लिए, पूरा पाठ्यक्रम देखें.

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