Phase 00 - Lesson 09

Gerenciamento de Dados

Os dados são o combustível. Como você os gerencia determina a sua velocidade.

Tipo: Build Linguagem: Python Pré-requisitos: Fase 0, Lição 01 Tempo: ~45 minutos

Objetivos de Aprendizagem

• Carregar, transmitir (stream) e cachear datasets usando a biblioteca datasets da Hugging Face
• Converter entre os formatos CSV, JSON, Parquet e Arrow e explicar seus tradeoffs
• Criar splits de treino/validação/teste reprodutíveis com seeds aleatórias fixas
• Gerenciar arquivos grandes de modelos e datasets usando .gitignore, Git LFS ou DVC

O Problema

Todo projeto de IA começa com dados. Você precisa encontrar datasets, baixá-los, converter entre formatos, dividi-los para treinamento e avaliação, e versioná-los para que os experimentos sejam reprodutíveis. Fazer isso manualmente toda vez é lento e propenso a erros. Você precisa de um fluxo de trabalho repetível.

O Conceito

graph TD
    A["Hugging Face Hub"] --> B["datasets library"]
    B --> C["Load / Stream"]
    C --> D["Local Cache<br/>~/.cache/huggingface/"]
    B --> E["Format Conversion<br/>CSV, JSON, Parquet, Arrow"]
    E --> F["Data Splits<br/>train / val / test"]
    F --> G["Your Training Pipeline"]

A biblioteca datasets da Hugging Face é a forma padrão de carregar dados para o trabalho com IA. Ela lida com download, cache, conversão de formato e streaming de forma nativa.

Mãos à Obra

Passo 1: Instalar a biblioteca datasets

pip install datasets huggingface_hub

Passo 2: Carregar um dataset

from datasets import load_dataset

dataset = load_dataset("imdb")
print(dataset)
print(dataset["train"][0])

Isso baixa o dataset de avaliações de filmes IMDB. Após o primeiro download, ele carrega do cache em ~/.cache/huggingface/datasets/.

Passo 3: Transmitir datasets grandes

Alguns datasets são grandes demais para caber em disco. O streaming os carrega linha por linha sem baixar a coisa toda.

dataset = load_dataset("wikimedia/wikipedia", "20220301.en", split="train", streaming=True)

for i, example in enumerate(dataset):
    print(example["title"])
    if i >= 4:
        break

O streaming fornece um IterableDataset. Você processa as linhas conforme elas chegam. O uso de memória permanece constante independentemente do tamanho do dataset.

Passo 4: Formatos de dataset

A biblioteca datasets usa o Apache Arrow por baixo dos panos. Você pode converter para outros formatos dependendo do que seu pipeline precisa.

dataset = load_dataset("imdb", split="train")

dataset.to_csv("imdb_train.csv")
dataset.to_json("imdb_train.json")
dataset.to_parquet("imdb_train.parquet")

Comparação de formatos:

Para o trabalho com IA, o Parquet é o melhor formato de armazenamento. O Arrow é o que você trabalha em memória. CSV e JSON são para intercâmbio.

Passo 5: Splits de dados

Todo projeto de ML precisa de três splits:

• Treino: O modelo aprende com isso (normalmente 80%)
• Validação: Você verifica o progresso durante o treinamento (normalmente 10%)
• Teste: Avaliação final após o treinamento concluído (normalmente 10%)

Alguns datasets já vêm divididos. Quando não vêm, divida-os você mesmo:

dataset = load_dataset("imdb", split="train")

split = dataset.train_test_split(test_size=0.2, seed=42)
train_val = split["train"].train_test_split(test_size=0.125, seed=42)

train_ds = train_val["train"]
val_ds = train_val["test"]
test_ds = split["test"]

print(f"Train: {len(train_ds)}, Val: {len(val_ds)}, Test: {len(test_ds)}")

Sempre defina uma seed para reprodutibilidade. A mesma seed produz o mesmo split toda vez.

Passo 6: Baixar e cachear modelos

Modelos são arquivos grandes. A biblioteca huggingface_hub lida com download e cache.

from huggingface_hub import hf_hub_download, snapshot_download

model_path = hf_hub_download(
    repo_id="sentence-transformers/all-MiniLM-L6-v2",
    filename="config.json"
)
print(f"Cached at: {model_path}")

model_dir = snapshot_download("sentence-transformers/all-MiniLM-L6-v2")
print(f"Full model at: {model_dir}")

Os modelos são cacheados em ~/.cache/huggingface/hub/. Uma vez baixados, eles carregam instantaneamente em execuções subsequentes.

Passo 7: Lidar com arquivos grandes

Pesos de modelos e datasets grandes não devem ir para o git. Três opções:

Opção A: .gitignore (mais simples)

*.bin
*.safetensors
*.pt
*.onnx
data/*.parquet
data/*.csv
models/

Opção B: Git LFS (versionar arquivos grandes no git)

git lfs install
git lfs track "*.bin"
git lfs track "*.safetensors"
git add .gitattributes

O Git LFS armazena ponteiros no seu repositório e os arquivos reais em um servidor separado. O GitHub te dá 1 GB grátis.

Opção C: DVC (controle de versão de dados)

pip install dvc
dvc init
dvc add data/training_set.parquet
git add data/training_set.parquet.dvc data/.gitignore
git commit -m "Track training data with DVC"

O DVC cria pequenos arquivos .dvc que apontam para os seus dados. Os dados em si ficam no S3, GCS ou outro backend de armazenamento remoto.

Para este curso, o .gitignore é suficiente. Use o DVC quando precisar reproduzir experimentos exatos entre máquinas.

Passo 8: Padrões de armazenamento

Armazenamento local funciona para datasets abaixo de ~10 GB. O cache da HF lida com isso automaticamente.

Armazenamento na nuvem é para qualquer coisa maior ou compartilhada entre máquinas:

import os

local_path = os.path.expanduser("~/.cache/huggingface/datasets/")

# s3_path = "s3://my-bucket/datasets/"
# gcs_path = "gs://my-bucket/datasets/"

O DVC integra-se diretamente com S3 e GCS:

dvc remote add -d myremote s3://my-bucket/dvc-store
dvc push

Para este curso, o armazenamento local é suficiente. O armazenamento na nuvem se torna relevante quando você faz fine-tuning em instâncias GPU remotas.

Datasets Usados Neste Curso

Você não precisa baixar todos esses agora. Cada lição especifica o que precisa.

Use Isso

Rode o script utilitário para verificar se tudo funciona:

python code/data_utils.py

Isso baixa um dataset pequeno, converte-o, divide-o e imprime um resumo.

Entregue (Ship It)

Esta lição produz:

• code/data_utils.py - utilitário reutilizável de carregamento e cache de dados
• outputs/prompt-data-helper.md - prompt para encontrar o dataset certo para uma tarefa

Exercícios

1. Carregue o dataset glue com a config mrpc e inspecione os 5 primeiros exemplos
2. Faça streaming do dataset c4 e conte quantos exemplos você consegue processar em 10 segundos
3. Converta um dataset para Parquet e compare o tamanho do arquivo com o CSV
4. Crie um split de treino/validação/teste 70/15/15 com uma seed fixa e verifique os tamanhos

Termos-Chave