הצגת מודלים פתוחים של Gemma באמצעות TPU ב-GKE עם Saxml

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

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

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

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

רקע

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

‏Gemma

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

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

TPUs

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

במדריך הזה נעשה שימוש במודלים Gemma 2B ו-Gemma 7B. ‫GKE מארח את המודלים האלה במאגרי הצמתים הבאים של TPU v5e עם מארח יחיד:

  • ‫Gemma 2B: מודל שעבר כוונון לפי הוראות, מתארח במאגר צומתי TPU v5e עם טופולוגיה 1x1 שמייצגת שבב TPU אחד. סוג המכונה של הצמתים הוא ct5lp-hightpu-1t.
  • ‫Gemma 7B: מודל שעבר כוונון לפי הוראות, מתארח במאגר צמתים של TPU v5e עם טופולוגיה של 2x2 שמייצגת ארבעה שבבי TPU. סוג המכונה של הצמתים הוא ct5lp-hightpu-4t.

Saxml

‫Saxml היא מערכת ניסיונית שמשמשת להסקת מסקנות ממודלים של Paxml,‏ JAX ו-PyTorch. מערכת Saxml כוללת את הרכיבים הבאים:

  • תא Saxml או אשכול Sax: שרת אדמין וקבוצה של שרתי מודלים. שרת האדמין עוקב אחרי שרתי המודלים, מקצה מודלים שפורסמו לשרתי מודלים כדי להכניס אותם לשימוש בסביבת הייצור, ועוזר ללקוחות לאתר שרתי מודלים שמכניסים לשימוש בסביבת הייצור מודלים ספציפיים שפורסמו.
  • לקוח Saxml: ממשק התכנות שפונה למשתמשים במערכת Saxml. לקוח Saxml כולל כלי לשורת הפקודה (saxutil) וחבילה של ספריות לקוח ב-Python, ב-C++‎ וב-Go.

במדריך הזה משתמשים גם בשרת ה-HTTP של Saxml. שרת ה-HTTP של Saxml הוא שרת HTTP מותאם אישית שמכיל את ספריית הלקוח של Saxml Python וחושף ממשקי API של REST כדי ליצור אינטראקציה עם מערכת Saxml. ממשקי ה-API של REST כוללים נקודות קצה לפרסום מודלים, לרישום מודלים, לביטול הפרסום של מודלים וליצירת תחזיות.

מטרות

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

ארכיטקטורה

בקטע הזה מתוארת ארכיטקטורת GKE שבה נעשה שימוש במדריך הזה. הארכיטקטורה כוללת אשכול GKE Standard שמקצה TPU ומארח רכיבי Saxml כדי לפרוס מודלים של Gemma 2B או 7B ולהפעיל אותם. בתרשים הבא מוצגים הרכיבים של הארכיטקטורה הזו:

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

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

  • אשכול אזורי של GKE Standard.
  • מאגר צמתים של פרוסת TPU עם מארח יחיד, שתלוי במודל Gemma שרוצים להפעיל:
    • ‫Gemma 2B: מוגדר עם TPU v5e עם 1x1 טופולוגיה. מופע אחד של שרת מודל Saxml מוגדר לשימוש במאגר הצמתים הזה.
    • ‫Gemma 7B: מוגדר עם TPU v5e עם טופולוגיה של 2x2. מופע אחד של שרת מודל Saxml מוגדר לשימוש במאגר הצמתים הזה.
  • מאגר צמתים של CPU כברירת מחדל, שבו מתבצע פריסה של שרת האדמין של Saxml ושרת ה-HTTP של Saxml.
  • שתי קטגוריות של Cloud Storage:
    • קטגוריה אחת של Cloud Storage מאחסנת את המצב שמנוהל על ידי שרת אדמין.
    • קטגוריה אחת של Cloud Storage שבה מאוחסנות נקודות הביקורת של מודל Gemma.

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

  • Artifact Registry ציבורי מנהל את קובצי האימג' של הקונטיינרים עבור רכיבי Saxml.
  • אשכול GKE משתמש באיחוד זהויות של עומסי עבודה ל-GKE. כל הרכיבים של Saxml משתמשים באיחוד זהויות של עומסי עבודה (WIF) שמשלב חשבון שירות של IAM כדי לגשת לשירותים חיצוניים כמו קטגוריות של Cloud Storage.
  • היומנים שנוצרים על ידי רכיבי Saxml משולבים ב-Cloud Logging.
  • אפשר להשתמש ב-Cloud Monitoring כדי לנתח את מדדי הביצועים של מאגרי צמתים ב-GKE, כמו אלה שנוצרים במדריך הזה.

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

  • נכנסים לחשבון 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/iam.policyAdmin, roles/iam.securityAdmin, roles/iam.roleAdmin

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

    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.

