Treinamento de modelos com as suas próprias anotações

Novo na v2.14.0

O treinamento de modelos ajusta um modelo aos rótulos que os seus anotadores já deram, pontua o modelo em itens reservados do treinamento e pode mostrar as respostas do modelo aos anotadores como pré-rótulos para confirmar ou corrigir. Esta página explica o ciclo de treinamento, a página Training do administrador, os treinadores agrupados por tarefa e a página ou o tutorial que cobre cada parte em detalhe. A página é escrita para responsáveis por estudos e administradores que operam um servidor Potato próprio. A página Training e o treinador sklearn-text fazem parte do Potato desde a 2.11. A versão 2.14.0 acrescenta 37 treinadores, treinamento remoto em servidores com GPU e clusters SLURM, pontuações em itens reservados na tabela Runs e publicação no Hugging Face Hub.

O ciclo de treinamento

Cada rodada do ciclo treina um modelo com os rótulos humanos coletados até agora e dá ao próximo anotador as respostas do modelo como ponto de partida. O ciclo tem seis etapas:

1. Anotar. Os anotadores rotulam os itens como de costume, e o Potato resolve os rótulos de vários anotadores em um item em um único rótulo, com Dawid-Skene por padrão ou com voto majoritário.
2. Treinar. Uma execução divide os itens rotulados em conjuntos train, val e test e ajusta o modelo em um processo separado. Cada item mantém a mesma divisão de uma execução para outra, porque a divisão é um hash com semente do ID do item.
3. Pontuar. A execução pontua o modelo nos itens reservados val e test.
4. Gravar de volta. As predições da execução entram nos dados de cada item como pré-rótulos para os esquemas que você escolher. Predições abaixo de um limite mínimo de confiança e predições em itens da divisão train ficam de fora.
5. Corrigir. O próximo anotador vê a resposta do modelo já preenchida e a confirma ou a altera. Um revisor também pode registrar se o modelo acertou.
6. Retreinar. A execução seguinte treina com os novos rótulos, e todo item que um revisor corrigiu vai para a divisão train.

Ligando o treinamento

O treinamento de modelos vem desligado por padrão, e uma chave de configuração o liga. Adicione este bloco a uma configuração existente:

model_training:
  enabled: true

Reinicie o servidor e abra /admin/training com uma sessão de administrador ou com a chave de API de administrador. Sem enabled: true, as rotas de treinamento não existem. Ligar o treinamento não muda nada do que os anotadores veem, porque os pré-rótulos aparecem apenas para os esquemas listados em writeback.schemas, e a lista vem vazia por padrão.

O painel Start a run, no alto da página Training, reúne toda a configuração de uma execução. Schema lista os esquemas de anotação do estudo, Trainer lista os treinadores que se ajustam ao tipo e aos itens do esquema selecionado, e Runs on lista os lugares onde uma execução pode rodar. O campo Parameters recebe JSON e começa pela entrada do treinador escolhido em model_training.trainer_params. A nota sob o campo nomeia todos os parâmetros que o treinador aceita. Train now inicia a execução. Uma execução iniciada enquanto outra está em andamento espera em uma fila e aparece na tabela Runs como waiting #N, com um botão Cancel run.

Duas execuções de sklearn-text em um esquema de sentimento, cada uma com uma pontuação medida em avaliações que o modelo nunca viu no treinamento

Cada ID de execução na tabela Runs abre a página da execução em /admin/training/runs/<run_id>. A página da execução mostra o status, o treinador, o backend, os tamanhos das divisões, a pontuação em itens reservados e os parâmetros da execução, depois todas as métricas que a execução registrou e o log da execução. Uma execução que falhou acrescenta uma seção What went wrong. Na página da execução você também pode salvar os itens val, test ou train da execução como uma versão do conjunto de dados e publicar o modelo no Hugging Face Hub. Para uma primeira execução completa em um projeto de exemplo sem GPU, siga Treine o seu primeiro modelo.

Treinadores por tarefa

O Potato 2.14.0 tem 38 treinadores, cada um nomeado no menu Trainer pelo nome no registro. A tabela agrupa os treinadores pelo tipo de anotação com que cada um aprende:

Os cinco treinadores da última linha não ajustam nada. Cada um dos cinco envia os itens reservados a um modelo que roda em outro lugar, e o Potato pontua, grava de volta e revisa as respostas como as de um modelo treinado. sklearn-text não precisa de nada além de uma instalação simples do Potato, e pip install "potato-annotation[train]" instala o que os treinadores de texto, imagem, áudio e LLM precisam. Um treinador que não está instalado aparece na página Training como "not installed", com o comando que o instala. Treinadores dá, para cada treinador, os tipos de anotação, os tipos de item, o comando de instalação e os parâmetros.

Onde as execuções rodam

Uma execução roda em um backend, escolhido por execução no menu Runs on ou por padrão com model_training.backend. O Potato tem quatro tipos de backend:

