Dataset LoRA automatizado: extrair, filtrar, etiquetar

TL;DR

• Extraia I-frames de episódios de anime com ffmpeg -vf select=eq(pict_type\,I) — eles se alinham bem com keyframes de animação e fornecem milhares de imagens candidatas.
• Etiquete frames automaticamente com DeepDanbooru (modelo TensorFlow treinado em dados do Danbooru 2021) usando load_model_from_project, load_tags_from_project e load_image_for_evaluate; filtre por tags do Booru (1girl, red_hair, nomes de personagens) para isolar um único personagem.
• Reduza a pasta resultante a 20–50 imagens diversas: remova personagens errados, cenas multi-personagem, sequências duplicadas, frames de OP/ED, in-betweens e recortes de baixa qualidade.
• Alternativamente, gere conjuntos sintéticos com ChatGPT Plus / DALL-E 3 usando um template de prompt com placeholder [SUBJECT]; espere nomes de arquivo longos e grids ocasionais na saída.

Por que a automação importa

Treinar um LoRA de personagem começa com um dataset. Selecionar e legendar 30–50 imagens manualmente do zero é tedioso o bastante para que muitos desistam. Existem dois caminhos de automação:

1. Vídeo → frames → tags → filtro → poda — transforme uma série de anime em dataset específico de personagem.
2. Template de prompt → DALL-E 3 → download → renomear → curadoria — sintetize um dataset de conceito do zero.

Ambos produzem uma pasta de imagens emparelhadas com arquivos .txt de legenda. Frames extraídos são on-model mas ruidosos; imagens geradas são limpas mas podem derivar off-model. Escolha o caminho que combina com seu material de origem. A escolha entre os caminhos depende do seu material de origem. Se você já tem arquivos de episódios de anime no disco, o Caminho A produzirá imagens autenticamente on-model. Se você quer algo que ainda não existe como referência — um conceito customizado, um estilo de objeto específico, ou um personagem dos seus próprios designs — o Caminho B permite gerar dados de treino a partir de uma descrição textual. Ambas as abordagens escalam de forma diferente: o Caminho A é limitado pelos episódios que você possui; o Caminho B é limitado apenas pela sua paciência com limites de taxa por requisição.

Caminho A: Vídeo de anime para dataset de personagem

Requisitos

• ffmpeg — no PATH.
• Python 3.8+ — para os scripts de orquestração.
• Arquivos de vídeo — MKV/MP4/WebM sem legendas gravadas no vídeo. Se você consegue desligar as legendas no seu player, está bom.
• Espaço em disco — uma série de 12 episódios 1080p pode gerar dezenas de gigabytes de keyframes PNG; o tamanho real depende das configurações de GOP na codificação da fonte. O autor do guia original estimou cerca de 30 GB para uma série típica de 12 episódios 1080p.

Extrair apenas I-frames

Codecs de vídeo armazenam frames completos (I-frames) em mudanças de cena e em intervalos regulares de GOP. Keyframes de anime — os desenhos que definem uma pose — frequentemente coincidem com essas mudanças de cena. O filtro select mantém apenas I-frames:

ffmpeg -i episode.mkv -vf "select=eq(pict_type\,I)" -vsync vfr "episode-%06d.png"

A flag select=eq(pict_type\,I) mantém frames onde pict_type == I. A flag -vsync vfr produz saída de taxa variável para evitar frames duplicados. A nomenclatura de saída usa %06d para números de sequência com zero à esquerda. Esta sintaxe de comando é confirmada pelo Stack Overflow.

O autor do artigo faz uma distinção crítica: keyframes de anime (poses definidoras do artista) e keyframes de vídeo / I-frames (frames completos comprimidos) não são o mesmo conceito. No entanto, na prática, I-frames de vídeo são colocados em mudanças de cena, que frequentemente se alinham com keyframes de anime. Este alinhamento significa que extrair I-frames resulta num conjunto enriquecido para desenhos on-model, embora também capture alguns in-between frames que aconteceram de cair num limite de GOP.

Processe uma pasta em lote com um loop Python curto (veja o guia fonte para o script completo).

O script extrator do artigo fonte itera sobre cada arquivo na pasta de entrada, reconhece extensões de vídeo comuns (.avi, .mp4, .mkv, .ogm, .webm), e executa o comando ffmpeg para cada episódio. Esta abordagem em lote significa que uma série de 12 episódios pode ser processada sem supervisão. A estrutura de diretórios de saída espelha os nomes dos arquivos de entrada: cada episódio produz sua própria sequência numerada (ex.: Magical Girl Lyrical Nanoha - S04E01.mkv-000007.png), facilitando rastrear qualquer frame de volta ao seu episódio e timestamp de origem.

Etiquetar automaticamente com DeepDanbooru

