Treinando um modelo com dados de anotação

Para treinar um modelo com dados de anotação, resolva os rótulos de cada item em um único alvo ou na divisão dos votos dos anotadores, atribua os itens às divisões de treinamento, validação e teste por uma regra que permaneça fixa entre as rodadas e informe a pontuação em test sempre que a divisão de validação tiver escolhido o checkpoint. O treinamento de modelos do Potato executa cada etapa nas anotações do próprio estudo e registra em quais itens cada execução treinou.

Novo na v2.14.0

Os dados de anotação raramente chegam no formato que um treinador lê. Um estudo com sobreposição tem vários rótulos por item, e os rótulos muitas vezes discordam. Um estudo em andamento ganha rótulos todos os dias, e cada rodada de retreinamento vê mais itens que a anterior. Um treinador precisa de um alvo por item e de um conjunto fixo de itens para pontuar, e as decisões abaixo produzem os dois. Cada seção abaixo nomeia a configuração do Potato que toma a decisão. Para a página Training em si, veja a visão geral do treinamento de modelos e o tutorial que treina um primeiro modelo. Para treinar no seu próprio código, Exportando anotações para aprendizado de máquina trata dos formatos de exportação, e as mesmas decisões valem para o arquivo exportado.

Resolvendo vários anotadores em um único rótulo

A agregação transforma os rótulos que vários anotadores deram a um item no único rótulo com que um modelo treina. O método mais simples é o voto majoritário. O voto majoritário conta a resposta de cada anotador uma vez e mantém a resposta mais comum. Dawid e Skene (1979) estimam uma matriz de confusão para cada anotador com maximização de expectativa e ponderam cada voto pela confiabilidade estimada do anotador. Um anotador descuidado influencia então o resultado menos do que um anotador cuidadoso. Agregando rótulos de crowdsourcing compara os dois métodos e os modelos construídos sobre o Dawid-Skene.

Uma execução de treinamento no Potato resolve os rótulos com model_training.aggregation. O padrão, consensus, executa o Dawid-Skene sempre que o projeto tem mais de um anotador e recorre ao voto majoritário se a estimativa falhar. O outro valor, majority, executa apenas o voto majoritário. Os dois métodos tratam a resposta inteira de um anotador em um esquema como um voto. Duas respostas multiselect contam, portanto, como o mesmo voto apenas quando as duas respostas marcam o mesmo conjunto de rótulos.

A configuração consensus da execução e a exportação de consenso são recursos separados. A exportação de consenso dá um voto a cada anotador, informa a contagem e a fração de cada resposta em cada item e marca cada item como retired ou needs_review. Leia a exportação antes de treinar quando quiser ver, item por item, onde os anotadores se dividem. O MACE estima uma pontuação de competência para cada anotador a partir dos mesmos votos.

Aprendendo com a discordância

Em tarefas subjetivas, como ofensividade ou emoção, os anotadores podem discordar porque cada um lê o item de modo diferente, e um único rótulo por voto descarta a divisão. Uma et al. (2021) revisam métodos que treinam com a discordância em vez de um único rótulo agregado. Uma família desses métodos treina com rótulos suaves. Um rótulo suave é uma distribuição de probabilidade sobre os rótulos, construída a partir da parcela de anotadores que escolheu cada rótulo.

hf-text-classification aceita o parâmetro soft_targets: true. Com o parâmetro definido, um item que dois ou mais anotadores rotularam treina em direção à divisão dos anotadores por entropia cruzada com a distribuição. Quando dois de três anotadores disseram positive, o alvo é 0,67 positive e 0,33 negative. Para um esquema multiselect, cada rótulo treina em direção à parcela de anotadores que o marcou. Um item com um anotador treina com o rótulo desse anotador, como antes. O modelo permanece então incerto onde as pessoas discordaram, e cada predição inclui as probabilities do modelo. Em itens reservados com divisão de votos, a execução informa três métricas adicionais:

Em um esquema de rótulo suave, cada anotador dá uma distribuição com controles deslizantes. hf-text-classification sempre treina um esquema soft_label em direção à distribuição média dos anotadores, e o pré-rótulo ajusta os controles deslizantes para a distribuição prevista. Alvos suaves precisam de dois ou mais rótulos em um item. Um estudo que pretende treinar com a discordância coleta, portanto, rótulos sobrepostos desde o início, e Quantos anotadores você precisa? trata das configurações de sobreposição. Discordância é sinal, não ruído apresenta o argumento para manter a divisão nos dados.

