CommunityEscrita e Ediçãogithub.com

wshobson/curation-dataset

Prepare, formatte e valide datasets para ajuste fino supervisionado e treinamento de preferência. Use ao converter dados brutos em formato de treinamento, aplicar templates de chat, configurar empacotamento de sequência, gerar dados sintéticos de treinamento ou escrever um cartão de dataset antes de uma execução.

O que é curation-dataset?

Este skill foca na curadoria de datasets para ajuste fino (SFT) e otimização de preferência (DPO, ORPO, KTO, GRPO/RLVR). Ele orienta o usuário na seleção do formato correto de dados de acordo com o método de treinamento, na aplicação de templates de chat com mascaramento de perda (loss masking), e no empacotamento (packing) para reduzir desperdício computacional. Também fornece regras críticas para misturar dados sintéticos com dados reais, evitando colapso de qualidade, e exige a criação de um cartão de dataset com campos obrigatórios (proveniência, contagens, proporção sintético/real, método de dedup, template usado e config de packing). Suporta as principais plataformas de treinamento (TRL, etc.) e é um passo obrigatório antes de iniciar o treinamento propriamente dito, garantindo que o dataset esteja validado e documentado.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/wshobson/agents/tree/main/plugins/llm-finetuning/skills/dataset-curation

Installed? Explore more Escrita e Edição skills: steipete/notion, langchain-ai/langchain, bytedance/podcast-generation · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Curadoria de Dataset

Este skill assume que a seleção-de-método-de-ajuste-fino já foi direcionada para cá — o próximo passo é preparar dados, não escolher um método. O que vem a seguir: seleção de formato pelo método alvo, os mecanismos de template/empacotamento por trás das falhas silenciosas de treinamento mais comuns, regras para misturar dados sintéticos sem colapso, e o cartão de dataset que encerra a Fase 2 antes de uma execução começar.

Entrada: exemplos brutos (demonstrações, julgamentos de preferência ou prompts de tarefa) mais uma decisão de roteamento vinda de seleção-de-método-de-ajuste-fino. Formato de saída: um dataset JSONL formatado, empacotado, validado, mais um cartão de dataset completo — o artefato da Fase 2 que /finetune verifica antes de lançar o treinamento.

Seleção de Formato

MétodoFormaLinhas
SFT, turno únicoInstrução (instrução/resposta ou prompt/completamento)~1.000+ mínimo
SFT, múltiplos turnosLista de mensagens Conversa/ChatML~1.000+ mínimo
DPO / ORPOPar de preferência (prompt, escolhido, rejeitado)Depende do método, veja otimização-de-preferência
KTONão pareado (prompt, completamento, rótulo)Depende do método, veja otimização-de-preferência
GRPO / RLVRApenas prompt (prompt + metadados de verificador)Depende do método, veja treinamento-grpo-rlvr
  • ~1.000+ linhas é o mínimo recomendado para SFT, não um alvo. Abaixo disso, um punhado de exemplos de baixa qualidade ou duplicados pode dominar o gradiente; acima disso, qualidade sobre quantidade — um conjunto menor, verificado e desduplicado, supera um maior e ruidoso.

  • O formato ChatML, para orientação; os outros quatro formatos, mais uma nota de conversão ShareGPT, estão em referências/formatos-e-templates.md:

    {"mensagens": [
      {"papel": "usuário", "conteúdo": "..."},
      {"papel": "assistente", "conteúdo": "..."}
    ]}
    

Templates de Chat e Mascaramento de Perda

Aplique o template de chat do modelo alvo antes de qualquer concatenação ou empacotamento, nunca depois — empacotar texto bruto e aplicar o template no bloco empacotado posteriormente corrompe os limites entre turnos, colocando marcadores de papel no lugar errado em relação a cada exemplo.

  • Treine apenas nas respostas do assistente. Masque a perda (-100 no tensor de rótulos) nas viradas de sistema/usuário e nos próprios marcadores de papel do template — apenas tokens de conteúdo dos turnos do assistente contribuem para a perda.

  • Incompatibilidades template/tokenizador são uma das principais falhas silenciosas. Um modelo treinado com um template de chat, mas servido ou avaliado com outro, degrada sem emitir erros. Verifique se a mesma string de template usada no treinamento é aplicada na inferência e na avaliação.

  • Mantenha o dataset no formato mensagens e deixe o trainer aplicar o template e mascarar (perda_apenas_assistente=True no TRL atual) — pré-renderizar para um campo de texto simples destrói os limites de turno que o mascaramento precisa. Esboço completo do código: referências/formatos-e-templates.md. Faça uma verificação de sanidade antes do treinamento — decodifique apenas posições não mascaradas; espere apenas texto do assistente:

    manter = lote["rótulos"][0] != -100
    print(tokenizador.decodificar(lote["ids_entrada"][0][manter]))
    

