Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

הצגת Gemma באמצעות מעבדי TPU ב-GKE עם JetStream

טייס אוטומטי רגילה

במדריך הזה נראה לכם איך להפעיל מודל שפה גדול (LLM) של Gemma באמצעות יחידות לעיבוד טנסורים (TPU) ב-Google Kubernetes Engine ‏ (GKE). פורסים קונטיינר מוכן מראש עם JetStream ו-MaxText ב-GKE. בנוסף, אתם מגדירים את GKE לטעינת המשקלים של Gemma 7B מ-Cloud Storage בזמן הריצה.

המדריך הזה מיועד למהנדסי למידת מכונה (ML), לאדמינים ולאופרטורים של פלטפורמות ולמומחים בתחום הנתונים וה-AI שרוצים להשתמש ביכולות של Kubernetes לניהול קונטיינרים כדי להפעיל מודלים גדולים של שפה (LLM). כדי לקבל מידע נוסף על תפקידים נפוצים ועל משימות לדוגמה שאנחנו מתייחסים אליהן בGoogle Cloud תוכן, אפשר לעיין במאמר תפקידים נפוצים של משתמשים ומשימות ב-GKE.

לפני שקוראים את הדף הזה, חשוב לוודא שמכירים את הנושאים הבאים:

מצב Autopilot ומצב רגיל
זמינות של גרסאות TPU עדכניות עם ארכיטקטורת מערכת Cloud TPU
TPU ב-GKE

רקע

בקטע הזה מתוארות הטכנולוגיות העיקריות שבהן נעשה שימוש במדריך הזה.

‏Gemma

‫Gemma הוא קבוצה של מודלים קלים של בינה מלאכותית גנרטיבית (AI), שזמינים לשימוש חופשי ופורסמו ברישיון קוד פתוח. מודלים של AI זמינים להרצה באפליקציות, בחומרה, במכשירים ניידים או בשירותים מתארחים. אפשר להשתמש במודלים של Gemma ליצירת טקסט, אבל אפשר גם לכוונן את המודלים האלה למשימות מיוחדות.

מידע נוסף מופיע במאמרי העזרה בנושא Gemma.

TPUs

יחידות TPU הן מעגלים משולבים לאפליקציות ספציפיות (ASIC) שפותחו על ידי Google כדי להאיץ למידת מכונה ומודלים של AI שנבנו באמצעות frameworks כמו TensorFlow,‏ PyTorch ו-JAX.

במדריך הזה נסביר איך להשתמש במודל Gemma 7B. ‫GKE פורס את המודל בצומתי TPUv5e של מארח יחיד עם טופולוגיות TPU שהוגדרו על סמך דרישות המודל להצגת הנחיות עם זמן אחזור נמוך.

JetStream

‫JetStream הוא מודל קוד פתוח ש-Google פיתחה כדי להסיק מסקנות. ‫JetStream מאפשרת הסקת מסקנות עם ביצועים גבוהים, תפוקה גבוהה ואופטימיזציה של הזיכרון ב-TPU וב-GPU. היא מספקת אופטימיזציות מתקדמות של הביצועים, כולל טכניקות של עיבוד באצווה רציפה וקוונטיזציה, כדי להקל על פריסת מודלים גדולים של שפה (LLM). ‫JetStream מאפשרת הצגת מודלים של PyTorch/XLA ו-JAX TPU כדי להשיג ביצועים אופטימליים.

מידע נוסף על האופטימיזציות האלה זמין במאגרי הפרויקטים JetStream PyTorch ו-JetStream MaxText.

MaxText

‫MaxText הוא הטמעה של מודל שפה גדול (LLM) של JAX, שניתן להתאמה, לשינוי גודל ולביצועים טובים. הוא מבוסס על ספריות קוד פתוח של JAX כמו Flax,‏ Orbax ו-Optax. ההטמעה של מודל שפה גדול (LLM) ב-MaxText, שכוללת רק פענוח, כתובה ב-Python. הוא מסתמך במידה רבה על מהדר XLA כדי להשיג ביצועים גבוהים בלי צורך ליצור ליבות מותאמות אישית.

