Partilhar via

Carregar dados no ambiente de execução da IA

Importante

O tempo de execução da IA para tarefas de nó único está em Pré-visualização Pública. A API de treino distribuída para cargas de trabalho multi-GPU permanece em Beta.

Esta secção cobre informações sobre carregamento de dados no AI Runtime, especificamente para aplicações de ML e DL. Consulte o tutorial para saber mais sobre como carregar e transformar dados usando a API Python do Spark.

Observação

O Unity Catalog é obrigatório. Todo o acesso a dados no AI Runtime passa pelo Unity Catalog. As suas tabelas e volumes devem estar registados no Catálogo Unity e acessíveis ao seu utilizador ou principal de serviço.

Carregar dados tabulares

Use o Spark Connect para carregar dados de aprendizagem automática tabulares de tabelas Delta.

Para o treino em nó único, pode converter DataFrames Apache Spark em DataFrames pandas usando o método PySparktoPandas(), e depois, opcionalmente, converter para formato NumPy usando o método PySparkto_numpy().

Observação

O Spark Connect adia a análise e a resolução de nomes para o tempo de execução, o que pode alterar o comportamento do seu código. Consulte Comparar o Spark Connect com o Spark Classic.

O Spark Connect suporta a maioria das APIs PySpark, incluindo Spark SQL, Pandas API no Spark, Structured Streaming e MLlib (baseado em DataFrame). Consulte a documentação de referência da API PySpark para as APIs mais recentes suportadas.

Para outras limitações, consulte as limitações da computação sem servidor.

Carregar grandes tabelas Delta usando volumes

Para tabelas Delta grandes demais para serem convertidas com toPandas(), exporte os dados para um volume do Unity Catalog e carregue-os diretamente usando 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")

Esta abordagem evita a sobrecarga do Spark durante o treino e funciona bem tanto para fluxos de trabalho de treino com GPU única como distribuídos.

Carregar dados não estruturados a partir de volumes

Para dados não estruturados, como imagens, áudio e ficheiros de texto, utilize volumes do Unity Catalog. O exemplo seguinte mostra como ler ficheiros de um volume e usá-los com um 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

Carregue dados no decorador @distributed

Ao usar a API de GPU Serverless para treinamento distribuído, mova o código de carregamento de dados para dentro do decorador @distributed. O tamanho do conjunto de dados pode exceder o tamanho máximo permitido pelo pickle, por isso é recomendado criar o conjunto de dados dentro do decorador, como mostrado abaixo:

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

Desempenho de carregamento de dados

/Workspace e /Volumes os diretórios são alojados em armazenamento remoto do Unity Catalog. Se o seu conjunto de dados estiver armazenado no Unity Catalog, a velocidade de carregamento dos dados é limitada pela largura de banda da rede disponível. Se estiver a realizar o treino em várias épocas, a abordagem recomendada é primeiro copiar os dados localmente, especificamente para o diretório /tmp, que está alojado em armazenamento NVMe SSD rápido.

Se o seu conjunto de dados for grande, as seguintes técnicas podem melhorar o desempenho:

  • Armazene os dados em cache localmente para treino multi-época. Copie conjuntos de dados para /tmp para um acesso mais rápido entre iterações.

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

  • Paralelizar a obtenção de dados. Use o DataLoader da lanterna com múltiplos trabalhadores para sobrepor o carregamento de dados ao cálculo da GPU. Definir num_workers para pelo menos 2. Para melhorar o desempenho, aumentar num_workers (o que aumenta as leituras paralelas) ou prefetch_factor (o que aumenta o número de itens que cada trabalhador precarrega):

    from torch.utils.data import DataLoader

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

  • Use o Spark Connect para grandes conjuntos de dados tabulares. O Spark Connect suporta a maioria das APIs PySpark e gere leituras distribuídas de forma eficiente.

Conjuntos de dados em streaming

Para conjuntos de dados muito grandes que não cabem na memória, utilize abordagens de streaming:

  • Last updated on