ביצוע התאמה עדינה של מודלים פתוחים של Gemma באמצעות כמה יחידות GPU ב-GKE

במדריך הזה נסביר איך לכוונן את מודל השפה הגדול (LLM) Gemma, משפחה של מודלים פתוחים, באמצעות יחידות עיבוד גרפי (GPU) ב-Google Kubernetes Engine ‏ (GKE) עם ספריית Transformers מ-Hugging Face. התאמה עדינה היא תהליך למידה מפוקחת שמשפר את היכולת של מודל שאומן מראש לבצע משימות ספציפיות, על ידי עדכון הפרמטרים שלו באמצעות מערך נתונים חדש. במדריך הזה מורידים מודלים של משפחת Gemma שעברו אימון מראש עם 2 מיליארד פרמטרים מ-Hugging Face, ומבצעים כוונון עדין שלהם באשכול Autopilot או Standard של GKE.

המדריך הזה הוא נקודת התחלה טובה אם אתם צריכים שליטה מדויקת, מדרגיות, חוסן (resilience), ניידות ויעילות כלכלית של Kubernetes מנוהל כשאתם מכווננים מודל שפה גדול (LLM).

שיטה מומלצת:

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

רקע

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

‏Gemma

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

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

מערך הנתונים שבו משתמשים במסמך הזה הוא b-mc2/sql-create-context.

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

יחידות GPU

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

לפני שמשתמשים ביחידות GPU ב-GKE, כדאי לעבור על תוכנית הלימודים הבאה:

  1. מידע על הזמינות של הגרסה הנוכחית של GPU
  2. מידע על יחידות GPU ב-GKE

Hugging Face Transformers

באמצעות ספריית Transformers של Hugging Face, אפשר לגשת למודלים מתקדמים שעברו אימון מראש. ספריית Transformers מאפשרת לצמצם את הזמן, המשאבים והעלויות החישוביות שקשורים לאימון המודל המלא.

במדריך הזה תשתמשו בממשקי ה-API ובכלים של Hugging Face כדי להוריד את המודלים האלה שאומנו מראש ולשפר אותם.

מטרות

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

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

  1. מכינים את הסביבה עם אשכול GKE במצב Autopilot.
  2. יוצרים מאגר תגים לשיפור הדיוק.
  3. שימוש ביחידות GPU כדי לבצע כוונון עדין של מודל Gemma 2B והעלאת המודל ל-Hugging Face.

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

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

    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 APIs

  • 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 APIs.

    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 APIs

    •

  • צריך לוודא שיש לכם בפרויקט את התפקיד או התפקידים הבאים: roles/container.admin, roles/iam.serviceAccountAdmin, roles/cloudbuild.builds.editor

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

    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 לצורך פריסה ב-GKE, קודם צריך לחתום על הסכם הרישיון ואז ליצור טוקן גישה ל-Hugging Face.

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

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

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

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

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

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

הכנת הסביבה

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

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

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

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

    gcloud config set 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
export HF_PROFILE=HF_PROFILE

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

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

  3. משכפלים את מאגר הקוד לדוגמה מ-GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/ai-ml/llm-finetuning-gemma

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

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

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

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

שיטה מומלצת:

כדי ליהנות מחוויית Kubernetes מנוהלת לחלוטין, אפשר להשתמש ב-Autopilot.

טייס אוטומטי

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

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

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

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

‫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. מריצים את הפקודה הבאה כדי ליצור מאגר צמתים עבור האשכול:

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

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

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

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

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

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

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

    • ‫CONTROL_PLANE_LOCATION: האזור של Compute Engine במישור הבקרה של האשכול.
    • ‫CLUSTER_NAME: השם של האשכול.

  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 שיצרתם קודם, או משתמשים במשתנה הסביבה אם הגדרתם אותו.

יצירת קונטיינר לכוונון עדין באמצעות Docker ו-Cloud Build

