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

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

עומסי עבודה אינטראקטיביים של Pathways הם עומסי עבודה מרוחקים של JAX שפועלים במכונה וירטואלית שלא שייכת לאשכול GKE שמארח את אשכול Pathways. בניגוד לעומסי עבודה של אצווה, השלמת הפעולה של עומס עבודה אינטראקטיבי לא גורמת להשבתה של רכיבי אשכול Pathways, והם נשארים זמינים לחיבור על ידי לקוחות JAX אחרים. במסמך הזה נעשה שימוש ב-Jupyter notebook כדוגמה להדגמת עומסי עבודה אינטראקטיביים.

משתמשי JAX שולחים פקודות לאשכול Pathways באמצעות הממשק IFRT. קוד JAX, בין אם הוא מופעל ממסוף, מ-notebook או מכל סביבה שתואמת ל-Python, יכול ליצור אינטראקציה חלקה עם משאבי Pathways.

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

ודאו שיש לכם:

יצירת אשכול GKE באמצעות Pathways
Installed Cluster Toolkit
כלים של Kubernetes שהותקנו
התקנתם את ה-CLI של gcloud
הפעלתם את Google Kubernetes Engine API
מוודאים שהתכונה 'תוכניות לימודים' מופעלת בפרויקט Google Cloud

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

