Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

הצגת מודל LLM עם מספר מעבדי GPU ב-GKE

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

במדריך הזה נדגים איך לפרוס מודל שפה גדול (LLM) ולהכניס לשימוש בסביבת הייצור באמצעות כמה יחידות GPU ב-GKE, כדי להסיק מסקנות בצורה יעילה וניתנת להרחבה. אתם יוצרים אשכול GKE שמשתמש בכמה GPU ברמה L4 ומכינים תשתית להפעלת אחד מהמודלים הבאים:

מספר ה-GPU הנדרש משתנה בהתאם לפורמט הנתונים של המודל. במדריך הזה, כל מודל משתמש בשני מעבדי GPU מסוג L4. מידע נוסף זמין במאמר בנושא חישוב מספר ה-GPU.

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

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

מטרות

במדריך הזה תלמדו:

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

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

לפני שמתחילים, חשוב לוודא שביצעתם את הפעולות הבאות:

מפעילים את ממשק Google Kubernetes Engine API.

הפעלת Google Kubernetes Engine API

אם רוצים להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.
הערה: אם כבר התקנתם את ה-CLI של gcloud, הקפידו להגדיר את compute/region המאפיין. אם אתם משתמשים בעיקר באשכולות אזוריים, עליכם להגדיר את compute/zone במקום זאת. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו השגיאה הבאה: One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

יש מודלים שנדרשות עבורם דרישות נוספות. חשוב לוודא שאתם עומדים בדרישות הבאות:
- כדי לגשת למודלים מ-Hugging Face, צריך להשתמש בטוקן של HuggingFace.
- למודל Mixtral 8x7b – מאשרים את התנאים של מודל Mistral Mixtral.
- למודל Llama 3 70b – מוודאים שיש לכם רישיון פעיל לשימוש במודלים של Meta Llama.
אזהרה: קבלת גישה ואישור לשימוש במודל Llama עשויה להימשך עד שלושה ימים.

הכנת הסביבה

במסוף Google Cloud , מפעילים מכונת Cloud Shell:
פתיחת Cloud Shell
מגדירים את משתני הסביבה שמוגדרים כברירת מחדל:
```
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=us-central1
```
מחליפים את PROJECT_ID במזהה הפרויקט ב- Google Cloud.

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

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

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

טייס אוטומטי

ב-Cloud Shell, מריצים את הפקודה הבאה:
```
gcloud container clusters create-auto l4-demo \
  --project=${PROJECT_ID} \
  --location=${CONTROL_PLANE_LOCATION} \
  --release-channel=rapid
```
‫GKE יוצר אשכול Autopilot עם צמתים של מעבד ו-GPU לפי הבקשה של עומסי העבודה שנפרסו.

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

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

רגילה

ב-Cloud Shell, מריצים את הפקודה הבאה כדי ליצור אשכול רגיל שמשתמש באיחוד זהויות של עומסי עבודה ל-GKE:
```
gcloud container clusters create l4-demo \
  --location ${CONTROL_PLANE_LOCATION} \
  --workload-pool ${PROJECT_ID}.svc.id.goog \
  --enable-image-streaming \
  --node-locations=${CONTROL_PLANE_LOCATION}-a \
  --workload-pool=${PROJECT_ID}.svc.id.goog \
  --machine-type n2d-standard-4 \
  --num-nodes 1 --min-nodes 1 --max-nodes 5 \
  --release-channel=rapid
```
הערה: יכול להיות שתצטרכו לשנות את הדגל --node-locations בהתאם לאזור שתבחרו. אם משנים את us-central1 האזור
, צריך לבדוק באילו אזורים כרטיסי ה-GPU מדגם L4 זמינים.
יצירת האשכול עשויה להימשך כמה דקות.
מריצים את הפקודה הבאה כדי ליצור מאגר צמתים עבור האשכול:
```
gcloud container node-pools create g2-standard-24 --cluster l4-demo \
  --location ${CONTROL_PLANE_LOCATION} \
  --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
  --machine-type g2-standard-24 \
  --enable-autoscaling --enable-image-streaming \
  --num-nodes=0 --min-nodes=0 --max-nodes=3 \
  --node-locations ${CONTROL_PLANE_LOCATION}-a,${CONTROL_PLANE_LOCATION}-c \
  --spot
```
‫GKE יוצר את המשאבים הבאים עבור ה-LLM:
- אשכול Standard ציבורי.
- מאגר צמתים עם סוג מכונה g2-standard-24 שהוקטן ל-0 צמתים. לא תחויבו על יחידות GPU עד שתפעילו Pods שמבקשים יחידות GPU. מאגר הצמתים הזה מספק מכונות וירטואליות מסוג Spot, שהמחיר שלהן נמוך יותר מהמחיר של מכונות וירטואליות רגילות של Compute Engine, ואין עליהן הבטחה לזמינות. אפשר להסיר את הדגל --spot מהפקודה הזו, ואת בורר הצמתים cloud.google.com/gke-spot בהגדרות text-generation-inference.yaml כדי להשתמש במכונות וירטואליות לפי דרישה.

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

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