מידע נוסף על המודלים העדכניים וגדלי הפרמטרים שנתמכים ב-MaxText זמין במאגר הפרויקטים של MaxText.

מטרות

מכינים אשכול GKE Autopilot או אשכול רגיל עם טופולוגיית TPU מומלצת על סמך מאפייני המודל.
פריסת רכיבי JetStream ב-GKE.
קבלת המודל Gemma 7B instruction tuned ופרסום שלו.
הצגה ואינטראקציה עם המודל שפורסם.

ארכיטקטורה

בקטע הזה מתוארת ארכיטקטורת GKE שבה נעשה שימוש במדריך הזה. הארכיטקטורה כוללת אשכול GKE Autopilot או אשכול Standard שמקצה TPU ומארח רכיבי JetStream כדי לפרוס את המודלים ולהציג אותם.

בתרשים הבא מוצגים רכיבי הארכיטקטורה הזו:

ארכיטקטורה של אשכול GKE עם מאגרי צמתים של TPU במארח יחיד, שמכילים את הרכיבים Maxengine ו-Max HTTP.

הארכיטקטורה הזו כוללת את הרכיבים הבאים:

אשכול אזורי של GKE Autopilot או Standard.
שתי קבוצות של צומתי TPU slice עם מארח יחיד, שמארחות את הפריסה של JetStream.
רכיב השירות מפזר את התנועה הנכנסת לכל העותקים המשוכפלים של JetStream HTTP.
‫JetStream HTTP הוא שרת HTTP שמקבל בקשות כעטיפה לפורמט הנדרש של JetStream ושולח אותן ללקוח ה-GRPC של JetStream.
‫Maxengine הוא שרת JetStream שמבצע הסקה עם אצווה רציפה.

לפני שמתחילים

נכנסים לחשבון Google Cloud . אם אתם משתמשים חדשים ב- Google Cloud, צרו חשבון כדי שתוכלו להעריך את הביצועים של המוצרים שלנו בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300$ להרצה, לבדיקה ולפריסה של עומסי העבודה.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

צריך לוודא שיש לכם בפרויקט את התפקיד או התפקידים הבאים: roles/container.admin, roles/iam.serviceAccountAdmin, roles/resourcemanager.projectIamAdmin
בדיקת התפקידים
1. נכנסים לדף IAM במסוף Google Cloud .
  כניסה לדף IAM
2. בוחרים את הפרויקט.
3. בעמודה Principal (חשבון המשתמש), מוצאים את כל השורות שבהן מופיע השם שלכם או של קבוצה שאתם נכללים בה. כדי לברר באילו קבוצות אתם נכללים, פנו לאדמין.
4. בודקים את העמודה Role בכל השורות שבהן מצוין או מופיע השם שלכם, כדי לראות אם רשימת התפקידים כוללת את התפקידים הנדרשים.
מתן התפקידים
1. נכנסים לדף IAM במסוף Google Cloud .
  כניסה לדף IAM
2. בוחרים את הפרויקט.
3. לוחצים על Grant access.
4. בשדה New principals, מזינים את מזהה המשתמש. ‫ בדרך כלל מזהה המשתמש הוא כתובת האימייל של חשבון Google.
  ‫
5. לוחצים על Select a role ומחפשים את התפקיד.
6. כדי לתת עוד תפקידים, לוחצים על Add another role ומוסיפים אותם.
7. לוחצים על Save.

מוודאים שיש לכם מספיק מכסת שימוש לשמונה שבבי TPU v5e PodSlice Lite. במדריך הזה משתמשים במופעים על פי דרישה.
אם עדיין אין לכם חשבון Kaggle, אתם צריכים ליצור חשבון.

גישה למודל

כדי לקבל גישה למודל Gemma לצורך פריסה ב-GKE, צריך קודם לחתום על הסכם הרישיון.

כדי להשתמש ב-Gemma, צריך לחתום על הסכם ההסכמה. פועלים לפי ההוראות הבאות:

נכנסים אל דף ההסכמה לשימוש במודל Gemma באתר Kaggle.com.
אם עדיין לא עשיתם זאת, מתחברים לחשבון Kaggle.
לוחצים על בקשת גישה.
בקטע Choose Account for Consent (בחירת חשבון להסכמה), בוחרים באפשרות Verify via Kaggle Account (אימות באמצעות חשבון Kaggle) כדי להשתמש בחשבון Kaggle לצורך קבלת הסכמה.
מאשרים את התנאים וההגבלות של המודל.

יצירת אסימון גישה

כדי לגשת למודל דרך Kaggle, צריך טוקן Kaggle API.

אם עדיין אין לכם אסימון, אתם יכולים ליצור אסימון חדש באמצעות השלבים הבאים:

בדפדפן, עוברים אל ההגדרות של Kaggle.
בקטע API, לוחצים על Create New Token (יצירת אסימון חדש).

מתבצעת הורדה של קובץ בשם kaggle.json.

הכנת הסביבה

במדריך הזה משתמשים ב-Cloud Shell כדי לנהל משאבים שמתארחים ב-Google Cloud. ב-Cloud Shell מותקן מראש התוכנה שצריך למדריך הזה, כולל kubectl ו- gcloud CLI.

כדי להגדיר את הסביבה באמצעות Cloud Shell:

ב Google Cloud מסוף, מפעילים סשן של Cloud Shell על ידי לחיצה על Activate Cloud Shell בGoogle Cloud מסוף. תופעל סשן בחלונית התחתונה של Google Cloud המסוף.
מגדירים את משתני הסביבה שמוגדרים כברירת מחדל:
```
gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export NODE_LOCATION=NODE_LOCATION
export CLUSTER_VERSION=CLUSTER_VERSION
```
מחליפים את הערכים הבאים:
- ‫PROJECT_ID: Google Cloud מזהה הפרויקט.
- ‫CLUSTER_NAME: השם של אשכול GKE.
- ‫BUCKET_NAME: שם הקטגוריה של Cloud Storage. אין צורך לציין את הקידומת gs://.
- ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול. באזור הזה צריכים להיות אזורים שבהם זמינים סוגי מכונות TPU v5e (לדוגמה, us-west1,‏ us-west4,‏ us-central1,‏ us-east1,‏ us-east5 או europe-west4). באשכולות Autopilot, צריך לוודא שיש לכם מספיק משאבי TPU v5e אזוריים באזור שבחרתם.
- (אשכול רגיל בלבד) NODE_LOCATION: האזור שבו משאבי ה-TPU זמינים (לדוגמה, us-west4-a). באשכולות במצב Autopilot, אין צורך לציין את הערך הזה.
- ‫CLUSTER_VERSION: גרסת GKE, שצריכה לתמוך בסוג המכונה שרוצים להשתמש בו. שימו לב: יכול להיות שהגרסה של GKE שמוגדרת כברירת מחדל לא תהיה זמינה ל-TPU שלכם. רשימה של גרסאות GKE מינימליות שזמינות לפי סוג מכונת TPU מופיעה במאמר זמינות של TPU ב-GKE.

יצירה והגדרה של Google Cloud משאבים

כדי ליצור את המשאבים הנדרשים, פועלים לפי ההוראות הבאות.

יצירת אשכול GKE

אפשר להפעיל את Gemma ב-TPU באשכול GKE Autopilot או באשכול רגיל. מומלץ להשתמש באשכול Autopilot כדי ליהנות מחוויית Kubernetes מנוהלת באופן מלא. כדי לבחור את מצב הפעולה של GKE שהכי מתאים לעומסי העבודה שלכם, אפשר לעיין במאמר בחירת מצב פעולה של GKE.

טייס אוטומטי

ב-Cloud Shell, מריצים את הפקודה הבאה:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --location=${CONTROL_PLANE_LOCATION} \
  --cluster-version=${CLUSTER_VERSION}

רגילה

יוצרים אשכול GKE Standard אזורי שמשתמש ב-Workload Identity Federation for GKE.

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --cluster-version=${CLUSTER_VERSION} \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${CONTROL_PLANE_LOCATION}

יצירת האשכול עשויה להימשך כמה דקות.

