Cloud Run जॉब का इस्तेमाल करके, एलएलएम को बेहतर बनाने का तरीका

1. परिचय

खास जानकारी

इस कोडलैब में, Gemma 3 मॉडल को बेहतर बनाने के लिए, Cloud Run jobs का इस्तेमाल किया जाएगा. इसके बाद, vLLM का इस्तेमाल करके, Cloud Run पर नतीजे दिखाए जाएंगे.

आपको क्या करना होगा

KomeijiForce/Text2Emoji डेटासेट का इस्तेमाल करके, किसी मॉडल को ट्रेनिंग दें, ताकि वह किसी खास वाक्यांश के जवाब में कोई खास नतीजा दे सके. यह डेटासेट, EmojiLM: Modeling the New Emoji Language के तहत बनाया गया है.

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

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

  • Cloud Run Jobs GPU का इस्तेमाल करके फ़ाइन ट्यूनिंग कैसे करें
  • vLLM के साथ Cloud Run का इस्तेमाल करके मॉडल को कैसे सर्व करें
  • मॉडल को तेज़ी से अपलोड और सर्व करने के लिए, जीपीयू जॉब के लिए डायरेक्ट वीपीसी कॉन्फ़िगरेशन का इस्तेमाल कैसे करें

2. शुरू करने से पहले

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

इस कोडलैब का इस्तेमाल शुरू करने से पहले, इन एपीआई को चालू करें. इसके लिए, यह कमांड चलाएं:

gcloud services enable run.googleapis.com \
    compute.googleapis.com \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    secretmanager.googleapis.com \
    artifactregistry.googleapis.com

जीपीयू कोटा

जीपीयू कोटा का दस्तावेज़ देखें. इससे आपको कोटा का अनुरोध करने का तरीका पता चलेगा.

अगर आपको "आपके पास जीपीयू इस्तेमाल करने का कोटा नहीं है" से जुड़ी कोई गड़बड़ी दिखती है, तो g.co/cloudrun/gpu-quota पर जाकर अपने कोटे की पुष्टि करें.

ध्यान दें: अगर किसी नए प्रोजेक्ट का इस्तेमाल किया जा रहा है, तो एपीआई चालू करने और कोटा पेज पर कोटा दिखने में कुछ मिनट लग सकते हैं.

Hugging Face

यह कोडलैब, Hugging Face पर होस्ट किए गए मॉडल का इस्तेमाल करता है. यह मॉडल पाने के लिए, "पढ़ें" अनुमति के साथ Hugging Face के उपयोगकर्ता के ऐक्सेस टोकन का अनुरोध करें. बाद में, आपको इसे YOUR_HF_TOKEN के तौर पर इस्तेमाल करना होगा.

gemma-3-1b-it मॉडल का इस्तेमाल करने के लिए, आपको इस्तेमाल की शर्तों से सहमत होना होगा.

3. सेटअप और ज़रूरी शर्तें

इन संसाधनों को सेट अप करें:

  • आईएएम सेवा खाता और उससे जुड़ी आईएएम अनुमतियां,
  • Hugging Face टोकन को सेव करने के लिए, Secret Manager सीक्रेट
  • फ़ाइन-ट्यून किए गए मॉडल को सेव करने के लिए Cloud Storage बकेट, और
  • Artifact Registry रिपॉज़िटरी, जिसमें मॉडल को बेहतर बनाने के लिए बनाई गई इमेज सेव की जाएगी.
  1. इस कोडलैब के लिए एनवायरमेंट वैरिएबल सेट करें. हमने आपके लिए कई वैरिएबल पहले से भर दिए हैं. अपना प्रोजेक्ट आईडी, क्षेत्र, और Hugging Face टोकन बताएं.
    export PROJECT_ID=<YOUR_PROJECT_ID>
export REGION=<YOUR_REGION>
export HF_TOKEN=<YOUR_HF_TOKEN>

export NEW_MODEL=gemma-emoji
export AR_REPO=codelab-finetuning-jobs
export IMAGE_NAME=finetune-to-gcs
export JOB_NAME=finetuning-to-gcs-job
export BUCKET_NAME=$PROJECT_ID-codelab-finetuning-jobs
export SECRET_ID=HF_TOKEN
export SERVICE_ACCOUNT="finetune-job-sa"
export SERVICE_ACCOUNT_ADDRESS=$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
  2. इस कमांड को चलाकर सेवा खाता बनाएं:
    gcloud iam service-accounts create $SERVICE_ACCOUNT \
  --display-name="Service account for fine-tuning codelab"
  3. Hugging Face के ऐक्सेस टोकन को सेव करने के लिए, Secret Manager का इस्तेमाल करें:
    gcloud secrets create $SECRET_ID \
      --replication-policy="automatic"