Empacotamento

Sem empacotamento, 40–70% do computacional é gasto em preenchimento — exemplos de comprimento variável agrupados em um comprimento de sequência fixo desperdiçam a lacuna entre o comprimento de cada exemplo e o máximo do lote. O empacotamento concatena vários exemplos em uma sequência até o comprimento máximo, cortando a maior parte desse desperdício.

  • O empacotamento altera a semântica do lote. Uma sequência empacotada pode conter vários exemplos originais, então "passos por época" e qualquer agenda de taxa de aprendizado baseada na contagem de exemplos muda quando o empacotamento é ativado — recalcule os marcos da agenda em relação à contagem de sequências empacotadas.

  • OBRIGATÓRIO: decodifique e inspecione manualmente 5–10 sequências empacotadas antes de escalar para uma execução completa. Confirme que os limites dos exemplos estão onde esperado, que os marcadores de template estão intactos por sub-exemplo, e que a máscara de perda ainda é apenas do assistente dentro de cada sequência empacotada. Não é opcional — bugs de empacotamento são silenciosos (a curva de perda parece normal) e só aparecem na qualidade da avaliação, horas depois:

    for seq in dataset_empacotado.selecionar(intervalo(10)):
        print(tokenizador.decodificar(seq["ids_entrada"]))
    

Regras para Dados Sintéticos

  • Mantenha ≥25% de dados reais como proteção contra colapso. Treinar com uma parcela crescente de dados gerados por modelo sem um piso de dados reais leva a um colapso de qualidade mensurável ao longo de gerações sucessivas — 25% reais é o mínimo que segura a linha. Linhas de repetição de domínio geral contam para este piso — "real" significa "não gerado para esta tarefa a partir deste aluno," não "escrito por humano." Um dataset totalmente sintético por construção pode atender ao piso de ≥25% apenas através de repetição (veja a receita de Construção de Mistura com Repetição em referências/dados-sintéticos.md); declare quais linhas contam como "reais" no cartão do dataset em vez de deixar o piso estruturalmente inatingível.
  • Magpie e amostragem por rejeição são os cavalos de batalha. Magpie extrai prompts do template anterior do próprio modelo; a amostragem por rejeição gera vários candidatos por prompt e mantém apenas aqueles que passam em um filtro. Ambos superam a geração ingênua de tiro único.
  • Geração direcionada e ciente do aluno supera a geração estática em 1.3–2x de eficiência de amostragem — mirando nos modos de falha reais do aluno atinge um patamar de qualidade com menos exemplos filtrados.
  • Taxas de aceitação típicas após filtragem ficam em 10–30%. Planeje o volume de acordo — um alvo de 10.000 linhas com 15% de aceitação precisa de ~65.000+ gerações brutas.
  • Classificação de métodos de geração, funil de filtro, construção de mistura com repetição e padrão de destilação: referências/dados-sintéticos.md.

O Cartão do Dataset

Todo dataset que chega ao treinamento recebe um cartão — o artefato obrigatório da Fase 2 que /finetune verifica antes de lançar. O cartão não é documentação livre; ele DEVE conter estes campos:

  • Proveniência — de onde veio cada linha (fonte(s) real(is), método(s) sintético(s), ou ambos), rastreável até a saída de rastrear-para-dados-de-treinamento.
  • Contagens — total de linhas e linhas por divisão (treino/avaliação/separado) se dividido.
  • Proporção sintético/real — a proporção medida, verificada contra o piso de ≥25% reais acima.
  • Método de dedup — correspondência exata, semântica (limiar de incorporação), ou ambos; veja o funil de filtro em referências/dados-sintéticos.md.
  • Template usado — a string/identificador exato do template de chat, mantido consistente durante a inferência e avaliação — é isso que vincula uma execução de avaliação-primeiro ao checkpoint.
  • Configuração de empacotamento — se o empacotamento foi usado, comprimento máximo de sequência e confirmação de que a inspeção manual de 5–10 sequências acima foi feita.

