הצגת מודלים גדולים של שפה (LLM) ניתנים להרחבה ב-GKE באמצעות TorchServe

במדריך הזה נסביר איך לפרוס ולהכניס לשימוש בסביבת הייצור מודל של למידת מכונה (ML) שניתן להרחבה באשכול Google Kubernetes Engine ‏ (GKE) באמצעות המסגרת TorchServe. אתם מכניסים לשימוש בסביבת הייצור מודל PyTorch שעבר אימון מראש ומייצר חיזויים על סמך בקשות משתמשים. אחרי פריסת המודל, מקבלים כתובת URL לחיזוי שהאפליקציה משתמשת בה כדי לשלוח בקשות לחיזוי. השיטה הזו מאפשרת לכם להרחיב את המודל ואת אפליקציית האינטרנט באופן עצמאי. כשפורסים את עומס העבודה של ה-ML ואת האפליקציה ב-Autopilot, ‏ GKE בוחר את סוג המכונה והגודל הבסיסיים היעילים ביותר להרצת עומסי העבודה.

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

לפני שקוראים את הדף הזה, חשוב להכיר את מצב Autopilot ב-GKE.

מידע על אפליקציית המדריך

האפליקציה היא אפליקציית אינטרנט קטנה ב-Python שנוצרה באמצעות מסגרת Fast Dash. אתם משתמשים באפליקציה כדי לשלוח בקשות לחיזוי למודל T5. האפליקציה הזו מתעדת את קלט הטקסט של המשתמשים ואת צמדי השפות, ושולחת את המידע למודל. המודל מתרגם את הטקסט ומחזיר את התוצאה לאפליקציה, שבה התוצאה מוצגת למשתמש. מידע נוסף על Fast Dash זמין במאמרי העזרה בנושא Fast Dash.

מטרות

  • מכינים מודל T5 שאומן מראש ממאגר Hugging Face להכניס לשימוש בסביבת הייצור על ידי אריזתו כקובץ אימג' של קונטיינר והעברתו בדחיפה אל Artifact Registry
  • פריסת המודל באשכול Autopilot
  • פריסת אפליקציית Fast Dash שמתקשרת עם המודל
  • שינוי קנה מידה אוטומטי של המודל על סמך מדדי Prometheus

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

