Crie um Conjunto de Dados para Ajuste Fino a Partir da Web: URLs para JSONL

Um bom ajuste fino é 90% conjunto de dados. Este é o pipeline de URLs brutas para JSONL limpo — obtenção em escala, deduplicação, filtros de licença e o formato de chat que os treinadores realmente esperam.

Um ajuste fino é tão bom quanto os dados que você fornece, e a parte mais difícil do ajuste fino quase nunca é a execução do treinamento — é construir um conjunto de dados limpo. A web é a fonte mais rica desses dados, mas páginas brutas são desorganizadas, duplicadas, não rotuladas e legalmente desiguais. Este guia é o pipeline de URLs para JSONL pronto para treinamento: quanto de dados você realmente precisa, como obtê-los em escala, como limpá-los e deduplicá-los, como lidar com licenciamento e como formatá-los na estrutura de chat que os treinadores esperam. Assume-se que você está construindo um ajuste fino de instrução ou chat a partir de conteúdo público da web.

Quanto de dados você realmente precisa?

Comece com metas realistas para não construir em excesso ou em falta. O mínimo prático para um ajuste fino que produz resultados razoáveis é cerca de 100 linhas; para um desempenho sólido, geralmente você quer mais de 1.000. Mais geralmente ajuda, mas apenas se estiver limpo — mil exemplos bem rotulados superam dez mil ruidosos. Para referência de escala, o clássico conjunto de dados Alpaca tinha 52.000 pares de instrução/saída, gerados ao solicitar um modelo mais forte. E se você estiver usando um modelo grande para gerar exemplos sintéticos, inicie-o com pelo menos dez exemplos escritos à mão para que ele aprenda a estrutura e o tom exatos que você deseja antes de produzir mais.

Obtenção: rastreamento para markdown limpo

O objetivo na etapa de obtenção é texto limpo, não HTML bruto. Uma linha de ajuste fino quer a substância de uma página — o artigo, os documentos, o Q&A — sem as barras de navegação, banners de cookies e marcações de anúncios que poluem uma raspagem ingênua. Portanto, rastreie suas páginas-alvo e converta-as em markdown na ingestão, o que remove o boilerplate enquanto mantém a estrutura como cabeçalhos e listas. Em qualquer volume real, você atingirá limites de taxa e bloqueios de IP, então direcione o rastreamento através de um pool rotativo. Uma Scraper API que retorna markdown diretamente faz ambos os trabalhos — saída limpa e resistência a bloqueios — em uma única chamada, e é por isso que a cobrimos em nosso guia sobre alimentar LLMs com dados frescos da web.

# Sketch: crawl target URLs to clean markdown, ready for shaping into rows.
import requests

API = "https://api.quantumproxies.io/scrape"   # returns markdown, handles rotation

def fetch_markdown(url):
    r = requests.get(API, params={"url": url, "format": "markdown"},
                     headers={"Authorization": "Bearer YOUR_KEY"}, timeout=60)
    return r.json()["markdown"]

docs = [fetch_markdown(u) for u in seed_urls]   # clean text, no boilerplate

O formato JSONL que os treinadores esperam

A maioria das ferramentas modernas de ajuste fino padrão usa um formato JSONL conversacional: um objeto JSON por linha, cada um com um array messages de pares de papel/conteúdo, onde os papéis são system, user e assistant e as alternâncias são entre usuário/assistente. Esse é o formato de chat que os treinadores no estilo Hugging Face e OpenAI ingerem. Conjuntos de dados de instrução mais antigos usam uma forma de três campos (instruction, input, output) — adequado para ajuste fino supervisionado de turno único — e formatos de conversa de múltiplos turnos também existem, mas eles se convertem facilmente no formato de mensagens. Escolha um formato alvo e padronize tudo para ele.

// One training example per line (.jsonl). Chat / messages format:
{"messages":[
  {"role":"system","content":"You classify support tickets by urgency."},
  {"role":"user","content":"My payment failed three times and the event is tomorrow."},
  {"role":"assistant","content":"high"}
]}
{"messages":[
  {"role":"system","content":"You classify support tickets by urgency."},
  {"role":"user","content":"How do I change my avatar?"},
  {"role":"assistant","content":"low"}
]}

Combine o formato com o objetivo de treinamento: texto bruto para pré-treinamento contínuo, instrução mais saída ou chat de múltiplos turnos para ajuste fino supervisionado, respostas classificadas para métodos baseados em preferência. Se você estiver construindo um ajuste fino de raciocínio, mantenha a pergunta e a resposta, mas reescreva a resposta para incluir as etapas de raciocínio que você deseja que o modelo aprenda.

Limpeza: onde a qualidade é conquistada

Esta é a etapa que decide seu resultado, e é principalmente uma filtragem sem glamour. Nunca assuma que linhas obtidas da web ou geradas por modelo estão corretas — inspecione-as. Os modos de falha recorrentes são específicos e vale a pena verificar por nome:

• Inconsistência de rótulo: a mesma categoria escrita como "Positivo" em uma linha e "positivo" em outra — normalize maiúsculas e ortografia.
• Respostas fora do alvo: o assistente retorna uma frase ou uma pergunta de acompanhamento em vez do rótulo ou formato exato para o qual você está treinando.
• Linhas mal rotuladas: uma entrada ambígua atribuída à saída errada — o tipo de ruído mais prejudicial.
• Resíduo de boilerplate: texto de navegação, avisos de cookies ou fragmentos de "leia mais" que sobreviveram à conversão para markdown.
• Duplicatas: exemplos idênticos ou quase idênticos que inflacionam a contagem de linhas e tendem a enviesar o modelo em direção a conteúdo repetido.

Um bom hábito é manter tanto o JSONL pré-limpo quanto o limpo para que você possa medir o que foi removido. E equilibre o conjunto entre categorias — uma classe super-representada ensina o modelo a superestimar.

Deduplicação e licenciamento

Os dados da web estão cheios de repetições — artigos sindicados, documentos espelhados, parágrafos de boilerplate — e duplicatas prejudicam silenciosamente um ajuste fino ao sobrecarregar o que é repetido. Faça duas passagens: deduplicação de correspondência exata ao fazer hash do texto normalizado para capturar linhas idênticas, depois detecção de quase duplicatas (uma técnica de similaridade ou shingling como MinHash) para capturar cópias reescritas que um hash exato perde. Sobre licenciamento, seja deliberado: nem tudo que é público é livremente reutilizável. Acompanhe a fonte e a licença de cada documento, filtre o conteúdo cujos termos proíbem o uso para treinamento e prefira fontes com permissões claras de reutilização. É muito mais barato registrar a proveniência enquanto você rastreia do que reconstruí-la depois de ter misturado tudo.

Fonte de dados limpos da web para LLMs

Combine, registre e divida

Quando você está obtendo de várias fontes, padronize todas para um formato e mescle em um único conjunto de dados unificado antes do treinamento — um ajuste fino limpo no conjunto combinado supera o ajuste fino sequencial em cada fonte, que tende a erodir o que o modelo aprendeu anteriormente. Depois escreva um cartão de conjunto de dados: um breve registro de onde os dados vieram, como foram limpos, seu tamanho e distribuição de rótulos, seu licenciamento e quaisquer limitações conhecidas. É o que torna o conjunto de dados reproduzível e auditável meses depois. Finalmente, reserve uma divisão de avaliação que você nunca treina, para que você possa medir o ajuste fino honestamente em vez de avaliá-lo em dados que ele memorizou. Se você estiver alimentando um sistema de recuperação em vez de um ajuste fino, nosso guia de pipeline RAG cobre o lado de atualização do mesmo problema.

Perguntas frequentes

Quantas linhas eu preciso para ajustar um LLM?

Cerca de 100 linhas é o mínimo prático para resultados razoáveis, e mais de 1.000 é um bom alvo para desempenho sólido. Mais geralmente ajuda, mas apenas se os dados permanecerem limpos — um conjunto menor e bem rotulado supera um grande e ruidoso. Para geração sintética, inicie o gerador com pelo menos dez exemplos escritos à mão para que ele aprenda seu formato exato primeiro.

Em que formato os dados de ajuste fino devem estar?

JSONL — um objeto JSON por linha. A maioria dos treinadores modernos padrão usa um formato conversacional com um array messages de pares de papel-conteúdo de system/user/assistant. Conjuntos de dados de instrução mais antigos usam campos de instrução/input/output. Escolha um formato alvo com base no seu objetivo de treinamento e padronize todas as fontes para ele antes do treinamento.

Como limpo um conjunto de dados raspado para ajuste fino?

Converta páginas para markdown para remover boilerplate, depois filtre manualmente para as falhas comuns: rótulos inconsistentes, respostas fora do alvo, linhas mal rotuladas e texto de navegação ou cookie restante. Deduplicate com um hash exato e uma passagem de quase duplicata, equilibre as categorias e mantenha tanto as versões brutas quanto as limpas para que você possa medir o que foi removido.

Posso usar qualquer conteúdo da web para treinar um modelo?

Não automaticamente — público não significa livremente reutilizável. Alguns conteúdos possuem termos que proíbem o uso para treinamento, e dados pessoais trazem suas próprias regras. Acompanhe a fonte e a licença de cada documento enquanto você os coleta, filtre qualquer coisa cujos termos proíbam o treinamento e prefira fontes com permissões claras. Esta é uma informação geral, não um conselho jurídico; obtenha aconselhamento para conjuntos de dados comerciais.

Construir um conjunto de dados para ajuste fino a partir da web é um pipeline de filtragem: obtenha markdown limpo, molde-o no formato de mensagens que seu treinador espera, deduplicate e verifique rótulos rigorosamente, filtre por licença e registre o resultado. Obtenha aproximadamente mil linhas limpas e reserve uma divisão de avaliação honesta, e você gastará seu orçamento de treinamento em sinal em vez de ruído.

Construa seu conjunto de dados com dados da web QuantumProxies