Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan TGI Hugging Face

Autopilot Standard

Tutorial ini menunjukkan cara menyajikan model bahasa besar (LLM) Gemma menggunakan unit pemrosesan grafis (GPU) di Google Kubernetes Engine (GKE) dengan framework layanan Text Generation Inference (TGI) dari Hugging Face. Dalam tutorial ini, Anda mendownload parameter 2B dan 7B yang telah dilatih sebelumnya dan menginstruksi model Gemma yang telah disesuaikan dari Hugging Face dan men-deploy-nya di cluster GKE Autopilot atau Standard menggunakan container yang menjalankan TGI.

Panduan ini adalah titik awal yang bagus jika Anda membutuhkan kontrol terperinci, skalabilitas, ketahanan, portabilitas, dan efektivitas biaya Kubernetes terkelola saat men-deploy dan menyalurkan workload AI/ML Anda. Jika Anda memerlukan platform AI terkelola terpadu untuk membangun dan menyajikan model ML dengan cepat dan hemat biaya, sebaiknya coba solusi deployment Vertex AI kami.

Latar belakang

Dengan menyajikan Gemma menggunakan GPU di GKE bersama TGI, Anda dapat menerapkan solusi penyajian inferensi yang tangguh 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 generatif (AI) ringan yang tersedia secara terbuka yang dirilis dengan lisensi terbuka. Model AI ini tersedia untuk berjalan di aplikasi, hardware, perangkat seluler, atau layanan yang dihosting. Anda dapat menggunakan model Gemma untuk pembuatan teks, tetapi Anda juga dapat menyesuaikan model ini untuk tugas khusus.

Untuk mempelajari lebih lanjut, lihat dokumentasi Gemma.

GPU

GPU memungkinkan Anda mempercepat workload tertentu yang berjalan di node Anda, 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 Anda menggunakan GPU di GKE, sebaiknya selesaikan jalur pembelajaran berikut:

Pelajari ketersediaan versi GPU saat ini
Pelajari GPU di GKE

Inferensi Pembuatan Teks (TGI)

TGI adalah toolkit Hugging Face untuk men-deploy dan menyalurkan LLM. TGI memungkinkan pembuatan teks berperforma tinggi untuk LLM open source populer, termasuk Gemma. TGI mencakup fitur seperti:

Penerapan transformer yang dioptimalkan dengan Flash Attention dan PagedAttention
Pengelompokan berkelanjutan untuk meningkatkan throughput penayangan secara keseluruhan
Paralelisme tensor untuk inferensi yang lebih cepat pada beberapa GPU

Untuk mempelajari lebih lanjut, lihat dokumentasi TTI.

Tujuan

Panduan ini ditujukan bagi pelanggan AI Generatif yang menggunakan PyTorch, pengguna baru atau lama dari GKE, ML Engineers, engineer MLOps (DevOps), atau administrator platform yang tertarik menggunakan kemampuan orkestrasi container Kubernetes untuk menyalurkan LLM pada hardware GPU H100, A100, dan L4.

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

Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot.
Deploy TGI ke cluster Anda.
Gunakan TGI untuk menyalurkan model Gemma 2B atau 7B melalui curl dan antarmuka chat web.

Sebelum memulai

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

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

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API yang diperlukan.

Mengaktifkan API

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

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API yang diperlukan.

Mengaktifkan API

Pastikan Anda memiliki peran berikut di project: roles/container.admin, roles/iam.serviceAccountAdmin
Memeriksa peran
1. Di konsol Google Cloud, buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Di kolom Akun utama, cari baris yang berisi alamat email Anda.
  
  Jika alamat email Anda tidak ada di kolom tersebut, berarti Anda tidak memiliki peran apa pun.
4. Di kolom Peran untuk baris yang berisi alamat email Anda, periksa apakah daftar peran menyertakan peran yang diperlukan.
Memberikan peran
1. Di konsol Google Cloud, buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Klik Berikan akses.
4. Di kolom Akun utama baru, masukkan alamat email Anda.
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 Wajah Menjurus, jika Anda belum memilikinya.
Pastikan project Anda memiliki kuota yang cukup untuk GPU. Untuk mempelajari lebih lanjut, lihat artikel Tentang GPU dan Kuota alokasi.

Mendapatkan akses ke model

Guna mendapatkan akses ke model Gemma untuk deployment ke GKE, Anda harus menandatangani perjanjian izin lisensi terlebih dahulu, lalu membuat token akses Wajah Hugging.

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

Akses halaman izin model di Kaggle.com.
Verifikasi izin menggunakan akun Wajah Memeluk Anda.
Setujui persyaratan model.