printf $HF_TOKEN | gcloud secrets versions add $SECRET_ID --data-file=-
  4. अपने सेवा खाते को Secret Manager Secret Accessor की भूमिका असाइन करें:
    gcloud secrets add-iam-policy-binding $SECRET_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role='roles/secretmanager.secretAccessor'
  5. एक ऐसा बकेट बनाएं जिसमें फ़ाइन-ट्यून किया गया मॉडल होस्ट किया जाएगा:
    gcloud storage buckets create -l $REGION gs://$BUCKET_NAME
  6. अपने सेवा खाते को बकेट का ऐक्सेस दें:
    gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role=roles/storage.objectAdmin
  7. कंटेनर इमेज को सेव करने के लिए, Artifact Registry रिपॉज़िटरी बनाएं:
    gcloud artifacts repositories create $AR_REPO \
    --repository-format=docker \
    --location=$REGION \
    --description="codelab for finetuning using CR jobs" \
    --project=$PROJECT_ID

4. Cloud Run जॉब की इमेज बनाना

अगले चरण में, आपको ऐसा कोड बनाना होगा जो ये काम करे:

  • यह Hugging Face से Gemma मॉडल इंपोर्ट करता है
  • यह Hugging Face के डेटासेट का इस्तेमाल करके, मॉडल को बेहतर बनाता है. इस जॉब में फ़ाइन ट्यूनिंग के लिए, एक L4 GPU का इस्तेमाल किया जाता है.
  • new_model नाम के फ़ाइन-ट्यून किए गए मॉडल को आपके Cloud Storage बकेट में अपलोड करता है
  1. फ़ाइन ट्यूनिंग के लिए इस्तेमाल किए जाने वाले जॉब कोड के लिए एक डायरेक्ट्री बनाएं.
    mkdir codelab-finetuning-job
cd codelab-finetuning-job
  2. finetune.py नाम की फ़ाइल बनाना
    # Copyright 2025 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os

import torch
from datasets import load_dataset
from peft import LoraConfig, PeftModel
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
)
from trl import SFTTrainer

# Cloud Storage bucket to upload the model
bucket_name = os.getenv("BUCKET_NAME", "YOUR_BUCKET_NAME")

# The model that you want to train from the Hugging Face hub
model_name = os.getenv("MODEL_NAME", "google/gemma-3-1b-it")

# The instruction dataset to use
dataset_name = "KomeijiForce/Text2Emoji"

# Fine-tuned model name
new_model = os.getenv("NEW_MODEL", "gemma-emoji")

############################ Setup ############################################

# Load the entire model on the GPU 0
device_map = {"": torch.cuda.current_device()}

# Limit dataset to a random selection
dataset = load_dataset(dataset_name, split="train").shuffle(seed=42).select(range(1000))

# Setup input formats: trains the model to respond to "Translate to emoji:" with emoji output.
tokenizer = AutoTokenizer.from_pretrained(model_name)

def format_to_chat(example):
    return {
        "conversations": [
            {"role": "user", "content": f"Translate to emoji: {example['text']}"},
            {"role": "assistant", "content": example["emoji"]},
        ]
    }

formatted_dataset = dataset.map(
    format_to_chat,
    batched=False,                        # Process row by row
    remove_columns=dataset.column_names,  # Optional: Keep only the new column
)

def apply_chat_template(examples):
    texts = tokenizer.apply_chat_template(examples["conversations"], tokenize=False)
    return {"text": texts}

final_dataset = formatted_dataset.map(apply_chat_template, batched=True)

############################# Config #########################################

# Load tokenizer and model with QLoRA configuration
bnb_4bit_compute_dtype = "float16"  # Compute dtype for 4-bit base models
compute_dtype = getattr(torch, bnb_4bit_compute_dtype)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,  # Activate 4-bit precision base model loading
    bnb_4bit_quant_type="nf4",  # Quantization type (fp4 or nf4)
    bnb_4bit_compute_dtype=compute_dtype,
    bnb_4bit_use_double_quant=False,  # Activate nested quantization for 4-bit base models (double quantization)
)

# Load base model
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map=device_map,
    torch_dtype=torch.float16,
)
model.config.use_cache = False
model.config.pretraining_tp = 1

