Data Pipeline para LLMs

Pipeline de curadoria de dados em escala: crawler, deduplicação, filtragem de qualidade, PII scrubbing. Atualizado em abril de 2026.

Visão Geral

A qualidade dos dados de treino é o fator #1 de performance de um LLM. Um modelo treinado em 1T de tokens bem curados supera um modelo treinado em 5T de tokens sujos.

O pipeline típico tem 5 etapas:

Coleta → Deduplicação → Filtragem → PII Scrubbing → Formatação Final

Cada etapa reduz o volume mas aumenta drasticamente a qualidade.

Etapa 1: Coleta (Crawler)

Fontes de dados

CommonCrawl

O CommonCrawl é a fonte primária de dados web.每个月 (~1B páginas, ~5PB raw).

*ipeline típico:*

WARC files (raw) → WET files (texto extraído) → Filtragem → Dedup → Limpo

*erramentas:*

• *c_net*(Facebook) — pipeline completo de CC para treino
• *atatrove*(HuggingFace) — pipeline modular em Python
• *esiliparse*— extração de texto de HTML rápido (Rust)
• *rafilatura*— extração de conteúdo principal de páginas web

Para código

*ara o Kode:*The Stack v2 é a melhor fonte de código — já filtrado, deduplicado, com metadados de licença.

Etapa 2: Deduplicação

Deduplicação é a etapa mais subestimada e mais importante. Dados duplicados causam:

• *verfitting*— o modelo memoriza em vez de generalizar
• *iés*— textos repetidos pesam mais no gradiente
• *neficiência*— compute gasto processando a mesma informação

Níveis de deduplicação

MinHash + LSH (Near-Deduplicação)

A técnica padrão-ouro da indústria (usada por RefinedWeb, FineWeb, RedPajama):

1. Shingling: dividir documento em shingles de n-grams (ex: 5-grams de palavras)
2. MinHash: aplicar ~200 hash functions, pegar o mínimo de cada → assinatura de 200 ints
3. LSH (Locality Sensitive Hashing): agrupar assinaturas similares em buckets
4. Comparar dentro de buckets: Jaccard similarity > 0.8 → duplicata

*erformance:*Processa 100B de documentos em ~24 horas com 64 cores.

*erramentas:*

• *atasketch*(Python) — implementação de MinHash + LSH
• *ext-dedup*(HuggingFace) — pipeline completo de deduplicação
• *ineweb deduplication*— referência de implementação

Resultados típicos

*egra prática:*espere remover 30–40% do dataset apenas com deduplicação.

Etapa 3: Filtragem de Qualidade

Após deduplicação, filtrar o que sobra para remover lixo:

Filtros heurísticos

Filtros baseados em modelo

Pipeline de filtragem do RefinedWeb (Falcon)

Referência da indústria:

1. Filtro por URL: remover domains de baixa qualidade
2. Filtro heurístico: comprimento, repetição, boilerplate
3. Filtro de idioma: fastText (manter apenas inglês, espanhol, etc.)
4. Filtro de qualidade: classifier treinado em Wikipedia vs spam
5. Filtro de PII: regex + NER
6. Deduplicação: MinHash + LSH no final

*esultado:*De 5PB de CommonCrawl bruto → 1.8T tokens de alta qualidade.

Etapa 4: PII Scrubbing

PII (Personally Identifiable Information) inclui:

• Nomes completos
• Endereços de email
• Números de telefone
• CPFs, RGs, documentos
• Endereços físicos
• Números de cartão de crédito
• IPs

Técnicas

Microsoft Presidio

from presidio_analyzer import AnalyzerEngine
from presidio_anonymizer import AnonymizerEngine

analyzer = AnalyzerEngine()
anonymizer = AnonymizerEngine()