מריצים את הפקודה הבאה כדי ליצור מאגר צמתים עבור האשכול:

gcloud container node-pools create gemma-7b-tpu-nodepool \
  --cluster=${CLUSTER_NAME} \
  --machine-type=ct5lp-hightpu-8t \
  --project=${PROJECT_ID} \
  --num-nodes=2 \
  --location=${CONTROL_PLANE_LOCATION} \
  --node-locations=${NODE_LOCATION}

‫GKE יוצר מאגר צמתים של TPU v5e עם טופולוגיה 2x4 ושני צמתים.

יצירת קטגוריה של Cloud Storage

ב-Cloud Shell, מריצים את הפקודה הבאה:

gcloud storage buckets create gs://${BUCKET_NAME} --location=${CONTROL_PLANE_LOCATION}

פעולה זו יוצרת קטגוריה של Cloud Storage לאחסון קובצי המודל שהורדתם מ-Kaggle.

העלאת טוקן הגישה ל-Cloud Shell

ב-Cloud Shell, אפשר להעלות את אסימון Kaggle API לפרויקט Google Cloud:

ב-Cloud Shell, לוחצים על אפשרויות נוספות > העלאה.
בוחרים באפשרות 'קובץ' ולוחצים על בחירת קבצים.
פותחים את הקובץ kaggle.json.
לוחצים על Upload.

יצירת Kubernetes Secret לפרטי הכניסה של Kaggle

ב-Cloud Shell, מבצעים את הפעולות הבאות:

מגדירים את kubectl לתקשורת עם האשכול:

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

יוצרים סוד לאחסון פרטי הכניסה של Kaggle:

kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json

הגדרת גישה לעומסי עבודה באמצעות איחוד שירותי אימות הזהות של עומסי עבודה ב-GKE

מקצים Kubernetes ServiceAccount לאפליקציה ומגדירים את Kubernetes ServiceAccount כך שיפעל כחשבון שירות של IAM.

יוצרים חשבון שירות ב-IAM לאפליקציה:
```
gcloud iam service-accounts create wi-jetstream
```

מוסיפים קישור למדיניות IAM לחשבון השירות ב-IAM כדי לנהל את Cloud Storage:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

כדי לאפשר ל-ServiceAccount של Kubernetes להתחזות לחשבון השירות של IAM, מוסיפים קשר בין כללי מדיניות של IAM בין שני חשבונות השירות. הקישור הזה מאפשר לחשבון השירות של Kubernetes לפעול בתור חשבון שירות של IAM:
```
gcloud iam service-accounts add-iam-policy-binding wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
```

מוסיפים הערה לחשבון השירות ב-Kubernetes עם כתובת האימייל של חשבון השירות ב-IAM:

kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com

המרת נקודות הביקורת של המודל

בקטע הזה, תיצרו Job כדי לבצע את הפעולות הבאות:

מורידים את נקודת הבדיקה הבסיסית של Orbax מ-Kaggle.
מעלים את נקודת הבדיקה לקטגוריה של Cloud Storage.
ממירים את נקודת הביקורת לנקודת ביקורת שתואמת ל-MaxText.
מבטלים את הסריקה של נקודת הבדיקה שבה רוצים להשתמש להצגת מודעות.

פריסת משימת ההמרה של נקודת הביקורת של המודל

כדי להוריד ולהמיר את קובצי נקודות הבדיקה של מודל Gemma 7B: במדריך הזה נעשה שימוש ב-Kubernetes Job. ב-Kubernetes, בקר משימות יוצר פוד אחד או יותר ועוזר לוודא שהם מבצעים משימה ספציפית בהצלחה.

יוצרים את קובץ המניפסט הבא בשם job-7b.yaml.

apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.5
        args:
        - -b=BUCKET_NAME
        - -m=google/gemma/maxtext/7b-it/2
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret

החלת המניפסט:
```
kubectl apply -f job-7b.yaml
```
מחכים שהתזמון של ה-Pod יתחיל להריץ את העבודה:
```
kubectl get pod -w
```
הפלט אמור להיראות כך, והתהליך עשוי להימשך כמה דקות:
```
NAME                  READY   STATUS              RESTARTS   AGE
data-loader-7b-abcd   0/1     ContainerCreating   0          28s
data-loader-7b-abcd   1/1     Running             0          51s
```
במקרים של אשכולות Autopilot, יכול להיות שיחלפו כמה דקות עד שהמשאבים הנדרשים של TPU יוקצו.