############################## Train ##########################################

# Load LoRA configuration
peft_config = LoraConfig(
    lora_alpha=16,     # Alpha parameter for LoRA scaling
    lora_dropout=0.1,  # Dropout probability for LoRA layers,
    r=8,               # LoRA attention dimension
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "v_proj"],
)

# Set training parameters
training_arguments = TrainingArguments(
    output_dir="./results",
    num_train_epochs=1,
    per_device_train_batch_size=1,  # Batch size per GPU for training
    gradient_accumulation_steps=2,  # Number of update steps to accumulate the gradients for
    optim="paged_adamw_32bit",
    save_steps=0,
    logging_steps=5,
    learning_rate=2e-4,    # Initial learning rate (AdamW optimizer)
    weight_decay=0.001,    # Weight decay to apply to all layers except bias/LayerNorm weights
    fp16=True, bf16=False, # Enable fp16/bf16 training
    max_grad_norm=0.3,     # Maximum gradient normal (gradient clipping)
    warmup_ratio=0.03,     # Ratio of steps for a linear warmup (from 0 to learning rate)
    group_by_length=True,  # Group sequences into batches with same length # Saves memory and speeds up training considerably
    lr_scheduler_type="cosine",
)

trainer = SFTTrainer(
    model=model,
    train_dataset=final_dataset,
    peft_config=peft_config,
    dataset_text_field="text",
    max_seq_length=512,  # Maximum sequence length to use
    tokenizer=tokenizer,
    args=training_arguments,
    packing=False,       # Pack multiple short examples in the same input sequence to increase efficiency
)

trainer.train()
trainer.model.save_pretrained(new_model)

################################# Save ########################################

# Reload model in FP16 and merge it with LoRA weights
base_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map=device_map,
)
model = PeftModel.from_pretrained(base_model, new_model)
model = model.merge_and_unload()

# push results to Cloud Storage
file_path_to_save_the_model = "/finetune/new_model"
model.save_pretrained(file_path_to_save_the_model)
tokenizer.save_pretrained(file_path_to_save_the_model)
  3. requirements.txt फ़ाइल बनाने के लिए:
    accelerate==0.34.2
bitsandbytes==0.45.5
datasets==2.19.1
transformers==4.51.3
peft==0.11.1
trl==0.8.6
torch==2.3.0
  4. Dockerfile बनाएं:
    FROM nvidia/cuda:12.6.2-runtime-ubuntu22.04

