Menyesuaikan model terbuka Gemma menggunakan beberapa GPU di GKE

Autopilot Standard

---

Tutorial ini menunjukkan cara menyesuaikan model bahasa besar (LLM) Gemma, keluarga model terbuka, menggunakan unit pemrosesan grafis (GPU) di Google Kubernetes Engine (GKE) dengan library Transformers dari Hugging Face. Penyesuaian Lanjutan adalah proses pembelajaran dengan pengawasan yang meningkatkan kemampuan model terlatih untuk melakukan tugas tertentu dengan memperbarui parameternya dengan set data baru. Dalam tutorial ini, Anda akan mendownload model keluarga Gemma terlatih parameter 2B dari Hugging Face dan menyesuaikannya di cluster GKE Autopilot atau Standard.

Panduan ini adalah titik awal yang baik jika Anda memerlukan kontrol terperinci, skalabilitas, ketahanan, portabilitas, dan hemat biaya dari Kubernetes terkelola saat menyesuaikan LLM.

Praktik terbaik:

Coba solusi Vertex AI kami jika Anda memerlukan platform AI terkelola terpadu untuk membuat dan menayangkan model ML dengan cepat dan hemat biaya.

Latar belakang

Dengan menayangkan Gemma menggunakan GPU di GKE dengan library transformer, Anda dapat menerapkan solusi penayangan inferensi yang andal dan siap produksi dengan semua manfaat Kubernetes terkelola, termasuk skalabilitas yang efisien dan ketersediaan yang lebih tinggi. Bagian ini menjelaskan teknologi utama yang digunakan dalam panduan ini.

Gemma

Gemma adalah serangkaian model kecerdasan buatan (AI) generatif yang ringan dan tersedia secara terbuka yang dirilis dengan lisensi terbuka. Model AI ini tersedia untuk dijalankan di aplikasi, hardware, perangkat seluler, atau layanan yang dihosting.

Dalam panduan ini, kami memperkenalkan Gemma untuk pembuatan teks. Anda juga dapat menyesuaikan model ini agar berspesialisasi dalam melakukan tugas tertentu.

Set data yang Anda gunakan dalam dokumen ini adalah b-mc2/sql-create-context.

Untuk mempelajari lebih lanjut, lihat dokumentasi Gemma.

GPU

GPU memungkinkan Anda mempercepat workload tertentu yang berjalan di node, seperti machine learning dan pemrosesan data. GKE menyediakan berbagai opsi jenis mesin untuk konfigurasi node, termasuk jenis mesin dengan GPU NVIDIA H100, L4, dan A100.

Sebelum menggunakan GPU di GKE, sebaiknya selesaikan jalur pembelajaran berikut:

1. Pelajari ketersediaan versi GPU saat ini
2. Pelajari GPU di GKE

Transformer Hugging Face

Dengan library Transformers dari Hugging Face, Anda dapat mengakses model terlatih mutakhir. Library Transformers memungkinkan Anda mengurangi waktu, resource, dan biaya komputasi yang terkait dengan pelatihan model lengkap.

Dalam tutorial ini, Anda akan menggunakan API dan alat Hugging Face untuk mendownload dan menyesuaikan model terlatih ini.

Tujuan

Panduan ini ditujukan untuk pengguna baru atau lama GKE, Engineer ML, engineer MLOps (DevOps), atau administrator platform yang tertarik menggunakan kemampuan orkestrasi penampung Kubernetes untuk meningkatkan kualitas LLM di hardware GPU H100, A100, dan L4.

Di akhir panduan ini, Anda akan dapat melakukan langkah-langkah berikut:

1. Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot.
2. Buat penampung penyesuaian.
3. Gunakan GPU untuk menyesuaikan model Gemma 2B dan upload model ke Hugging Face.

Sebelum memulai

• Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

• Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

  Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

  Buka pemilih project

• Make sure that billing is enabled for your Google Cloud project.