צפייה ביומנים מהמשימה:

kubectl logs -f jobs/data-loader-7b

כשהעבודה מסתיימת, הפלט אמור להיראות כך:

Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
+ echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'

Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items

פריסת JetStream

בקטע הזה פורסים את מאגר JetStream כדי להפעיל את מודל Gemma.

כדי לפרוס את מודל Gemma 7B שעבר כוונון להוראות, פועלים לפי ההוראות הבאות. במדריך הזה נעשה שימוש בפריסת Kubernetes. פריסה היא אובייקט Kubernetes API שמאפשר להפעיל כמה רפליקות של Pods שמפוזרות בין הצמתים באשכול.

שומרים את מניפסט הפריסה הבא בשם jetstream-gemma-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: maxengine-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: maxengine-server
  template:
    metadata:
      labels:
        app: maxengine-server
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: maxengine-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.4
        args:
        - model_name=gemma-7b
        - tokenizer_path=assets/tokenizer.gemma
        - per_device_batch_size=4
        - max_prefill_predict_length=1024
        - max_target_length=2048
        - async_checkpointing=false
        - ici_fsdp_parallelism=1
        - ici_autoregressive_parallelism=-1
        - ici_tensor_parallelism=1
        - scan_layers=false
        - weight_dtype=bfloat16
        - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
        - prometheus_port=PROMETHEUS_PORT
        ports:
        - containerPort: 9000
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.4
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: maxengine-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000
  - protocol: TCP
    name: jetstream-grpc
    port: 9000
    targetPort: 9000

בקובץ המניפסט מוגדרים מאפייני המפתח הבאים:

‫tokenizer_path: הנתיב ל-tokenizer של המודל.
‫load_parameters_path: הנתיב בקטגוריה של Cloud Storage שבה מאוחסנים נקודות הבדיקה.
‫per_device_batch_size: גודל אצווה הפענוח לכל מכשיר, כאשר שבב TPU אחד שווה למכשיר אחד.
‫max_prefill_predict_length: האורך המקסימלי של המילוי המקדים כשמבצעים רגרסיה אוטומטית.
‫max_target_length: אורך הרצף המקסימלי.
‫model_name: שם המודל (gemma-7b).
‫ici_fsdp_parallelism: מספר הרסיסים לביצוע מקביליות נתונים עם רסיסים מלאים (FSDP).
‫ici_tensor_parallelism: מספר הרסיסים של טנזור מקבילי.
‫ici_autoregressive_parallelism: מספר הרסיסים של מקביליות אוטורגרסיבית.
‫prometheus_port: יציאה לחשיפת מדדי Prometheus. אם לא צריך מדדים, מסירים את הארגומנט הזה.
‫scan_layers: דגל בוליאני של סריקת שכבות (boolean).
‫weight_dtype: סוג הנתונים של המשקל (bfloat16).

החלת המניפסט:

kubectl apply -f jetstream-gemma-deployment.yaml

אימות הפריסה:
```
kubectl get deployment
```
הפלט אמור להיראות כך:
```
NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
maxengine-server                  2/2     2            2           ##s
```
במקרים של אשכולות Autopilot, יכול להיות שיחלפו כמה דקות עד שהמשאבים הנדרשים של TPU יוקצו.

מעיינים ביומני השרת HTTP כדי לוודא שהמודל נטען ועבר קומפילציה. יכול להיות שיחלפו כמה דקות עד שהשרת ישלים את הפעולה הזו.

kubectl logs deploy/maxengine-server -f -c jetstream-http

הפלט אמור להיראות כך:

kubectl logs deploy/maxengine-server -f -c jetstream-http

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)

בודקים את היומנים של MaxEngine ומוודאים שהקומפילציה הסתיימה.

kubectl logs deploy/maxengine-server -f -c maxengine-server

