הצגת מודלים פתוחים של Gemma באמצעות יחידות GPU ב-GKE עם Hugging Face TGI

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

במדריך הזה נסביר איך לפרוס מודלים גדולים של שפה (LLM) ולהשתמש בהם באמצעות יחידות GPU ב-Google Kubernetes Engine ‏ (GKE) עם Text Generation Inference ‏ (TGI),‏ framework להפעלת מודלים מבית Hugging Face. המדריך הזה מספק בסיס להבנה ולבדיקה של פריסת LLM מעשית להסקת מסקנות בסביבת Kubernetes מנוהלת. פורסים קונטיינר מוכן מראש שמריץ TGI ב-GKE. אתם גם מגדירים את GKE לטעינת המשקלים של Gemma 2B,‏ 9B ו-27B מ-Hugging Face.

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

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

אם אתם צריכים פלטפורמת AI מנוהלת ומאוחדת כדי ליצור ולהכניס לשימוש בסביבת הייצור במהירות מודלים של למידת מכונה בצורה חסכונית, מומלץ לנסות את פתרון הפריסה שלנו Vertex AI.

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

• מצב Autopilot ומצב רגיל
• זמינות הגרסה הנוכחית של GPU
• יחידות GPU ב-GKE

רקע

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

‏Gemma

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

במדריך הזה נציג את המודלים הבאים:

• ‫Gemma ליצירת טקסט, אפשר גם לכוונן את המודלים האלה כדי להתמחות בביצוע משימות ספציפיות.
• ‫CodeGemma היא אוסף של מודלים חזקים וקלי משקל שיכולים לבצע מגוון משימות תכנות כמו השלמת קוד, יצירת קוד, הבנת שפה טבעית, חשיבה מתמטית וביצוע הוראות.

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

יחידות GPU

מעבדי GPU מאפשרים להאיץ עומסי עבודה ספציפיים שפועלים בצמתים, כמו למידת מכונה ועיבוד נתונים. ‫GKE מספק מגוון אפשרויות של סוגי מכונות להגדרת צמתים, כולל סוגי מכונות עם מעבדי GPU של NVIDIA H100,‏ L4 ו-A100.

Text Generation Inference (TGI)

‫TGI הוא ערכת הכלים של Hugging Face לפריסה ולהצגה של מודלים גדולים של שפה (LLM). ‫TGI מאפשר יצירת טקסט בביצועים גבוהים למודלים פופולריים של LLM בקוד פתוח, כולל Gemma. ‫TGI כולל תכונות כמו:

• הטמעה אופטימלית של טרנספורמר עם Flash Attention ו-PagedAttention
• הוספת תכונה של אצווה מתמשכת כדי לשפר את התפוקה הכוללת של הצגת המודעות
• מקביליות טנסור להסקת מסקנות מהירה יותר בכמה מעבדי GPU

מידע נוסף זמין במאמרי העזרה בנושא TGI.

מטרות

1. מכינים את הסביבה עם אשכול GKE במצב Autopilot.
2. פורסים את TGI באשכול.
3. אפשר להשתמש ב-TGI כדי להפעיל את מודל Gemma 2 באמצעות curl וממשק צ'אט באינטרנט.

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

נכנסים לחשבון 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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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

  בדיקת התפקידים

  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.

• יוצרים חשבון ב-Hugging Face, אם עדיין אין לכם חשבון.
• מוודאים שיש בפרויקט מכסה מספקת ל-GPU L4. מידע נוסף זמין במאמרים מידע על יחידות GPU ומכסות הקצאה.

גישה למודל

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

חתימה על הסכם הסכמה לרישיון

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

1. נכנסים אל דף ההסכמה לשימוש במודל באתר Kaggle.com.
2. צריך לאמת את ההסכמה באמצעות חשבון Hugging Face.
3. מאשרים את התנאים של המודל.

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

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

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

1. לוחצים על הפרופיל שלך > הגדרות > טוקנים של גישה.
2. בוחרים באפשרות New Token (טוקן חדש).
3. מציינים שם לבחירתכם ותפקיד ברמה של Read לפחות.
4. לוחצים על יצירת אסימון.
5. מעתיקים את הטוקן שנוצר ללוח.