הכנת הסביבה ל-Gemma

הפעלת Cloud Shell

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

  1. במסוף Google Cloud , מפעילים מכונה של Cloud Shell:
    פותחים את Cloud Shell

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

    gcloud config set project PROJECT_ID
    export PROJECT_ID=$(gcloud config get project)
    export LOCATION=LOCATION
    export CLUSTER_NAME=saxml-tpu
    

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

יצירת אשכול רגיל

בקטע הזה יוצרים את אשכול ה-GKE ואת מאגר הצמתים.

Gemma 2B-it

אפשר להשתמש ב-Cloud Shell כדי:

  1. יוצרים אשכול Standard שמשתמש באיחוד זהויות של עומסי עבודה ל-GKE:

    gcloud container clusters create ${CLUSTER_NAME} \
        --enable-ip-alias \
        --machine-type=e2-standard-4 \
        --num-nodes=2 \
        --release-channel=rapid \
        --workload-pool=${PROJECT_ID}.svc.id.goog \
        --location=${LOCATION}
    

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

  2. יוצרים מאגר צמתים של TPU v5e עם טופולוגיה של 1x1 וצומת אחד:

    gcloud container node-pools create tpu-v5e-1x1 \
        --cluster=${CLUSTER_NAME} \
        --machine-type=ct5lp-hightpu-1t \
        --num-nodes=1 \
        --location=${LOCATION}
    

    אתם מפעילים את מודל Gemma 2B במאגר הצמתים הזה.

Gemma 7B-it

אפשר להשתמש ב-Cloud Shell כדי:

  1. יוצרים אשכול Standard שמשתמש באיחוד זהויות של עומסי עבודה ל-GKE:

    gcloud container clusters create ${CLUSTER_NAME} \
        --enable-ip-alias \
        --machine-type=e2-standard-4 \
        --num-nodes=2 \
        --release-channel=rapid \
        --workload-pool=${PROJECT_ID}.svc.id.goog \
        --location=${LOCATION}
    

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

  2. יוצרים מאגר צמתים של TPU v5e עם טופולוגיה של 2x2 וצומת אחד:

    gcloud container node-pools create tpu-v5e-2x2 \
        --cluster=${CLUSTER_NAME} \
        --machine-type=ct5lp-hightpu-4t \
        --num-nodes=1 \
        --location=${LOCATION}
    

    אתם מפעילים את המודל Gemma 7B במאגר הצמתים הזה.

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

