Aprendizado Ativo

Visão geral

aprendizado ativo (active learning) é um cenário de aprendizado de máquina (machine learning) em que o modelo (ou uma estratégia de aquisição (acquisition strategy) em torno do modelo) escolhe quais exemplos não rotulados devem ser rotulados em seguida para aprender da forma mais eficiente possível. O objetivo é atingir um desempenho-alvo com menos exemplos rotulados do que no Aprendizado Supervisionado (Supervised Learning) padrão (passivo).

Isso é especialmente valioso quando:

  • Dados não rotulados são abundantes (logs, texto da web, imagens, fluxos de sensores)
  • Rotular é caro (tempo de especialistas, experimentos de laboratório, revisão humana, diretrizes de anotação)
  • Melhoria iterativa é aceitável (você pode rotular em rodadas)

Você pode pensar no aprendizado ativo como uma abordagem com base em princípios para “o que devemos rotular em seguida?” — uma parte central de muitos sistemas de ML com humano no loop (human-in-the-loop).

Quando o aprendizado ativo ajuda (e quando não ajuda)

O aprendizado ativo tende a ajudar mais quando:

  • Rótulos são caros: por exemplo, imagens de radiologia, documentos jurídicos, relatórios de incidentes de segurança.
  • A fronteira de decisão (decision boundary) é aprendível com menos exemplos: o modelo consegue generalizar rapidamente se vir os casos certos.
  • Há redundância no pool de não rotulados: muitos quase-duplicados; rotular todos desperdiça orçamento.
  • Você consegue iterar: rotular → retreinar → selecionar novos itens → rotular novamente.

Ele pode ajudar menos (ou até prejudicar) quando:

  • A incerteza do modelo é mal calibrada, especialmente no começo (comum em redes neurais profundas (deep nets)).
  • O pool de não rotulados está fortemente fora da distribuição (out-of-distribution, OOD) em relação aos dados de implantação (você pode acabar rotulando itens “estranhos” que não importam).
  • O ruído de rótulo domina (exemplos incertos costumam ser genuinamente ambíguos, levando a rótulos inconsistentes).
  • Você precisa construir um dataset de uma vez só sem iteração.

O aprendizado ativo é complementar a:

Principais configurações de aprendizado ativo

Aprendizado ativo baseado em pool (pool-based active learning) (mais comum)

Você tem:

  • Um pequeno conjunto rotulado (L)
  • Um grande pool de não rotulados (U)

Você seleciona repetidamente os itens “melhores” de (U) para rotular, adiciona-os a (L), retreina e repete.

Isso se encaixa em muitos fluxos de trabalho reais: você coleta muitos dados brutos e então decide o que enviar para anotadores.

Baseado em fluxo (stream-based) (amostragem seletiva (selective sampling))

Exemplos chegam em um fluxo. Para cada exemplo, você decide:

  • Consultar seu rótulo (pagar o custo), ou
  • Pular (não consultar)

Isso se assemelha à triagem em tempo real (por exemplo, filas de moderação de conteúdo) e se relaciona com Aprendizado Online.

Síntese por consulta de pertinência (membership query synthesis) (menos comum no aprendizado profundo (deep learning) moderno)

O aprendiz pode construir novas entradas para serem rotuladas (por exemplo, gerar pontos sintéticos). Isso pode ser poderoso em problemas de baixa dimensionalidade, mas muitas vezes é impraticável para dados naturais (texto/imagens), a menos que seja combinado com fortes restrições gerativas.

O loop de aprendizado ativo (fluxo de trabalho prático)

Um loop típico baseado em pool:

  1. Semente (seed): Rotule um pequeno conjunto inicial (aleatório ou estratificado).
  2. Treinar: Ajuste um modelo no conjunto rotulado.
  3. Pontuar: Calcule uma pontuação de aquisição (acquisition score) para cada item não rotulado.
  4. Selecionar: Escolha um lote dos itens com maior pontuação (frequentemente com restrições de diversidade).
  5. Anotar: Humanos rotulam os itens selecionados (com garantia de qualidade (quality assurance, QA), arbitragem (adjudication)).
  6. Atualizar: Adicione os rótulos ao conjunto de treino; retreine ou faça ajuste fino (fine-tune).
  7. Parar: Quando o orçamento acabar ou o desempenho saturar.

