Condividi tramite

Caricare i dati nel runtime di intelligenza artificiale

Importante

Il runtime di intelligenza artificiale per le attività a nodo singolo è disponibile in anteprima pubblica. L'API di training distribuita per i carichi di lavoro con più GPU rimane in beta.

Questa sezione illustra le informazioni sul caricamento dei dati nel runtime di intelligenza artificiale in modo specifico per le applicazioni ML e DL. Vedere l'esercitazione per altre informazioni su come caricare e trasformare i dati usando l'API Python Spark.

Annotazioni

Il catalogo unity è obbligatorio. Tutti gli accessi ai dati nel runtime di intelligenza artificiale passano attraverso Unity Catalog. Le tabelle e i volumi devono essere registrati nel Catalogo Unity e accessibili all'utente o al principale del servizio.

Caricare dati tabulari

Usare Spark Connect per caricare dati di Machine Learning tabulari da tabelle Delta.

Per il training a nodo singolo, è possibile convertire i DataFrame Apache Spark in DataFrame pandas utilizzando il metodo PySparktoPandas(), e quindi, facoltativamente, convertire in formato NumPy utilizzando il metodo PySparkto_numpy().

Annotazioni

Spark Connect rinvia l'analisi e la risoluzione dei nomi al tempo di esecuzione, che può modificare il comportamento del codice. Vedi Confronta Spark Connect con Spark Classic.

Spark Connect supporta la maggior parte delle API PySpark, tra cui Spark SQL, API Pandas in Spark, Structured Streaming e MLlib (basata su dataframe). Vedere la documentazione di riferimento dell'API PySpark per le API supportate più recenti.

Per altre limitazioni, vedere Limitazioni di calcolo serverless.

Caricare tabelle Delta di grandi dimensioni usando volumi

Per tabelle Delta di grandi dimensioni troppo grandi per la conversione con toPandas(), esportare i dati in un volume di Catalogo Unity e caricarli direttamente usando PyTorch o 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")

Questo approccio evita il sovraccarico di Spark durante il training e funziona bene sia per i flussi di lavoro di training a GPU singola che per i flussi di lavoro di training distribuiti.

Caricare dati non strutturati dai volumi

Per i dati non strutturati, ad esempio immagini, audio e file di testo, usare i volumi di Unity Catalog. L'esempio seguente illustra come leggere i file da un volume e usarli con 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

Caricare i dati all'interno del decoratore @distributed

Quando si utilizza l'API GPU serverless per l'addestramento distribuito, spostare il codice di caricamento dei dati all'interno del decoratore @distributed. Le dimensioni del dataset possono superare la dimensione massima consentita da pickle, pertanto è consigliabile generare il dataset all'interno del decoratore, come illustrato di seguito:

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

Prestazioni di caricamento dei dati

/Workspace e /Volumes le directory sono ospitate nell'archiviazione remota del catalogo Unity. Se il set di dati viene archiviato in Unity Catalog, la velocità di caricamento dei dati è limitata dalla larghezza di banda di rete disponibile. Se si esegue il training di più periodi, l'approccio consigliato consiste nel copiare i dati in locale, in particolare nella /tmp directory, ospitata in un archivio SSD NVMe veloce.

Se il set di dati è di grandi dimensioni, le tecniche seguenti possono migliorare le prestazioni:

  • Memorizzare nella cache i dati in locale per l'addestramento multi-epoca. Copiare i set di dati in /tmp per un accesso più rapido tra periodi:

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

  • Parallelizzare il recupero dei dati. Usare la torch DataLoader con più ruoli di lavoro per sovrapporre il caricamento dei dati con il calcolo GPU. Impostare num_workers su almeno 2. Per migliorare le prestazioni, aumentare num_workers (aumentando le letture parallele) o prefetch_factor (aumentando il numero di elementi che ogni worker prelettura):

    from torch.utils.data import DataLoader

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

  • Usare Spark Connect per set di dati tabulari di grandi dimensioni. Spark Connect supporta la maggior parte delle API PySpark e gestisce le letture distribuite in modo efficiente.

Set di dati di streaming

Per set di dati di dimensioni molto grandi che non rientrano nella memoria, usare gli approcci di streaming:

  • Last updated on