Divisões de treinamento, validação e teste

As divisões de treinamento, validação e teste cumprem três funções diferentes. A divisão de treinamento ajusta os pesos do modelo. A divisão de validação escolhe entre modelos candidatos, por exemplo a época em que parar. A divisão de teste estima o desempenho em dados nunca vistos e não participa de nenhuma das duas escolhas. Escolher um checkpoint na validação é uma forma de ajuste à validação. O checkpoint mantido pela melhor pontuação de validação tem uma pontuação de validação enviesada para cima, e apenas a pontuação de teste vem de itens que a escolha nunca consultou.

Uma execução do Potato divide os itens rotulados em 70/15/15 por padrão (splits). A divisão de cada item vem de um hash com semente do ID do item (split_seed). Um item reservado em uma execução permanece reservado na execução seguinte, desde que split_seed e splits continuem os mesmos. Mudar qualquer uma das duas configurações pode mover itens reservados para o treinamento, e toda pontuação depois da mudança passa a medir em parte a memorização. Defina as duas uma só vez, no início do estudo.

Os treinadores de ajuste fino, como hf-text-classification, mantêm o checkpoint da época que obteve a melhor pontuação na validação. A pontuação principal dessa execução vem de test. sklearn-text, setfit, rdkit-property, os treinadores de modelos de decisão e as pontes de inferência não escolhem nada na validação, e uma execução de um desses treinadores toma a pontuação principal da validação sempre que a validação tem itens. A dica da coluna Held-out score da tabela Runs nomeia a divisão e a métrica por trás de cada número. Um item com rótulo e sem predição conta como errado. Um treinador não consegue elevar a pontuação ignorando itens difíceis, e <split>_coverage informa a parcela de itens que receberam uma predição.

Itens corrigidos e fixados

Dois tipos de item vão para a divisão train de toda execução posterior, qualquer que seja a divisão atribuída pelo hash. O primeiro é um item que um revisor corrigiu na revisão de modelos, e o segundo é um item que alguém fixou com Train on these, ao lado de uma fatia na página Catalog. As correções vêm dos itens em que o modelo foi pior, e em validação ou teste as correções pontuariam o modelo em uma amostra dos próprios erros do modelo. Uma execução que move itens reservados para o treinamento registra um aviso com a contagem, e a pontuação em itens reservados da execução deixa então de ser diretamente comparável com a pontuação de uma execução anterior. Uma execução que treina em um item corrigido que uma execução anterior havia reservado também registra um aviso, porque uma pontuação nos itens de validação ou teste da execução anterior, ou em um conjunto de dados salvo desses itens, passa a incluir itens em que o novo modelo treinou. Correções e itens fixados sempre treinam dá as regras.

Registrando em que cada modelo treinou

Comparar duas execuções exige saber em quais itens cada execução treinou e foi pontuada. Toda execução do Potato grava um pacote em <output_annotation_dir>/training/runs/<run_id>/bundle/ com train.jsonl, val.jsonl, test.jsonl, labels.json e manifest.json. O manifesto registra a semente da divisão, o método de agregação, a contagem de itens em cada divisão, a contagem de itens forçados para o treinamento e um resumo SHA-256 dos arquivos de divisão. Nada em um pacote remete de volta ao Potato, e um script fora do Potato pode ler o pacote como uma cópia autônoma dos rótulos resolvidos e das divisões.

O banco de dados do projeto, project.sqlite, mantém um registro com uma linha por execução. Cada linha registra o treinador, os parâmetros, os tamanhos das divisões, a semente da divisão, as métricas em itens reservados e o resumo do pacote. Uma segunda tabela registra em qual divisão cada item esteve em cada execução. A gravação de volta lê essa tabela e nunca pré-rotula um item em que alguma execução ainda presente no registro treinou (retain_runs mantém cinco execuções concluídas por padrão). Um modelo tem confiança nos itens em que treinou, por razões que nada dizem sobre dados novos.