Dois pontos práticos frequentemente determinam o sucesso:

  • Bom design de anotação (definições claras de rótulos, ferramentas, checagens de qualidade)
  • Seleção que equilibra incerteza e diversidade, e não apenas “os mais incertos”

Estratégias de consulta (funções de aquisição)

O coração do aprendizado ativo é a função de aquisição (acquisition function): uma pontuação que estima o valor de rotular uma instância não rotulada.

1) Amostragem por incerteza (uncertainty sampling)

Selecione exemplos em que o modelo está menos confiante.

Variações comuns para classificação:

  • Menor confiança:
    [ a(x) = 1 - \max_y p(y \mid x) ]
  • Amostragem por margem (binária ou multiclasse): pequena diferença entre as duas maiores probabilidades previstas.
  • Entropia: [ a(x) = -\sum_y p(y\mid x)\log p(y\mid x) ]

Por que funciona: pontos perto da fronteira de decisão podem reduzir mais a ambiguidade.

Armadilha: a incerteza pode ser alta para outliers ou exemplos fora da distribuição, então você pode desperdiçar rótulos a menos que adicione restrições de representatividade/densidade.

2) Consulta por Comitê (Query-by-Committee, QBC)

Treine um comitê de modelos (ou snapshots de modelos) e escolha exemplos em que eles mais discordam.

Medidas de discordância:

  • Entropia de voto (o quanto os rótulos previstos estão divididos)
  • Divergência KL entre distribuições preditivas
  • Razão de variação

Por que funciona: a discordância aproxima a incerteza sobre o espaço de hipóteses (hypothesis space).

Em aprendizado profundo, o “comitê” frequentemente é aproximado por:

  • Conjuntos de modelos (ensembles)
  • Dropout de Monte Carlo (MC dropout)
  • Diferentes sementes aleatórias / bootstraps de dados

3) Aprendizado ativo bayesiano (Bayesian active learning) (baseado em informação)

Se você consegue aproximar uma posterior bayesiana (Bayesian posterior) sobre os parâmetros do modelo, pode escolher pontos que maximizem o ganho de informação esperado (expected information gain).

Um critério popular em classificação profunda é o BALD (Bayesian Active Learning by Disagreement), que seleciona pontos maximizando a informação mútua (mutual information) entre previsões e parâmetros do modelo: [ I(y, \theta \mid x, D) ]

Na prática, o BALD frequentemente é aproximado usando dropout de Monte Carlo ou conjuntos de modelos.

4) Mudança esperada no modelo / métodos baseados em gradiente

Escolha pontos que mudariam mais os parâmetros do modelo se fossem rotulados.

Intuição: rotular deve “mover” o modelo.

Frequentemente aproximado via:

  • Comprimento esperado do gradiente
  • Funções de influência (influence functions) (mais complexas, caras)

5) Redução esperada de erro / valor da informação

Escolha o ponto que deve reduzir mais o erro de generalização (generalization error) após o retreinamento.

Isso é conceitualmente atraente, mas computacionalmente caro porque exige simular o retreinamento sob possíveis rótulos.

6) Diversidade e representatividade (coverage-based)

Em vez de focar apenas em incerteza, selecione exemplos que cubram a distribuição de dados.

Abordagens comuns:

  • Clusterização e amostragem de representantes de clusters
  • Seleção k-center / conjunto central (core-set) no espaço de embeddings (embeddings space) (escolher pontos que minimizam a distância máxima até o conjunto selecionado)
  • Maximização submodular (submodular maximization) (seleção gulosa com retornos decrescentes)

Isso é especialmente importante em aprendizado ativo em lote (batch active learning), em que você rotula muitos pontos por rodada.

7) Estratégias híbridas (comuns em produção)

O aprendizado ativo prático frequentemente combina:

  • Incerteza (encontrar casos informativos perto da fronteira)
  • Diversidade (evitar pontos redundantes)
  • Densidade/representatividade (evitar outliers raros)