DeepDanbooru é um classificador multi-label TensorFlow que produz tags no estilo Danbooru. O modelo pré-treinado (release v3-20211112-sgd-e28) foi treinado em dados do Danbooru de novembro de 2021 usando o otimizador SGD. O repositório o descreve como um "sistema de classificação de imagens de garotas multi-label baseado em IA, implementado usando TensorFlow." Instale:

pip install git+https://github.com/KichangKim/DeepDanbooru.git
pip install tensorflow tensorflow-io

Principais funções da API do repositório fonte:

• load_model_from_project(path, compile_model=False) — carrega o modelo .keras/.h5 de uma pasta de projeto. Assinatura confirmada em project.py.
• load_tags_from_project(path) — lê tags.txt (separado por novas linhas) do projeto.
• load_tags(path) — carregador genérico de arquivo de tags usado pelos dois acima. Implementação em data/dataset.py.
• load_image_for_evaluate(path, width, height) — carrega, redimensiona (preservando aspecto + padding), normaliza para [0,1]; retorna np.ndarray. Assinatura confirmada em data/__init__.py.

Esboço do script de etiquetagem (do artigo 218):

import deepdanbooru
import os

model = deepdanbooru.project.load_model_from_project(model_path, compile_model=False)
tags = deepdanbooru.project.load_tags_from_project(model_path)
tags_char = deepdanbooru.data.load_tags(os.path.join(model_path, "tags-character.txt"))
tags_gen  = deepdanbooru.data.load_tags(os.path.join(model_path, "tags-general.txt"))

for frame in frames:
    img = deepdanbooru.data.load_image_for_evaluate(
        frame, width=model.input_shape[2], height=model.input_shape[1]
    )
    probs = model.predict(img[None, ...])[0]
    keep = [tags[i] for i, p in enumerate(probs) if p >= 0.5]
    char_tags = [t for t in keep if t in tags_char]
    gen_tags  = [t for t in keep if t in tags_gen]
    with open(frame.replace(".png", ".txt"), "w") as f:
        f.write(", ".join(t.replace("_", " ") for t in set(char_tags + gen_tags)))

Nota sobre arquivos de tags. O README do repositório documenta apenas tags.txt. O código referencia tags-character.txt e tags-general.txt, que podem existir dentro dos assets do release ZIP. Se estiverem ausentes no seu download, divida tags.txt você mesmo ou filtre por prefixos conhecidos.

O script de etiquetagem separa tags de personagem de tags gerais, o que é essencial para a etapa de filtro. Tags de personagem (como takamachi_nanoha) identificam personagens nomeados específicos; tags gerais (como 1girl, red_hair, blue_eyes, school_uniform) descrevem atributos visuais. O script escreve ambas as categorias no arquivo .txt de legenda, mas apenas tags gerais são usadas para o filtro de atributo visual mostrado acima. Esta separação permite filtrar por uma tag de personagem conhecida (para personagens mais antigos e populares) ou por uma combinação de atributos visuais (para personagens novos ou menos populares onde a tag de personagem não existe no vocabulário do modelo). O limiar de probabilidade 0.5 é a convenção do autor do artigo — a biblioteca não expõe um padrão.

Filtrar para um personagem

O autor do artigo fonte enfatiza que as tags resultantes não serão perfeitas, mas serão boas o suficiente para treino. Inspeção manual da pasta etiquetada antes da poda é um passo valioso — permite calibrar quais tags identificam seu personagem de forma confiável e quais são ruído.

Tags do Booru tornam o filtro direto. Para uma personagem feminina de cabelo vermelho (do artigo 218):

if "1girl" in gen_tags and "1boy" not in gen_tags and "red_hair" in gen_tags:
    copy_image_and_tags(frame, output_dir, activation_tag="my_character")

Para personagens que existiam antes de novembro de 2021, você pode combinar a tag de personagem diretamente (ex.: takamachi_nanoha em tags_char). O sucesso depende de se o personagem aparece nos dados de treino.

O artigo fonte recomenda gastar cerca de meia hora nessa etapa de poda. O fluxo de trabalho é direto: abra um visualizador de imagens, avance pela pasta, e apague frames que se encaixem em qualquer das categorias acima. A pergunta-chave para cada frame é: esta imagem mostra claramente meu personagem sozinho, com qualidade razoável, sem elementos visuais distraídos? Em dúvida, apague — um dataset mais apertado treina um LoRA mais consistente.

Poda manual para 20–50 imagens

Automação aproxima; revisão humana garante qualidade. Abra a pasta de saída num visualizador de imagens e apague: Categoria | O que procurar | Por que prejudica

|----------|------------------|--------------

Personagem errado | Tag combina mas visual não | Polui o conceito Múltiplos personagens | Braços extras, figuras ao fundo | Dilui o alvo Sequências duplicadas | Frames consecutivos quase idênticos de diálogo | Reduz diversidade Frames de OP/ED | Sequências de créditos recorrentes entre episódios | Imagens idênticas repetidas Tweens (in-betweens) | Motion blur, rostos off-model, poses estranhas | Não representativo Baixa qualidade | Cenas distantes, linework ruim, artefatos de compressão | Treina ruído Esta checklist de poda vem diretamente do artigo 218. O alvo de 20–50 imagens é uma convenção da comunidade; nenhuma fonte única autoritativa o prescreve.