Para comparar modelos posteriores exatamente nos mesmos itens, Keep this split as a dataset, na página da execução, salva os itens de validação, teste ou treinamento da execução como uma versão de um conjunto de dados, com os rótulos humanos acordados. Uma versão salva não muda depois. Cada versão salva contém uma divisão e começa do zero em vez de acrescentar à versão anterior. Os itens de validação da execução 2 salvos sobre os da execução 1 incluiriam, do contrário, itens em que a execução 2 treinou. Uma avaliação em uma versão salva não consegue ler a resposta do modelo, porque as entradas salvas deixam de fora o campo do pré-rótulo. Salvar exige datasets.enabled: true. Quando o modelo ou o conjunto de dados deixa o projeto, Documentando conjuntos de dados e modelos trata de datasheets e cartões de modelo.

De quantos dados um primeiro modelo precisa

Cada treinador do Potato se recusa a ajustar o modelo com menos de min_instances itens na divisão train. Os padrões abaixo são as contagens em que uma execução começa:

O limite conta apenas a divisão train. Com a divisão padrão 70/15/15, uma execução de sklearn-text começa quando cerca de 15 itens têm um rótulo. O exemplo de treinamento de modelos no repositório do Potato dá um ponto medido. Com 120 das 160 avaliações sintéticas de produtos do exemplo rotuladas uma vez cada, uma execução de sklearn-text obteve 0,84 de macro-F1 na validação e publicou 80 pré-rótulos. O valor vem de uma única tarefa sintética de dois rótulos, e a pontuação em itens reservados das suas próprias execuções é o número a ler para a sua tarefa.

Comece com sklearn-text. O treinador não precisa de nada além de uma instalação simples e não precisa de GPU. Retreine conforme os rótulos chegam e acompanhe a pontuação em itens reservados de execução para execução com split_seed inalterado. Os pré-rótulos ancoram os anotadores. Deixe writeback.schemas vazio até que a pontuação em itens reservados justifique mostrar as respostas do modelo. Rotulagem assistida por modelo trata do que muda quando os anotadores veem pré-rótulos, e Como distinguir revisão de carimbo trata de como verificar que os anotadores ainda leem os itens.

Uma configuração que define cada decisão

A configuração abaixo treina com um esquema de sentimento de dois rótulos. Cada chave em model_training define uma das decisões acima:

annotation_task_name: "Review sentiment"
task_dir: "."
data_files:
  - "data/reviews.json"
item_properties:
  id_key: "id"
  text_key: "text"
output_annotation_dir: "annotation_output"
 
annotation_schemes:
  - annotation_type: "radio"
    name: "sentiment"
    description: "Is this review positive or negative?"
    labels: ["positive", "negative"]
 
model_training:
  enabled: true
  aggregation: consensus
  split_seed: 0
  splits: {train: 0.7, val: 0.15, test: 0.15}
  trainer_params:
    hf-text-classification:
      soft_targets: true

aggregation: consensus resolve rótulos sobrepostos com o Dawid-Skene. split_seed e splits estão escritos com os valores padrão porque nenhuma das duas configurações deve mudar durante a vida do estudo. soft_targets: true faz toda execução de hf-text-classification no projeto treinar com divisões de votos. Esse treinador precisa de pip install "potato-annotation[train-text]", e sklearn-text roda com a mesma configuração sem nenhuma instalação extra. Sem um bloco writeback, os anotadores não veem pré-rótulos. Reinicie o servidor com a configuração, abra /admin/training, escolha um treinador e o esquema sentiment e clique em Train now. A referência da configuração do treinamento de modelos lista todas as chaves, e o tutorial de modelo no ciclo acrescenta a gravação de volta e o retreinamento automático.

Leitura complementar

• Visão geral do treinamento de modelos
• Treine o seu primeiro modelo
• Rotulagem assistida por modelo
• Exportando anotações para aprendizado de máquina
• Agregando rótulos de crowdsourcing
• Concordância entre anotadores
• Referência de treinamento de modelos no GitHub, com as métricas em itens reservados de cada tipo de esquema

Referências

• Dawid, A. P., and Skene, A. M. (1979). Maximum Likelihood Estimation of Observer Error-Rates Using the EM Algorithm. Applied Statistics, 28(1), 20. doi.org/10.2307/2346806
• Uma, A. N., Fornaciari, T., Hovy, D., Paun, S., Plank, B., and Poesio, M. (2021). Learning from Disagreement: A Survey. Journal of Artificial Intelligence Research, 72, 1385–1470. doi.org/10.1613/jair.1.12752