יוצרים שתי קטגוריות של Cloud Storage לניהול המצב של שרת האדמין של Saxml ונקודות הביקורת של המודל.

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

  1. יוצרים קטגוריה של Cloud Storage לאחסון ההגדרות של שרת האדמין של Saxml.

    gcloud storage buckets create gs://ADMIN_BUCKET_NAME
    

    מחליפים את ADMIN_BUCKET_NAME בשם של קטגוריית Cloud Storage שבה מאוחסן שרת האדמין של Saxml.

  2. יוצרים קטגוריה של Cloud Storage לאחסון נקודות ביקורת של המודל:

    gcloud storage buckets create gs://CHECKPOINTS_BUCKET_NAME
    

    מחליפים את CHECKPOINTS_BUCKET_NAME בשם של קטגוריה של Cloud Storage שבה מאוחסנים נקודות הבדיקה של המודל.

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

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

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

    gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${LOCATION}
    
  2. יוצרים חשבון שירות ב-Kubernetes שהאפליקציה תוכל להשתמש בו:

    gcloud iam service-accounts create wi-sax
    
  3. מוסיפים קישור למדיניות IAM לחשבון השירות של IAM כדי לקרוא ולכתוב ב-Cloud Storage:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
        --member "serviceAccount:wi-sax@${PROJECT_ID}.iam.gserviceaccount.com" \
        --role roles/storage.objectUser
    
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
        --member "serviceAccount:wi-sax@${PROJECT_ID}.iam.gserviceaccount.com" \
        --role roles/storage.insightsCollectorService
    
  4. כדי לאפשר ל-ServiceAccount של Kubernetes להתחזות לחשבון השירות של IAM, מוסיפים קשר בין כללי מדיניות של IAM בין שני חשבונות השירות. הקישור הזה מאפשר לחשבון השירות של Kubernetes לפעול כחשבון שירות של IAM:

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

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

גישה למודל

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

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

  1. נכנסים אל דף ההסכמה לשימוש במודל באתר 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 מורידה קובץ בשם kaggle.json.

העלאה של טוקן הגישה ל-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=${LOCATION}
    
  2. יוצרים סוד לאחסון פרטי הכניסה של Kaggle:

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

פריסת Saxml

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

פריסת שרת האדמין של Saxml

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

  1. יוצרים את קובץ המניפסט saxml-admin-server.yaml הבא:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: sax-admin-server
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: sax-admin-server
      template:
        metadata:
          labels:
            app: sax-admin-server
        spec:
          hostNetwork: false
          containers:
          - name: sax-admin-server
            image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server:v1.2.0
            securityContext:
              privileged: true
            ports:
            - containerPort: 10000
            env:
            - name: GSBUCKET
              value: ADMIN_BUCKET_NAME

    מחליפים את ADMIN_BUCKET_NAME בשם הקטגוריה שיצרתם בקטע יצירת קטגוריות של Cloud Storage. אל תכללו את הקידומת gs://.

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

    kubectl apply -f saxml-admin-server.yaml
    
  3. מאמתים את פריסת שרת האדמין:

    kubectl get deployment
    

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

    NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
    sax-admin-server                  1/1     1            1           ##s
    

פריסת שרת מודלים של Saxml

פועלים לפי ההוראות האלה כדי לפרוס את שרת המודלים של Gemma 2B או Gemma 7B.

Gemma 2B-it

  1. יוצרים את קובץ המניפסט saxml-model-server-1x1.yaml הבא:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: sax-model-server-v5e-1x1
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: gemma-server
      strategy:
        type: Recreate
      template:
        metadata:
          labels:
            app: gemma-server
            ai.gke.io/model: gemma-2b-it
            ai.gke.io/inference-server: saxml
            examples.ai.gke.io/source: user-guide
        spec:
          nodeSelector:
            cloud.google.com/gke-tpu-topology: 1x1
            cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
          hostNetwork: false
          restartPolicy: Always
          containers:
          - name: inference-server
            image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
            args:
            - "--jax_platforms=tpu"
            - "--platform_chip=tpuv5e"
            - "--platform_topology=1x1"
            - "--port=10001"
            - "--sax_cell=/sax/test"
            ports:
            - containerPort: 10001
            securityContext:
              privileged: true
            env:
            - name: SAX_ROOT
              value: "gs://ADMIN_BUCKET_NAME/sax-root"
            resources:
              requests:
                google.com/tpu: 1
              limits:
                google.com/tpu: 1

    מחליפים את ADMIN_BUCKET_NAME בשם הקטגוריה שיצרתם בקטע יצירת קטגוריות של Cloud Storage. אל תכללו את הקידומת gs://.

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

    kubectl apply -f saxml-model-server-1x1.yaml
    
  3. בודקים את סטטוס הפריסה של שרת המודל:

    kubectl get deployment
    

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

    NAME                                              READY   STATUS    RESTARTS   AGE
    sax-admin-server                                  1/1     Running   0          ##m
    sax-model-server-v5e-1x1                          1/1     Running   0          ##s
    