הכנת עומס העבודה

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

Llama 3 70b

מגדירים את משתני הסביבה שמוגדרים כברירת מחדל:
```
export HF_TOKEN=HUGGING_FACE_TOKEN
```
מחליפים את HUGGING_FACE_TOKEN באסימון שלכם ב-HuggingFace.

יוצרים סוד של Kubernetes עבור טוקן HuggingFace:

kubectl create secret generic l4-demo \
    --from-literal=HUGGING_FACE_TOKEN=${HF_TOKEN} \
    --dry-run=client -o yaml | kubectl apply -f -

יוצרים את מניפסט הפריסה text-generation-inference.yaml הבא:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llm
  template:
    metadata:
      labels:
        app: llm
    spec:
      containers:
      - name: llm
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
        resources:
          requests:
            cpu: "10"
            memory: "60Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "10"
            memory: "60Gi"
            nvidia.com/gpu: "2"
        env:
        - name: MODEL_ID
          value: meta-llama/Meta-Llama-3-70B-Instruct
        - name: NUM_SHARD
          value: "2"
        - name: MAX_INPUT_TOKENS
          value: "2048"
        - name: PORT
          value: "8080"
        - name: QUANTIZE
          value: bitsandbytes-nf4
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: l4-demo
              key: HUGGING_FACE_TOKEN
        volumeMounts:
          - mountPath: /dev/shm
            name: dshm
          # mountPath is set to /tmp as it's the path where the HUGGINGFACE_HUB_CACHE environment
          # variable in the TGI DLCs is set to instead of the default /data set within the TGI default image.
          # i.e. where the downloaded model from the Hub will be stored
          - mountPath: /tmp
            name: ephemeral-volume
      volumes:
        - name: dshm
          emptyDir:
              medium: Memory
        - name: ephemeral-volume
          ephemeral:
            volumeClaimTemplate:
              metadata:
                labels:
                  type: ephemeral
              spec:
                accessModes: ["ReadWriteOnce"]
                storageClassName: "premium-rwo"
                resources:
                  requests:
                    storage: 150Gi
      nodeSelector:
        cloud.google.com/gke-accelerator: "nvidia-l4"
        cloud.google.com/gke-spot: "true"

במניפסט הזה:

הערך של NUM_SHARD חייב להיות 2 כי המודל דורש שני מעבדי GPU מסוג NVIDIA L4.
הערך של QUANTIZE מוגדר כ-bitsandbytes-nf4, כלומר המודל נטען ב-4 ביט במקום ב-32 ביט. כך GKE יכול להקטין את כמות זיכרון ה-GPU שנדרשת ולשפר את מהירות ההסקה. עם זאת, רמת הדיוק של המודל עלולה לרדת. במאמר חישוב מספר ה-GPU מוסבר איך מחשבים את מספר ה-GPU שצריך לבקש.

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

kubectl apply -f text-generation-inference.yaml

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

deployment.apps/llm created

מאמתים את הסטטוס של המודל:

kubectl get deploy

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

NAME          READY   UP-TO-DATE   AVAILABLE   AGE
llm           1/1     1            1           20m

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

kubectl logs -l app=llm

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