כדי להעריך את ההוצאות בהתאם לתחזית השימוש שלכם, אתם יכולים להיעזר במחשבון העלויות.

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

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

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

  2. התקינו את ה-CLI של Google Cloud.

  3. אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

  4. כדי לאתחל את ה-CLI של gcloud, הריצו את הפקודה הבאה: 

    gcloud init

  5. יוצרים או בוחרים Google Cloud פרויקט.

    תפקידים שנדרשים כדי לבחור או ליצור פרויקט

    • Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
    • יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (יצירת פרויקטים) (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים

    • יוצרים Google Cloud פרויקט:

      gcloud projects create PROJECT_ID

      מחליפים את PROJECT_ID בשם של פרויקט Google Cloud שיוצרים.

    • בוחרים את הפרויקט שיצרתם: Google Cloud 

      gcloud config set project PROJECT_ID

      מחליפים את PROJECT_ID בשם הפרויקט ב- Google Cloud .

  6. מוודאים שהחיוב מופעל בפרויקט Google Cloud .

  7. מפעילים את ממשקי ה-API של Kubernetes Engine,‏ Cloud Storage,‏ Artifact Registry ו-Cloud Build:

    תפקידים שנדרשים להפעלת ממשקי API

    כדי להפעיל ממשקי API, צריך את תפקיד ה-IAM 'אדמין של Service Usage' (roles/serviceusage.serviceUsageAdmin), שכולל את ההרשאה serviceusage.services.enable. איך מקצים תפקידים 

    gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

  8. התקינו את ה-CLI של Google Cloud.

  9. אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

  10. כדי לאתחל את ה-CLI של gcloud, הריצו את הפקודה הבאה: 

    gcloud init

  11. יוצרים או בוחרים Google Cloud פרויקט.

    תפקידים שנדרשים כדי לבחור או ליצור פרויקט

    • Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
    • יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (יצירת פרויקטים) (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים

    • יוצרים Google Cloud פרויקט:

      gcloud projects create PROJECT_ID

      מחליפים את PROJECT_ID בשם של פרויקט Google Cloud שיוצרים.

    • בוחרים את הפרויקט שיצרתם: Google Cloud 

      gcloud config set project PROJECT_ID

      מחליפים את PROJECT_ID בשם הפרויקט ב- Google Cloud .

  12. מוודאים שהחיוב מופעל בפרויקט Google Cloud .

  13. מפעילים את ממשקי ה-API של Kubernetes Engine,‏ Cloud Storage,‏ Artifact Registry ו-Cloud Build:

    תפקידים שנדרשים להפעלת ממשקי API

    כדי להפעיל ממשקי API, צריך את תפקיד ה-IAM 'אדמין של Service Usage' (roles/serviceusage.serviceUsageAdmin), שכולל את ההרשאה serviceusage.services.enable. איך מקצים תפקידים 

    gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
    14.

הכנת הסביבה

משכפלים את מאגר הדוגמאות ופותחים את ספריית ההדרכה:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

יצירת האשכול

מריצים את הפקודה הבאה:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

מחליפים את מה שכתוב בשדות הבאים:

  • ‫RELEASE_CHANNEL: ערוץ ההפצה של האשכול. חייב להיות אחד מהערכים rapid, regular או stable. כדי להשתמש ב-GPU ברמה 4, צריך לבחור ערוץ עם GKE בגרסה 1.28.3-gke.1203000 ומעלה. כדי לראות את הגרסאות שזמינות בערוץ ספציפי, אפשר לעיין במאמר בנושא הצגת גרסאות ברירת המחדל והגרסאות הזמינות לערוצי הפצה.
  • ‫CLUSTER_VERSION: גרסת GKE לשימוש. הערך חייב להיות 1.28.3-gke.1203000 או מאוחר יותר.

הפעולה הזו תימשך כמה דקות.

יצירת מאגר Artifact Registry

  1. יוצרים מאגר רגיל חדש ב-Artifact Registry בפורמט Docker באותו אזור שבו נמצא האשכול:

    gcloud artifacts repositories create models \
    --repository-format=docker \
    --location=us-central1 \
    --description="Repo for T5 serving image"

  2. בודקים את שם המאגר:

    gcloud artifacts repositories describe models \
    --location=us-central1

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

    Encryption: Google-managed key
Repository Size: 0.000MB
createTime: '2023-06-14T15:48:35.267196Z'
description: Repo for T5 serving image
format: DOCKER
mode: STANDARD_REPOSITORY
name: projects/PROJECT_ID/locations/us-central1/repositories/models
updateTime: '2023-06-14T15:48:35.267196Z'

אריזת המודל

בקטע הזה, אורזים את המודל ואת מסגרת ההגשה בקובץ אימג' אחד של קונטיינר באמצעות Cloud Build, ומעבירים בדחיפה את קובץ האימג' שנוצר למאגר Artifact Registry.

  1. בודקים את קובץ ה-Dockerfile של קובץ האימג' של הקונטיינר:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

ARG BASE_IMAGE=pytorch/torchserve:0.12.0-cpu

FROM alpine/git

ARG MODEL_NAME=t5-small
ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
ENV MODEL_NAME=${MODEL_NAME}
ENV MODEL_VERSION=${MODEL_VERSION}

RUN git clone "${MODEL_REPO}" /model

FROM ${BASE_IMAGE}

ARG MODEL_NAME=t5-small
ARG MODEL_VERSION=1.0
ENV MODEL_NAME=${MODEL_NAME}
ENV MODEL_VERSION=${MODEL_VERSION}

COPY --from=0 /model/. /home/model-server/
COPY handler.py \
     model.py \
     requirements.txt \
     setup_config.json /home/model-server/

RUN  torch-model-archiver \
     --model-name="${MODEL_NAME}" \
     --version="${MODEL_VERSION}" \
     --model-file="model.py" \
     --serialized-file="pytorch_model.bin" \
     --handler="handler.py" \
     --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
     --runtime="python" \
     --export-path="model-store" \
     --requirements-file="requirements.txt"

FROM ${BASE_IMAGE}

ENV PATH /home/model-server/.local/bin:$PATH
ENV TS_CONFIG_FILE /home/model-server/config.properties
# CPU inference will throw a warning cuda warning (not error)
# Could not load dynamic library 'libnvinfer_plugin.so.7'
# This is expected behaviour. see: https://stackoverflow.com/a/61137388
ENV TF_CPP_MIN_LOG_LEVEL 2

COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
COPY config.properties /home/model-server/

    קובץ ה-Dockerfile הזה מגדיר את תהליך הבנייה הרב-שלבי הבא:

    1. מורידים את ארטיפקטי המודל ממאגר Hugging Face.
    2. אורזים את המודל באמצעות הכלי PyTorch Serving Archive. נוצר קובץ ארכיון של המודל (‎.mar) ששרת ההיקש משתמש בו כדי לטעון את המודל.
    3. יוצרים את התמונה הסופית באמצעות PyTorch Serve.

  2. יוצרים את קובץ האימג' ומעבירים אותו בדחיפה באמצעות Cloud Build:

    gcloud builds submit model/ \
    --region=us-central1 \
    --config=model/cloudbuild.yaml \
    --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0

    תהליך ה-build נמשך כמה דקות. אם משתמשים במודל בגודל גדול יותר מ-t5-small, תהליך build עשוי להימשך הרבה יותר זמן.

  3. בודקים שהתמונה נמצאת במאגר:

    gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models

    מחליפים את PROJECT_ID במזהה הפרויקט ב- Google Cloud.

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

    IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38

פריסת המודל הארוז ב-GKE

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

משנים את מניפסט Kubernetes במאגר לדוגמה כך שיתאים לסביבה שלכם.

  1. בודקים את המניפסט של עומס העבודה של ההיסק:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: t5-inference
  labels:
    model: t5
    version: v1.0
    machine: gpu
spec:
  replicas: 1
  selector:
    matchLabels:
      model: t5
      version: v1.0
      machine: gpu
  template:
    metadata:
      labels:
        model: t5
        version: v1.0
        machine: gpu
    spec:
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      securityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsGroup: 1000
      containers:
        - name: inference
          image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
          imagePullPolicy: IfNotPresent
          args: ["torchserve", "--start", "--foreground"]
          resources:
            limits:
              nvidia.com/gpu: "1"
              cpu: "3000m"
              memory: 16Gi
              ephemeral-storage: 10Gi
            requests:
              nvidia.com/gpu: "1"
              cpu: "3000m"
              memory: 16Gi
              ephemeral-storage: 10Gi
          ports:
            - containerPort: 8080
              name: http
            - containerPort: 8081
              name: management
            - containerPort: 8082
              name: metrics
          readinessProbe:
            httpGet:
              path: /ping
              port: http
            initialDelaySeconds: 120
            failureThreshold: 10
          livenessProbe:
            httpGet:
              path: /models/t5-small
              port: management
            initialDelaySeconds: 150
            periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: t5-inference
  labels:
    model: t5
    version: v1.0
    machine: gpu
spec:
  type: ClusterIP
  selector:
    model: t5
    version: v1.0
    machine: gpu
  ports:
    - port: 8080
      name: http
      targetPort: http
    - port: 8081
      name: management
      targetPort: management
    - port: 8082
      name: metrics
      targetPort: metrics

  2. מחליפים את PROJECT_ID במזהה הפרויקט ב- Google Cloud:

    sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"

    כך מוודאים שנתיב קובץ האימג' של קונטיינר במפרט ה-Deployment (פריסה) תואם לנתיב של מודל T5 ב-Artifact Registry.

  3. יוצרים את משאבי Kubernetes:

    kubectl create -f kubernetes/serving-gpu.yaml

כדי לוודא שהפריסה של המודל בוצעה בהצלחה:

  1. קבלת הסטטוס של הפריסה והשירות:

    kubectl get -f kubernetes/serving-gpu.yaml

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

    NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
deployment.apps/t5-inference    1/1     1             0           66s

NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s

  2. פותחים יציאה מקומית עבור השירות t5-inference:

    kubectl port-forward svc/t5-inference 8080

  3. פותחים חלון טרמינל חדש ושולחים בקשת בדיקה לשירות:

    curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"

    אם בקשת הבדיקה נכשלת והחיבור ל-Pod נסגר, צריך לבדוק את היומנים:

    kubectl logs deployments/t5-inference

    אם הפלט דומה לזה, סימן שההתקנה של TorchServe נכשלה בגלל תלות במודל מסוים:

    org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small

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

    kubectl rollout restart deployment t5-inference

    בקר הפריסה יוצר Pod חדש. חוזרים על השלבים הקודמים כדי לפתוח יציאה ב-Pod החדש.

גישה למודל שנפרס באמצעות אפליקציית האינטרנט

כדי לגשת למודל שנפרס באמצעות אפליקציית האינטרנט Fast Dash, צריך לבצע את הפעולות הבאות:

  1. בונים את אפליקציית האינטרנט Fast Dash ומעבירים אותה בדחיפה כקובץ אימג' של קונטיינר ב-Artifact Registry:

    gcloud builds submit client-app/ \
    --region=us-central1 \
    --config=client-app/cloudbuild.yaml

  2. פותחים את kubernetes/application.yaml בכלי לעריכת טקסט ומחליפים את PROJECT_ID בשדה image: במזהה הפרויקט. אפשר גם להריץ את הפקודה הבאה:

    sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"

  3. יוצרים את משאבי Kubernetes:

    kubectl create -f kubernetes/application.yaml

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

  4. כדי לבדוק את הסטטוס, מריצים את הפקודה הבאה:

    kubectl get -f kubernetes/application.yaml

    ממתינים עד שהפלט יציג Pods מוכנים, כמו בדוגמה הבאה:

    NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/fastdash   1/1     1            0           1m

NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m

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

    kubectl port-forward service/fastdash 8050

  6. בדפדפן, פותחים את ממשק האינטרנט:

    • אם אתם משתמשים במעטפת מקומית, פותחים דפדפן ועוברים אל http://127.0.0.1:8050.
    • אם אתם משתמשים ב-Cloud Shell, לוחצים על תצוגה מקדימה באינטרנט ואז על שינוי היציאה. מציינים את היציאה 8050.

  7. כדי לשלוח בקשה למודל T5, מציינים ערכים בשדות TEXT (טקסט), FROM LANG (שפת המקור) ו-TO LANG (שפת היעד) בממשק האינטרנט ולוחצים על Submit (שליחה). רשימת השפות הזמינות מופיעה במאמרי העזרה בנושא T5.

הפעלת שינוי גודל אוטומטי של המודל

בקטע הזה מוסבר איך להפעיל התאמה אוטומטית לעומס של המודל על סמך מדדים מהשירות המנוהל של Google Cloud ל-Prometheus, באמצעות הפעולות הבאות:

  1. התקנת Custom Metrics Stackdriver Adapter
  2. החלת הגדרות של PodMonitoring ו-HorizontalPodAutoscaling

השירות המנוהל של Google Cloud ל-Prometheus מופעל כברירת מחדל באשכולות Autopilot שפועלת בהם גרסה 1.25 ואילך.

התקנת Custom Metrics Stackdriver Adapter

המתאם הזה מאפשר לאשכול להשתמש במדדים מ-Prometheus כדי לקבל החלטות לגבי התאמה אוטומטית לעומס ב-Kubernetes.

  1. פורסים את המתאם:

    kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. יוצרים חשבון שירות ב-IAM לשימוש המתאם:

    gcloud iam service-accounts create monitoring-viewer

  3. מקצים לחשבון השירות ב-IAM את התפקיד monitoring.viewer בפרויקט ואת התפקיד iam.workloadIdentityUser:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"

    מחליפים את PROJECT_ID במזהה הפרויקט ב- Google Cloud.

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

    kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
    --namespace custom-metrics \
    iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com

  5. מפעילים מחדש את המתאם כדי להפיץ את השינויים:

    kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
    --namespace=custom-metrics

החלת הגדרות של PodMonitoring ו-HorizontalPodAutoscaling

‫PodMonitoring הוא משאב מותאם אישית של השירות המנוהל של Google Cloud ל-Prometheus, שמאפשר הטמעה של מדדים וגירוד של יעדים במרחב שמות ספציפי.

  1. פורסים את משאב PodMonitoring באותו מרחב שמות כמו TorchServe Deployment:

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. בודקים את מניפסט ה-HorizontalPodAutoscaler:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: t5-inference
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: t5-inference
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
      target:
        type: AverageValue
        averageValue: "30000"

    ה-HorizontalPodAutoscaler משנה את מספר ה-Pods של מודל T5 בהתאם למשך המצטבר של תור הבקשות. התאמה אוטומטית לעומס מבוססת על המדד ts_queue_latency_microseconds, שמציג את משך התור המצטבר במיקרו-שניות.

  3. יוצרים את HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

אימות של שינוי גודל אוטומטי באמצעות מחולל עומסים

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

  1. יוצרים את מחולל העומסים:

    kubectl apply -f kubernetes/loadgenerator.yaml

    ממתינים עד שה-Pods של מחולל העומסים יהיו מוכנים.

  2. חושפים את ממשק האינטרנט של מחולל העומסים באופן מקומי:

    kubectl port-forward svc/loadgenerator 8080

    אם מופיעה הודעת שגיאה, נסו שוב כשה-Pod פועל.

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

    • אם אתם משתמשים במעטפת מקומית, פותחים דפדפן ועוברים אל http://127.0.0.1:8080.
    • אם אתם משתמשים ב-Cloud Shell, לוחצים על תצוגה מקדימה באינטרנט ואז על שינוי היציאה. מזינים את יציאת 8080.

  4. לוחצים על הכרטיסייה תרשימים כדי לראות את הביצועים לאורך זמן.

  5. פותחים חלון טרמינל חדש וצופים בספירת הרפליקות של ה-Horizontal Pod Autoscalers:

    kubectl get hpa -w

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

    NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s

המלצות

  • יוצרים את המודל עם אותה גרסה של קובץ הבסיס של Docker שבה תשתמשו להצגת המודל.
  • אם למודל יש תלות מיוחדת בחבילות, או אם גודל התלות גדול, צריך ליצור גרסה מותאמת אישית של תמונת הבסיס של Docker.
  • צפייה בגרסת העץ של חבילות התלות של המודל. מוודאים שיחסי התלות של החבילה תומכים בגרסאות של כל אחד מהם. לדוגמה, גרסה 2.0.3 של Panda תומכת ב-NumPy מגרסה 1.20.3 ואילך.
  • להריץ מודלים שדורשים הרבה משאבי GPU בצמתים של GPU, ומודלים שדורשים הרבה משאבי CPU בצמתים של CPU. כך אפשר לשפר את היציבות של פרסום המודל ולוודא שאתם משתמשים במשאבי הצמתים בצורה יעילה.

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

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

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

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

הסרת המשאבים

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

מחיקת הפרויקט

    כדי למחוק Google Cloud פרויקט:

    gcloud projects delete PROJECT_ID

מחיקת משאבים בודדים

  1. מחיקת משאבי Kubernetes:

    kubectl delete -f kubernetes/loadgenerator.yaml
kubectl delete -f kubernetes/hpa.yaml
kubectl delete -f kubernetes/pod-monitoring.yaml
kubectl delete -f kubernetes/application.yaml
kubectl delete -f kubernetes/serving-gpu.yaml
kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. מחיקת אשכול GKE:

    gcloud container clusters delete "ml-cluster" \
    --location="us-central1" --quiet

  3. מוחקים את חשבון השירות של IAM ואת הקישורים למדיניות IAM:

    gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts remove-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
gcloud iam service-accounts delete monitoring-viewer

  4. מוחקים את התמונות ב-Artifact Registry. אפשר גם למחוק את כל המאגר. הוראות מופיעות במסמכי התיעוד של Artifact Registry בנושא מחיקת תמונות.

סקירה כללית של הרכיב

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

מידע על מודל T5

במדריך הזה נעשה שימוש במודל T5 רב-לשוני שאומן מראש. ‫T5 הוא טרנספורמר מסוג יצירת טקסט על סמך טקסט שממיר טקסט משפה אחת לשפה אחרת. ב-T5, הקלט והפלט הם תמיד מחרוזות טקסט, בניגוד למודלים בסגנון BERT שיכולים להפיק רק תווית של מחלקה או טווח של הקלט. אפשר להשתמש במודל T5 גם למשימות כמו סיכום, שאלות ותשובות או סיווג טקסט. המודל עבר אימון על כמות גדולה של טקסט מ-Colossal Clean Crawled Corpus (C4) ומ-Wiki-DPR.

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

‫Colin Raffel,‏ Noam Shazeer,‏ Adam Roberts,‏ Katherine Lee,‏ Sharan Narang,‏ Michael Matena,‏ Yanqi Zhou,‏ Wei Li ו-Peter J. ליו הציג את מודל T5 במאמר Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer שפורסם ב-Journal of Machine Learning Research.

מודל T5 תומך בגדלים שונים של מודלים, עם רמות מורכבות שונות שמתאימות לתרחישי שימוש ספציפיים. במדריך הזה נעשה שימוש בגודל ברירת המחדל, t5-small, אבל אפשר גם לבחור גודל אחר. הגודל הבא של T5 מופץ ברישיון Apache 2.0:

  • ‫t5-small: 60 מיליון פרמטרים
  • ‫t5-base: 220 מיליון פרמטרים
  • ‫t5-large: 770 million parameters. ההורדה היא בנפח 3GB.
  • ‫t5-3b: 3 מיליארד פרמטרים. ההורדה היא בנפח 11GB.
  • t5-11b: 11 מיליארד פרמטרים. הורדה של 45GB.

מודלים אחרים של T5 זמינים במאגר Hugging Face.

מידע על TorchServe

‫TorchServe הוא כלי גמיש להצגת מודלים של PyTorch. הוא מספק תמיכה מוכנה לשימוש בכל ה-frameworks העיקריים של למידה עמוקה, כולל PyTorch,‏ TensorFlow ו-ONNX. אפשר להשתמש ב-TorchServe כדי לפרוס מודלים בסביבת ייצור, או כדי ליצור אב-טיפוסים במהירות ולבצע ניסויים.

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