Caminho B: Dataset sintético com ChatGPT Plus / DALL-E 3

Template de prompt

Crie um prompt base com placeholder [SUBJECT] (do artigo 3327):

Photo of a delicious-looking cinnamon-bun [SUBJECT]. The entire aircraft is
constructed from fresh, golden-brown cinnamon bun material, with swirls of
cinnamon and icing visible.

Alimente o ChatGPT com uma lista de 30+ assuntos e instrua-o a gerar imagens por assunto, substituindo [SUBJECT] a cada vez.

Pontos de atrito (snapshot Jun 2024)

Sintoma | Causa | Contorno

|---------|-------|------------

Apenas 1 imagem por assunto | Limite por requisição mudou (era 4, depois 2, depois 1, segundo relato de fonte única) | Re-prompt ou repita a lista; organize arquivos manualmente Saída grid/collage | Modelo retorna uma única imagem contendo todas as 4 | Reformule: "gere 4 imagens separadas" ou regenere Cooldown de tráfego | Limite por sessão baseado na carga do servidor (relato de fonte única) | Espere o cooldown informado; às vezes retoma antes Nomes de arquivo longos | Prompt embutido no nome do arquivo | Script de renomear em lote (GUI Tkinter drag-drop fornecida na fonte) A progressão 4→2→1 e o cooldown baseado em tráfego são observações de fonte única do artigo 3327. A OpenAI não publica esses números. Em julho de 2026, os limites reais podem ser diferentes.

Renomear em escala

O artigo fonte inclui um renomeador drag-and-drop tkinterdnd2 que converte nomes longos do DALL-E para nomedapasta_001.png, nomedapasta_002.png, etc., com suporte a desfazer.

Legendas: o que as fontes não cobrem

Nenhum dos artigos usa LLM para escrever legendas para imagens existentes. DeepDanbooru emite tags, não legendas em linguagem natural. ChatGPT é usado apenas para geração, não para legenda visão-para-texto. Para legendas descritivas, você precisa de um modelo visão-linguagem separado (BLIP-2, LLaVA, GPT-4V) — fora do escopo destes guias.

Erros comuns e correções

Error / Symptom | Likely cause | Fix

|-----------------|--------------|-----

ffmpeg: command not found | ffmpeg não está no PATH | Instale ffmpeg; adicione ao PATH ModuleNotFoundError: deepdanbooru | Pacote não instalado | pip install git+https://github.com/KichangKim/DeepDanbooru.git tensorflow import falha | Incompatibilidade de versão | Combine versão no requirements.txt (listado como ≥2.17.0 no main do repo) Zero tags escritas | Limiar alto demais ou arquivos de tag ausentes | Reduza limiar; verifique se arquivos de tag existem ChatGPT retorna uma imagem em vez de quatro | Limite por requisição mudou | Re-prompt ChatGPT retorna grid 2×2 | Modelo interpreta pedido como collage | Proíba grids no prompt Script de renomear falha | Limite de 260 chars de caminho no Windows | Habilite long paths ou use caminho curto

FAQ

Como criar automaticamente um dataset de treino LoRA a partir de anime? Extraia I-frames com ffmpeg -vf select=eq(pict_type\,I), etiquete automaticamente com DeepDanbooru, filtre por tags de personagem, copie correspondências para uma nova pasta, depois pode para 20–50 imagens diversas.

Quantas imagens você precisa para um LoRA? Prática da comunidade almeja 20–50 imagens curadas. Menos arrisca underfitting; mais traz retornos decrescentes. Nenhuma documentação oficial de trainer especifica número fixo.

Pode usar ChatGPT para gerar dados de treino LoRA? Sim. Com ChatGPT Plus, use template de prompt com placeholder [SUBJECT], alimente lista de assuntos, e solicite imagens por assunto. Baixe, renomeie em lote, e curta.

Quais ferramentas etiquetam imagens de anime automaticamente? DeepDanbooru (TensorFlow, dados de treino Danbooru 2021) emite tags Booru para arquivos .txt. WD1.4 Tagger (usado no Kohya-ss, A1111) é outra opção.

Como extrair keyframes de anime para treino? Use ffmpeg -i input.mkv -vf "select=eq(pict_type\,I)" -vsync vfr "out-%06d.png". I-frames são frames completos em mudanças de cena e intervalos regulares de GOP; mudanças de cena de anime frequentemente se alinham com keyframes de animação.

Internal links

• Guia de hiperparâmetros de treino LoRA
• Comparação DeepDanbooru vs WD1.4 Tagger
• Pré-processamento de vídeo de anime para datasets ML