הכנת הסביבה

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

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

1. ב Google Cloud מסוף, מפעילים סשן של Cloud Shell על ידי לחיצה על Activate Cloud Shell בGoogle Cloud מסוף. תופעל סשן בחלונית התחתונה של 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 CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
   export CLUSTER_NAME=CLUSTER_NAME
   export HF_TOKEN=HF_TOKEN
   

   מחליפים את הערכים הבאים:

   • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud.
   • ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול. האזור הזה צריך לתמוך בסוג המאיץ שבו רוצים להשתמש, לדוגמה, us-central1 ל-GPU מסוג L4.
   • ‫CLUSTER_NAME: השם של האשכול.
   • ‫HF_TOKEN: אסימון Hugging Face שיצרתם קודם.

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

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

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

יצירת אשכול GKE ומאגר צמתים

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

טייס אוטומטי

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

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --release-channel=rapid

מחליפים את הערכים הבאים:

• ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud.
• ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול. האזור הזה צריך לתמוך בסוג המאיץ שבו רוצים להשתמש, לדוגמה, us-central1 ל-GPU מסוג L4.
• ‫CLUSTER_NAME: השם של האשכול.

‫GKE יוצר אשכול Autopilot עם צמתים של מעבד ו-GPU לפי הבקשה של עומסי העבודה שנפרסו.

רגילה

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

   gcloud container clusters create CLUSTER_NAME \
       --project=PROJECT_ID \
       --location=CONTROL_PLANE_LOCATION \
       --workload-pool=PROJECT_ID.svc.id.goog \
       --release-channel=rapid \
       --num-nodes=1
   

   מחליפים את הערכים הבאים:

   • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud.
   • ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול. האזור הזה צריך לתמוך בסוג המאיץ שבו רוצים להשתמש, לדוגמה, us-central1 ל-GPU מסוג L4.
   • ‫CLUSTER_NAME: השם של האשכול.

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

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

   Gemma 2 2B

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

   ‫GKE יוצר מאגר צמתים יחיד שמכיל GPU ברמה 4 לכל צומת.

   Gemma 2 9B

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

   ‫GKE יוצר מאגר צמתים יחיד שמכיל שני GPU מסוג L4 לכל צומת.

   Gemma 2 27B

   gcloud container node-pools create gpupool \
       --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
       --project=PROJECT_ID \
       --location=CONTROL_PLANE_LOCATION \
       --node-locations=CONTROL_PLANE_LOCATION-a \
       --cluster=CLUSTER_NAME \
       --machine-type=g2-standard-48 \
       --num-nodes=1 \
       --disk-size=180
   

   ‫GKE יוצר מאגר צמתים יחיד שמכיל ארבעה GPU מסוג L4 לכל צומת.

יצירת סוד ב-Kubernetes לפרטי הכניסה של Hugging Face

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

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

   gcloud container clusters get-credentials CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

2. יוצרים סוד של Kubernetes שמכיל את הטוקן של Hugging Face:

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

   מחליפים את HF_TOKEN בטוקן של Hugging Face שיצרתם קודם.

פריסת TGI

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

Gemma 2 2B-it

כדי לפרוס את מודל Gemma 2B שעבר כוונון להוראות, פועלים לפי ההוראות הבאות.

1. יוצרים את קובץ המניפסט tgi-2-2b-it.yaml הבא:

   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-2-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/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "2"
               memory: "10Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: "1"
             limits:
               cpu: "2"
               memory: "10Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: "1"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '1'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-2b-it
           - 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. החלת המניפסט:

   kubectl apply -f tgi-2-2b-it.yaml
   

Gemma 2 9B-it

כדי לפרוס את מודל Gemma 9B שעבר כוונון להוראות, פועלים לפי ההוראות הבאות.