Um híbrido simples é: escolher os candidatos mais incertos e, em seguida, reduzir para um subconjunto diverso via clusterização.

Aprendizado ativo em lote (rotulando em rodadas)

Em fluxos de trabalho reais de anotação, você raramente rotula um exemplo por vez — você rotula um lote.

Pegar ingenuamente os (k) pontos mais incertos pode produzir um lote de quase-duplicados. Métodos em lote tratam isso incentivando diversidade, por exemplo:

  • Seleção submodular gulosa
  • Incerteza + clusterização
  • Seleção de conjunto central (k-center) no espaço de embeddings
  • Processos pontuais determinantal (determinantal point processes, DPPs) para diversidade (menos comum em produção)

Regra prática:

  • Lotes maiores reduzem o overhead de retreinamento, mas podem reduzir a eficiência de rótulos.
  • Lotes menores são mais eficientes em rótulos, mas aumentam o custo de iteração.

Fundamentos teóricos (por que pode reduzir rótulos)

O aprendizado ativo frequentemente é analisado via complexidade de rótulos (label complexity): quantos exemplos rotulados são necessários para atingir um erro-alvo.

Em algumas classes de hipóteses (hypothesis classes), sob suposições favoráveis, o aprendizado ativo pode alcançar melhorias exponenciais na complexidade de rótulos em comparação com o aprendizado passivo. Ideias-chave incluem:

  • Espaço de versões (version space): o conjunto de hipóteses consistente com os dados rotulados. Consultas reduzem esse espaço mais rapidamente quando escolhidas perto de fronteiras.
  • Região de discordância (disagreement region): a região em que hipóteses plausíveis discordam; rotular ali é mais informativo.
  • Coeficiente de discordância (disagreement coefficient): uma quantidade que caracteriza quando o aprendizado ativo produz ganhos fortes.

Ressalvas importantes:

  • Muitos resultados teóricos fortes assumem realizabilidade (realizability) (existe um classificador perfeito na classe de hipóteses) e condições benignas de ruído.
  • Em problemas reais com ruído de rótulo, sobreposição de classes e inadequação do modelo, os ganhos podem ser menores e exigir estratégias robustas.

A teoria ainda é valiosa porque explica o que o aprendizado ativo está tentando fazer: gastar rótulos onde eles reduzem mais a incerteza sobre hipóteses.

Considerações práticas para sistemas reais

Partida a frio (cold start) e semeadura

O aprendizado ativo precisa de um modelo inicial, então você precisa de um conjunto rotulado semente. Boas práticas:

  • Comece com amostragem aleatória (random sampling) para evitar viés inicial.
  • Garanta cobertura de estratos conhecidos (por exemplo, categorias de produto, idiomas).
  • Se você tiver embeddings de um modelo pré-treinado, faça a semeadura por amostragem diversa no espaço de embeddings.

A calibração importa

A amostragem por incerteza assume que probabilidades significam algo. Modelos profundos modernos podem ser mal calibrados, então considere:

  • Escalonamento de temperatura (temperature scaling)
  • Conjuntos de modelos / dropout de Monte Carlo
  • Usar margem em vez de confiança bruta

(Ver também: um tópico complementar típico seria “Calibração de Modelo”.)

Ruído de anotação e ambiguidade

Exemplos selecionados ativamente costumam ser os mais difíceis, o que pode:

  • Aumentar a discordância entre anotadores
  • Revelar falhas na política de rotulagem

Mitigações:

  • Adicionar um rótulo “incerto/outro” quando apropriado
  • Usar rotulagem com múltiplos anotadores e arbitragem
  • Acompanhar a concordância entre anotadores (inter-annotator agreement) em itens amostrados ativamente

Desbalanceamento de classes

O aprendizado ativo pode superamostrar casos confusos de minorias ou de fronteira — ou ignorar classes raras se o modelo nunca as prevê.

Mitigações:

  • Usar seleção estratificada ou restrições (mínimo por classe/cluster)
  • Combinar com busca direcionada (filtros por palavra-chave, amostragem baseada em recuperação (retrieval-based sampling))

