Pular para o conteúdo principal
Última atualização em

Carregar dados no AI Runtime

info

Pré-visualização pública

Runtime AI para tarefas de nó único está em versão prévia pública. A API de treinamento distribuído para cargas de trabalho com múltiplas GPUs permanece em versão Beta.

Esta seção aborda informações sobre o carregamento de dados no AI Runtime , especificamente para aplicações de aprendizado ML e aprendizado profundo (DL). Confira o tutorial para saber mais sobre como carregar e transformar dados usando a API Spark Python .

nota

É necessário o Unity Catalog. Todo o acesso a dados no AI Runtime é feito através do Unity Catalog. Suas tabelas e volumes devem estar registrados no Unity Catalog e acessíveis ao seu usuário ou entidade de serviço.

Carregar dados tabulares​

Utilize Spark Connect para carregar dados tabulares machine learning a partir de tabelasDelta.

Para treinamento de nó único, você pode converter DataFrames Apache Spark em DataFrames Pandas usando o métodoPySpark toPandas() e, opcionalmente, converter para o formato NumPy usando o métodoPySpark to_numpy().

nota

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

Spark Connect é compatível com a maioria APIs PySpark , incluindo Spark SQL, Pandas API on Spark, transmissão estruturada e MLlib (baseada em DataFrame). Consulte a documentação de referência da API PySpark para obter informações sobre as APIs suportadas mais recentes.

Para outras limitações, consulte Limitações compute sem servidor.

Carregar tabelas Delta grandes usando volumes​

Para tabelas Delta grandes demais para serem convertidas com toPandas(), exporte os dados para um volume Unity Catalog e carregue-os diretamente usando PyTorch ou Hugging Face:

Python
# 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)
Python
# 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 Spark durante o treinamento e funciona bem tanto para treinamento com uma única GPU quanto para treinamento distribuído com fluxo de trabalho.

Carregar dados não estruturados de volumes​

Para dados não estruturados, como imagens, arquivos de áudio e texto, use volumes Unity Catalog . O exemplo a seguir mostra como ler arquivos de um volume e usá-los com o PyTorch Dataset:

Python
# 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 dentro do decorador @distributed​

Ao usar a APIde GPU sem servidor para treinamento distribuído, mova o código de carregamento de dados para dentro do decorador @distributed . O tamanho dataset pode exceder o tamanho máximo permitido pelo pickle, portanto, recomenda-se gerar o dataset dentro do decorador, conforme mostrado abaixo:

Python
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 os diretórios /Volumes estão hospedados no armazenamento remoto Unity Catalog . Se o seu dataset estiver armazenado no Unity Catalog, a velocidade de carregamento dos 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 diretório /tmp , que está hospedado em armazenamento SSD NVMe rápido.

Se o seu dataset for grande, as seguintes técnicas podem melhorar o desempenho:

  • Armazene dados em cache localmente para treinamento com múltiplas épocas. Copie o conjunto de dados para /tmp para acesso mais rápido entre épocas:

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

  • Paralelizar a busca de dados. Utilize o DataLoader do PyTorch com múltiplos workers para sobrepor o carregamento de dados com a computação em GPU. Defina num_workers com 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 worker pré-busca):

    Python
    from torch.utils.data import DataLoader

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

  • Utilize Spark Connect para conjuntos de dados tabulares de grande porte. O Spark Connect é compatível com a maioria das APIs do PySpark e lida com leituras distribuídas de forma eficiente.

Conjunto de dados Me​

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