Um dataset que não tenha algum desses seis campos não está pronto para /finetune — o cartão é uma porta, não um resumo escrito depois do fato.

Lista de Verificação de Saída da Fase 2

Antes de passar para /finetune, confirme:

  1. Formato corresponde ao método (tabela acima).
  2. Template aplicado antes da concatenação.
  3. Perda mascarada apenas para turnos do assistente.
  4. 5–10 sequências empacotadas decodificadas e lidas.
  5. ≥25% de dados reais na mistura final.
  6. Cartão do dataset completo — todos os seis campos.

Referências

  • referências/formatos-e-templates.md — exemplos JSONL por formato, código de mascaramento do TRL atual e a nota de conversão ShareGPT.
  • referências/dados-sintéticos.md — classificação de métodos de geração, funil de filtro, construção de mistura com repetição e padrão de destilação professor→aluno.

Skills relacionados: seleção-de-método-de-ajuste-fino roteia para cá; lora-qlora-receitas, visão-sft e otimização-de-preferência consomem os datasets que este skill produz; rastrear-para-dados-de-treinamento é a fonte de proveniência para datasets de trajetória graduada; avaliação-primeiro avalia o checkpoint resultante.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

wshobson/accessibility-compliance

Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Use when auditing accessibility, implementing ARIA patterns, building for screen readers, or ensuring inclusive user experiences.

wshobson/airflow-dag-patterns

Build production Apache Airflow DAGs with best practices for operators, sensors, testing, and deployment. Use when creating data pipelines, orchestrating workflows, or scheduling batch jobs.

wshobson/angular-migration

Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code.

wshobson/anti-reversing-techniques

Understand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use this skill when analyzing malware evasion techniques, when implementing anti-debugging protections for CTF challenges, when reverse engineering packed binaries, or when building security research tools that need to detect virtualized environments.

wshobson/api-design-principles

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

wshobson/architecture-decision-records

Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.

wshobson/architecture-patterns

Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing clean architecture for a new microservice, when refactoring a monolith to use bounded contexts, when implementing hexagonal or onion architecture patterns, or when debugging dependency cycles between application layers.

wshobson/async-python-patterns

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

wshobson/attack-tree-construction

Build comprehensive attack trees to visualize threat paths. Use when mapping attack scenarios, identifying defense gaps, or communicating security risks to stakeholders.

wshobson/auth-implementation-patterns

Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when implementing auth systems, securing APIs, or debugging security issues.

wshobson/avoid-ai-writing

Audit and rewrite prose so it stops reading as machine-generated. Use this skill when asked to remove AI-isms, clean up AI writing, edit a draft for AI tells, audit a README, changelog, release note, PR description, or blog post for machine-sounding prose, or make text sound less like AI. Supports a detect-only mode, a rewrite mode, and an edit-in-place mode, with optional voice and context profiles.

wshobson/backtesting-frameworks

Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.

wshobson/bash-defensive-patterns

Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety.

wshobson/bats-testing-patterns

Master Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring test-driven development of shell utilities.

wshobson/bazel-build-optimization

Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases.

wshobson/before-you-build

Pre-build product and feature risk review for founders, product managers, and AI-assisted builders. Use this skill when the user is about to build a landing page, MVP, SaaS product, internal tool, agent workflow, or major feature and needs to check demand, positioning, monetization, retention, trust, distribution, and adoption risk before implementation starts.

wshobson/billing-automation

Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing, automating invoicing, or managing recurring payment systems.

wshobson/binary-analysis-patterns

Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries.

wshobson/block-no-verify-hook

Configure a PreToolUse hook to prevent AI agents from skipping git pre-commit hooks with --no-verify and other bypass flags. Use when setting up Claude Code projects that enforce commit quality gates.

wshobson/brand-landingpage

Brand-first landing page designer — runs a brand-identity interview (colors, typography, shape language), then generates and iterates on a polished landing page via Stitch with deployment-ready HTML. Use when the user asks to create, design, or build a landing page, homepage, or marketing page and has no established visual direction. Skip when they have a design mockup, need a dashboard or app UI, are working at component level, building a multi-page app, or restyling with known design tokens — use frontend-design instead.

Habilidades Relacionadas