Partage via

Charger des données sur AI Runtime

Important

AI Runtime pour les tâches à nœud unique est disponible en préversion publique. L’API d’entraînement distribuée pour les charges de travail multi-GPU reste en version bêta.

Cette section décrit les informations sur le chargement de données sur AI Runtime spécifiquement pour les applications ML et DL. Consultez le tutoriel pour en savoir plus sur la façon de charger et de transformer des données à l’aide de l’API Python Spark.

Note

Le catalogue Unity est requis. Tous les accès aux données sur AI Runtime passent par le catalogue Unity. Vos tables et volumes doivent être inscrits dans le catalogue Unity et accessibles à votre utilisateur ou principal de service.

Charger les données tabulaires

Utilisez Spark Connect pour charger des données De Machine Learning tabulaires à partir de tables Delta.

Pour l’entraînement à nœud unique, vous pouvez convertir des DataFrames Apache Spark en DataFrames pandas à l’aide de la méthode toPandas(), puis éventuellement convertir en format NumPy à l’aide de la méthodeto_numpy() PySpark.

Note

Spark Connect reporte l’analyse et la résolution de noms au temps d’exécution, ce qui peut modifier le comportement de votre code. Consultez Comparer Spark Connect à Spark Classic.

Spark Connect prend en charge la plupart des API PySpark, notamment Spark SQL, l’API Pandas sur Spark, Structured Streaming et MLlib (dataFrame). Consultez la documentation de référence de l’API PySpark pour connaître les dernières API prises en charge.

Pour d’autres limitations, consultez les limitations de calcul serverless.

Charger de grandes tables Delta à l’aide de volumes

Pour les grandes tables Delta qui sont trop grandes pour les convertir avec toPandas(), exportez les données vers un volume du Unity Catalog et chargez-les directement en utilisant PyTorch ou 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")

Cette approche évite la surcharge Spark pendant l’entraînement et fonctionne correctement pour les flux de travail d’entraînement à gpu unique et distribué.

Charger des données non structurées à partir de volumes

Pour les données non structurées telles que les images, les fichiers audio et texte, utilisez des volumes catalogue Unity. L’exemple suivant montre comment lire des fichiers à partir d’un volume et les utiliser avec un PyTorch Dataset:

# 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

Charger des données à l’intérieur du @distributed décorateur

Lorsque vous utilisez l’API GPU serverless pour l’entraînement distribué, déplacez le code de chargement des données à l’intérieur du décorateur @distributed . La taille du jeu de données peut dépasser la taille maximale autorisée par pickle. Il est donc recommandé de générer le jeu de données à l’intérieur du décorateur, comme indiqué ci-dessous :

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

Performances de chargement des données

/Workspace et /Volumes répertoires sont hébergés sur le stockage distant de Unity Catalog. Si votre jeu de données est stocké dans le catalogue Unity, la vitesse de chargement des données est limitée par la bande passante réseau disponible. Si vous entraînez plusieurs époques, l’approche recommandée consiste à d’abord copier les données localement, en particulier dans le /tmp répertoire, qui est hébergé sur un stockage SSD NVMe rapide.

Si votre jeu de données est volumineux, les techniques suivantes peuvent améliorer les performances :

  • Mettre en cache les données localement pour l’apprentissage multi-époque. Copiez des jeux de données pour /tmp un accès plus rapide entre les époques :

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

  • Parallélisez la récupération des données. Utilisez le torch DataLoader avec plusieurs workers pour superposer le chargement des données au calcul GPU. Défini num_workers sur au moins 2. Pour améliorer les performances, augmentez num_workers (ce qui augmente les lectures parallèles) ou prefetch_factor (ce qui augmente le nombre d’éléments que chaque travailleur prérécupère) :

    from torch.utils.data import DataLoader

loader = DataLoader(
    dataset,
    batch_size=32,
    num_workers=2,
    prefetch_factor=2,
    pin_memory=True
)

  • Utilisez Spark Connect pour les jeux de données tabulaires volumineux. Spark Connect prend en charge la plupart des API PySpark et gère efficacement les lectures distribuées.

Jeux de données de streaming

Pour les jeux de données très volumineux qui ne correspondent pas à la mémoire, utilisez des approches de diffusion en continu :

  • Last updated on