• Aktifkan API yang diperlukan.

  Mengaktifkan API

• Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

  Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

  Buka pemilih project

• Make sure that billing is enabled for your Google Cloud project.

• Aktifkan API yang diperlukan.

  Mengaktifkan API

• Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

  Check for the roles

  1. In the Google Cloud console, go to the IAM page.

     Go to IAM
  2. Select the project.

  3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

  4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

  Grant the roles

  1. In the Google Cloud console, go to the IAM page.

     Buka IAM
  2. Pilih project.
  3. Klik Berikan akses.

  4. Di kolom New principals, masukkan ID pengguna Anda. Ini biasanya adalah alamat email untuk Akun Google.

  5. Di daftar Pilih peran, pilih peran.
  6. Untuk memberikan peran tambahan, klik Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
  7. Klik Simpan.

• Buat akun Hugging Face, jika Anda belum memilikinya.
• Pastikan project Anda memiliki kuota yang memadai untuk GPU. Untuk mempelajari lebih lanjut, lihat Tentang GPU dan Kuota alokasi.

Mendapatkan akses ke model

Untuk mendapatkan akses ke model Gemma untuk di-deploy ke GKE, Anda harus menandatangani perjanjian izin lisensi terlebih dahulu, lalu membuat token akses Hugging Face.

Menandatangani perjanjian izin lisensi

Anda harus menandatangani perjanjian izin untuk menggunakan Gemma. Ikuti petunjuk berikut:

1. Akses halaman izin model di Kaggle.com.
2. Verifikasi izin menggunakan akun Hugging Face Anda.
3. Setujui persyaratan model.

Membuat token akses

Untuk mengakses model melalui Hugging Face, Anda memerlukan token Hugging Face.

Ikuti langkah-langkah berikut untuk membuat token baru jika Anda belum memilikinya:

1. Klik Profil Anda > Setelan > Token Akses.
2. Pilih New Token.
3. Tentukan Nama pilihan Anda dan Peran minimal Write.
4. Pilih Buat token.
5. Salin token yang dihasilkan ke papan klip Anda.

Menyiapkan lingkungan Anda

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal dengan software yang akan Anda perlukan untuk tutorial ini, termasuk kubectl dan gcloud CLI.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

1. Di konsol Google Cloud, luncurkan sesi Cloud Shell dengan mengklik Aktifkan Cloud Shell di konsol Google Cloud. Tindakan ini akan meluncurkan sesi di panel bawah Konsol Google Cloud.

2. Tetapkan variabel lingkungan default:

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export REGION=REGION
   export CLUSTER_NAME=finetuning
   export HF_TOKEN=HF_TOKEN
   export HF_PROFILE=HF_PROFILE
   

   Ganti nilai berikut:

   • PROJECT_ID: Project ID Google Cloud Anda.
   • REGION: Region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
   • HF_TOKEN: Token Hugging Face yang Anda buat sebelumnya.
   • HF_PROFILE: ID Profil Hugging Face yang Anda buat sebelumnya.

3. Clone repositori kode contoh dari GitHub:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/ai-ml/llm-finetuning-gemma
   

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk ini untuk membuat resource yang diperlukan.

Membuat cluster dan node pool GKE

Anda dapat menayangkan Gemma di GPU dalam cluster GKE Autopilot atau Standard. Untuk memilih mode operasi GKE yang paling sesuai untuk workload Anda, lihat Memilih mode operasi GKE.

Praktik terbaik:

Gunakan Autopilot untuk pengalaman Kubernetes yang sepenuhnya dikelola.

Autopilot

Jalankan perintah berikut di Cloud Shell:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.29

GKE membuat cluster Autopilot dengan node CPU dan GPU seperti yang diminta oleh beban kerja yang di-deploy.

Standard