{"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
{"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
{"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
{"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}

‫Mixtral 8x7b

מגדירים את משתני הסביבה שמוגדרים כברירת מחדל:
```
export HF_TOKEN=HUGGING_FACE_TOKEN
```
מחליפים את HUGGING_FACE_TOKEN באסימון שלכם ב-HuggingFace.

יוצרים סוד של Kubernetes עבור טוקן HuggingFace:

kubectl create secret generic l4-demo \
    --from-literal=HUGGING_FACE_TOKEN=${HF_TOKEN} \
    --dry-run=client -o yaml | kubectl apply -f -

יוצרים את מניפסט הפריסה text-generation-inference.yaml הבא:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llm
  template:
    metadata:
      labels:
        app: llm
    spec:
      containers:
      - name: llm
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "5"
            memory: "40Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "5"
            memory: "40Gi"
            nvidia.com/gpu: "2"
        env:
        - name: MODEL_ID
          value: mistralai/Mixtral-8x7B-Instruct-v0.1
        - name: NUM_SHARD
          value: "2"
        - name: PORT
          value: "8080"
        - name: QUANTIZE
          value: bitsandbytes-nf4
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: l4-demo
              key: HUGGING_FACE_TOKEN          
        volumeMounts:
          - mountPath: /dev/shm
            name: dshm
          # mountPath is set to /tmp as it's the path where the HF_HOME environment
          # variable in the TGI DLCs is set to instead of the default /data set within the TGI default image.
          # i.e. where the downloaded model from the Hub will be stored
          - mountPath: /tmp
            name: ephemeral-volume
      volumes:
        - name: dshm
          emptyDir:
              medium: Memory
        - name: ephemeral-volume
          ephemeral:
            volumeClaimTemplate:
              metadata:
                labels:
                  type: ephemeral
              spec:
                accessModes: ["ReadWriteOnce"]
                storageClassName: "premium-rwo"
                resources:
                  requests:
                    storage: 100Gi
      nodeSelector:
        cloud.google.com/gke-accelerator: "nvidia-l4"
        cloud.google.com/gke-spot: "true"

במניפסט הזה:

הערך של NUM_SHARD חייב להיות 2 כי המודל דורש שני מעבדי GPU מסוג NVIDIA L4.
הערך של QUANTIZE מוגדר כ-bitsandbytes-nf4, כלומר המודל נטען ב-4 ביט במקום ב-32 ביט. כך GKE יכול להקטין את כמות זיכרון ה-GPU שנדרשת ולשפר את מהירות ההסקה. עם זאת, יכול להיות שהפעולה הזו תפגע ברמת הדיוק של המודל. במאמר חישוב מספר ה-GPU מוסבר איך מחשבים את מספר ה-GPU שצריך לבקש.

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

kubectl apply -f text-generation-inference.yaml

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

deployment.apps/llm created

מאמתים את הסטטוס של המודל:
```
watch kubectl get deploy
```
כשהפריסה מוכנה, הפלט אמור להיראות כך:
```
NAME          READY   UP-TO-DATE   AVAILABLE   AGE
llm           1/1     1            1           10m
```
כדי לצאת מהשעון, מקלידים CTRL + C.

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

kubectl logs -l app=llm

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

{"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
{"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
{"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
{"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}

Falcon 40b

יוצרים את מניפסט הפריסה text-generation-inference.yaml הבא:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llm
  template:
    metadata:
      labels:
        app: llm
    spec:
      containers:
      - name: llm
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.1-4.ubuntu2204.py310
        resources:
          requests:
            cpu: "10"
            memory: "60Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "10"
            memory: "60Gi"
            nvidia.com/gpu: "2"
        env:
        - name: MODEL_ID
          value: tiiuae/falcon-40b-instruct
        - name: NUM_SHARD
          value: "2"
        - name: PORT
          value: "8080"
        - name: QUANTIZE
          value: bitsandbytes-nf4
        volumeMounts:
          - mountPath: /dev/shm
            name: dshm
          # mountPath is set to /data as it's the path where the HUGGINGFACE_HUB_CACHE environment
          # variable points to in the TGI container image i.e. where the downloaded model from the Hub will be
          # stored
          - mountPath: /data
            name: ephemeral-volume
      volumes:
        - name: dshm
          emptyDir:
              medium: Memory
        - name: ephemeral-volume
          ephemeral:
            volumeClaimTemplate:
              metadata:
                labels:
                  type: ephemeral
              spec:
                accessModes: ["ReadWriteOnce"]
                storageClassName: "premium-rwo"
                resources:
                  requests:
                    storage: 175Gi
      nodeSelector:
        cloud.google.com/gke-accelerator: "nvidia-l4"
        cloud.google.com/gke-spot: "true"

במניפסט הזה:

הערך של NUM_SHARD חייב להיות 2 כי המודל דורש שני מעבדי GPU מסוג NVIDIA L4.
הערך של QUANTIZE מוגדר כ-bitsandbytes-nf4, כלומר המודל נטען ב-4 ביט במקום ב-32 ביט. כך GKE יכול להקטין את כמות זיכרון ה-GPU שנדרשת ולשפר את מהירות ההסקה. עם זאת, רמת הדיוק של המודל עלולה לרדת. במאמר חישוב מספר ה-GPU מוסבר איך מחשבים את מספר ה-GPU שצריך לבקש.

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

kubectl apply -f text-generation-inference.yaml

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

deployment.apps/llm created

מאמתים את הסטטוס של המודל:
```
watch kubectl get deploy
```
כשהפריסה מוכנה, הפלט אמור להיראות כך:
```
NAME          READY   UP-TO-DATE   AVAILABLE   AGE
llm           1/1     1            1           10m
```
כדי לצאת מהשעון, מקלידים CTRL + C.

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

kubectl logs -l app=llm

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

{"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
{"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
{"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
{"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}

יצירת שירות מסוג ClusterIP

חשיפת ה-Pods באופן פנימי בתוך האשכול כדי שאפליקציות אחרות יוכלו לגלות אותם ולגשת אליהם.

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

apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: llm
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

החלת המניפסט:
```
kubectl apply -f llm-service.yaml
```

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

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

Llama 3 70b

יוצרים קובץ בשם gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  strategy:
    type: Recreate
  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: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "meta-llama/Meta-Llama-3-70B-Instruct"
        - name: USER_PROMPT
          value: "<|begin_of_text|><|start_header_id|>user<|end_header_id|> prompt <|eot_id|><|start_header_id|>assistant<|end_header_id|>"
        - name: SYSTEM_PROMPT
          value: "prompt <|eot_id|>"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio-service
spec:
  type: LoadBalancer
  selector:
    app: gradio
  ports:
  - port: 80
    targetPort: 7860

החלת המניפסט:
```
kubectl apply -f gradio.yaml
```

מוצאים את כתובת ה-IP החיצונית של השירות:

kubectl get svc

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

NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m

מעתיקים את כתובת ה-IP החיצונית מהעמודה EXTERNAL-IP.
כדי להציג את ממשק המודל בדפדפן האינטרנט, משתמשים בכתובת ה-IP החיצונית עם היציאה שנחשפה:
```
http://EXTERNAL_IP
```

‫Mixtral 8x7b

יוצרים קובץ בשם gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  strategy:
    type: Recreate
  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: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "mixtral-8x7b"
        - name: USER_PROMPT
          value: "[INST] prompt [/INST]"
        - name: SYSTEM_PROMPT
          value: "prompt"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio-service
spec:
  type: LoadBalancer
  selector:
    app: gradio
  ports:
  - port: 80
    targetPort: 7860

החלת המניפסט:
```
kubectl apply -f gradio.yaml
```

מוצאים את כתובת ה-IP החיצונית של השירות:

kubectl get svc

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

NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m

מעתיקים את כתובת ה-IP החיצונית מהעמודה EXTERNAL-IP.
אפשר לראות את ממשק המודל מדפדפן האינטרנט באמצעות כתובת ה-IP החיצונית עם היציאה שנחשפה:
```
http://EXTERNAL_IP
```

Falcon 40b

יוצרים קובץ בשם gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  strategy:
    type: Recreate
  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: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "falcon-40b-instruct"
        - name: USER_PROMPT
          value: "User: prompt"
        - name: SYSTEM_PROMPT
          value: "Assistant: prompt"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio-service
spec:
  type: LoadBalancer
  selector:
    app: gradio
  ports:
  - port: 80
    targetPort: 7860

החלת המניפסט:
```
kubectl apply -f gradio.yaml
```

מוצאים את כתובת ה-IP החיצונית של השירות:

kubectl get svc

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

NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m

מעתיקים את כתובת ה-IP החיצונית מהעמודה EXTERNAL-IP.
אפשר לראות את ממשק המודל מדפדפן האינטרנט באמצעות כתובת ה-IP החיצונית עם היציאה שנחשפה:
```
http://EXTERNAL_IP
```

חישוב מספר ה-GPU

מספר ה-GPU תלוי בערך של הדגל QUANTIZE. במדריך הזה, הערך של QUANTIZE מוגדר ל-bitsandbytes-nf4, כלומר המודל נטען ב-4 ביט.

מודל עם 70 מיליארד פרמטרים דורש זיכרון GPU בנפח 40GB לפחות, ששווה ל-70 מיליארד כפול 4 ביט (70 מיליארד x 4 ביט= 35GB), וכולל 5GB של תקורה. במקרה כזה, ל-GPU יחיד מסוג L4 לא יהיה מספיק זיכרון. לכן, בדוגמאות במדריך הזה נעשה שימוש ב-שני זיכרונות L4 GPU (2 x 24 = 48 GB). ההגדרה הזו מספיקה להרצת Falcon 40b או Llama 3 70b במעבדי GPU מסוג L4.

הסרת המשאבים

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

מחיקת האשכול

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

gcloud container clusters delete l4-demo --location ${CONTROL_PLANE_LOCATION}

הצגת מודל LLM עם מספר מעבדי GPU ב-GKE קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

מטרות

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

הכנת הסביבה

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

טייס אוטומטי

רגילה

הכנת עומס העבודה

Llama 3 70b

‫Mixtral 8x7b

Falcon 40b

יצירת שירות מסוג ClusterIP

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

Llama 3 70b

‫Mixtral 8x7b

Falcon 40b

חישוב מספר ה-GPU

הסרת המשאבים

מחיקת האשכול

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

הצגת מודל LLM עם מספר מעבדי GPU ב-GKE