RUN apt-get update && \
    apt-get -y --no-install-recommends install python3-dev gcc python3-pip git && \
    rm -rf /var/lib/apt/lists/*

COPY requirements.txt /requirements.txt

RUN pip3 install -r requirements.txt --no-cache-dir

COPY finetune.py /finetune.py

ENV PYTHONUNBUFFERED 1

CMD python3 /finetune.py --device cuda
  5. Artifact Registry की रिपॉज़िटरी में कंटेनर बनाएं:
    gcloud builds submit \
  --tag $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$IMAGE_NAME \
  --region $REGION

5. जॉब डिप्लॉय और एक्ज़ीक्यूट करना

इस चरण में, आपको डायरेक्ट वीपीसी इग्रेस का इस्तेमाल करके जॉब बनानी होगी, ताकि Google Cloud Storage में डेटा को तेज़ी से अपलोड किया जा सके.

  1. Cloud Run जॉब बनाएं:
    gcloud run jobs create $JOB_NAME \
  --region $REGION \
  --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$IMAGE_NAME \
  --set-env-vars BUCKET_NAME=$BUCKET_NAME \
  --set-secrets HF_TOKEN=$SECRET_ID:latest \
  --cpu 8.0 \
  --memory 32Gi \
  --gpu 1 \
  --add-volume name=finetuned_model,type=cloud-storage,bucket=$BUCKET_NAME \
  --add-volume-mount volume=finetuned_model,mount-path=/finetune/new_model \
  --service-account $SERVICE_ACCOUNT_ADDRESS
  2. जॉब को लागू करना:
    gcloud run jobs execute $JOB_NAME --region $REGION --async

इस प्रोसेस को पूरा होने में करीब 10 मिनट लगेंगे. पिछली कमांड के आउटपुट में दिए गए लिंक का इस्तेमाल करके, स्थिति देखी जा सकती है.

6. vLLM की मदद से फ़ाइनट्यून किए गए मॉडल को उपलब्ध कराने के लिए, Cloud Run सेवा का इस्तेमाल करना

इस चरण में, Cloud Run सेवा को डिप्लॉय किया जाएगा. यह कॉन्फ़िगरेशन, सीधे वीपीसी का इस्तेमाल करता है. इससे निजी नेटवर्क पर Cloud Storage बकेट को ऐक्सेस किया जा सकता है, ताकि डाउनलोड तेज़ी से हो सकें.

  • Cloud Run सेवा को डिप्लॉय करें:
    gcloud run deploy serve-gemma-emoji \
  --image us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250601_0916_RC01 \
  --region $REGION \
  --port 8000 \
  --set-env-vars MODEL_ID=new_model,HF_HUB_OFFLINE=1 \
  --cpu 8.0 \
  --memory 32Gi \
  --gpu 1 \
  --add-volume name=finetuned_model,type=cloud-storage,bucket=$BUCKET_NAME \
  --add-volume-mount volume=finetuned_model,mount-path=/finetune/new_model \
  --service-account $SERVICE_ACCOUNT_ADDRESS \
  --max-instances 1 \
  --command python3 \
  --args="-m,vllm.entrypoints.api_server,--model=/finetune/new_model,--tensor-parallel-size=1" \
  --no-gpu-zonal-redundancy \
  --labels=dev-tutorial=codelab-tuning \
  --no-invoker-iam-check

7. फ़ाइन-ट्यून किए गए मॉडल को टेस्ट करना

इस चरण में, आपको अपने मॉडल को curl का इस्तेमाल करके फ़ाइन ट्यूनिंग की जांच करने के लिए प्रॉम्प्ट करना होगा.

  1. Cloud Run सेवा के लिए, सेवा का यूआरएल पाएं:
    SERVICE_URL=$(gcloud run services describe serve-gemma-emoji \
    --region $REGION --format 'value(status.url)')
  2. अपने मॉडल के लिए प्रॉम्प्ट बनाएं.
    USER_PROMPT="Translate to emoji: I ate a banana for breakfast, later I'm thinking of having soup!"
  3. अपने मॉडल को प्रॉम्प्ट करने के लिए, curl का इस्तेमाल करके अपनी सेवा को कॉल करें. साथ ही, jq का इस्तेमाल करके नतीजों को फ़िल्टर करें:
    curl -s -X POST ${SERVICE_URL}/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: bearer $(gcloud auth print-identity-token)" \
-d @- <<EOF | jq ".choices[0].message.content"
{   "model": "${NEW_MODEL}",
    "messages": [{
        "role": "user",
        "content": [ { "type": "text", "text": "${USER_PROMPT}"}]
    }]
}
EOF

आपको कुछ ऐसा जवाब दिखेगा:

🍌🤔😋🥣

8. बधाई हो!

कोडलैब पूरा करने के लिए बधाई!

हमारा सुझाव है कि आप Cloud Run Jobs GPU से जुड़ा दस्तावेज़ पढ़ें.

हमने क्या-क्या कवर किया है

  • Cloud Run Jobs GPU का इस्तेमाल करके फ़ाइन ट्यूनिंग कैसे करें
  • vLLM के साथ Cloud Run का इस्तेमाल करके मॉडल को कैसे सर्व करें
  • मॉडल को तेज़ी से अपलोड और सर्व करने के लिए, जीपीयू जॉब के लिए डायरेक्ट वीपीसी कॉन्फ़िगरेशन का इस्तेमाल कैसे करें

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

अनचाहे शुल्क से बचने के लिए, उदाहरण के लिए, अगर Cloud Run सेवाओं को मुफ़्त टियर में Cloud Run सेवाओं के लिए तय की गई मासिक सीमा से ज़्यादा बार इस्तेमाल किया जाता है, तो चरण 6 में बनाई गई Cloud Run सेवा को मिटाया जा सकता है.

Cloud Run सेवा को मिटाने के लिए, Cloud Run Cloud Console पर जाएं. इसके लिए, https://console.cloud.google.com/run पर जाएं और serve-gemma-emoji सेवा को मिटाएं.

पूरे प्रोजेक्ट को मिटाने के लिए, संसाधन मैनेज करें पर जाएं. इसके बाद, दूसरे चरण में बनाया गया प्रोजेक्ट चुनें और मिटाएं को चुनें. प्रोजेक्ट मिटाने पर, आपको Cloud SDK में प्रोजेक्ट बदलने होंगे. gcloud projects list कमांड चलाकर, सभी उपलब्ध प्रोजेक्ट की सूची देखी जा सकती है.