1. Di Cloud Shell, jalankan perintah berikut untuk membuat cluster Standar:

   gcloud container clusters create ${CLUSTER_NAME} \
     --project=${PROJECT_ID} \
     --region=${REGION} \
     --workload-pool=${PROJECT_ID}.svc.id.goog \
     --release-channel=rapid \
     --num-nodes=1
   

   Pembuatan cluster mungkin memerlukan waktu beberapa menit.

2. Jalankan perintah berikut untuk membuat node pool untuk cluster Anda:

   gcloud container node-pools create gpupool \
     --accelerator type=nvidia-l4,count=8,gpu-driver-version=latest \
     --project=${PROJECT_ID} \
     --location=${REGION} \
     --node-locations=${REGION}-a \
     --cluster=${CLUSTER_NAME} \
     --machine-type=g2-standard-96 \
     --num-nodes=1
   

   GKE membuat satu node pool yang berisi dua GPU L4 untuk setiap node.

Membuat secret Kubernetes untuk kredensial Hugging Face

Di Cloud Shell, lakukan hal berikut:

1. Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

   gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
   

2. Buat Secret Kubernetes yang berisi token Hugging Face:

   kubectl create secret generic hf-secret \
     --from-literal=hf_api_token=${HF_TOKEN} \
     --dry-run=client -o yaml | kubectl apply -f -
   

Membuat container penyesuaian halus dengan Docker dan Cloud Build

Penampung ini menggunakan kode PyTorch dan Hugging Face Transformers untuk menyesuaikan model Gemma terlatih yang ada.

1. Membuat Repositori Docker Artifact Registry

   gcloud artifacts repositories create gemma \
       --project=${PROJECT_ID} \
       --repository-format=docker \
       --location=us \
       --description="Gemma Repo"
   

2. Mem-build dan mengirim image

   gcloud builds submit .
   

3. Ekspor IMAGE_URL untuk digunakan nanti dalam tutorial ini.

   export IMAGE_URL=us-docker.pkg.dev/$PROJECT_ID/gemma/finetune-gemma-gpu:1.0.0
   

Menjalankan Tugas penyesuaian di GKE

Men-deploy tugas penyesuaian Gemma

1. Buka file finetune.yaml.

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: finetune-job
     namespace: default
   spec:
     backoffLimit: 2
     template:
       metadata:
         annotations:
           kubectl.kubernetes.io/default-container: finetuner
       spec:
         terminationGracePeriodSeconds: 600
         containers:
         - name: finetuner
           image: $IMAGE_URL
           resources:
             limits:
               nvidia.com/gpu: "8"
           env:
           - name: MODEL_NAME
             value: "google/gemma-2b"
           - name: NEW_MODEL
             value: "gemma-2b-sql-finetuned"
           - name: LORA_R
             value: "8"
           - name: LORA_ALPHA
             value: "16"
           - name: TRAIN_BATCH_SIZE
             value: "1"
           - name: EVAL_BATCH_SIZE
             value: "2"
           - name: GRADIENT_ACCUMULATION_STEPS
             value: "2"
           - name: DATASET_LIMIT
             value: "1000"
           - name: MAX_SEQ_LENGTH
             value: "512"
           - name: LOGGING_STEPS
             value: "5"
           - name: HF_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         volumes:
         - name: dshm
           emptyDir:
             medium: Memory
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
         restartPolicy: OnFailure

2. Terapkan manifes untuk membuat tugas penyesuaian:

   envsubst < finetune.yaml | kubectl apply -f -
   

   Petunjuk ini mengganti IMAGE_URL dengan variabel dalam manifes.

3. Pantau Tugas dengan menjalankan perintah berikut:

   watch kubectl get pods
   

4. Periksa log tugas dengan menjalankan perintah berikut:

   kubectl logs job.batch/finetune-job -f
   

   Resource Tugas mendownload data model, lalu menyesuaikan model di semua 8 GPU. Proses ini dapat memerlukan waktu hingga 20 menit.