• local treina no servidor do Potato, em um subprocesso. device: auto escolhe CUDA primeiro, depois o Metal da Apple e depois a CPU.
• ssh treina em um servidor com GPU que o Potato alcança com ssh por chave. O Potato copia o código-fonte do Potato para o servidor, inicia a execução ali e copia o modelo de volta depois de uma execução bem-sucedida.
• slurm se conecta ao nó de login de um cluster da mesma forma e envia o trabalho de treinamento a um nó de computação com sbatch. O backend chama apenas sbatch, squeue, scancel e scontrol. Um cluster sem srun ou sacct portanto funciona.
• agent atende uma máquina que o Potato não alcança, como uma estação de trabalho atrás de NAT. potato training agent, nessa máquina, consulta o servidor em busca de trabalhos, e os arquivos do modelo ficam nessa máquina.

potato training check <backend> config.yaml testa um backend antes da primeira execução, e o botão Check da página Training faz o mesmo. Configuração lista todas as chaves de backend, e Treinamento em um servidor com GPU ou cluster configura os três tipos remotos passo a passo.

Pontuações em itens reservados

Cada execução pontua o modelo nos itens val e test, com uma métrica escolhida para o tipo de anotação do esquema. Um classificador de rótulo único recebe macro-F1, um marcador de trechos recebe F1 de trechos, um detector de caixas recebe mAP com IoU 0,5 e um modelo de transcrição recebe 1 menos a taxa de erro de palavras. A tabela Runs mostra uma pontuação principal por execução, e a página da execução lista todas as métricas com a divisão no nome da métrica, como val_macro_f1 ou test_f1. Um item com rótulo e sem predição conta como erro. Um treinador portanto não consegue aumentar a pontuação pulando itens difíceis. Quando um treinador escolhe o melhor checkpoint nos itens val, a pontuação principal vem dos itens test, porque a pontuação val já moldou o modelo. Um treinador que não escolhe nada em val, como sklearn-text, toma a pontuação principal dos itens val. Configuração dá as métricas de cada tipo de anotação.

Pré-rótulos e a fila de revisão de modelos

Um pré-rótulo é uma resposta do modelo preenchida na página de anotação para o anotador confirmar ou alterar. A gravação de volta transforma as predições de uma execução em pré-rótulos para os esquemas listados em writeback.schemas, sem precisar de um bloco pre_annotation. Adicione o bloco writeback em model_training:

model_training:
  enabled: true
  writeback:
    schemas: [sentiment]
    min_confidence: 0.6
    include_unlabeled: true

Com este bloco, uma predição de sentiment com confiança abaixo de 0,6 é armazenada e não é mostrada. include_unlabeled: true faz cada execução prever também nos itens que ninguém rotulou ainda. Sem essa opção, uma execução prevê apenas nos itens reservados val e test. Itens da divisão train de uma execução nunca recebem um pré-rótulo, e a gravação de volta nunca altera um rótulo humano. Um pré-rótulo só se torna a resposta do anotador quando o anotador o edita ou passa para o próximo item.

Um novo anotador vê a resposta do modelo selecionada e a confirma ou a altera

assignment_strategy: model_review serve os itens pré-rotulados aos revisores do menos confiante para o mais confiante. Um revisor registra um veredito accept, correct ou reject em cada item. Um pré-rótulo rejeitado sai do item e não é mostrado de novo. Toda execução seguinte treina com um item que tem veredito correct e nunca pontua o modelo nesse item. Os pré-rótulos puxam os anotadores para a resposta do modelo. Ative include_unlabeled quando a pontuação em itens reservados sustentar o modelo, e use Como distinguir revisão de carimbo automático em dados pré-rotulados para encontrar anotadores que aceitam pré-rótulos sem lê-los. O modelo no ciclo percorre a gravação de volta, a revisão e o retreinamento em um só projeto.

Retreinar conforme as anotações chegam

auto_retrain inicia execuções automaticamente conforme as anotações chegam, e cada nova execução substitui os pré-rótulos da execução anterior. Adicione o bloco em model_training:

model_training:
  enabled: true
  auto_retrain:
    enabled: true
    trainer: sklearn-text
    schemas: [sentiment]
    update_frequency: 25
    min_interval_s: 600

Com esses valores, uma execução começa quando 25 anotações chegaram desde a última execução automática e 600 segundos se passaram desde o fim da última execução. Configuração lista todas as chaves de auto_retrain e os motivos pelos quais uma verificação pula uma execução, e O modelo no ciclo mostra quando ligar o retreinamento.

Publicando um modelo no Hugging Face Hub

Uma execução bem-sucedida cujo modelo está no servidor do Potato tem um formulário Publish to the Hugging Face Hub na página da execução. O envio carrega os pesos, a configuração e os arquivos do tokenizador do modelo, além de um cartão do modelo README.md escrito a partir da execução. O cartão do modelo nomeia o treinador, o modelo base, os esquemas, os rótulos, os tamanhos das divisões e a pontuação em itens reservados. As predições da execução e qualquer cópia dos dados de treinamento ficam no servidor.