Gemma 7B-it

  1. יוצרים את קובץ המניפסט saxml-model-server-2x2.yaml הבא:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: sax-model-server-v5e-2x2
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: gemma-server
      strategy:
        type: Recreate
      template:
        metadata:
          labels:
            app: gemma-server
            ai.gke.io/model: gemma-7b-it
            ai.gke.io/inference-server: saxml
            examples.ai.gke.io/source: user-guide
        spec:
          nodeSelector:
            cloud.google.com/gke-tpu-topology: 2x2
            cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
          hostNetwork: false
          restartPolicy: Always
          containers:
          - name: inference-server
            image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
            args:
            - "--jax_platforms=tpu"
            - "--platform_chip=tpuv5e"
            - "--platform_topology=2x2"
            - "--port=10001"
            - "--sax_cell=/sax/test"
            ports:
            - containerPort: 10001
            securityContext:
              privileged: true
            env:
            - name: SAX_ROOT
              value: "gs://ADMIN_BUCKET_NAME/sax-root"
            resources:
              requests:
                google.com/tpu: 4
              limits:
                google.com/tpu: 4

    מחליפים את ADMIN_BUCKET_NAME בשם הקטגוריה שיצרתם בקטע יצירת קטגוריות של Cloud Storage. אל תכללו את הקידומת gs://.

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

    kubectl apply -f saxml-model-server-2x2.yaml
    
  3. בודקים את סטטוס הפריסה של שרת המודל:

    kubectl get deployment
    

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

    NAME                                              READY   STATUS    RESTARTS   AGE
    sax-admin-server                                  1/1     Running   0          ##m
    sax-model-server-v5e-2x2                          1/1     Running   0          ##s
    

פריסת שרת ה-HTTP של Saxml

בקטע הזה פורסים את שרת ה-HTTP של Saxml ויוצרים שירות Cluster IP שמשמש לגישה לשרת.

  1. יוצרים את קובץ המניפסט saxml-http.yaml הבא:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: sax-http
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: sax-http
      template:
        metadata:
          labels:
            app: sax-http
        spec:
          hostNetwork: false
          containers:
          - name: sax-http
            image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-http:v1.2.0
            imagePullPolicy: Always
            ports:
            - containerPort: 8888
            env:
            - name: SAX_ROOT
              value: "gs://ADMIN_BUCKET_NAME/sax-root"
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: sax-http-svc
    spec:
      selector:
        app: sax-http
      ports:
      - protocol: TCP
        port: 8888
        targetPort: 8888
      type: ClusterIP

    מחליפים את ADMIN_BUCKET_NAME בשם של קטגוריית Cloud Storage שבה מאוחסן שרת האדמין של Saxml.

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

    kubectl apply -f saxml-http.yaml
    
  3. בודקים את סטטוס הפריסה של שרת ה-HTTP של Saxml:

    kubectl get deployment
    

    Gemma 2B-it

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

    NAME                                              READY   STATUS    RESTARTS   AGE
    sax-admin-server                                  1/1     Running   0          ##m
    sax-model-server-v5e-1x1                          1/1     Running   0          ##m
    sax-http                                          1/1     Running   0          ##s
    

    Gemma 7B-it

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

    NAME                                              READY   STATUS    RESTARTS   AGE
    sax-admin-server                                  1/1     Running   0          ##m
    sax-model-server-v5e-2x2                          1/1     Running   0          ##m
    sax-http                                          1/1     Running   0          ##s
    

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

בקטע הזה, מריצים משימה (Job) ב-Kubernetes שמביאה, מורידה ומאחסנת את נקודת הבדיקה של המודל. ב-Kubernetes, בקר משימות יוצר פוד אחד או יותר ועוזר לוודא שהם מבצעים בהצלחה משימה ספציפית.