מגדירים את משתני הסביבה הבאים:
```
export WORKLOAD=WORKLOAD
export WORKLOAD_NODEPOOL_COUNT=WORKLOAD_NODEPOOL_COUNT
export COMPUTE_TYPE="COMPUTE_TYPE"
export TOPOLOGY="TOPOLOGY"
export PROJECT_ID=PROJECT_ID
export REGION=REGION
export ZONE=ZONE
export CLUSTER=CLUSTER
export BUCKET_NAME=BUCKET_NAME
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫WORKLOAD: צריך להגדיר שם ייחודי כדי לזהות את עומס העבודה (השם צריך לכלול 22 תווים או פחות בגלל מגבלות התווית של DNS)
- ‫WORKLOAD_NODEPOOL_COUNT: מספר מאגרי הצמתים שמשמשים עומס עבודה של Pathways
- ‫COMPUTE_TYPE: סוג מכונת ה-TPU (לדוגמה, ct6e-standard-4t). למידע נוסף על סוגי ה-TPU הנתמכים לכל גרסת TPU, אפשר לעיין במאמר בנושא גרסאות TPU.
- ‫TOPOLOGY: טופולוגיית המיקום של ה-TPU (לדוגמה, 2x4)
- ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud
- ‫REGION: האזור שבו נמצאים הקטגוריה והאשכול
- ‫ZONE: האזור שבו אתם מתכננים להריץ את עומס העבודה
- ‫CLUSTER: השם של אשכול GKE
- ‫BUCKET_NAME: הקטגוריה של Cloud Storage עבור ארטיפקטים של תוכניות לימודים
אם עוד לא יצרתם קטגוריה של Cloud Storage בשביל ארטיפקטים של תוכניות לימודים, אתם צריכים ליצור אחת:
```
gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}
```

יוצרים את מאגרי הנתונים של Pathways באשכול. כדי להריץ עומס עבודה ללא ממשק משתמש, משתמשים בפקודה gcluster job submit (מידע נוסף זמין במדריך לשליחת משימות ב-Cluster Toolkit):

gcluster job submit \
    --pathways \
    --pathways-gcs-location="gs://${BUCKET_NAME}/pathways-artifacts" \
    --name=${WORKLOAD} \
    --cluster=${CLUSTER} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --num-slices=${WORKLOAD_NODEPOOL_COUNT} \
    --compute-type=${COMPUTE_TYPE} \
    --topology=${TOPOLOGY} \
    --pathways-headless

בשלב הזה, עומס העבודה של JAX יכול להתחבר לשרת ה-Proxy של IFRT.

התחברות לאשכול Pathways במצב אינטראקטיבי

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

התחברות באמצעות העברת נתונים ליציאה אחרת

בשלב הזה אפשר להשתמש בהעברת יציאות (מכל מארח עם גישה למישור הבקרה של האשכול) כדי לגשת לשרת ה-proxy:

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

Cluster Toolkit

PROXY_POD=$(kubectl get pods | grep ${WORKLOAD}-pathways-head | awk '{print $1}')
PROXY_PORT=29000
kubectl port-forward ${PROXY_POD} ${PROXY_PORT}:${PROXY_PORT}

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

Forwarding from 127.0.0.1:29000 -> 29000
Forwarding from [::1]:29000 -> 29000

kubectl

PROXY_POD=$(kubectl get pods | grep pathways-${USER}-pathways-head | awk '{print $1}')
PROXY_PORT=29000
kubectl port-forward ${PROXY_POD} ${PROXY_PORT}:${PROXY_PORT}

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

Forwarding from 127.0.0.1:29000 -> 29000
Forwarding from [::1]:29000 -> 29000

באותו מארח, פותחים חלון טרמינל חדש. מגדירים את משתני הסביבה JAX_PLATFORMS ו-JAX_BACKEND_TARGET ומריצים סקריפט Python שמייבא את pathwaysutils ואת jax:

python3 -m venv .venv
source .venv/bin/activate
pip install pathwaysutils jax

JAX_PLATFORMS=proxy JAX_BACKEND_TARGET=grpc://127.0.0.1:29000 python -c 'import pathwaysutils; import jax; import pprint; pathwaysutils.initialize(); pprint.pprint(jax.devices())'

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

[device(144,TPU_DEVICE,coords=[0,0,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(145,TPU_DEVICE,coords=[1,0,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(146,TPU_DEVICE,coords=[0,1,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(147,TPU_DEVICE,coords=[1,1,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(148,TPU_DEVICE,coords=[0,0,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(149,TPU_DEVICE,coords=[1,0,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(150,TPU_DEVICE,coords=[0,1,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(151,TPU_DEVICE,coords=[1,1,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(162,TPU_DEVICE,coords=[0,0,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(163,TPU_DEVICE,coords=[1,0,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(164,TPU_DEVICE,coords=[0,1,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(165,TPU_DEVICE,coords=[1,1,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(166,TPU_DEVICE,coords=[0,0,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
device(167,TPU_DEVICE,coords=[1,0,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
device(168,TPU_DEVICE,coords=[0,1,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
device(169,TPU_DEVICE,coords=[1,1,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3)]
Waiting up to 5 seconds.
Sent all pending logs.
2024-11-13 21:38:51.267523: W external/xla/xla/python/ifrt_proxy/client/grpc_client.cc:63] IFRT proxy server disconnected: CANCELLED: Cancelled

התחברות ממארחים ב-VPC בלי להשתמש בהעברת יציאות

אם אתם לא רוצים להשתמש בהעברת יציאות, אתם יכולים להתחבר לאשכול Pathways באמצעות Cloud DNS או מאזן עומסים פנימי.

התחברות באמצעות Cloud DNS

הפעלת Cloud DNS באשכול מעבירה את ספק ה-DNS מ-kube-dns ל-Cloud DNS. כשמפעילים את האפשרות הזו, נוצר תחום DNS פרטי ב-Cloud DNS בענן וירטואלי פרטי (VPC) שלכם עבור השמות של Cloud DNS. מידע נוסף מופיע במאמר שימוש ב-Cloud DNS ל-GKE.

אם מפעילים את Cloud DNS עם היקף האשכול, ה-VPC או ה-VPC המצטבר, אפשר לפתור את השמות של Kubernetes Cloud DNS ממכונות וירטואליות שאינן GKE בתוך הענן הווירטואלי הפרטי. השמות הם בפורמט <service_name>.<namespace>.svc.<custom_dns_domain>. ל-Pod של Pathways head יש שירות בשם <jobset_name>-pathways-head-0-0.<jobset_name>.<namespace>.svc.<custom_dns_domain>.

הפקודות הבאות מראות איך להתחבר לאשכול Pathways באמצעות Cloud DNS:

מוודאים שאפשר לפתור את רשומת Cloud DNS של הלידר ממארח שאינו GKE:

Cluster Toolkit

host WORKLOAD-pathways-head-0-0.WORKLOAD.default.svc.USERNAME-test

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

<WORKLOAD>-pathways-head-0-0.<WORKLOAD>.default.svc.<user>-test has address 10.0.2.75

kubectl

host pathways-USERNAME-pathways-head-0-0.pathways-USERNAME.default.svc.USERNAME-test

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

pathways-<user>-pathways-head-0-0.pathways-<user>.default.svc.<user>-test has address 10.0.2.75

מתחברים לאשכול Pathways באמצעות שם Cloud DNS:

Cluster Toolkit

JAX_PLATFORMS=proxy JAX_BACKEND_TARGET=grpc://WORKLOAD-pathways-head-0-0.WORKLOAD.default.svc.USERNAME-test:29000 python -c 'import pathwaysutils; import jax; import pprint; pathwaysutils.initialize(); pprint.pprint(jax.devices())'

kubectl

JAX_PLATFORMS=proxy JAX_BACKEND_TARGET=grpc://pathways-USERNAME-pathways-head-0-0.pathways-USERNAME.default.svc.USERNAME-test:29000 python -c 'import pathwaysutils; import jax; import pprint; pathwaysutils.initialize(); pprint.pprint(jax.devices())'

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

[device(216,TPU_DEVICE,coords=[0,0,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(217,TPU_DEVICE,coords=[1,0,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(218,TPU_DEVICE,coords=[0,1,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(219,TPU_DEVICE,coords=[1,1,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
device(220,TPU_DEVICE,coords=[0,0,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(221,TPU_DEVICE,coords=[1,0,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(222,TPU_DEVICE,coords=[0,1,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(223,TPU_DEVICE,coords=[1,1,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
device(234,TPU_DEVICE,coords=[0,0,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(235,TPU_DEVICE,coords=[1,0,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(236,TPU_DEVICE,coords=[0,1,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(237,TPU_DEVICE,coords=[1,1,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
device(238,TPU_DEVICE,coords=[0,0,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
device(239,TPU_DEVICE,coords=[1,0,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
device(240,TPU_DEVICE,coords=[0,1,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
device(241,TPU_DEVICE,coords=[1,1,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3)]
Waiting up to 5 seconds.
Sent all pending logs.
2024-11-14 00:02:49.882044: W external/xla/xla/python/ifrt_proxy/client/grpc_client.cc:63] IFRT proxy server disconnected: CANCELLED: Cancelled

חיבור באמצעות מאזן עומסים פנימי

כדי ליצור כתובת IP פרטית ב-VPC שמפנה לפריסת Pathways, צריך ליצור שירות שמגובה על ידי מאזן עומסים פנימי. לא נדרש להפעיל את Cloud DNS באשכול.

אם אתם יוצרים מאזני עומסים פנימיים, אנחנו ממליצים להפעיל את התכונה 'חלוקת משנה של ILB' באשכולות עם הרבה מכונות וירטואליות. מידע נוסף זמין במאמר הפעלת חלוקת משנה של GKE באשכול קיים. אם לא מפעילים את האפשרות 'חלוקה לקבוצות משנה של איזון עומסים פנימי', כל הצמתים באשכול יהיו חלק מקבוצת המופעים של השרת העורפי לכל מאזני העומסים הפנימיים. הפתרון הזה לא מתאים לאשכולות עם יותר מ-250 צמתים. כשהתכונה 'חלוקת משנה של ILB' מופעלת, GKE יוצר קבוצות של נקודות קצה ברשת במקום קבוצות של מכונות וירטואליות, וכולל רק צמתים שמריצים אחד מה-Pods של השירות. ההפעלה של חלוקת משנה של איזון עומסים פנימי כרוכה בהשהיה חד-פעמית בהגדרה (כ-15 דקות). הפקודה הבאה מראה איך להפעיל את חלוקת המשנה של ILB:

gcloud container clusters update ${CLUSTER} \
  --project=${PROJECT} \
  [--zone=${ZONE} | --region=${REGION}] \
  --enable-l4-ilb-subsetting

אחרי שמפעילים את התכונה 'חלוקת משנה של איזון עומסים פנימי', אפשר ליצור שירות Kubernetes מסוג LoadBalancer באמצעות קובץ ה-YAML הבא. הפעולה הזו תגרום ל-GKE ליצור מאזן עומסים פנימי בתוך ה-VPC של האשכול:

apiVersion: v1
kind: Service
metadata:
  name: pathways-USERNAME-ilb
  annotations:
    networking.gke.io/load-balancer-type: "Internal"
    networking.gke.io/internal-load-balancer-allow-global-access: "true"
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local
  selector:
    jobset.sigs.k8s.io/jobset-name: pathways-USER
    jobset.sigs.k8s.io/replicatedjob-name: pathways-head
  ports:
  - name: tcp-port
    protocol: TCP
    port: 29000
    targetPort: 29000

מעדכנים את USER עם Google Cloud מזהה המשתמש ושומרים את הקובץ בשם pathways-headless-ilb.yaml.

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

kubectl apply -f pathways-headless-ilb.yaml

אחרי שמאזן העומסים נוצר (כדקה לאחר מכן), בעמודה EXTERNAL-IP יופיע ערך:

kubectl get services
NAME                  TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
pathways-$USER       ClusterIP      None            <none>        <none>         30m
pathways-$USER-ilb   LoadBalancer   34.118.232.46   10.0.0.22     80:31246/TCP   2m41s

אתם יכולים לגשת לפריסת נתיבי הלמידה בלי להגדיר העברת נתונים דרך יציאה במארחים באותו VPC כמו האשכול שלכם:

JAX_PLATFORMS=proxy JAX_BACKEND_TARGET=grpc://10.0.0.22:29000 python -c 'import pathwaysutils; import jax; import pprint; pathwaysutils.initialize(); pprint.pprint(jax.devices())'

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

[device(288,TPU_DEVICE,coords=[0,0,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
 device(289,TPU_DEVICE,coords=[1,0,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
 device(290,TPU_DEVICE,coords=[0,1,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
 device(291,TPU_DEVICE,coords=[1,1,0,0],vtask=0,slice=0,default_mem=device,mem_spaces=3),
 device(292,TPU_DEVICE,coords=[0,0,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
 device(293,TPU_DEVICE,coords=[1,0,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
 device(294,TPU_DEVICE,coords=[0,1,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
 device(295,TPU_DEVICE,coords=[1,1,1,0],vtask=1,slice=0,default_mem=device,mem_spaces=3),
 device(306,TPU_DEVICE,coords=[0,0,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
 device(307,TPU_DEVICE,coords=[1,0,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
 device(308,TPU_DEVICE,coords=[0,1,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
 device(309,TPU_DEVICE,coords=[1,1,0,0],vtask=0,slice=1,default_mem=device,mem_spaces=3),
 device(310,TPU_DEVICE,coords=[0,0,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
 device(311,TPU_DEVICE,coords=[1,0,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
 device(312,TPU_DEVICE,coords=[0,1,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3),
 device(313,TPU_DEVICE,coords=[1,1,1,0],vtask=1,slice=1,default_mem=device,mem_spaces=3)]
Waiting up to 5 seconds.
Sent all pending logs.
2024-11-14 00:30:07.296917: W external/xla/xla/python/ifrt_proxy/client/grpc_client.cc:63] IFRT proxy server disconnected: CANCELLED: Cancelled

נוטבוקים של Jupyter

אפשר ליצור מחברת Jupyter באמצעות Vertex AI או ליצור מחברת Jupyter באירוח עצמי.

יצירת מכונה של Vertex AI Workbench

אחרי שמגדירים ומאמתים את אשכול Pathways, אפשר לגשת למכונות וירטואליות של GKE TPU מתוך מחברת Jupyter של Vertex AI. ההוראות הבאות להגדרה מניחות שקלאסטר GKE Pathways נמצא באותה רשת ענן וירטואלי פרטי (VPC) (שהיא רשת ברירת המחדל, אלא אם הגדרתם אחרת). עוברים אל מסוף Vertex AI Workbench.

יוצרים מכונת Workbench חדשה (מהכרטיסייה Instances) באמצעות הכפתור Create new. מוודאים שהרשת זהה לרשת של אשכול GKE. אפשר להשתמש בשורת הפקודה כדי ליצור מכונת Workbench חדשה.

gcloud workbench instances create INSTANCE_NAME \
--machine-type=e2-standard-4 \
--data-disk-size=100 \
--location=ZONE \
[--network=NETWORK]

אחרי שהמופע נוצר, מנווטים אליו ולוחצים על Open Jupyterlab.

יצירת מופע של מחברת Jupyter באירוח עצמי

הפקודה הבאה מראה איך ליצור מכונה של מחברת Jupyter באירוח עצמי באמצעות הפקודה gcluster job submit:

gcluster job submit \
    --pathways \
    --name=${WORKLOAD} \
    --cluster=${CLUSTER} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --num-slices=${WORKLOAD_NODEPOOL_COUNT} \
    --compute-type=${COMPUTE_TYPE} \
    --topology=${TOPOLOGY} \
    --pathways-gcs-location="gs://${BUCKET_NAME}/pathways-artifacts" \
    --image=jupyter/base-notebook \
    --command="start-notebook.sh"

קובץ ה-YAML הבא מראה איך ליצור מופע של מחברת Jupyter באירוח עצמי באמצעות kubectl. אחרי שיוצרים אשכול של Pathways ללא GUI, מחילים את קובץ ה-YAML הבא. מידע נוסף זמין במאמר בנושא הפעלת Pathways במצב אינטראקטיבי באמצעות kubectl.

apiVersion: batch/v1
kind: Job
metadata:
  name: jupyter-notebook-USERNAME
spec:
  template:
    spec:
      restartPolicy: OnFailure
      containers:
      - name: jupyter-notebook
        image: jupyter/base-notebook  # Use the appropriate Jupyter image
        ports:
        - containerPort: 8888

ניווט למופע של ה-notebook

מתחברים ל-notebook מהמחשב המקומי באמצעות העברת יציאות:

Cluster Toolkit

  MAIN_POD=$(kubectl get pods | grep ${WORKLOAD}-pathways-head | awk '{print $1}')
  kubectl port-forward pod/${MAIN_POD} 8888:8888

kubectl

  MAIN_POD=$(kubectl get pods | grep jupyter-notebook-USERNAME | awk '{print $1}')
  kubectl port-forward pod/${MAIN_POD} 8888:8888

בדפדפן המקומי, עוברים אל http://localhost:8888?token=<var>your-token</var>. מחליפים את <your-token> באסימון מיומני הרישום של קונטיינר ה-notebook של Jupyter.

kubectl logs ${MAIN_POD}

הפלט שיתקבל:

...
Or copy and paste one of these URLs:
  http://jupyter-notebook-<user>-bbbdh:8888/lab?token=<token>
  http://127.0.0.1:8888/lab?token=<token>

קישוריות של מחברת לאשכול Pathways

ב-Jupyterlab, יוצרים נוטבוק חדש של Python 3.
התחברות לשרת ה-proxy של Pathways

במחברת, מוסיפים תא להתקנת pathwaysutils, מגדירים את JAX_PLATFORMS לערך proxy ומגדירים את JAX_BACKEND_TARGET לערך PROXY_ADDRESS.

!pip install pathwaysutils
%env JAX_PLATFORMS=proxy
  # Replace your proxy address below:
%env JAX_BACKEND_TARGET=PROXY_ADDRESS

מוסיפים תא שני כבדיקה מסוג 'שלום עולם' ומדפיסים את המכשירים באשכול Pathways.

import pathwaysutils
import jax

pathwaysutils.initialize()
print(jax.devices())

אם הכול פועל כמו שצריך, תוצג הודעה שמציינת שהמערכת האחורית של Pathways-on-Cloud זוהתה.

מספר מכשירי ה-JAX שמופיעים צריך להיות זהה למספר שבבי ה-TPU ולמספר הפרוסות שציינתם כשנוצר אשכול Pathways.

הוספת קוד ל-Notebook

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

import jax
import jax.numpy as jnp
from jax import lax
import numpy as np

# You can use JAX APIs as usual across any of the devices.
jax.jit(jnp.sin, device=jax.devices()[-1])(np.pi / 2.)

# pmap can run across all devices on all slices
num_tpus = jax.device_count()
f = jax.pmap(lambda x: lax.psum(1, 'i'), 'i')
x = jnp.arange(num_tpus)
y = f(x)
print(y)

# You can also target devices from a specific slice
slice0_devices = [d for d in jax.devices() if d.slice_index == 0]
f = jax.pmap(lambda x: lax.psum(1, 'i'), 'i', devices=slice0_devices)
x = jnp.arange(len(slice0_devices))
y = f(x)
print(y)
print(y.global_shards)

# You can send data produced on one slice to another slice
slice1_devices = [d for d in jax.devices() if d.slice_index == 1]
g = jax.pmap(lambda x: x + lax.axis_index('i'), 'i', devices=slice1_devices)
z = g(y)
print(z)
print(z.global_shards)

מחיקת עומס עבודה אינטראקטיבי ב-Pathways

Cluster Toolkit

gcluster job cancel WORKLOAD --cluster=CLUSTER --project=PROJECT_ID --location=ZONE

kubectl

kubectl delete -f pathways-headless-workload.yaml

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

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

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

התחברות לאשכול Pathways במצב אינטראקטיבי

התחברות באמצעות העברת נתונים ליציאה אחרת

Cluster Toolkit

kubectl

התחברות ממארחים ב-VPC בלי להשתמש בהעברת יציאות

התחברות באמצעות Cloud DNS

Cluster Toolkit

kubectl

Cluster Toolkit

kubectl

חיבור באמצעות מאזן עומסים פנימי

נוטבוקים של Jupyter

יצירת מכונה של Vertex AI Workbench

יצירת מופע של מחברת Jupyter באירוח עצמי

ניווט למופע של ה-notebook

Cluster Toolkit

kubectl

קישוריות של מחברת לאשכול Pathways

הוספת קוד ל-Notebook

מחיקת עומס עבודה אינטראקטיבי ב-Pathways

Cluster Toolkit

kubectl

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

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