שימוש ב-GPU

אתם יכולים לצרף מאיצי GPU לעומסי עבודה באצווה של Managed Service for Apache Spark כדי להשיג את התוצאות הבאות:

  • להאיץ את העיבוד של עומסי עבודה גדולים של ניתוח נתונים.

  • להאיץ את אימון המודלים בקבוצות נתונים גדולות באמצעות ספריות למידת מכונה של GPU.

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

כל סביבות זמן הריצה הנתמכות של Managed Service for Apache Spark מוסיפות את ספריית NVIDIA cuDF for Apache Spark לכל צומת של עומס עבודה. ב-Managed Service for Apache Spark, גרסה 1.1 של סביבת זמן הריצה מוסיפה גם את ספריית XGBoost לצומתי עומס העבודה. הספריות האלה מספקות כלים מתקדמים לטרנספורמציה של נתונים וללמידת מכונה, שאפשר להשתמש בהם בעומסי עבודה עם האצת GPU.

היתרונות של GPU

הנה כמה מהיתרונות של שימוש במעבדים גרפיים בעומסי העבודה של Spark ב-Managed Service for Apache Spark:

  • שיפור הביצועים: האצת GPU יכולה לשפר משמעותית את הביצועים של עומסי העבודה ב-Spark, במיוחד במשימות שדורשות משאבי מחשוב רבים, כמו למידת מכונה ולמידה עמוקה, עיבוד גרפים וניתוח נתונים מורכב.

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

  • יכולת התאמה לעומס (Scalability): הלקוחות יכולים להוסיף עוד צומתי GPU או מעבדי GPU חזקים יותר לצמתים כדי להתמודד עם צורכי עיבוד מורכבים יותר.

  • חיסכון בעלויות: למרות שמעבדי GPU דורשים השקעה ראשונית, אתם יכולים לחסוך בעלויות לאורך זמן בזכות זמני עיבוד קצרים יותר וניצול יעיל יותר של המשאבים.

  • ניתוח נתונים משופר: האצת GPU מאפשרת לבצע ניתוח מתקדם, כמו ניתוח תמונות וסרטונים ועיבוד שפה טבעית, במערכי נתונים גדולים.

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

מגבלות ושיקולים

תמחור

מאיצי GPU זמינים ברמת התמחור פרימיום. למידע על מחירי המאיצים, ראו התמחור של Managed Service for Apache Spark.

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