Você digita o nome do repositório duas vezes, e o envio só prossegue quando os dois nomes coincidem. Private vem marcado por padrão, e o token do Hugging Face vem de uma variável de ambiente no servidor (HF_TOKEN por padrão), não da página. Um modelo deixado em um host remoto ou em uma máquina de agente não pode ser enviado pela página da execução. Configuração lista quais arquivos sobem e a rota da API, e Ajuste fino de um LLM com as suas anotações executa um envio do começo ao fim.

Treinamento de modelos e o motor de rotulagem

O motor de rotulagem usa os mesmos treinadores. Com a destilação ligada (features.distill), o motor ajusta um modelo com um treinador (sklearn-text por padrão) nos rótulos humanos do motor e nos rótulos de máquina que um contrato certificou, e então coloca o modelo à frente da cascata configurada como uma fonte trained. Itens das divisões cert e audit do motor nunca entram no conjunto de treinamento da destilação. Uma fonte trained também pode carregar um modelo de uma execução de treinamento, com o diretório do modelo da execução como artifact_dir. Configuração do motor de rotulagem lista as chaves da destilação.

Treinamento de modelos e aprendizado ativo

O aprendizado ativo do Potato ajusta um modelo aos rótulos do estudo com um propósito mais restrito do que o treinamento de modelos. O aprendizado ativo ajusta um classificador do scikit-learn dentro do processo do servidor a cada update_frequency anotações e usa o classificador para reordenar a fila, com os itens mais incertos primeiro. Os anotadores recebem a fila reordenada apenas com assignment_strategy: active_learning. O classificador do aprendizado ativo é pontuado nos itens em que foi ajustado, e as predições do classificador nunca são mostradas aos anotadores.

O treinamento de modelos executa qualquer um dos 38 treinadores em um processo separado ou em outra máquina, pontua o modelo em itens reservados e mostra as respostas do modelo como pré-rótulos. O treinamento de modelos também pode ordenar a fila. Com assignment_strategy: llm_confidence, os itens cujo pré-rótulo publicado tem menor confiança vêm primeiro. O parâmetro acquisition de hf-text-classification e hf-image-classification substitui essa ordem por uma pontuação de margem, entropia, BALD ou core-set. Use o aprendizado ativo para decidir quais itens as pessoas rotulam em seguida. Use o treinamento de modelos quando precisar de um modelo pontuado em itens reservados, de pré-rótulos para os anotadores ou de um modelo para publicar.

Tutoriais

Cada tutorial executa uma configuração, da instalação até uma execução pontuada:

• Treine o seu primeiro modelo com as suas anotações treina sklearn-text em um estudo de sentimento, sem GPU.
• Treine em um servidor com GPU, cluster SLURM ou máquina atrás de NAT configura um servidor ssh com GPU, um cluster SLURM e um agente que consulta o servidor.
• Rotulagem com o modelo no ciclo, com pré-rótulos e retreinamento cobre a gravação de volta, a revisão, a aquisição, auto_retrain e as versões de conjuntos de dados.
• Ajuste fino de um LLM com as suas anotações treina modelos SFT, DPO, de recompensa e de recompensa por processo, com QLoRA e envio ao Hub.
• Treine modelos de detecção e segmentação em anotações de imagens treina detectores e segmentadores em imagens, lâminas, microscopia e mapas, além de Cellpose, SAM, LayoutLMv3 e modelos de visão e linguagem.
• Treine modelos de fala e áudio com as suas anotações treina Whisper, diarização de falantes, detectores de espectrograma e marcadores de áudio, com arquivos RTTM.
• Treine modelos em volumes, nuvens de pontos e vídeo treina volume-unet, external-3d e video-track.
• Treine modelos em moléculas, espectros, sinais e episódios de robôs treina rdkit-property, peak-cnn, signal-cnn e episode-model.
• Pré-rótulos e pontuações em itens reservados de um modelo que você já executa conecta um modelo que você já serve por uma ponte de inferência ou por label-studio-ml.
• Ajuste fino com privacidade diferencial usando Opacus treina um classificador com o parâmetro dp e o Opacus.

Leitura adicional

• Treinadores - Os 38 treinadores, agrupados por tarefa
• Configuração - Todas as chaves de model_training, backends, rotas e caminhos de armazenamento
• Aprendizado ativo - Reordenação da fila com um classificador do scikit-learn
• Pré-anotação com LLMs e modelos de visão - Pré-rótulos de um LLM ou de um modelo de visão em vez de um modelo treinado
• O motor de rotulagem - Rótulos de máquina testados contra uma amostra cega de rótulos humanos
• Simulador de usuários - Anotadores simulados para experimentar o ciclo antes de os anotadores reais começarem

Para detalhes de implementação, consulte a documentação-fonte.