Jak dostosować LLM za pomocą zadań Cloud Run

1. Wprowadzenie

Przegląd

W tym module dowiesz się, jak używać zadań Cloud Run do dostrajania modelu Gemma 3, a następnie udostępniać wynik w Cloud Run za pomocą vLLM.

Jakie zadania wykonasz

Wytrenuj model, aby odpowiadał na konkretną frazę konkretnym wynikiem, korzystając ze zbioru danych KomeijiForce/Text2Emoji, który powstał w ramach projektu EmojiLM: Modeling the New Emoji Language.

Po wytrenowaniu model odpowiada na zdanie poprzedzone tekstem „Translate to emoji: ” serią emotikonów odpowiadających temu zdaniu.

Czego się nauczysz

• Jak przeprowadzić dostrajanie za pomocą GPU w Cloud Run Jobs
• Jak udostępniać model za pomocą Cloud Run z vLLM
• Jak używać konfiguracji bezpośredniego połączenia VPC w przypadku zadania GPU, aby szybciej przesyłać i udostępniać model

2. Zanim zaczniesz

Włącz interfejsy API

Zanim zaczniesz korzystać z tego laboratorium, włącz te interfejsy API, uruchamiając to polecenie:

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

Limit GPU

Zapoznaj się z dokumentacją limitu GPU, aby dowiedzieć się, jak poprosić o zwiększenie limitu.

Jeśli napotkasz błędy „Nie masz limitu na korzystanie z GPU”, sprawdź swój limit na stronie g.co/cloudrun/gpu-quota.

Uwaga: jeśli używasz nowego projektu, może minąć kilka minut od włączenia interfejsu API do pojawienia się limitów na stronie limitów.

Hugging Face

W tym ćwiczeniu w Codelabs używamy modelu hostowanego na platformie Hugging Face. Aby uzyskać ten model, poproś o token dostępu użytkownika Hugging Face z uprawnieniami do odczytu. Będzie on dalej występować jako YOUR_HF_TOKEN.

Aby korzystać z modelu gemma-3-1b-it, musisz zaakceptować warunki użytkowania.

3. Konfiguracja i wymagania

Skonfiguruj te zasoby:

• konto usługi IAM i powiązane z nim uprawnienia IAM;
• Secret Manager secret do przechowywania tokena Hugging Face,
• zasobnik Cloud Storage, w którym będzie przechowywany dostrojony model,
• Repozytorium Artifact Registry do przechowywania obrazu, który zostanie utworzony na potrzeby dostrajania modelu.

1. Ustaw zmienne środowiskowe na potrzeby tych ćwiczeń z programowania. Wstępnie wypełniliśmy dla Ciebie kilka zmiennych. Podaj identyfikator projektu, region i token 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. Utwórz konto usługi, uruchamiając to polecenie:

   gcloud iam service-accounts create $SERVICE_ACCOUNT \
     --display-name="Service account for fine-tuning codelab"
   

3. Użyj Secret Managera do przechowywania tokena dostępu Hugging Face:

   gcloud secrets create $SECRET_ID \
         --replication-policy="automatic"
   
   printf $HF_TOKEN | gcloud secrets versions add $SECRET_ID --data-file=-
   

4. Przypisz do konta usługi rolę uzyskującego dostęp do obiektów tajnych w Menedżerze obiektów tajnych:

   gcloud secrets add-iam-policy-binding $SECRET_ID \
     --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
     --role='roles/secretmanager.secretAccessor'
   

5. Utwórz zasobnik, w którym będzie przechowywany model dostrojony:

   gcloud storage buckets create -l $REGION gs://$BUCKET_NAME
   

6. Przyznaj kontu usługi dostęp do zasobnika:

   gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
     --role=roles/storage.objectAdmin
   