לפני שיוצרים עומס עבודה של אצווה ללא שרת עם מאיצי GPU מצורפים, צריך לבצע את הפעולות הבאות:

  1. 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

  2. Verify that billing is enabled for your Google Cloud project.

  3. Enable the Dataproc, Compute Engine, and Cloud Storage APIs, if any are 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 APIs

  4. Install the Google Cloud CLI.

  5. Configure the gcloud CLI to use your federated identity.

    For more information, see Sign in to the gcloud CLI with your federated identity.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init
  7. במסוף Google Cloud , נכנסים לדף Buckets של Cloud Storage.

    כניסה לדף Buckets

  8. לוחצים על Create.
  9. ממלאים את פרטי הקטגוריה בדף Create a bucket. כדי לעבור לשלב הבא לוחצים על Continue.
    1. בקטע Get started, מבצעים את הפעולות הבאות:
    2. בקטע Choose where to store your data, מבצעים את הפעולות הבאות:
      1. בוחרים Location type.
      2. בתפריט הנפתח Location type, בוחרים את המיקום שבו נתוני הקטגוריה יאוחסנו באופן קבוע.
      3. כדי להגדיר רפליקציה בין קטגוריות, בוחרים באפשרות Add cross-bucket replication via Storage Transfer Service ופועלים לפי השלבים הבאים:

        הגדרת רפליקציה בין קטגוריות

        1. בתפריט Bucket, בוחרים קטגוריה.

        2. בקטע Replication settings, לוחצים על Configure כדי לקבוע את ההגדרות של משימת הרפליקציה.

          מופיעה החלונית Configure cross-bucket replication.

          • כדי לסנן אובייקטים לשכפול לפי קידומת של שם האובייקט, מזינים את הקידומת שרוצים לכלול או להחריג אובייקטים ממנה, ואז לוחצים על Add a prefix.
          • כדי להגדיר סוג אחסון לאובייקטים שנוצרו ברפליקציה, בוחרים סוג אחסון בתפריט Storage class. אם מדלגים על השלב הזה, האובייקטים המשוכפלים ישתמשו כברירת מחדל בסוג האחסון של קטגוריית היעד.
          • לוחצים על סיום.
    3. בקטע Choose how to store your data, מבצעים את הפעולות הבאות:
      1. בוחרים סוג אחסון (storage class) שמוגדר כברירת מחדל לקטגוריה, או בוחרים ב-Autoclass לניהול אוטומטי של סוג האחסון של נתוני הקטגוריה.
      2. כדי להפעיל מרחב שמות היררכי, בקטע Optimize storage for data-intensive workloads בוחרים באפשרות Enable hierarchical namespace on this bucket.
    4. בקטע Choose how to control access to objects, בוחרים אם הקטגוריה אוכפת public access prevention או לא, ואז בוחרים access control method לאובייקטים של הקטגוריה.
    5. בקטע Choose how to protect object data, מבצעים את הפעולות הבאות:
      • בוחרים את האפשרויות שרוצים להגדיר לקטגוריה בקטע הגנה על נתונים.
        • כדי להפעיל את האפשרות מחיקה זמנית, לוחצים על תיבת הסימון Soft delete policy (For data recovery) ומציינים את מספר הימים שבהם רוצים לשמור את האובייקטים אחרי המחיקה.
        • כדי להגדיר ניהול גרסאות של אובייקטים, לוחצים על תיבת הסימון ניהול גרסאות של אובייקטים (לניהול גרסאות) ומציינים את המספר המקסימלי של גרסאות לכל אובייקט ואת מספר הימים שאחריהם פג התוקף של הגרסאות הלא עדכניות.
        • כדי להפעיל את מדיניות שמירת הנתונים על אובייקטים וקטגוריות, לוחצים על תיבת הסימון Retention (For compliance)‎ ואז מבצעים את הפעולות הבאות:
          • כדי להפעיל את נעילת שמירת האובייקטים, לוחצים על תיבת הסימון Enable object retention.
          • כדי להפעיל את Bucket Lock, לוחצים על תיבת הסימון Set bucket retention policy ובוחרים יחידת זמן ואת משך הזמן של תקופת השמירה.
      • כדי לבחור איך להצפין את נתוני האובייקטים, מרחיבים את הקטע Data encryption () ובוחרים שיטה ל-Data encryption.
  10. לוחצים על יצירה.

יצירת עומס עבודה של אצווה ללא שרת (serverless) עם מאיצי GPU

שולחים עומס עבודה באצווה ל-Managed Service for Apache Spark שמשתמש במעבדי GPU מסוג NVIDIA L4 כדי להריץ משימת PySpark במקביל. כך עושים את זה באמצעות ה-CLI של gcloud:

  1. לוחצים על Expand me, ואז יוצרים ושומרים את קוד ה-PySpark שמופיע ברשימה בקובץ test-py-spark-gpu.py במחשב המקומי באמצעות עורך טקסט או עורך קוד.

    #!/usr/bin/env python

"""S8s Accelerators Example."""

import subprocess
from typing import Any
from pyspark.sql import SparkSession
from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType
from pyspark.sql.types import StructField
from pyspark.sql.types import StructType

spark = SparkSession.builder.appName("joindemo").getOrCreate()


def get_num_gpus(_: Any) -> int:
  """Returns the number of GPUs."""
  p_nvidia_smi = subprocess.Popen(
      ["nvidia-smi", "-L"], stdin=None, stdout=subprocess.PIPE
  )
  p_wc = subprocess.Popen(
      ["wc", "-l"],
      stdin=p_nvidia_smi.stdout,
      stdout=subprocess.PIPE,
      stderr=subprocess.PIPE,
      universal_newlines=True,
  )
  [out, _] = p_wc.communicate()
  return int(out)


