Dela via

Ladda data i AI Runtime

Viktigt!

AI Runtime för aktiviteter med en nod finns i offentlig förhandsversion. Det distribuerade tränings-API:et för multi-GPU-arbetsbelastningar finns kvar i Beta.

Det här avsnittet beskriver information om inläsning av data på AI Runtime specifikt för ML- och DL-program. Läs självstudien för att lära dig mer om hur du läser in och transformerar data med hjälp av Spark Python API:et.

Anmärkning

Unity Catalog krävs. All dataåtkomst på AI Runtime går via Unity Catalog. Dina tabeller och datavolymer måste vara registrerade i Unity Catalog och vara tillgängliga för din användare eller tjänstens huvudnamn (service principal).

Läsa in tabelldata

Använd Spark Connect för att läsa in tabellbaserade maskininlärningsdata från Delta-tabeller.

För träning med en nod kan du konvertera Apache Spark DataFrames till Pandas DataFrames med pyspark-metodentoPandas() och sedan konvertera till NumPy-format med pyspark-metodento_numpy().

Anmärkning

Spark Connect skjuter upp analys och namnupplösning till exekveringstid, vilket kan förändra hur din kod beter sig. Se Jämför Spark Connect med Spark Classic.

Spark Connect stöder de flesta PySpark-API:er, inklusive Spark SQL, Pandas API på Spark, Structured Streaming och MLlib (DataFrame-baserad). Se referensdokumentationen för PySpark API för de senaste API:erna som stöds.

Andra begränsningar finns i Begränsningar för serverlös beräkning.

Ladda stora Delta-tabeller med hjälp av volymer

För stora Delta-tabeller som är för stora för att konvertera med toPandas()exporterar du data till en Unity Catalog-volym och läser in dem direkt med PyTorch eller 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")

Den här metoden undviker Spark-omkostnader under träning och fungerar bra för både arbetsflöden för enskild GPU och distribuerad utbildning.

Läsa in ostrukturerade data från volymer

För ostrukturerade data, till exempel bilder, ljudfiler och textfiler, använder du Unity Catalog-volymer. I följande exempel visas hur du läser filer från en volym och använder dem med en 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

Läs in data i dekoratören @distributed

När du använder det serverlösa GPU-API: et för distribuerad träning flyttar du datainläsningskoden i @distributed dekoratören. Datamängdens storlek kan överskrida den maximala storlek som tillåts av pickle, så vi rekommenderar att du genererar datamängden inuti dekoratören enligt nedan:

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

Datainläsningsprestanda

/Workspace och /Volumes kataloger finns på fjärransluten Unity Catalog-lagring. Om din datauppsättning lagras i Unity Catalog begränsas datainläsningshastigheten av den tillgängliga nätverksbandbredden. Om du tränar flera epoker är den rekommenderade metoden att först kopiera data lokalt, särskilt till /tmp katalogen, som finns på snabb NVMe SSD-lagring.

Om datamängden är stor kan följande tekniker förbättra prestandan:

  • Buffra data lokalt för träning över flera epoker. Kopiera datauppsättningar till /tmp för snabbare åtkomst mellan epoker:

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

  • Parallellisera datahämtning. Använd torch DataLoader med flera workers för att datainläsning ska ske samtidigt som GPU-beräkning. Ange num_workers till minst 2. För att förbättra prestandan, öka antingen num_workers (vilket ökar antalet parallella läsningar) eller prefetch_factor (vilket ökar antalet objekt som varje arbetsenhet läser in i förväg).

    from torch.utils.data import DataLoader

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

  • Använd Spark Connect för stora tabelldatauppsättningar. Spark Connect stöder de flesta PySpark-API:er och hanterar distribuerade läsningar effektivt.

Strömmande datauppsättningar

För mycket stora datamängder som inte får plats i minnet använder du strömningsmetoder:

  • Last updated on