הצגת 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 ומשימות.

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

רקע

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

‏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 זמין במאגר הפרויקט של MaxtText.

מטרות

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

ארכיטקטורה

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

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

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

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

  • אשכול אזורי של GKE במצב Autopilot או במצב רגיל.
  • שני מאגרי צמתים של חלקי TPU עם מארח יחיד, שמארחים את הפריסה של 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, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). 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, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). 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, צריך לחתום על הסכם ההסכמה. פועלים לפי ההוראות הבאות:

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

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

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

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

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

קובץ בשם kaggle.json יורד.

הכנת הסביבה

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

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

  1. במסוף Google Cloud , לוחצים על Activate Cloud Shell בGoogle Cloud מסוף כדי להפעיל סשן של Cloud Shell. סמל ההפעלה של Cloud Shell ייפתח סשן בחלונית התחתונה של מסוף Google Cloud .

  2. מגדירים את משתני הסביבה שמוגדרים כברירת מחדל:

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
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 אזוריים באזור שבחרתם.
    • ‫(Standard cluster only) 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}

רגילה

  1. יוצרים אשכול 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}

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

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

    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} \
    --uniform-bucket-level-access

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

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

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

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

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

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

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

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

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

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

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

נותנים ל-default Kubernetes ServiceAccount במרחב השמות default את תפקידי ה-IAM הנדרשים (roles/storage.objectUser ו-roles/storage.insightsCollectorService) לניהול Cloud Storage:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/default" \
    --role="roles/storage.objectUser" \
    --condition=None

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/default" \
    --role="roles/storage.insightsCollectorService" \
    --condition=None

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

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

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

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

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

  1. יוצרים את קובץ המניפסט הבא בשם 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

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

    kubectl apply -f job-7b.yaml

  3. מחכים שה-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 יוקצו.

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

    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 שמפוזרים בין הצמתים באשכול.

  1. שומרים את מניפסט הפריסה הבא בשם 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).

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

    kubectl apply -f jetstream-gemma-deployment.yaml

  3. מאמתים את הפריסה:

    kubectl get deployment

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

    NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
maxengine-server                  2/2     2            2           ##s

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

  4. מעיינים ביומני שרת ה-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)

  5. בודקים את היומנים של 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

  1. כדי לוודא שיש לכם גישה לשרת ה-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 עם ChatInterface wrapper שיוצר ממשקי משתמש לצ'אטבוטים.

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

  1. ב-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

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

    kubectl apply -f gradio.yaml

  3. ממתינים עד שהפריסה תהיה זמינה:

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

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

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

    kubectl port-forward service/gradio 8080:8080

    הפעולה הזו יוצרת העברת פורטים מ-Cloud Shell לשירות Gradio.

  2. לוחצים על הלחצן הסמל של תצוגה מקדימה באינטרנט Web Preview (תצוגה מקדימה באינטרנט) בפינה הימנית העליונה של סרגל המשימות של Cloud Shell. לוחצים על תצוגה מקדימה ביציאה 8080. תיפתח כרטיסייה חדשה בדפדפן.

  3. מנהלים אינטראקציה עם Gemma באמצעות ממשק הצ'אט של Gradio. מוסיפים הנחיה ולוחצים על שליחה.

פתרון בעיות

הסרת המשאבים

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

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

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

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

gcloud storage rm --recursive gs://BUCKET_NAME

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