הפלט אמור להיראות כך:

2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------

פרסום המודל

בקטע הזה אתם מנהלים אינטראקציה עם המודל.

הגדרת העברה ליציאה אחרת

אפשר לגשת לפריסת JetStream דרך שירות ClusterIP שיצרתם בשלב הקודם. אפשר להגיע לשירותי ClusterIP רק מתוך האשכול. לכן, כדי לגשת לשירות מחוץ לאשכול, צריך לבצע את השלבים הבאים:

כדי ליצור הפניית יציאה, מריצים את הפקודה הבאה:

kubectl port-forward svc/jetstream-svc 8000:8000

אינטראקציה עם המודל באמצעות curl

כדי לוודא שיש לכם גישה לשרת ה-HTTP של JetStream, פותחים טרמינל חדש ומריצים את הפקודה הבאה:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8000/generate \
--data \
'{
    "prompt": "What are the top 5 programming languages",
    "max_tokens": 200
}'

יכול להיות שיחלפו כמה שניות עד שהבקשה הראשונית תושלם, כי המודל צריך להתחמם. הפלט אמור להיראות כך:

{
    "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
}

(אופציונלי) אינטראקציה עם המודל דרך ממשק צ'אט של Gradio

בקטע הזה תבנו אפליקציית צ'אט באינטרנט שתאפשר לכם ליצור אינטראקציה עם מודל שהותאם להוראות.

‫Gradio היא ספריית Python עם wrapper של ChatInterface שיוצר ממשקי משתמש לצ'אטבוטים.

פריסת ממשק הצ'אט

ב-Cloud Shell, שומרים את קובץ המניפסט הבא בשם 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.3
        resources:
          requests:
            cpu: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://jetstream-svc:8000"
        - name: LLM_ENGINE
          value: "max"
        - 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

החלת המניפסט:
```
kubectl apply -f gradio.yaml
```

מחכים שהפריסה תהיה זמינה:

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

שימוש בממשק הצ'אט

ב-Cloud Shell, מריצים את הפקודה הבאה:
```
kubectl port-forward service/gradio 8080:8080
```
הפעולה הזו יוצרת העברת פורטים מ-Cloud Shell לשירות Gradio.
לוחצים על הלחצן Web Preview (תצוגה מקדימה באינטרנט) שנמצא בפינה השמאלית העליונה של סרגל המשימות ב-Cloud Shell. לוחצים על תצוגה מקדימה ביציאה 8080. תיפתח כרטיסייה חדשה בדפדפן.
אינטראקציה עם Gemma באמצעות ממשק הצ'אט של Gradio. מוסיפים הנחיה ולוחצים על שליחה.

פתרון בעיות

אם מוצגת ההודעה Empty reply from server, יכול להיות שההורדה של נתוני המודל מהקונטיינר לא הסתיימה. בודקים שוב את היומנים של ה-Pod כדי לראות את ההודעה Connected שמעידה שהמודל מוכן להצגה.
אם מופיע Connection refused, צריך לוודא שהעברת הפורטים פעילה.

הסרת המשאבים

כדי להימנע מחיובים בחשבון Google Cloud בגלל השימוש במשאבים שנעשה במסגרת המדריך הזה, אפשר למחוק את הפרויקט שמכיל את המשאבים, או להשאיר את הפרויקט ולמחוק את המשאבים בנפרד.

מחיקת המשאבים שנפרסו

כדי להימנע מחיובים בחשבון Google Cloud על המשאבים שיצרתם במדריך הזה, מריצים את הפקודות הבאות ופועלים לפי ההנחיות:

gcloud container clusters delete ${CLUSTER_NAME} --location=${CONTROL_PLANE_LOCATION}

gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

gcloud storage rm --recursive gs://BUCKET_NAME

המאמרים הבאים

איך מריצים מודלים של Gemma ב-GKE ואיך מריצים עומסי עבודה של AI/ML שעברו אופטימיזציה באמצעות יכולות התזמור של פלטפורמת GKE.
מידע נוסף על TPU ב-GKE
מעיינים במאגר GitHub של JetStream.
מעיינים ב-Vertex AI Model Garden.