Aprendizado Ativo
Reordene a fila de anotação do Potato pela incerteza do modelo, com cinco estratégias de consulta, classificadores do sklearn, tratamento de partida a frio e persistência do modelo entre reinicializações.
O aprendizado ativo reordena a fila de anotação para que os anotadores vejam as instâncias sobre as quais um modelo tem menos certeza, em vez de percorrer o corpus na ordem em que ele chegou.
Como Funciona
- Colete um conjunto inicial de anotações
- Treine um classificador com o que foi rotulado até agora
- Pontue o conjunto não rotulado por incerteza
- Reordene a fila para colocar as instâncias mais incertas na frente
- Anote as instâncias priorizadas
- Retreine periodicamente à medida que as anotações se acumulam
Invista o esforço de anotação onde o modelo mais aprende
Configuração
Configuração Básica
Os anotadores recebem a fila reordenada somente com assignment_strategy: active_learning. Com active_learning.enabled: true e qualquer outra estratégia, o Potato ainda treina o classificador e reordena o conjunto, e serve os itens na ordem da outra estratégia. A linha de log Reordered N instances nomeia a estratégia e diz se a ordem é servida, e GET /admin/active-learning/stats informa ordering_is_served.
assignment_strategy: active_learning
active_learning:
enabled: true
schema_names:
- sentiment
min_annotations_per_instance: 1
min_instances_for_training: 20
update_frequency: 50
max_instances_to_reorder: 1000O padrão de min_instances_for_training é 10 e o de update_frequency é 5. Os dois padrões são baixos o bastante para valer a pena aumentá-los em um projeto real, já que retreinar a cada cinco anotações gasta processamento com um modelo que mal mudou.
Configuração Completa
active_learning:
enabled: true
schema_names:
- sentiment
min_annotations_per_instance: 1
min_instances_for_training: 20
update_frequency: 50
max_instances_to_reorder: 1000
# How disagreement between annotators resolves into one training label
resolution_strategy: majority_vote
# Fraction of the queue left in random order, so the model does not
# only ever see what it already found interesting
random_sample_percent: 0.2
classifier:
name: sklearn.linear_model.LogisticRegression
hyperparameters:
C: 1.0
max_iter: 1000
vectorizer:
name: sklearn.feature_extraction.text.TfidfVectorizer
hyperparameters:
max_features: 5000
ngram_range: [1, 2]
query_strategy: uncertainty
model_persistence:
enabled: true
save_directory: "models/"
retention_count: 5Os blocos aninhados classifier, vectorizer e model_persistence são a forma documentada e a que o potato validate --strict reconhece. Suas subchaves são name e hyperparameters nos dois primeiros, e enabled, save_directory e retention_count no terceiro. Um bloco que usa outros nomes de subchave é ignorado sem aviso, e a execução volta silenciosamente aos valores padrão.
Estratégias de Consulta
| Estratégia | Descrição |
|---|---|
uncertainty | Instâncias em que o modelo tem menos confiança. É o padrão |
diversity | Instâncias menos parecidas com o que já foi anotado |
badge | Batch Active learning by Diverse Gradient Embeddings |
bald | Bayesian Active Learning by Disagreement |
hybrid | Uma combinação ponderada de incerteza e diversidade |
active_learning:
query_strategy: uncertaintyUm nome de estratégia não reconhecido volta para uncertainty com um aviso, em vez de impedir a inicialização. Por isso, confira o log se uma estratégia parecer não ter efeito.
Ajuste de Hybrid e BALD
Por padrão, hybrid usa 70% de incerteza e 30% de diversidade:
active_learning:
query_strategy: hybrid
hybrid_weights:
uncertainty: 0.7
diversity: 0.3bald treina um pequeno ensemble e ordena pela discordância dentro dele:
active_learning:
query_strategy: bald
bald_params:
n_estimators: 5
bootstrap_fraction: 0.8Classificadores
Os classificadores são indicados pelo caminho de importação do sklearn. O padrão é sklearn.linear_model.LogisticRegression.
| Classificador | Caminho | Melhor Para | Velocidade |
|---|---|---|---|
| Regressão Logística | sklearn.linear_model.LogisticRegression | A maioria das tarefas com texto | Rápido |
| Random Forest | sklearn.ensemble.RandomForestClassifier | Padrões não lineares | Médio |
| SVC | sklearn.svm.SVC | Conjuntos de dados pequenos | Lento |
| Multinomial NB | sklearn.naive_bayes.MultinomialNB | Classificação simples de texto | Muito rápido |
Regressão logística, o ponto de partida recomendado:
active_learning:
classifier:
name: sklearn.linear_model.LogisticRegression
hyperparameters:
C: 1.0
max_iter: 1000Random forest, quando a decisão não é aproximadamente linear:
active_learning:
classifier:
name: sklearn.ensemble.RandomForestClassifier
hyperparameters:
n_estimators: 100
max_depth: 10Um SVC precisa ser instruído a produzir probabilidades, já que a pontuação de incerteza depende delas:
active_learning:
classifier:
name: sklearn.svm.SVC
hyperparameters:
kernel: rbf
probability: trueNaive Bayes, quando a velocidade importa mais do que o último ponto de acurácia:
active_learning:
classifier:
name: sklearn.naive_bayes.MultinomialNB
hyperparameters:
alpha: 1.0calibrate_probabilities vem ativado por padrão. Isso importa porque a amostragem por incerteza ordena pela probabilidade prevista, e um classificador não calibrado trata itens em que erra com confiança como se estivessem resolvidos.
Vetorizadores
O padrão é sklearn.feature_extraction.text.TfidfVectorizer.
TF-IDF, características ponderadas:
active_learning:
vectorizer:
name: sklearn.feature_extraction.text.TfidfVectorizer
hyperparameters:
max_features: 5000
ngram_range: [1, 2]
stop_words: englishContagens simples:
active_learning:
vectorizer:
name: sklearn.feature_extraction.text.CountVectorizer
hyperparameters:
max_features: 3000
ngram_range: [1, 1]Hashing, para um vocabulário grande demais para caber na memória:
active_learning:
vectorizer:
name: sklearn.feature_extraction.text.HashingVectorizer
hyperparameters:
n_features: 10000ngram_range é escrito como uma lista YAML e convertido na tupla que o sklearn espera, então [1, 2] está correto aqui e não exige sintaxe especial.
Partida a Frio
Antes de existir um modelo, não há nada sobre o que ter incerteza, então o primeiro lote é escolhido sem modelo:
active_learning:
cold_start_strategy: random
cold_start_batch_size: 20Seleção Assistida por LLM
Um LLM pode pontuar instâncias durante o período de partida a frio ou junto com o classificador:
active_learning:
enabled: true
schema_names:
- sentiment
llm:
enabled: true
endpoint_type: vllm
base_url: http://localhost:8000/v1
model: meta-llama/Llama-3.2-3B-Instruct
confidence_method: verbalizedconfidence_method define como a pontuação de confiança é obtida, e a escolha importa porque é essa pontuação que conduz a seleção:
| Método | Como funciona | Contrapartida |
|---|---|---|
verbalized | O modelo informa a própria confiança em uma escala de 1 a 10 | Universal, mas pouco confiável em alguns modelos |
logprobs | Calculado a partir das log-probabilidades dos tokens | O mais bem calibrado, exige um endpoint que retorne logprobs |
consistency | A mesma instância é consultada várias vezes e pontuada pela concordância | Funciona em qualquer lugar, ao custo de N chamadas por instância |
logprobs volta para a confiança verbalizada quando o endpoint não as retorna.
Persistência de Modelo
Os modelos treinados podem sobreviver a uma reinicialização em vez de serem reconstruídos do zero:
active_learning:
model_persistence:
enabled: true
save_directory: "models/"
retention_count: 5O padrão de retention_count é 2, e ele limita quantos modelos salvos são mantidos.
A persistência em banco de dados não é mais configurável. As chaves database_enabled e database_config foram removidas porque a camada por trás delas era um stub que registrava sucesso e não armazenava nada. O histórico de execuções agora é sempre registrado e não precisa de configuração, e as duas chaves são ignoradas se uma configuração ainda as contiver.
Múltiplos Esquemas
schema_names lista os esquemas cujas anotações treinam o modelo. Se não for definido, o padrão são os esquemas rotuláveis do projeto:
annotation_schemes:
- annotation_type: radio
name: sentiment
description: "What is the sentiment?"
labels: [Positive, Negative, Neutral]
- annotation_type: radio
name: topic
description: "What is the topic?"
labels: [Politics, Sports, Tech, Entertainment]
active_learning:
enabled: true
schema_names:
- sentiment
- topicConfiguração Completa
annotation_task_name: "Sentiment Analysis with Active Learning"
task_dir: "."
port: 8000
data_files:
- "data/reviews.json"
item_properties:
id_key: id
text_key: text
annotation_schemes:
- annotation_type: radio
name: sentiment
description: "What is the sentiment?"
labels:
- Positive
- Negative
- Neutral
sequential_key_binding: true
assignment_strategy: active_learning
active_learning:
enabled: true
schema_names:
- sentiment
min_annotations_per_instance: 1
min_instances_for_training: 30
update_frequency: 50
max_instances_to_reorder: 500
random_sample_percent: 0.2
classifier:
name: sklearn.linear_model.LogisticRegression
hyperparameters:
C: 1.0
max_iter: 1000
vectorizer:
name: sklearn.feature_extraction.text.TfidfVectorizer
hyperparameters:
max_features: 5000
ngram_range: [1, 2]
query_strategy: uncertainty
model_persistence:
enabled: true
save_directory: "models/"
retention_count: 5
output_annotation_dir: "output/"
export_annotation_format: jsonl
user_config:
allow_all_users: trueAprendizado Ativo e Treinamento de Modelos
O treinamento de modelos também pode escolher o que os anotadores rotulam em seguida, com um modelo diferente e uma estratégia de atribuição diferente. O bloco active_learning ajusta um classificador do scikit-learn dentro do servidor e reordena a fila, e os anotadores não veem nenhuma predição. Uma execução de treinamento de modelos ajusta um dos treinadores, pontua o modelo em itens reservados e mostra as predições do modelo aos anotadores como pré-rótulos.
Uma execução hf-text-classification ou hf-image-classification com o parâmetro acquisition grava uma pontuação em cada predição, e assignment_strategy: llm_confidence serve primeiro a pontuação mais alta. acquisition aceita margin, entropy, bald ou coreset, em esquemas de escolha única. O esquema precisa estar em model_training.writeback.schemas, e writeback.include_unlabeled: true dá uma predição para pontuar aos itens que ninguém rotulou. model_training.auto_retrain inicia uma nova execução a cada 25 novas anotações por padrão, e cada execução repontua os itens não rotulados.
Os dois bald são diferentes. O bald do bloco active_learning ordena pela discordância dentro de um conjunto de classificadores por bootstrap, e o bald do treinamento de modelos executa mc_samples passagens diretas com dropout ligado. Um estudo usa uma ordenação por vez, porque cada ordenação precisa da própria estratégia de atribuição. O bloco active_learning serve a um estudo de texto que só precisa de uma fila reordenada por um classificador barato. O treinamento de modelos serve a um estudo em que um transformer ou um modelo de imagem deve escolher, ou em que os anotadores devem corrigir as respostas do modelo. Rotulagem com modelo no ciclo, com pré-rótulos e retreinamento configura acquisition e auto_retrain em um estudo em andamento.
Combinando com Suporte de IA
O aprendizado ativo decide o que mostrar em seguida. O suporte de IA ajuda o anotador com o que está na tela. Os dois são independentes e se combinam:
assignment_strategy: active_learning
active_learning:
enabled: true
schema_names:
- sentiment
min_instances_for_training: 30
ai_support:
enabled: true
endpoint_type: openai
ai_config:
model: gpt-4o-mini
api_key: ${OPENAI_API_KEY}
max_tokens: 800
include:
all: trueLeia o resultado com cuidado. Se o modelo sugere um rótulo, o anotador o aceita e a mesma família de modelos escolheu a instância, a concordância que você mede no final é, em parte, o modelo concordando consigo mesmo.
Monitoramento
O painel do administrador mostra a acurácia do modelo, a contagem de ciclos de treinamento, a distribuição da incerteza e quantas instâncias restam. Para acessá-lo é preciso a chave de administrador ou um papel que tenha view_admin_dashboard.
Boas Práticas
Colete uma Base Primeiro
Não é possível treinar nada com um conjunto vazio, e um modelo treinado com vinte anotações reordena principalmente ruído:
active_learning:
min_instances_for_training: 50Acompanhe o Equilíbrio de Classes
A amostragem por incerteza se concentra na fronteira de decisão, o que afasta a distribuição de rótulos da distribuição do corpus. Isso não é problema para treinar um modelo, mas é enganoso se você apresentar a amostra anotada como uma descrição dos dados. random_sample_percent mantém parte da fila sem viés exatamente por esse motivo.
Não Retreine com Muita Frequência
active_learning:
update_frequency: 100Mantenha os Modelos entre Reinicializações
active_learning:
model_persistence:
enabled: true
save_directory: "models/"Solução de Problemas
O treinamento nunca começa
Verifique se as anotações atingiram min_instances_for_training e se cada classe tem pelo menos um exemplo. Não é possível ajustar um classificador com um conjunto de treinamento de uma única classe.
A reordenação parece não fazer nada
Verifique se assignment_strategy é active_learning. Com qualquer outra estratégia, o Potato calcula a ordem e nunca a serve. Procure no log uma query_strategy desconhecida, que volta silenciosamente para a incerteza. Confirme enabled: true e que schema_names nomeia esquemas que de fato existem.
Lentidão com um conjunto grande
Reduza max_instances_to_reorder, aumente update_frequency ou passe a usar HashingVectorizer para um vocabulário muito grande.
Leitura Adicional
- Suporte de IA - Assistência de LLM durante a anotação
- Atribuição de Tarefas - As outras estratégias de atribuição
- Painel do Administrador - Monitore o ciclo de treinamento
- Ordenação por Diversidade - Ordenação baseada em embeddings, sem classificador
- Treinamento de modelos - Treinar um modelo nos seus rótulos, com acquisition e pré-rótulos
Para detalhes de implementação, consulte a documentação de origem.