5. Setelah Tugas selesai, buka akun Hugging Face Anda. Model baru bernama $HF_PROFILE/gemma-2b-sql-finetuned akan muncul di profil Hugging Face Anda.

Menayangkan model yang telah disesuaikan di GKE

Di bagian ini, Anda akan men-deploy penampung vLLM untuk menayangkan model Gemma.

1. Buat manifes serve-gemma.yaml berikut:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: vllm-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2b
           ai.gke.io/inference-server: vllm
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240220_0936_RC01
           resources:
             requests:
               cpu: "2"
               memory: "7Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: 1
             limits:
               cpu: "2"
               memory: "7Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: 1
           command: ["python3", "-m", "vllm.entrypoints.api_server"]
           args:
           - --model=$(MODEL_ID)
           - --tensor-parallel-size=1
           env:
           - name: MODEL_ID
             value: google/gemma-2b
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
         volumes:
         - name: dshm
           emptyDir:
               medium: Memory
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 8000
         targetPort: 8000

2. Membuat variabel lingkungan untuk MODEL_ID baru

   export MODEL_ID=$HF_PROFILE/gemma-2b-sql-finetuned
   

3. Ganti MODEL_ID dalam manifes:

   sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml
   

4. Terapkan manifes:

   kubectl apply -f serve-gemma.yaml
   

   Pod di cluster mendownload bobot model dari Hugging Face dan memulai mesin penayangan.

5. Tunggu hingga Deployment tersedia:

   kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment
   

6. Lihat log dari Deployment yang sedang berjalan:

   kubectl logs -f -l app=gemma-server
   

Resource Deployment mendownload data model. Proses ini dapat memerlukan waktu beberapa menit. Outputnya mirip dengan hal berikut ini:

INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Pastikan model didownload sepenuhnya sebelum melanjutkan ke bagian berikutnya.

Menayangkan model

Di bagian ini, Anda akan berinteraksi dengan model.

Menyiapkan penerusan port

Setelah model di-deploy, jalankan perintah berikut untuk menyiapkan penerusan port ke model:

kubectl port-forward service/llm-service 8000:8000

Outputnya mirip dengan hal berikut ini:

Forwarding from 127.0.0.1:8000 -> 8000

Berinteraksi dengan model menggunakan curl

Dalam sesi terminal baru, gunakan curl untuk melakukan chat dengan model Anda:

Contoh perintah berikut adalah untuk TGI

USER_PROMPT="Question: What is the total number of attendees with age over 30 at kubecon eu? Context: CREATE TABLE attendees (name VARCHAR, age INTEGER, kubecon VARCHAR)"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "prompt": "${USER_PROMPT}",
    "temperature": 0.1,
    "top_p": 1.0,
    "max_tokens": 24
}
EOF

Output berikut menunjukkan contoh respons model:

{"generated_text":" Answer: SELECT COUNT(age) FROM attendees WHERE age > 30 AND kubecon = 'eu'\n"}

Bergantung pada kueri, Anda mungkin harus mengubah max_token untuk mendapatkan hasil yang lebih baik. Anda juga dapat menggunakan model yang disesuaikan dengan petunjuk untuk pengalaman chat yang lebih baik.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus resource yang di-deploy

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang dibuat dalam panduan ini, jalankan perintah berikut:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

Langkah selanjutnya

• Pelajari GPU di GKE lebih lanjut.
• Pelajari cara menggunakan Gemma dengan TGI di akselerator lain, termasuk GPU A100 dan H100, dengan melihat kode contoh di GitHub.
• Pelajari cara men-deploy workload GPU di Autopilot.
• Pelajari cara men-deploy workload GPU di Standard.
• Jelajahi Vertex AI Model Garden.
• Temukan cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.
• Pelajari cara menggunakan Assured Workloads untuk menerapkan kontrol ke folder di Google Cloud guna memenuhi persyaratan peraturan.