7. Utwórz repozytorium Artifact Registry, w którym będziesz przechowywać obraz kontenera:

   gcloud artifacts repositories create $AR_REPO \
       --repository-format=docker \
       --location=$REGION \
       --description="codelab for finetuning using CR jobs" \
       --project=$PROJECT_ID
   

4. Tworzenie obrazu zadania Cloud Run

W następnym kroku utworzysz kod, który będzie wykonywać te czynności:

• Importuje model Gemma z Hugging Face
• Dostraja model za pomocą zbioru danych z Hugging Face. Zadanie wykorzystuje 1 procesor graficzny L4 do dostrajania.
• przesyła dostrojony model o nazwie new_model do zasobnika Cloud Storage;

1. Utwórz katalog dla kodu zadania dostrajania.

   mkdir codelab-finetuning-job
   cd codelab-finetuning-job
   

2. Utwórz plik o nazwie 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. Utwórz plik 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. Utwórz 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. Skompiluj kontener w repozytorium Artifact Registry:

   gcloud builds submit \
     --tag $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$IMAGE_NAME \
     --region $REGION
   

5. Wdrażanie i wykonywanie zadania

W tym kroku utworzysz zadanie z bezpośrednim ruchem wychodzącym VPC, aby przyspieszyć przesyłanie do Google Cloud Storage.

1. Utwórz zadanie 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. Wykonaj zadanie:

   gcloud run jobs execute $JOB_NAME --region $REGION --async
   

Ukończenie zadania zajmie około 10 minut. Stan możesz sprawdzić, korzystając z linku podanego w danych wyjściowych ostatniego polecenia.

6. Używanie usługi Cloud Run do udostępniania dostrojonego modelu za pomocą vLLM

W tym kroku wdrożysz usługę Cloud Run. Ta konfiguracja używa bezpośredniej sieci VPC, aby uzyskać dostęp do zasobnika Cloud Storage przez sieć prywatną, co przyspiesza pobieranie.

• Wdróż usługę 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. Testowanie dostrojonego modelu

W tym kroku poprosisz model o przetestowanie dostrajania za pomocą polecenia curl.

1. Pobierz adres URL usługi Cloud Run:

   SERVICE_URL=$(gcloud run services describe serve-gemma-emoji \
       --region $REGION --format 'value(status.url)')
   

2. Utwórz prompta dla modelu.

   USER_PROMPT="Translate to emoji: I ate a banana for breakfast, later I'm thinking of having soup!"
   

3. Wywołaj usługę za pomocą polecenia curl, aby wysłać prompt do modelu, filtrując wyniki za pomocą 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
   
   

Powinna pojawić się odpowiedź podobna do tej:

🍌🤔😋🥣

8. Gratulacje!

Gratulujemy ukończenia ćwiczenia!

Zalecamy zapoznanie się z dokumentacją GPU w Cloud Run Jobs.

Omówione zagadnienia

• Jak przeprowadzić dostrajanie za pomocą GPU w Cloud Run Jobs
• Jak udostępniać model za pomocą Cloud Run z vLLM
• Jak używać konfiguracji bezpośredniego połączenia VPC w przypadku zadania GPU, aby szybciej przesyłać i udostępniać model

9. Czyszczenie danych

Aby uniknąć przypadkowych opłat, np. jeśli usługi Cloud Run zostaną przypadkowo wywołane więcej razy niż miesięczny limit wywołań Cloud Run w bezpłatnej wersji, możesz usunąć usługę Cloud Run utworzoną w kroku 6.

Aby usunąć usługę Cloud Run, otwórz konsolę Cloud Run w Cloud Console pod adresem https://console.cloud.google.com/run i usuń usługę serve-gemma-emoji.

Aby usunąć cały projekt, otwórz stronę Zarządzaj zasobami, wybierz projekt utworzony w kroku 2 i kliknij Usuń. Jeśli usuniesz projekt, musisz zmienić projekty w Cloud SDK. Listę wszystkich dostępnych projektów możesz wyświetlić, uruchamiając polecenie gcloud projects list.