1. परिचय
इस लैब में, आपको Google Gemini मॉडल पर सुपरवाइज़्ड फ़ाइन-ट्यूनिंग का पूरा वर्कफ़्लो करने का तरीका सिखाया जाएगा. इससे मॉडल को किसी खास टास्क के लिए तैयार किया जा सकेगा. जैसे, लेख की खास जानकारी देना. लार्ज लैंग्वेज मॉडल बहुत शक्तिशाली होते हैं. हालांकि, इनका इस्तेमाल सामान्य तौर पर किया जाता है. इसलिए, फ़ाइन-ट्यूनिंग की मदद से, इन्हें इस्तेमाल के खास उदाहरणों के लिए और भी असरदार बनाया जा सकता है. उदाहरणों के हाई-क्वालिटी डेटासेट पर मॉडल को ट्रेन करके, अपने टारगेट टास्क के लिए मॉडल की परफ़ॉर्मेंस को बेहतर बनाया जा सकता है.
आपको Gemini 2.5 Flash का इस्तेमाल करना होगा. यह एक हल्का और किफ़ायती मॉडल है. साथ ही, Vertex AI का इस्तेमाल करके, फ़ाइन-ट्यूनिंग करनी होगी.
आर्किटेक्चर के बारे में खास जानकारी
हम यहां यह बनाएंगे:
- Cloud Shell: यह आपका डेवलपमेंट एनवायरमेंट है.
- Cloud Storage: यह JSONL फ़ॉर्मैट में ट्रेनिंग/पुष्टि करने वाले डेटा को सेव करता है.
- Vertex AI Training: यह फ़ाइन-ट्यूनिंग के काम को मैनेज करता है.
- Vertex AI एंडपॉइंट: यह आपके फ़ाइन-ट्यून किए गए मॉडल को होस्ट करता है.
आपको क्या सीखने को मिलेगा
- निगरानी में रखकर फ़ाइन-ट्यूनिंग करने के लिए, अच्छी क्वालिटी के डेटासेट तैयार करें.
- Vertex AI SDK for Python का इस्तेमाल करके, फ़ाइन-ट्यूनिंग के कामों को कॉन्फ़िगर और लॉन्च करें.
- अपने-आप जनरेट होने वाली मेट्रिक (ROUGE स्कोर) का इस्तेमाल करके मॉडल का आकलन करें.
- बेहतर नतीजों का आकलन करने के लिए, बेस मॉडल और फ़ाइन-ट्यून किए गए मॉडल की तुलना करें.
2. प्रोजेक्ट सेटअप करना
Google खाता
अगर आपके पास पहले से कोई निजी Google खाता नहीं है, तो आपको Google खाता बनाना होगा.
ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.
Google Cloud Console में साइन इन करना
किसी निजी Google खाते का इस्तेमाल करके, Google Cloud Console में साइन इन करें.
बिलिंग चालू करें
Google Cloud के 500 रुपये के क्रेडिट रिडीम करें (ज़रूरी नहीं)
इस वर्कशॉप को चलाने के लिए, आपके पास कुछ क्रेडिट वाला बिलिंग खाता होना चाहिए. अगर आपको अपने बिलिंग सिस्टम का इस्तेमाल करना है, तो इस चरण को छोड़ा जा सकता है.
- इस लिंक पर क्लिक करें और किसी निजी Google खाते से साइन इन करें.आपको कुछ ऐसा दिखेगा:
- अपने क्रेडिट ऐक्सेस करने के लिए यहां क्लिक करें बटन पर क्लिक करें.इससे आपको एक ऐसे पेज पर ले जाया जाएगा जहां आपको अपनी बिलिंग प्रोफ़ाइल सेट अप करनी होगी
- पुष्टि करें पर क्लिक करें
अब आपका खाता, Google Cloud Platform के मुफ़्त में आज़माए जाने वाले बिलिंग खाते से कनेक्ट हो गया है.
प्रोजेक्ट बनाना (ज़रूरी नहीं)
अगर आपके पास कोई ऐसा मौजूदा प्रोजेक्ट नहीं है जिसका इस्तेमाल आपको इस लैब के लिए करना है, तो यहां नया प्रोजेक्ट बनाएं.
3. Cloud Shell Editor खोलें
- सीधे Cloud Shell Editor पर जाने के लिए, इस लिंक पर क्लिक करें
- अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.
- अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
- देखें पर क्लिक करें
- टर्मिनल
पर क्लिक करें
- टर्मिनल में, इस कमांड का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:
gcloud config set project [PROJECT_ID]- उदाहरण:
gcloud config set project lab-project-id-example - अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो इन कमांड का इस्तेमाल करके अपने सभी प्रोजेक्ट आईडी की सूची देखी जा सकती है:
gcloud projects list
- उदाहरण:
- आपको यह मैसेज दिखेगा:
Updated property [core/project].
4. एपीआई चालू करें
Vertex AI और अन्य सेवाओं का इस्तेमाल करने के लिए, आपको अपने Google Cloud प्रोजेक्ट में ज़रूरी एपीआई चालू करने होंगे.
- टर्मिनल में, इन एपीआई को चालू करें:
- Vertex AI API (
aiplatform.googleapis.com): इसकी मदद से, मॉडल को फ़ाइन-ट्यून करने और उन्हें इस्तेमाल करने के लिए Vertex AI का इस्तेमाल किया जा सकता है. - Cloud Storage API (
storage.googleapis.com): यह डेटासेट और मॉडल आर्टफ़ैक्ट को सेव करने की सुविधा देता है.
gcloud services enable aiplatform.googleapis.com \ storage.googleapis.com - Vertex AI API (
5. प्रोजेक्ट एनवायरमेंट सेट अप करना
वर्किंग डायरेक्ट्री बनाना
- टर्मिनल में, अपने प्रोजेक्ट के लिए एक डायरेक्ट्री बनाएं और उसमें नेविगेट करें.
mkdir gemini-finetuning cd gemini-finetuning
एनवायरमेंट वैरिएबल सेट अप करना
- टर्मिनल में, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करें. हम इन वैरिएबल को सेव करने के लिए, एक
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 बकेट बनाना
- टर्मिनल में, अपने डेटासेट और मॉडल आर्टफ़ैक्ट को सेव करने के लिए एक बकेट बनाएं.
gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID --location=$REGION
वर्चुअल एनवायरमेंट सेट अप करना
- हम अपने Python एनवायरमेंट को मैनेज करने के लिए,
uvका इस्तेमाल करेंगे. टर्मिनल में, यह कमांड चलाएं:uv venv .venv source .venv/bin/activate - टर्मिनल में, ज़रूरी Python पैकेज इंस्टॉल करें.
uv pip install google-cloud-aiplatform rouge-score matplotlib pandas tqdm
6. ट्रेनिंग के लिए डेटा तैयार करना
क्वालिटी डेटा, फ़ाइन-ट्यूनिंग को सफल बनाने के लिए ज़रूरी है. आपको WikiLingua डेटासेट का इस्तेमाल करना होगा. इसके बाद, इसे Gemini के लिए ज़रूरी JSONL फ़ॉर्मैट में बदलना होगा. इसके बाद, इसे अपने स्टोरेज बकेट में अपलोड करना होगा.
- टर्मिनल में,
prepare_data.pyनाम की एक फ़ाइल बनाएं.cloudshell edit prepare_data.py - नीचे दिए गए कोड को
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() - टर्मिनल में, डेटा तैयार करने वाली स्क्रिप्ट चलाएं.
python prepare_data.py
7. बेसलाइन परफ़ॉर्मेंस सेट अप करना
फ़ाइन-ट्यूनिंग से पहले, आपको एक बेंचमार्क की ज़रूरत होती है. आपको ROUGE स्कोर का इस्तेमाल करके यह मेज़र करना होगा कि जवाब देने के टास्क में, बेस gemini-2.5-flash मॉडल कैसा परफ़ॉर्म करता है.
- टर्मिनल में,
evaluate.pyनाम की एक फ़ाइल बनाएं.cloudshell edit evaluate.py - नीचे दिए गए कोड को
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() - टर्मिनल में, बेसलाइन का आकलन करें.
python evaluate.py --model "gemini-2.5-flash" --output "baseline.json"baseline.jsonफ़ाइल औरplots/baseline_dist.pngमें एक प्लॉट जनरेट होगा.
8. फ़ाइन-ट्यूनिंग को कॉन्फ़िगर करना और लॉन्च करना
अब आपको Vertex AI पर मैनेज की गई फ़ाइन-ट्यूनिंग का काम शुरू करना होगा.
- टर्मिनल में,
tune.pyनाम की एक फ़ाइल बनाएं.cloudshell edit tune.py - नीचे दिए गए कोड को
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() - टर्मिनल में, फ़ाइन-ट्यूनिंग स्क्रिप्ट चलाएं.
python tune.py
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. मॉडल की तुलना करें
फ़ाइन-ट्यूनिंग का काम पूरा होने के बाद, अपने नए मॉडल की परफ़ॉर्मेंस की तुलना बेसलाइन से की जा सकती है.
- ट्यून किए गए मॉडल का एंडपॉइंट पाएं. इसे
tune.pyस्क्रिप्ट के आखिर में प्रिंट किया गया था. यह कुछ ऐसा दिखेगा:projects/.../locations/.../endpoints/.... - आकलन करने वाली स्क्रिप्ट को फिर से चलाएं. इस बार, तुलना के लिए अपने ट्यून किए गए मॉडल और बेसलाइन के नतीजों को पास करें.
# 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" - नतीजे देखें. स्क्रिप्ट, ROUGE स्कोर की तुलना का आउटपुट देगी. साथ ही,
plots/comparison.pngचार्ट जनरेट करेगी, जिसमें सुधार दिखेगा. Cloud Shell Editor मेंplotsफ़ोल्डर खोलकर, प्लॉट देखे जा सकते हैं.
11. व्यवस्थित करें
शुल्क से बचने के लिए, बनाए गए संसाधनों को मिटाएं.
- टर्मिनल में, 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 हैशटैग के साथ शेयर करें.