Laden von Daten auf AI-Runtime

In diesem Abschnitt werden Informationen zum Laden von Daten auf AI Runtime speziell für ML- und DL-Anwendungen behandelt. Schauen Sie sich das Lernprogramm an, um mehr über das Laden und Transformieren von Daten mithilfe der Spark Python-API zu erfahren.

Laden von Tabellendaten

Verwenden Sie Spark Connect, um tabellarische Machine Learning-Daten aus Delta-Tabellen zu laden.

Für ein einzelnes Knoten-Training können Sie Apache Spark DataFrames mithilfe der PySpark-MethodetoPandas() in Pandas DataFrames konvertieren und dann optional mithilfe der PySpark-Methodeto_numpy() in das NumPy-Format konvertieren.

Spark Connect unterstützt die meisten PySpark-APIs, einschließlich Spark SQL, Pandas-API für Spark, Structured Streaming und MLlib (DataFrame-basiert). In der PySpark-API-Referenzdokumentation finden Sie die neuesten unterstützten APIs.

Weitere Einschränkungen finden Sie unter Serverless Compute Limitations.

Laden großer Delta-Tabellen mit Volumen

Exportieren Sie die Daten von großen Delta-Tabellen, die zu groß sind, um mit toPandas() konvertiert zu werden, in ein Unity-Katalog-Volume und laden Sie sie direkt mithilfe von PyTorch oder Hugging Face.

# Step 1: Export the Delta table to Parquet files in a UC volume
output_path = "/Volumes/catalog/schema/my_volume/training_data"
spark.table("catalog.schema.my_table").write.mode("overwrite").parquet(output_path)

# Step 2: Load the exported data directly using Hugging Face datasets
from datasets import load_dataset

dataset = load_dataset("parquet", data_files="/Volumes/catalog/schema/my_volume/training_data/*.parquet")

Dieser Ansatz vermeidet Spark-Overhead während der Schulung und eignet sich gut für Einzel-GPU- und verteilte Schulungsworkflows.This approach avoid Spark overhead during training and works well for both single-GPU and distributed training workflows.

Laden unstrukturierte Daten von Datenträgern

Verwenden Sie für unstrukturierte Daten wie Bilder, Audio und Textdateien Unity-Katalogvolumes. Das folgende Beispiel zeigt, wie Dateien aus einem Volume gelesen und mit einem PyTorch Datasetverwendet werden:

# Read files from a UC volume
volume_path = "/Volumes/catalog/schema/my_volume/images/"

from torch.utils.data import Dataset
import os
from PIL import Image

class ImageDataset(Dataset):
    def __init__(self, root_dir):
        self.file_list = [os.path.join(root_dir, f) for f in os.listdir(root_dir)]

    def __len__(self):
        return len(self.file_list)

    def __getitem__(self, idx):
        img = Image.open(self.file_list[idx])
        return img

Laden von Daten innerhalb des @distributed Dekorators

Wenn Sie die Serverless GPU-API für verteiltes Training verwenden, verschieben Sie den Datenladecode innerhalb des Dekorators @distributed. Die Datensatzgröße kann die maximal zulässige Größe des Pickle-Moduls überschreiten. Daher wird empfohlen, den Datensatz innerhalb des Dekorators zu erzeugen, wie im Folgenden gezeigt:

from serverless_gpu import distributed

# This may cause a pickle error if the dataset is too large
dataset = get_dataset(file_path)

@distributed(gpus=8, gpu_type='H100')
def run_train():
    # Load data inside the decorator to avoid pickle serialization issues
    dataset = get_dataset(file_path)
    ...

Leistung beim Laden von Daten

/Workspace- und /Volumes-Verzeichnisse werden im Remote-Speicher des Unity-Katalogs gehostet. Wenn Ihr Dataset im Unity-Katalog gespeichert ist, ist die Datenladegeschwindigkeit durch die verfügbare Netzwerkbandbreite begrenzt. Wenn Sie mehrere Epochen trainieren, empfiehlt es sich, die Daten zuerst lokal zu kopieren, insbesondere in das /tmp Verzeichnis, das auf schnellem NVMe-SSD-Speicher gehostet wird.

Wenn Ihr Dataset groß ist, können die folgenden Techniken die Leistung verbessern:

• Lokale Speicherung von Cache-Daten für das Training über mehrere Epochen. Kopieren Sie Datasets für /tmp einen schnelleren Zugriff über Epochen hinweg:

  import shutil
  shutil.copytree("/Volumes/catalog/schema/volume/dataset", "/tmp/dataset")
  

• Parallelisieren sie das Abrufen von Daten. Verwenden Sie den torch DataLoader mit mehreren Arbeitern, um das Laden von Daten mit der GPU-Berechnung zu überlappen. Stellen Sie num_workers auf mindestens 2 ein. Um die Leistung zu verbessern, erhöhen Sie num_workers (wodurch parallele Lesevorgänge erhöht werden) oder prefetch_factor (wodurch die Anzahl der Elemente erhöht wird, die jeder Mitarbeiter vornimmt):

  from torch.utils.data import DataLoader
  
  loader = DataLoader(
      dataset,
      batch_size=32,
      num_workers=2,
      prefetch_factor=2,
      pin_memory=True
  )
  

• Verwenden Sie Spark Connect für große tabellarische Datasets. Spark Connect unterstützt die meisten PySpark-APIs und behandelt verteilte Lesevorgänge effizient.

Streaming-Datensätze

Verwenden Sie für sehr große Datasets, die nicht in den Arbeitsspeicher passen, Streamingansätze:

• PyTorch IterableDataset für benutzerdefinierte Streaminglogik.
• Hugging Face-Datasets mit Streaming für Datasets, die auf dem Hub oder in Volumen gehostet werden.
• Ray Data für verteilte Batch-Datenverarbeitung.