‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

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

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

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

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

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

מטרות

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

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

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

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

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

הפעלת 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 כי המודל דורש שני מעבדי NVIDIA L4 GPU.
הערך של 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 כי המודל דורש שני מעבדי NVIDIA L4 GPU.
הערך של 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 כי המודל דורש שני מעבדי NVIDIA L4 GPU.
הערך של 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 לא יהיה מספיק זיכרון. לכן, בדוגמאות במדריך הזה נעשה שימוש ב-שני זיכרונות GPU מסוג L4 (‎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