פועלים לפי השלבים של מודל Gemma שרוצים להשתמש בו:

Gemma 2B-it

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

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: fetch-model-scripts
    data:
      fetch_model.sh: |-
        #!/usr/bin/bash -x
        pip install kaggle --break-system-packages && \
    
        MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
        VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    
        mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
        kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
        echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \
    
        gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
        echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
    ---
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: data-loader-2b
      labels:
        app: data-loader-2b
    spec:
      ttlSecondsAfterFinished: 120
      template:
        metadata:
          labels:
            app: data-loader-2b
        spec:
          restartPolicy: OnFailure
          containers:
          - name: gcloud
            image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
            command:
            - /scripts/fetch_model.sh
            env:
            - name: BUCKET_NAME
              value: CHECKPOINTS_BUCKET_NAME
            - name: KAGGLE_CONFIG_DIR
              value: /kaggle
            - name: MODEL_PATH
              value: "google/gemma/pax/2b-it/2"
            volumeMounts:
            - mountPath: "/kaggle/"
              name: kaggle-credentials
              readOnly: true
            - mountPath: "/scripts/"
              name: scripts-volume
              readOnly: true
          volumes:
          - name: kaggle-credentials
            secret:
              defaultMode: 0400
              secretName: kaggle-secret
          - name: scripts-volume
            configMap:
              defaultMode: 0700
              name: fetch-model-scripts

    מחליפים את CHECKPOINTS_BUCKET_NAME בשם הקטגוריה שיצרתם בקטע יצירת קטגוריות של Cloud Storage. אל תכללו את הקידומת gs://.

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

    kubectl apply -f job-2b.yaml
    
  3. ממתינים לסיום העבודה:

    kubectl wait --for=condition=complete --timeout=180s job/data-loader-2b
    

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

    job.batch/data-loader-2b condition met
    
  4. מוודאים שהעבודה הושלמה בהצלחה:

    kubectl get job/data-loader-2b
    

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

    NAME             COMPLETIONS   DURATION   AGE
    data-loader-2b   1/1           ##s        #m##s
    
  5. כדי לראות את היומנים של המשימה:

    kubectl logs --follow job/data-loader-2b
    

המשימה מעלה את נקודת הביקורת אל gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000.

Gemma 7B-it

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

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: fetch-model-scripts
    data:
      fetch_model.sh: |-
        #!/usr/bin/bash -x
        pip install kaggle --break-system-packages && \
    
        MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
        VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    
        mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
        kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
        echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \
    
        gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
        echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
    ---
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: data-loader-7b
      labels:
        app: data-loader-7b
    spec:
      ttlSecondsAfterFinished: 120
      template:
        metadata:
          labels:
            app: data-loader-7b
        spec:
          restartPolicy: OnFailure
          containers:
          - name: gcloud
            image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
            command:
            - /scripts/fetch_model.sh
            env:
            - name: BUCKET_NAME
              value: CHECKPOINTS_BUCKET_NAME
            - name: KAGGLE_CONFIG_DIR
              value: /kaggle
            - name: MODEL_PATH
              value: "google/gemma/pax/7b-it/2"
            volumeMounts:
            - mountPath: "/kaggle/"
              name: kaggle-credentials
              readOnly: true
            - mountPath: "/scripts/"
              name: scripts-volume
              readOnly: true
          volumes:
          - name: kaggle-credentials
            secret:
              defaultMode: 0400
              secretName: kaggle-secret
          - name: scripts-volume
            configMap:
              defaultMode: 0700
              name: fetch-model-scripts

    מחליפים את CHECKPOINTS_BUCKET_NAME בשם הקטגוריה שיצרתם בקטע יצירת קטגוריות של Cloud Storage. כן כוללים את הקידומת gs://.

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

    kubectl apply -f job-7b.yaml
    
  3. ממתינים לסיום העבודה:

    kubectl wait --for=condition=complete --timeout=360s job/data-loader-7b
    

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

    job.batch/data-loader-7b condition met
    
  4. מוודאים שהעבודה הושלמה בהצלחה:

    kubectl get job/data-loader-7b
    

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

    NAME             COMPLETIONS   DURATION   AGE
    data-loader-7b   1/1           ##s        #m##s
    
  5. כדי לראות את היומנים של המשימה:

    kubectl logs --follow job/data-loader-7b
    

