Compartilhar via

Carregar dados no AI Runtime

Importante

O AI Runtime para tarefas de nó único está na Visualização Pública. A API de treinamento distribuído para cargas de trabalho de várias GPUs permanece em Beta.

Esta seção aborda informações sobre o carregamento de dados no AI Runtime especificamente para aplicativos ML e DL. Verifique o tutorial para saber mais sobre como carregar e transformar dados usando a API do Python do Spark.

Observação

O Catálogo do Unity é necessário. Todo o acesso a dados no AI Runtime passa pelo Catálogo do Unity. Suas tabelas e volumes devem ser registrados no Catálogo do Unity e acessíveis para seu usuário ou entidade de serviço.

Carregar dados de tabela

Use o Spark Connect para carregar dados de machine learning tabulares de tabelas Delta.

Para o treinamento de nó único, você pode converter DataFrames do Apache Spark em DataFrames pandas usando o método PySpark e, opcionalmente, converter para formato NumPy usando o método PySpark.

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 código. Consulte Comparar o Spark Connect com o Spark Classic.

O Spark Connect dá suporte à maioria das APIs do PySpark, incluindo o Spark SQL, a API do Pandas no Spark, o Streaming Estruturado e o MLlib (baseado em DataFrame). Consulte a documentação de referência da API do PySpark para obter as APIs mais recentes com suporte.

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

Carregar tabelas Delta grandes usando volumes

Para tabelas Delta que são grandes demais para serem convertidas 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")

Essa abordagem evita a sobrecarga associada ao Spark durante o treinamento e funciona bem tanto para fluxos de trabalho de treinamento com um único GPU quanto para distribuídos.

Carregar dados não estruturados de volumes

Para dados não estruturados, como imagens, áudio e arquivos de texto, use volumes do Catálogo do Unity. O exemplo a seguir mostra como ler arquivos 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

Carregar dados no decorador @distributed

Ao usar a API de GPU sem servidor para treinamento distribuído, mova o código de carregamento de dados no decorador @distributed. O tamanho do conjunto de dados pode exceder o tamanho máximo permitido pelo pickle, assim, é recomendável gerar o conjunto de dados dentro do decorador, conforme 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 diretórios são hospedados no armazenamento remoto do Unity Catalog. Se o conjunto de dados estiver armazenado no Catálogo do Unity, a velocidade de carregamento de dados será limitada pela largura de banda de rede disponível. Se você estiver treinando várias épocas, a abordagem recomendada é primeiro copiar os dados localmente, especificamente para o /tmp diretório, que está hospedado no armazenamento rápido do SSD NVMe.

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

  • Armazenar dados em cache localmente para treinamento de várias épocas. Copie os conjuntos de dados para /tmp para um acesso mais rápido durante os períodos:

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

  • Paralelizar a busca de dados. Use o DataLoader do torch com múltiplos trabalhadores para sobrepor o carregamento de dados com a computação de GPU. Defina num_workers como pelo menos 2. Para melhorar o desempenho, aumente num_workers (o que aumenta as leituras paralelas) ou prefetch_factor (o que aumenta o número de itens que cada trabalhador pré-busca):

    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 dá suporte à maioria das APIs do PySpark e manipula leituras distribuídas com eficiência.

Conjuntos de dados de streaming

Para conjuntos de dados muito grandes que não se encaixam na memória, use abordagens de streaming:

  • Last updated on