Mudança de distribuição (distribution shift)

Se seu pool de não rotulados difere do tráfego de produção, você pode otimizar a coisa errada. Mantenha o pool de não rotulados alinhado com as fontes de implantação e monitore deriva (drift).

Critérios de parada

Sinais comuns para parar:

  • Desempenho em validação entra em platô
  • Confiança do modelo estabiliza em um conjunto separado (held-out set)
  • Ganho marginal por exemplo rotulado cai abaixo de um limiar
  • Restrições de orçamento/tempo

Protocolo de avaliação (evite resultados enganosos)

O aprendizado ativo deve ser comparado com orçamentos de rótulos iguais:

  • Plote desempenho vs. número de exemplos rotulados (curva de aprendizado (learning curve))
  • Use múltiplas sementes aleatórias (alta variância é comum)
  • Mantenha um conjunto de teste fixo e representativo
  • Cuidado: conjuntos de treino escolhidos ativamente não são amostras i.i.d.

Exemplos práticos

Exemplo 1: Triagem de e-mails / classificação de tickets de suporte

Você tem milhões de tickets, mas rotular é caro. O aprendizado ativo pode:

  • Começar com algumas centenas de tickets rotulados
  • Treinar um classificador
  • Selecionar tickets incertos (ou tickets de categorias sub-representadas) para rotulagem
  • Melhorar rapidamente a acurácia nos tipos de ticket mais confusos

Exemplo 2: Imagens médicas

Rotular exige clínicos. O aprendizado ativo pode:

  • Priorizar exames limítrofes em que os modelos discordam
  • Garantir diversidade entre tipos de scanner e demografias de pacientes
  • Reduzir o número de estudos rotulados necessários para atingir uma sensibilidade clinicamente útil

Exemplo 3: Moderação de conteúdo

Configuração em fluxo:

  • Itens chegam continuamente
  • O sistema consulta rótulos para itens perto de limites de política (discurso de ódio vs. palavrões vs. sátira)
  • Humanos rotulam os casos mais informativos, melhorando a consistência das decisões

Exemplo trabalhado: aprendizado ativo baseado em pool com amostragem por incerteza (Python)

Abaixo está uma ilustração mínima para classificação multiclasse (multi-class classification) usando scikit-learn. Ela simula um loop de aprendizado ativo selecionando repetidamente os pontos não rotulados mais incertos (maior entropia).

import numpy as np
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

def entropy(probs, eps=1e-12):
    probs = np.clip(probs, eps, 1.0)
    return -np.sum(probs * np.log(probs), axis=1)

# 1) Load data
data = fetch_20newsgroups(subset="train", remove=("headers", "footers", "quotes"))
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=0, stratify=data.target
)

# 2) Vectorize
vec = TfidfVectorizer(max_features=50000, ngram_range=(1, 2))
X_train_vec = vec.fit_transform(X_train)
X_test_vec = vec.transform(X_test)

n = X_train_vec.shape[0]
all_idx = np.arange(n)

# 3) Seed labeled set
rng = np.random.default_rng(0)
seed_size = 200
labeled_idx = rng.choice(all_idx, size=seed_size, replace=False)
unlabeled_mask = np.ones(n, dtype=bool)
unlabeled_mask[labeled_idx] = False

# 4) Active learning loop
batch_size = 200
rounds = 5

for t in range(rounds):
    # Train model on labeled data
    clf = LogisticRegression(max_iter=2000, n_jobs=-1)
    clf.fit(X_train_vec[labeled_idx], y_train[labeled_idx])

    # Evaluate
    y_pred = clf.predict(X_test_vec)
    acc = accuracy_score(y_test, y_pred)
    print(f"Round {t}: labeled={len(labeled_idx)}, test_acc={acc:.3f}")

    # Score unlabeled points by predictive entropy
    unlabeled_idx = all_idx[unlabeled_mask]
    probs = clf.predict_proba(X_train_vec[unlabeled_idx])
    scores = entropy(probs)

    # Select top-k most uncertain
    k = min(batch_size, len(unlabeled_idx))
    query_local = np.argpartition(-scores, kth=k-1)[:k]
    query_idx = unlabeled_idx[query_local]

    # "Acquire labels" (here we already have y_train; in reality you'd send to annotators)
    labeled_idx = np.concatenate([labeled_idx, query_idx])
    unlabeled_mask[query_idx] = False