המשימה מעלה את נקודת הביקורת אל gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000.

חשיפת שרת ה-HTTP של Saxml

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

  1. הקמת סשן של העברת יציאות:

    kubectl port-forward service/sax-http-svc 8888:8888
    
  2. כדי לוודא שיש לכם גישה לשרת ה-HTTP של Saxml, פותחים טרמינל חדש ומריצים את הפקודה הבאה:

    curl -s localhost:8888
    

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

    {
        "Message": "HTTP Server for SAX Client"
    }
    

שרת ה-HTTP של Saxml כולל את ממשק הלקוח למערכת Saxml, והוא חושף אותו באמצעות קבוצה של ממשקי API ל-REST. משתמשים בממשקי ה-API האלה כדי לפרסם, לנהל ולקיים אינטראקציה עם מודלים של Gemma 2B ו-Gemma 7B.

פרסום מודל Gemma

אחרי כן, תוכלו לפרסם את מודל Gemma בשרת מודלים שפועל במאגר צמתים של פרוסת TPU. משתמשים ב-API‏ publish של שרת ה-HTTP של Saxml כדי לפרסם מודל. כדי לפרסם את מודל הפרמטרים Gemma 2B או 7B:

מידע נוסף על API של שרת HTTP של Saxml זמין במאמר Saxml HTTP APIs.

Gemma 2B-it

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

    curl -s localhost:8888
    
  2. פרסום הפרמטר Gemma 2B:

    curl --request POST \
    --header "Content-type: application/json" \
    -s \
    localhost:8888/publish \
    --data \
    '{
        "model": "/sax/test/gemma2bfp16",
        "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
        "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
        "replicas": "1"
    }'
    

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

    {
        "model": "/sax/test/gemma2bfp16",
        "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
        "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
        "replicas": 1
    }
    

    בשלב הבא מוסבר איך לעקוב אחרי התקדמות הפריסה.

  3. כדי לעקוב אחרי ההתקדמות, בודקים את היומנים ב-Pod של שרת המודלים בפריסת sax-model-server-v5e-1x1.

    kubectl logs --follow deployment/sax-model-server-v5e-1x1
    

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

    I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
    I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma2bfp16
    
  4. כדי לוודא שיש לכם גישה למודל, מציגים את פרטי המודל:

    curl --request GET \
    --header "Content-type: application/json" \
    -s \
    localhost:8888/listcell \
    --data \
    '{
        "model": "/sax/test/gemma2bfp16"
    }'
    

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

    {
        "model": "/sax/test/gemma2bfp16",
        "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
        "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
        "max_replicas": 1,
        "active_replicas": 1
    }
    

Gemma 7B-it

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

    curl -s localhost:8888
    
  2. פרסום הפרמטר Gemma 7B:

    curl --request POST \
    --header "Content-type: application/json" \
    -s \
    localhost:8888/publish \
    --data \
    '{
        "model": "/sax/test/gemma7bfp16",
        "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
        "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
        "replicas": "1"
    }'
    

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

    {
        "model": "/sax/test/gemma7bfp16",
        "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
        "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
        "replicas": 1
    }
    

    בשלב הבא מוסבר איך לעקוב אחרי התקדמות הפריסה.

  3. כדי לעקוב אחרי ההתקדמות, בודקים את היומנים ב-Pod של שרת המודלים בפריסת sax-model-server-v5e-2x2.

    kubectl logs --follow deployment/sax-model-server-v5e-2x2
    

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

    I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
    I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma7bfp16
    
  4. כדי לוודא שהמודל פורסם, מציגים את פרטי המודל:

    curl --request GET \
    --header "Content-type: application/json" \
    -s \
    localhost:8888/listcell \
    --data \
    '{
        "model": "/sax/test/gemma7bfp16"
    }'
    

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

    {
        "model": "/sax/test/gemma7bfp16",
        "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
        "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
        "max_replicas": 1,
        "active_replicas": 1
    }
    