הקונטיינר הזה משתמש בקוד PyTorch ובקוד Hugging Face Transformers כדי לשפר את מודל Gemma הקיים שעבר אימון מראש.

  1. יוצרים מאגר Docker ב-Artifact Registry:

    gcloud artifacts repositories create gemma \
    --project=PROJECT_ID \
    --repository-format=docker \
    --location=us \
    --description="Gemma Repo"

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

  2. בנייה והעלאה של התמונה:

    gcloud builds submit .

  3. מייצאים את IMAGE_URL לשימוש בהמשך המדריך הזה.

    export IMAGE_URL=us-docker.pkg.dev/PROJECT_ID/gemma/finetune-gemma-gpu:1.0.0

הרצת משימת כוונון עדין ב-GKE

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

  1. פותחים את הקובץ finetune.yaml.

    apiVersion: batch/v1
kind: Job
metadata:
  name: finetune-job
  namespace: default
spec:
  backoffLimit: 2
  template:
    metadata:
      annotations:
        kubectl.kubernetes.io/default-container: finetuner
    spec:
      terminationGracePeriodSeconds: 600
      containers:
      - name: finetuner
        image: $IMAGE_URL
        resources:
          limits:
            nvidia.com/gpu: "8"
        env:
        - name: MODEL_NAME
          value: "google/gemma-2b"
        - name: NEW_MODEL
          value: "gemma-2b-sql-finetuned"
        - name: LORA_R
          value: "8"
        - name: LORA_ALPHA
          value: "16"
        - name: TRAIN_BATCH_SIZE
          value: "1"
        - name: EVAL_BATCH_SIZE
          value: "2"
        - name: GRADIENT_ACCUMULATION_STEPS
          value: "2"
        - name: DATASET_LIMIT
          value: "1000"
        - name: MAX_SEQ_LENGTH
          value: "512"
        - name: LOGGING_STEPS
          value: "5"
        - name: HF_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
      restartPolicy: OnFailure

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

    envsubst < finetune.yaml | kubectl apply -f -

    ההוראה הזו מחליפה את IMAGE_URL במשתנה במניפסט.

  3. מריצים את הפקודה הבאה כדי לעקוב אחרי העבודה:

    watch kubectl get pods

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

    kubectl logs job.batch/finetune-job -f

    משאב ה-Job מוריד את נתוני המודל ואז מבצע כוונון עדין של המודל בכל שמונת מעבדי ה-GPU. התהליך הזה יכול להימשך עד 20 דקות.

  5. אחרי שהעבודה תושלם, עוברים לחשבון Hugging Face. מודל חדש בשם HF_PROFILE/gemma-2b-sql-finetuned מופיע בפרופיל שלכם ב-Hugging Face.

הצגת המודל המכוונן ב-GKE

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

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

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-2b
        - 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. יוצרים את משתנה הסביבה בשביל MODEL_ID חדש:

    export MODEL_ID=HF_PROFILE/gemma-2b-sql-finetuned

    מחליפים את HF_PROFILE במזהה הפרופיל ב-Hugging Face שיצרתם קודם.

  3. מחליפים את MODEL_ID במניפסט:

    sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml

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

    kubectl apply -f serve-gemma.yaml

    ‫Pod באשכול מוריד את משקלי המודל מ-Hugging Face ומתחיל את מנוע ההצגה.

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

    kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment

  6. צפייה ביומנים מהפריסה הפעילה:

    kubectl logs -f -l app=gemma-server

המשאב Deployment מוריד את נתוני המודל. התהליך הזה יכול לקחת כמה דקות. הפלט אמור להיראות כך:

INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
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)

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

פרסום המודל

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

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

אחרי פריסת המודל, מריצים את הפקודה הבאה כדי להגדיר העברת נתונים (port forwarding) למודל:

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

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

Forwarding from 127.0.0.1:8000 -> 8000

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

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

הדוגמה הבאה היא פקודה ל-TGI:

USER_PROMPT="Question: What is the total number of attendees with age over 30 at kubecon eu? Context: CREATE TABLE attendees (name VARCHAR, age INTEGER, kubecon VARCHAR)"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "prompt": "${USER_PROMPT}",
    "temperature": 0.1,
    "top_p": 1.0,
    "max_tokens": 24
}
EOF

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

{"generated_text":" Answer: SELECT COUNT(age) FROM attendees WHERE age > 30 AND kubecon = 'eu'\n"}

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

הסרת המשאבים

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

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

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

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

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

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

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