num_workers = 5
result = (
    spark.sparkContext.range(0, num_workers, 1, num_workers)
    .map(get_num_gpus)
    .collect()
)
num_gpus = sum(result)
print(f"Total accelerators: {num_gpus}")

# Run the join example
schema = StructType([StructField("value", IntegerType(), True)])
df = (
    spark.sparkContext.parallelize(range(1, 10000001), 6)
    .map(lambda x: (x,))
    .toDF(schema)
)
df2 = (
    spark.sparkContext.parallelize(range(1, 10000001), 6)
    .map(lambda x: (x,))
    .toDF(schema)
)
joined_df = (
    df.select(col("value").alias("a"))
    .join(df2.select(col("value").alias("b")), col("a") == col("b"))
    .explain()
)

  2. משתמשים ב-CLI של gcloud במכונה המקומית כדי לשלוח את המשימה באצווה ללא שרת (serverless) של Managed Service for Apache Spark עם חמישה וורקרים, כשכל וורקר מואץ באמצעות מעבדי GPU מסוג L4:

    gcloud dataproc batches submit pyspark test-py-spark-gpu.py \
    --project=PROJECT_ID \
    --region=REGION \
    --deps-bucket=BUCKET_NAME \
    --version=1.1 \
    --properties=spark.dataproc.executor.compute.tier=premium,spark.dataproc.executor.disk.tier=premium,spark.dataproc.executor.resource.accelerator.type=l4,spark.executor.instances=5,spark.dataproc.driverEnv.LANG=C.UTF-8,spark.executorEnv.LANG=C.UTF-8,spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager

הערות:

  • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
  • ‫REGION: אזור זמין ב-Compute Engine להרצת עומס העבודה.
  • ‫BUCKET_NAME: השם של הקטגוריה ב-Cloud Storage. לפני הרצת עומס העבודה באצווה, Spark מעלה את יחסי התלות של עומס העבודה לתיקייה /dependencies בקטגוריה הזו.
  • ‫--version: כל סביבות זמן הריצה הנתמכות של Managed Service for Apache Spark מוסיפות את ספריית NVIDIA cuDF for Apache Spark לכל צומת של עומס עבודה עם האצת GPU. רק גרסה 1.1 של סביבת זמן הריצה מוסיפה את הספרייה XGBoost לכל צומת של עומס עבודה עם האצת GPU.

  • ‫‎--properties (ראו מאפייני הקצאת משאבים של Spark) :

    • ‫spark.dataproc.driverEnv.LANG=C.UTF-8 ו-spark.executorEnv.LANG=C.UTF-8 (חובה בגרסאות של סביבת זמן ריצה שקודמות ל-2.2): המאפיינים האלה מגדירים את מערכת התווים שמוגדרת כברירת מחדל ל-C.UTF-8.

    • spark.dataproc.executor.compute.tier=premium (חובה): עומסי עבודה עם האצת GPU מחויבים באמצעות יחידות מחשוב נתונים (DCU) פרימיום. מחירי המאיצים של Managed Service for Apache Spark

    • ‫spark.dataproc.executor.disk.tier=premium (חובה): צמתים עם מאיצי A100-40,‏ A100-80 או L4 חייבים להשתמש ברמת הדיסק Premium.

    • ‫spark.dataproc.executor.resource.accelerator.type=l4 (חובה): צריך לציין רק סוג אחד של GPU. במשימה לדוגמה נבחר ה-GPU מסוג L4. אפשר לציין את סוגי המאיצים הבאים באמצעות שמות הארגומנטים הבאים:

      סוג ה-GPU שם הארגומנט
      A100 40GB a100-40
      A100 80GB a100-80

    • ‫spark.executor.instances=5 (חובה): חייבים להיות לפחות שניים. בדוגמה הזו, מגדירים את הערך 5.

    • ‫spark.executor.cores (אופציונלי): אפשר להגדיר את המאפיין הזה כדי לציין את מספר ה-vCPU של הליבה. הערכים החוקיים למעבדי L4 GPU הם 4 (ברירת המחדל), 8,‏ 12,‏ 16,‏ 24,‏ 48 או 96. הערך התקין היחיד, וערך ברירת המחדל, ל-GPU מסוג A100 הוא 12. בהגדרות עם מעבדי L4 GPU וליבות 24,‏ 48 או 96, לכל מבצע משימה מצורפים מעבדי GPU מסוג 2,‏ 4 או 8. לכל שאר ההגדרות יש GPU אחד (1) מצורף.

    • ‫spark.dataproc.executor.disk.size (חובה): למעבדי GPU מסוג L4 יש גודל דיסק קבוע של 375GB, חוץ מהגדרות עם ליבות 24,‏ 48 או 96, שיש להן 750,‏ 1,500 או 3,000GB, בהתאמה. אם תגדירו למאפיין הזה ערך אחר כשאתם שולחים עומס עבודה עם האצת L4, תתרחש שגיאה. אם בוחרים ב-GPU מסוג A100 40 או A100 80, הגדלים החוקיים הם 375g,‏ 750g,‏ 1500g,‏ 3000g,‏ 6000g ו-9000g.

    • ‫spark.executor.memory (אופציונלי) ו-spark.executor.memoryOverhead (מוגבל): אפשר להגדיר זיכרון, אבל לא memoryOverhead. נפח הזיכרון הפנוי שלא מנוצל על ידי המאפיין שהוגדר מוקצה למאפיין שלא הוגדר. הערך של spark.executor.memoryOverhead מוגדר ל-40% מהזיכרון הזמין לעומסי עבודה באצווה של PySpark, ול-10% לעומסי עבודה אחרים (ראו מאפייני הקצאת משאבים של Spark).

      בטבלה הבאה מוצגת כמות הזיכרון המקסימלית שאפשר להגדיר להגדרות שונות של מעבדי GPU מסוג A100 ו-L4. הערך המינימלי של כל אחד מהמאפיינים הוא 1024MB.

      A100 (40 GB) A100 (80 GB) ‫L4 (‏4 ליבות) ‫L4‏ (8 ליבות) ‫L4 (‏12 ליבות) ‫L4‏ (16 ליבות) ‫L4‏ (24 ליבות) ‫L4‏ (48 ליבות) ‫L4 (‏96 ליבות)
      זיכרון כולל מקסימלי (MB) 78040 165080 13384 26768 40152 53536 113072 160608 321216

    • מאפייני הספרייה NVIDIA cuDF for Apache Spark (אופציונלי): כברירת מחדל, Managed Service for Apache Spark מגדיר את ערכי המאפיינים הבאים של הספרייה NVIDIA cuDF for Apache Spark:

      • spark.plugins=com.nvidia.spark.SQLPlugin
      • spark.executor.resource.gpu.amount=1
      • spark.task.resource.gpu.amount=1/$spark_executor_cores
      • spark.shuffle.manager=''. כברירת מחדל, המאפיין הזה לא מוגדר. כדי לשפר את הביצועים, NVIDIA ממליצה להפעיל את מנהל ה-shuffle של CUDA-X כשמשתמשים במעבדי GPU. כדי לעשות את זה, מגדירים את spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager כששולחים עומס עבודה.
      • spark.rapids.sql.concurrentGpuTasks= minimum of (gpuMemoryinMB / 8, 4)
      • ‫spark.rapids.shuffle.multiThreaded.writer.threads= minimum of (cpu cores in the VM / gpu count per VM, 32)
      • ‫spark.rapids.shuffle.multiThreaded.reader.threads= minimum of (cpu cores in the VM / gpu count per VM, 32)

      כדי להגדיר את המאפיינים של ספריית NVIDIA cuDF ל-Apache Spark, עיינו במאמר הגדרת הפלאגין NVIDIA cuDF ל-Apache Spark, וכדי להגדיר את המאפיינים המתקדמים של Spark, עיינו במאמר הגדרה מתקדמת של הפלאגין NVIDIA cuDF ל-Apache Spark.