Membuat token akses

Untuk mengakses model melalui Wajah Memeluk, Anda memerlukan token Wajah Hugging.

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

Klik Profil Anda > Setelan > Token Akses.
Pilih New Token.
Tentukan Nama pilihan Anda dan Peran minimal Read.
Pilih Buat token.
Salin token yang dibuat 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 dilengkapi dengan software bawaan yang akan Anda perlukan untuk tutorial ini, termasuk kubectl dan gcloud CLI.

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

Di konsol Google Cloud, luncurkan sesi Cloud Shell dengan mengklik Activate Cloud Shell di Google Cloud Console. Tindakan ini akan meluncurkan sesi di panel bawah Konsol Google Cloud.
Tetapkan variabel lingkungan default:
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=tgi
export HF_TOKEN=HF_TOKEN
```
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 Wajah Memeluk yang Anda buat sebelumnya.

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk berikut untuk membuat materi yang diperlukan.

Membuat cluster GKE dan node pool

Anda dapat menyalurkan Gemma pada GPU dalam GKE Autopilot atau cluster Standar. Sebaiknya gunakan cluster Autopilot untuk mendapatkan pengalaman Kubernetes yang terkelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai dengan beban kerja Anda, lihat Memilih mode operasi GKE.

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.28

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

Standar

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 memerlukan waktu beberapa menit.

Jalankan perintah berikut guna membuat kumpulan node untuk cluster Anda:

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

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

Membuat rahasia Kubernetes untuk kredensial Wajah Memeluk

Di Cloud Shell, lakukan hal berikut:

Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

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

Buat Secret Kubernetes yang berisi token Wajah Peluk:

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

Men-deploy TGI

Di bagian ini, Anda akan men-deploy container TGI untuk menyalurkan model Gemma yang ingin Anda gunakan. Untuk mempelajari petunjuk tentang model yang disesuaikan dan dilatih sebelumnya, serta model yang harus dipilih untuk kasus penggunaan Anda, lihat Model yang disesuaikan.

Gemma 2B-it

Ikuti petunjuk ini untuk men-deploy model yang telah disesuaikan dengan instruksi Gemma 2B.

Buat manifes tgi-2b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b-it
        ai.gke.io/inference-server: text-generation-inference
        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-hf-tgi-serve:20240220_0936_RC01
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b-it
        - name: PORT
          value: "8000"
        - 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

Terapkan manifes:
```
kubectl apply -f tgi-2b-it.yaml
```

Gemma 7B-it

Ikuti petunjuk ini untuk men-deploy model yang telah disesuaikan instruksi Gemma 7B.

Buat manifes tgi-7b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b-it
        ai.gke.io/inference-server: text-generation-inference
        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-hf-tgi-serve:20240220_0936_RC01
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/gemma-7b-it
        - name: PORT
          value: "8000"
        - 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

Terapkan manifes:
```
kubectl apply -f tgi-7b-it.yaml
```

Gemma 2 M

Ikuti petunjuk berikut untuk men-deploy model terlatih Gemma 2B.

Buat manifes tgi-2b.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-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: text-generation-inference
        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-hf-tgi-serve:20240220_0936_RC01
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b
        - name: PORT
          value: "8000"
        - 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

Terapkan manifes:
```
kubectl apply -f tgi-2b.yaml
```

Gemma 7B

Ikuti petunjuk berikut untuk men-deploy model terlatih Gemma 2B.

Buat manifes tgi-7b.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b
        ai.gke.io/inference-server: text-generation-inference
        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-hf-tgi-serve:20240220_0936_RC01
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/gemma-7b
        - name: PORT
          value: "8000"
        - 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

Terapkan manifes:
```
kubectl apply -f tgi-7b.yaml
```

Pod dalam cluster akan mendownload bobot model dari Wajah Pelukan dan memulai mesin inferensi.

Tunggu Deployment tersedia:

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

Lihat log dari Deployment yang sedang berjalan:

kubectl logs -f -l app=gemma-server

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

INFO text_generation_router: router/src/main.rs:237: Using the Hugging Face API to retrieve tokenizer config
INFO text_generation_router: router/src/main.rs:280: Warming up model
INFO text_generation_router: router/src/main.rs:316: Setting max batch total tokens to 666672
INFO text_generation_router: router/src/main.rs:317: Connected
WARN text_generation_router: router/src/main.rs:331: Invalid hostname, defaulting to 0.0.0.0
INFO text_generation_router::server: router/src/server.rs:1035: Built with `google` feature
INFO text_generation_router::server: router/src/server.rs:1036: Environment variables `AIP_PREDICT_ROUTE` and `AIP_HEALTH_ROUTE` will be respected.

Pastikan model telah didownload sepenuhnya sebelum melanjutkan ke bagian berikutnya.

Menyalurkan model

Di bagian ini, Anda akan berinteraksi dengan model.

Menyiapkan penerusan port

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

Bagian ini menunjukkan cara melakukan uji asap dasar untuk memverifikasi model terlatih atau model yang telah disesuaikan yang telah di-deploy. Untuk mempermudah, bagian ini menjelaskan pendekatan pengujian hanya menggunakan model terlatih dan model yang disesuaikan untuk 2B.

Terlatih (2 M)

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

USER_PROMPT="Java is a"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "${USER_PROMPT}",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

Output berikut menunjukkan contoh respons model:

{"generated_text":" general-purpose, high-level, class-based, object-oriented programming language. <strong>Is Java a statically typed language?</strong> Yes, Java is a statically typed language. Java also supports dynamic typing. Static typing means that the type of every variable is explicitly specified at the time of declaration. The type can be either implicit or explicit. Static typing means that if no types are assigned then it will be assumed as a primitive type.\n\n<h3>What is Java?</h3>\n\nJava is a general-purpose, class-based, object-oriented programming language. Java is one of the oldest programming languages that has gained a"}

Petunjuk disesuaikan (2B-it)

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

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

Output berikut menunjukkan contoh respons model:

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

(Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

Di bagian ini, Anda akan mem-build aplikasi chat web yang memungkinkan Anda berinteraksi dengan model yang telah disesuaikan dengan petunjuk. Untuk mempermudah, bagian ini hanya menjelaskan pendekatan pengujian menggunakan model 2B-it.

Gradio adalah library Python yang memiliki wrapper ChatInterface yang membuat antarmuka pengguna untuk chatbot.

Men-deploy antarmuka chat

Di Cloud Shell, simpan manifes berikut sebagai gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.0
        resources:
          requests:
            cpu: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 7860
  type: ClusterIP

Terapkan manifes:
```
kubectl apply -f gradio.yaml
```

Tunggu hingga deployment tersedia:

kubectl wait --for=condition=Available --timeout=300s deployment/gradio

Menggunakan antarmuka chat

Jalankan perintah berikut di Cloud Shell:
```
kubectl port-forward service/gradio 8080:8080
```
Tindakan ini akan membuat penerusan port dari Cloud Shell ke layanan Gradio.
Klik tombol Web Preview yang dapat ditemukan di kanan atas taskbar Cloud Shell. Klik Preview on Port 8080. Tab baru akan terbuka di browser Anda.
Berinteraksi dengan Gemma menggunakan antarmuka chat Gradio. Tambahkan perintah, lalu klik Kirim.

Memecahkan masalah

Jika Anda mendapatkan pesan Empty reply from server, penampung mungkin belum selesai mendownload data model. Periksa log Pod lagi untuk menemukan pesan Connected yang menunjukkan bahwa model siap ditayangkan.
Jika Anda melihat Connection refused, pastikan penerusan port aktif.

Pembersihan

Agar tidak dikenakan 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-nya.

Menghapus resource yang di-deploy

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang Anda buat 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 pada akselerator lainnya, termasuk GPU A100 dan H100, dengan melihat kode contoh di GitHub.
Pelajari cara men-deploy workload GPU dalam mode Autopilot.
Pelajari cara men-deploy workload GPU dalam Standar.
Pelajari dokumentasi TGI.
Jelajahi Model Garden Vertex AI.
Temukan cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.

Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan TGI Hugging Face

Latar belakang

Gemma

GPU

Inferensi Pembuatan Teks (TGI)

Tujuan

Sebelum memulai

Memeriksa peran

Memberikan peran

Mendapatkan akses ke model

Tanda tangani perjanjian izin lisensi

Membuat token akses

Menyiapkan lingkungan Anda

Membuat dan mengonfigurasi resource Google Cloud

Membuat cluster GKE dan node pool

Autopilot

Standar

Membuat rahasia Kubernetes untuk kredensial Wajah Memeluk

Men-deploy TGI

Gemma 2B-it

Gemma 7B-it

Gemma 2 M

Gemma 7B

Menyalurkan model

Menyiapkan penerusan port

Berinteraksi dengan model menggunakan curl

Terlatih (2 M)

Petunjuk disesuaikan (2B-it)

(Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

Men-deploy antarmuka chat

Menggunakan antarmuka chat

Memecahkan masalah

Pembersihan

Menghapus resource yang di-deploy

Langkah selanjutnya