1. יוצרים את קובץ המניפסט tgi-2-9b-it.yaml הבא:

   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-2-9b-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/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '2'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-9b-it
           - 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. החלת המניפסט:

   kubectl apply -f tgi-2-9b-it.yaml
   

Gemma 2 27B-it

כדי לפרוס את מודל Gemma 2 27B שעבר כוונון להוראות, פועלים לפי ההוראות הבאות.

1. יוצרים את קובץ המניפסט tgi-2-27b-it.yaml הבא:

   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-2-27b-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/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
             limits:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '4'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-27b-it
           - 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. החלת המניפסט:

   kubectl apply -f tgi-2-27b-it.yaml
   

CodeGemma 7B-it

כדי לפרוס את מודל CodeGemma 7B שעבר כוונון להוראות, פועלים לפי ההוראות הבאות.

1. יוצרים את קובץ המניפסט tgi-codegemma-1.1-7b-it.yaml הבא:

   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: codegemma-1.1-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/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           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/codegemma-1.1-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

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

   kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
   

פרסום המודל

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

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

מריצים את הפקודה הבאה כדי להגדיר העברת נתונים (פורט פורוורדינג) למודל:

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

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

Forwarding from 127.0.0.1:8000 -> 8000

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

בקטע הזה מוסבר איך לבצע בדיקת עשן בסיסית כדי לוודא שהמודלים שהופעלו הוכשרו מראש או הותאמו להוראות. לצורך פשטות, בקטע הזה מתוארת גישת הבדיקה באמצעות המודלים Gemma 2 instruction tuned ו-CodeGemma.

Gemma 2

בסשן חדש של מסוף, משתמשים ב-curl כדי לשוחח עם המודל:

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

בדוגמה הבאה אפשר לראות את התשובה של המודל:

{"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* **"}

CodeGemma

בסשן חדש של מסוף, משתמשים ב-curl כדי לשוחח עם המודל:

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

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

בדוגמה הבאה אפשר לראות את התשובה של המודל:

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

הצלחה: הצלחת להפעיל את Gemma באמצעות GPU ב-GKE עם TGI. עכשיו אפשר לתקשר עם המודל.

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

בקטע הזה תבנו אפליקציית צ'אט באינטרנט שתאפשר לכם ליצור אינטראקציה עם מודל שהותאם להוראות. כדי לפשט את ההסבר, בקטע הזה מתואר רק הגישה לבדיקה באמצעות מודל 2B-it.

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

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

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.4
           resources:
             requests:
               cpu: "250m"
               memory: "512Mi"
             limits:
               cpu: "500m"
               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
   

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. מוסיפים הנחיה ולוחצים על שליחה.

פתרון בעיות

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

מעקב אחר ביצועי המודל

כדי לראות את ביצועי המודל, אפשר להשתמש בשילוב של לוח הבקרה של TGI ב-Cloud Monitoring. לוח הבקרה הזה מאפשר לכם לראות מדדי ביצועים קריטיים כמו קצב העברת נתונים של טוקנים, זמן האחזור של הבקשות ושיעורי השגיאות.

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

לאחר מכן תוכלו לראות את המדדים באמצעות לוח הבקרה של TGI. מידע על שימוש בשירות המנוהל של Google Cloud ל-Prometheus כדי לאסוף מדדים מהמודל זמין במאמר בנושא TGI (שירות הטקסט הגנרטיבי) בתיעוד של Cloud Monitoring.

הסרת המשאבים

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

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

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

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

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

• מידע נוסף על יחידות GPU ב-GKE
• כדי ללמוד איך להשתמש ב-Gemma עם TGI במאיצים אחרים, כולל מעבדי GPU מסוג A100 ו-H100, אפשר לעיין בקוד לדוגמה ב-GitHub.
• איך פורסים עומסי עבודה של GPU בטייס אוטומטי
• איך פורסים עומסי עבודה של GPU ב-Standard
• למאמרי העזרה של TGI
• מעיינים ב-Vertex AI Model Garden.
• כך מריצים עומסי עבודה של AI/ML שעברו אופטימיזציה באמצעות יכולות התזמור של פלטפורמת GKE.