שימוש במודל

אתם יכולים לקיים אינטראקציה עם מודלים של Gemma 2B או 7B. משתמשים ב-API של שרת ה-HTTP של Saxml‏ generate כדי לשלוח הנחיה למודל.

Gemma 2B-it

הצגת בקשה להנחיה באמצעות נקודת הקצה generate של שרת ה-HTTP של Saxml:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma2bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

זוהי דוגמה לתשובת המודל. הפלט בפועל משתנה בהתאם להנחיה שאתם מזינים:

[
    [
        "\n\n1. **Python**\n2. **JavaScript**\n3. **Java**\n4. **C++**\n5. **Go**",
        -3.0704939365386963
    ]
]

אפשר להריץ את הפקודה עם פרמטרים שונים של query. אפשר גם לשנות פרמטרים נוספים כמו temperature, top_k, topc_p באמצעות generate API. מידע נוסף על API של שרת HTTP של Saxml זמין במאמר ממשקי HTTP API של Saxml.

Gemma 7B-it

הצגת בקשה להנחיה באמצעות נקודת הקצה generate של שרת ה-HTTP של Saxml:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma7bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

זוהי דוגמה לתשובת המודל. הפלט עשוי להשתנות בכל הנחיה שמוצגת:

[
    [
        "\n\n**1. JavaScript**\n\n* Most widely used language on the web.\n* Used for front-end development, such as websites and mobile apps.\n* Extensive libraries and frameworks available.\n\n**2. Python**\n\n* Known for its simplicity and readability.\n* Versatile, used for various tasks, including data science, machine learning, and web development.\n* Large and active community.\n\n**3. Java**\n\n* Object-oriented language widely used in enterprise applications.\n* Used for web applications, mobile apps, and enterprise software.\n* Strong ecosystem and support.\n\n**4. Go**\n\n",
        -16.806324005126953
    ]
]

אפשר להריץ את הפקודה עם פרמטרים שונים של query. אפשר גם לשנות פרמטרים נוספים כמו temperature,‏ top_k ו-topc_p באמצעות generate API. מידע נוסף על API של שרת HTTP של Saxml זמין במאמר ממשקי HTTP API של Saxml.

ביטול הפרסום של המודל

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

Gemma 2B-it

כדי לבטל את הפרסום של מודל Gemma 2B-it, מריצים את הפקודה הבאה:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

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

{
    "model": "/sax/test/gemma2bfp16"
}

אפשר להריץ את הפקודה עם הנחיות שונות שמועברות בפרמטר query.

Gemma 7B-it

כדי לבטל את הפרסום של מודל Gemma 7B-it, מריצים את הפקודה הבאה:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

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

{
    "model": "/sax/test/gemma7bfp16"
}

אפשר להריץ את הפקודה עם הנחיות שונות שמועברות בפרמטר query.

פתרון בעיות

הסרת המשאבים

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

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

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

gcloud container clusters delete ${CLUSTER_NAME} --location=${LOCATION}
gcloud iam service-accounts delete --quiet wi-sax@${PROJECT_ID}.iam.gserviceaccount.com
gcloud storage rm --recursive gs://ADMIN_BUCKET_NAME
gcloud storage rm --recursive gs://CHECKPOINTS_BUCKET_NAME

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

  • ‫ADMIN_BUCKET_NAME: השם של קטגוריה של Cloud Storage שבה מאוחסן שרת האדמין של Saxml.
  • ‫CHECKPOINTS_BUCKET_NAME: השם של קטגוריית Cloud Storage שבה מאוחסנים נקודות הביקורת של המודל.

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