text = "Meu email é rodrigo@koder.dev e meu CPF é 123.456.789-00"
results = analyzer.analyze(text=text, entities=["EMAIL_ADDRESS", "BR_CPF"], language='pt')
anonymized = anonymizer.anonymize(text=text, analyzer_results=results)
# "Meu email é <EMAIL_ADDRESS> e meu CPF é <BR_CPF>"

*ara o Kode:*Usar Presidio com entidades customizadas para o Brasil (CPF, CNPJ, RG, telefone BR).

Redução de qualidade por PII scrubbing

Scrubbing agressivo pode remover contexto valioso. Exemplo:

• "rodrigo@koder.dev" → "<EMAIL>" (ok, não perdemos nada)
• "John Smith wrote a paper" → "<PERSON> wrote a paper" (perdemos o nome, mas a frase ainda faz sentido)

*stratégia recomendada:*

1. Redact PII sensível (emails, CPFs, telefones) → substituir por placeholder
2. Para nomes próprios em contexto genérico → manter (não é PII se não identificar alguém específico)
3. Documentar o que foi scrubbed para auditoria

Etapa 5: Formatação Final

Tokenização e empacotamento

Textos limpos → Tokenização (BPE/SentencePiece) → Sequências de tokens
                                                   ↓
                                    Empacotamento (packing)
                                                   ↓
                                    Arquivos .bin ou .parquet

*acking vs. Padding:*

• *acking:*Concatenar documentos curtos até填满 o context window (sem waste)
• *adding:*Preencher documentos curtos com tokens de padding (waste de compute)

*acking é preferível*— até 30% mais eficiente em compute.

Formatos de armazenamento

Ferramentas e Frameworks

datatrove (HuggingFace)

Pipeline modular para processamento de dados em escala:

from datatrove.pipeline import (
    DocumentTokenizer,
    MinhashDedupSignature,
    MinhashDedupCluster,
    QualityFilter,
    PIIExtraction,
)

pipeline = [
    DocumentTokenizer(),
    MinhashDedupSignature(num_permutations=200),
    MinhashDedupCluster(threshold=0.8),
    QualityFilter(min_length=50, max_length=100000),
    PIIExtraction(),
]

*antagens:*Modular, escalável (Spark/Ray), open-source.

cc_net (Facebook)

Pipeline completo de CommonCrawl → dataset de treino:

• Extração de texto de WARC/WET
• Filtragem por idioma, qualidade, comprimento
• Deduplicação
• Tokenização

RedPajama Data Pipeline

Código aberto do pipeline que gerou o RedPajama v2 (30T tokens):

• GitHub: togethercomputer/RedPajama-Data
• Inclui scripts de crawling, filtragem, dedup

Spark + Ray

Para escala massiva (10T+ tokens):

• *pache Spark*— processamento distribuído batch
• *ay Data*— pipeline moderno, mais fácil que Spark

Métricas de Qualidade do Dataset

Para o Kode

Pipeline recomendado

Para construir o dataset de treino do Kode:

Fase 1: Coleta (1–2 semanas)
  → The Stack v2 (código) — já curado
  → CommonCrawl + cc_net (texto geral)
  → Documentação técnica (docs de libs, frameworks)

Fase 2: Deduplicação (3–5 dias)
  → MinHash + LSH (threshold 0.8)
  → Remover near-duplicatas cross-fonte

Fase 3: Filtragem (2–3 dias)
  → Heurísticas: comprimento, repetição, boilerplate
  → Language ID: manter Português + Inglês
  → Quality classifier: filtrar spam, lixo

Fase 4: PII Scrubbing (1 dia)
  → Presidio com entidades BR customizadas
  → Redact emails, CPFs, telefones

Fase 5: Tokenização e Packing (2–3 dias)
  → Tokenizer do Qwen2.5 ou Llama 3
  → Packing com context window de 8K–32K
  → Formato: Parquet para storage, MDS para treino

Estimativa de volume

Hardware para o pipeline

*usto total estimado:*R$ 5–15K (principalmente banda larga e storage).

Papers e Referências