Como você estenderia isso rumo à produção:

  • Substituir a etapa de “adquirir rótulos” por uma fila de anotação e um banco de dados
  • Adicionar filtragem de diversidade para evitar consultas redundantes
  • Acompanhar cobertura por classe e discordância de anotação
  • Usar um conjunto de modelos para estimativas de incerteza mais confiáveis

Aprendizado ativo com aprendizado profundo e arquiteturas modernas

Com Redes Neurais (Neural Networks) e Arquitetura Transformer (Transformer Architecture), o aprendizado ativo é amplamente usado, mas traz complicações adicionais:

  • Excesso de confiança e má calibração podem tornar a amostragem por incerteza ingênua pouco confiável.
  • O treinamento é caro, então retreinamentos frequentes por rodada podem ser impraticáveis.

Adaptações práticas comuns:

  • Usar embeddings pré-treinados (pretrained embeddings) e fazer a seleção no espaço de embeddings (conjunto central / clusterização).
  • Usar conjuntos de modelos ou dropout de Monte Carlo para estimar incerteza epistêmica (epistemic uncertainty).
  • Fazer lotes maiores com menos ciclos de retreinamento (por exemplo, 5–20 rodadas).
  • Combinar aprendizado ativo com Aprendizado Semi/Auto-Supervisionado: rotular ativamente um conjunto pequeno e então pseudo-rotular um conjunto maior.

Aprendizado ativo na era dos modelos de linguagem grandes (large language models, LLMs)

Para aplicações de modelos de linguagem grandes, “rotular” pode significar:

  • Rótulos de preferência humana (ranquear saídas)
  • Anotações específicas da tarefa (intenção, entidades, categorias de segurança)
  • Pontuações por rubrica de especialistas

As ideias de aprendizado ativo ainda se aplicam:

  • Selecionar prompts em que os modelos discordam (entre versões do modelo ou por amostragem)
  • Escolher entradas que maximizem a cobertura de intenções de usuários
  • Priorizar casos ambíguos no limite de políticas para revisão humana

Armadilhas comuns e anti-patterns

  • Caçar outliers: pontos de maior entropia podem ser casos extremos estranhos; adicione checagens de densidade/representatividade.
  • Lotes redundantes: top-k por incerteza frequentemente retorna quase-duplicados; imponha diversidade.
  • Ciclos de realimentação (feedback loops): o modelo influencia o que é rotulado, o que pode enviesar o dataset; mantenha alguma amostragem aleatória a cada rodada.
  • Ignorar a qualidade da anotação: o aprendizado ativo pode trazer itens ambíguos; invista em diretrizes e arbitragem.
  • Medir a métrica errada: otimizar eficiência de rótulos em um benchmark, mas falhar em melhorar KPIs de produção por incompatibilidade de distribuição.

Uma prática robusta é usar uma política mista (mixture policy), por exemplo:

  • 70% baseada em incerteza
  • 20% baseada em diversidade/cobertura
  • 10% exploração aleatória

Resumo

O aprendizado ativo é um cenário de problema e um fluxo de trabalho para escolher o que rotular para maximizar a eficiência de aprendizado. Ele pode reduzir drasticamente o custo de rotulagem quando aplicado com cuidado, especialmente em domínios com anotações caras e muitos dados não rotulados. O sucesso normalmente vem da combinação de:

  • Um modelo baseline forte (frequentemente pré-treinado)
  • Uma estratégia de aquisição sensata (incerteza + diversidade + representatividade)
  • Processos de anotação de alta qualidade
  • Avaliação cuidadosa com orçamentos de rótulos fixos e distribuições reais de dados

Na prática, o aprendizado ativo é menos sobre uma única heurística “melhor” e mais sobre projetar um loop humano–modelo (human–model loop) confiável que gaste esforço de rotulagem onde ele produz a maior melhoria.