Aprendizado Online

O que é Aprendizado Online?

Aprendizado online (online learning) é um cenário de aprendizado de máquina (machine learning) em que um modelo aprende sequencialmente a partir de um fluxo de dados, atualizando após cada exemplo (ou pequeno lote (batch)) em vez de treinar uma única vez em um conjunto de dados fixo. Um desafio definidor é que a distribuição dos dados pode mudar ao longo do tempo — por exemplo, preferências de usuários mudam, padrões de fraude evoluem ou o comportamento de sensores deriva. Essa não estacionariedade (non-stationarity) é frequentemente chamada de deriva de conceito (concept drift) (ver Deriva de Conceito (Concept Drift)).

O aprendizado online se situa dentro da família mais ampla de cenários de Aprendizado Supervisionado (Supervised Learning) e Aprendizado Não Supervisionado (Unsupervised Learning), mas difere em como os dados chegam e como o modelo é atualizado.

Um loop canônico de aprendizado online

No passo de tempo (t = 1,2,\dots):

O aprendiz tem parâmetros (w_t).
Ele recebe uma entrada (x_t).
Ele prediz (\hat{y}_t = f(x_t; w_t)).
Em seguida, observa um feedback (frequentemente o rótulo (label)) (y_t) e incorre em uma perda (loss) (\ell(\hat{y}_t, y_t)).
Atualiza os parâmetros para (w_{t+1}) usando ((x_t, y_t)).

Esse padrão “predizer-então-atualizar” é comum em classificação em fluxo, ranqueamento (ranking) e regressão.

Quando e por que o aprendizado online é usado

O aprendizado online é tipicamente escolhido quando uma ou mais destas restrições se aplicam:

Os dados chegam continuamente (fluxos, logs, eventos).
O ambiente muda (distribuições não estacionárias).
Adaptação de baixa latência é valiosa (personalização, fraude, mercados).
Armazenar todos os dados é impraticável (volume, privacidade, governança).
Os rótulos podem ser atrasados ou parciais (cliques, conversões, revisão humana).

Em contraste, o treinamento em lote (batch training) assume um conjunto de dados em grande parte fixo e, frequentemente, uma distribuição estacionária.

Principais variantes do cenário de aprendizado online

Online vs. incremental vs. streaming

Esses termos são relacionados, mas não idênticos:

Aprendizado online: atualizações sequenciais com uma meta explícita de desempenho ao longo do tempo (frequentemente formulada via arrependimento (regret)).
Aprendizado incremental (incremental learning): a propriedade de implementação de que um modelo pode atualizar sem retreinar do zero (por exemplo, partial_fit).
Aprendizado em fluxo (streaming learning): uma formulação de engenharia que enfatiza memória limitada e vazão (throughput); pode usar micro-lotes (micro-batches).

Perspectivas estocástica vs. adversarial

Trabalhos teóricos frequentemente distinguem:

Aprendizado online estocástico (stochastic online learning): exemplos são amostrados de uma distribuição (possivelmente derivando lentamente).
Aprendizado online adversarial (adversarial online learning): exemplos podem ser escolhidos para dificultar o aprendizado (pior caso). Isso gera garantias robustas e motiva algoritmos como Hedge/Gradiente Exponenciado (Exponentiated Gradient).

Ambas as visões são úteis: sistemas em produção enfrentam alguma estrutura (não totalmente adversarial), mas também não estacionariedade e loops de feedback que podem se assemelhar a comportamento adversarial.

Feedback completo vs. feedback parcial

Informação completa (full information): você observa o rótulo verdadeiro (y_t) após cada predição (típico em classificação online quando rótulos chegam).
Feedback bandit (bandit feedback): você observa apenas a recompensa da ação escolhida (por exemplo, você mostra uma recomendação e observa seu clique). Este é o domínio de Bandidos de Múltiplos Braços (Multi-Armed Bandits) e bandits contextuais (contextual bandits), intimamente relacionados ao aprendizado online e ao Aprendizado por Reforço (Reinforcement Learning).

Fundamentos teóricos

A teoria de aprendizado online fornece ferramentas para raciocinar sobre desempenho ao longo do tempo, especialmente sob condições mutáveis ou desconhecidas.

Arrependimento: competindo com um benchmark

Um conceito central é o arrependimento, que mede o quanto o aprendiz online se sai pior em comparação com o melhor preditor fixo em retrospecto.

Dadas perdas (\ell_t(w)) em cada passo de tempo, o arrependimento (estático) após (T) passos é:

[ R_T = \sum_{t=1}^T \ell_t(w_t) - \min_{w \in \mathcal{W}} \sum_{t=1}^T \ell_t(w) ]

Um algoritmo tem garantias “sem arrependimento” (no-regret) se (R_T/T \to 0) quando (T\to\infty).

Mas as distribuições mudam: arrependimento dinâmico

Com deriva, o “melhor preditor fixo” pode ser irrealista. Em vez disso, pode-se comparar com uma sequência de comparadores variável (u_t):

[ R_T^{\text{dyn}} = \sum_{t=1}^T \ell_t(w_t) - \sum_{t=1}^T \ell_t(u_t) ]

Os limites frequentemente dependem de quanto o comparador se move (seu comprimento de trajetória), capturando a ideia de que acompanhar um alvo que muda rapidamente é inerentemente mais difícil.

Otimização Convexa Online (Online Convex Optimization, OCO)

Uma grande parte da teoria de aprendizado online é construída sobre otimização convexa online, em que cada perda (\ell_t(w)) é convexa nos parâmetros (w), e o aprendiz escolhe (w_t) antes de ver (\ell_t).

Esse arcabouço cobre modelos lineares com perdas convexas (regressão logística (logistic regression), regressão linear (linear regression), perda hinge (hinge loss) no estilo SVM) e leva a algoritmos amplamente aplicáveis com limites de arrependimento.

Descida do Gradiente Online (Online Gradient Descent, OGD)

Um algoritmo central é a descida do gradiente online, uma versão sequencial de Descida do Gradiente (Gradient Descent):

[ w_{t+1} = \Pi_{\mathcal{W}}\left(w_t - \eta_t \nabla \ell_t(w_t)\right) ]

(\eta_t) é um cronograma de taxa de aprendizado (learning rate).
(\Pi_{\mathcal{W}}) projeta os parâmetros de volta em um conjunto viável (opcional, por exemplo, restrições de norma).

Para perdas convexas Lipschitz, a OGD atinge arrependimento na ordem de (O(\sqrt{T})) com taxas de aprendizado apropriadas; suposições mais fortes (convexidade forte (strong convexity)) produzem taxas mais rápidas.

Seguir o Líder Regularizado (Follow-the-Regularized-Leader, FTRL) e métodos adaptativos

Outra família influente é a FTRL, que escolhe:

[ w_{t+1} = \arg\min_{w \in \mathcal{W}} \left(\sum_{i=1}^t \ell_i(w) + \lambda R(w)\right) ]

Com certas escolhas, a FTRL se conecta a média dual (dual averaging), aprendizado online esparso (por exemplo, regularização L1 (L1 regularization)) e sistemas de larga escala amplamente usados para taxa de cliques (click-through rate, CTR).

Algoritmos online adaptativos como atualizações no estilo AdaGrad ajustam taxas de aprendizado por coordenada (per-coordinate learning rates), frequentemente melhorando desempenho em fluxos esparsos e de alta dimensionalidade.

Limites de erros e o Perceptron

Para dados linearmente separáveis, o algoritmo Perceptron fornece clássicos limites de erros (quantos erros de classificação ele pode cometer). Embora a separabilidade raramente se sustente em fluxos reais com deriva, o Perceptron introduziu ideias-chave: atualizações online, margem e robustez sob chegada sequencial.

Atualizações Passive-Aggressive

Algoritmos Passive-Aggressive (PA) ajustam o modelo apenas quando o exemplo atual é mal predito (ou viola uma margem), tornando-os atraentes para classificação online rápida:

Passivo: não muda se a predição é “boa o suficiente”.
Agressivo: muda apenas o necessário para corrigir a violação atual.

Desafios práticos em fluxos não estacionários

O aprendizado online se torna significativamente mais difícil quando as distribuições mudam.

Tipos de deriva

Padrões comuns incluem:

Deriva súbita (sudden drift): mudança abrupta (por exemplo, mudança de política, novo ataque de fraude).
Deriva gradual (gradual drift): tendência lenta (sazonalidade, preferências em evolução).
Contextos recorrentes (recurring contexts): padrões retornam (efeitos dia útil/fim de semana).
Deriva de atributos (feature drift): (P(x)) muda, mas (P(y|x)) permanece semelhante.
Deriva de conceito: (P(y|x)) muda (o mapeamento em si se desloca).

A deriva afeta tanto como você atualiza modelos quanto como você os avalia.

Esquecimento catastrófico

Quando um modelo se adapta rapidamente a novos dados, ele pode esquecer padrões antigos, mas ainda relevantes. Isso é especialmente proeminente no treinamento online de Redes Neurais (Neural Networks), sobrepondo-se ao Aprendizado Contínuo (Continual Learning).

Mitigações comuns incluem:

buffers de replay (replay buffers) (armazenar uma amostra de dados passados),
regularização contra deriva dos parâmetros,
modelos de mistura (mixture models) ou ensembles com diferentes escalas de tempo.

Rótulos atrasados, ausentes ou enviesados

Em muitos sistemas, rótulos chegam tarde (conversão após clique), estão ausentes (nem toda fraude é detectada) ou são enviesados pelas ações do modelo (você só observa resultados para aquilo que escolheu mostrar). Isso conecta o aprendizado online a bandits e a considerações causais.

Loops de feedback e dados não i.i.d.

Uma vez que um modelo influencia quais dados são coletados (recomendações, moderação, anúncios), os dados de treinamento deixam de ser independentes e identicamente distribuídos (independent and identically distributed, i.i.d.) e podem amplificar vieses. Monitoramento e estratégias de exploração (exploration) são frequentemente necessários.

Algoritmos comumente usados na prática

A “melhor” escolha depende de latência, memória, disponibilidade de rótulos e complexidade do modelo.

Modelos lineares com SGD / OGD

Para fluxos de alta vazão (anúncios, classificação de texto), modelos lineares treinados com descida estocástica do gradiente (stochastic gradient descent, SGD) online continuam extremamente fortes:

regressão logística / SVM linear com atributos esparsos
atualizações rápidas, pequena pegada de memória
fácil de regularizar e monitorar

Eles são tipicamente atualizados via gradientes por exemplo ou por micro-lote.

Árvores online: Árvores de Hoeffding (VFDT)

Para dados tabulares em fluxo, Árvores de Hoeffding usam limites estatísticos para decidir quando uma divisão é confiável, permitindo aprendizado incremental de árvores de decisão sem armazenar todos os dados. Elas são frequentemente combinadas com detectores de deriva (drift detectors) para resetar ou adaptar ramos.

Ensembles online e ponderação adaptativa no tempo

Ensembles podem lidar com deriva mantendo múltiplos aprendizes treinados em diferentes janelas de tempo e ponderando-os pelo desempenho recente. Exemplos incluem:

variantes de bagging / boosting online
arcabouços de “especialistas” (experts) com pesos multiplicativos (com respaldo teórico sob condições adversariais)

Clusterização em fluxo e detecção de anomalias

Para Aprendizado Não Supervisionado em fluxos:

k-means em fluxo / k-means em mini-lotes (mini-batch k-means)
PCA online (online PCA) / métodos de sketching
estimação incremental de densidade ou detectores de anomalia baseados em isolamento (frequentemente com janelamento)

Modelos profundos: ajuste fino online e padrões de aprendizado contínuo

Aprendizado online profundo (deep online learning) é viável, mas exige cuidado:

atualizações por micro-lotes a partir de dados recentes
replay para evitar esquecimento
taxas de aprendizado conservadoras e validação/rollback robustos
às vezes congelando a maioria das camadas e atualizando pequenos adaptadores (conceitualmente relacionado a Aprendizado por Transferência (Não Profundo) (Transfer Learning (Non-Deep)), mas, em cenários profundos, isso é mais parecido com ajuste fino contínuo)

Exemplos práticos

Exemplo 1: filtragem de spam que se adapta a novas campanhas

Um classificador de spam recebe e-mails sequencialmente. Atacantes evoluem constantemente a redação e a estrutura.

Use um classificador linear online (por exemplo, regressão logística com n-grams com hash).
Atualize quando um usuário marca spam/não spam (sinal de rótulo).
Use uma avaliação por janela deslizante para detectar degradação.

Benefício-chave: adaptação rápida sem retreinamento completo periódico.

Exemplo 2: detecção de fraude com estratégias de ataque mutáveis

Padrões de fraude mudam rapidamente e os rótulos podem ser atrasados (estornos dias depois).

Combine atualizações online de curto prazo com um modelo base de longo prazo.
Dê mais peso a dados recentes; opcionalmente use detectores de deriva para disparar resets.
Trate rótulos atrasados com cuidado (por exemplo, atualize quando o rótulo chegar; mantenha eventos “pendentes”).

Exemplo 3: recomendações personalizadas com feedback bandit

Você recomenda um item e observa um clique (feedback parcial).

Um algoritmo de bandit contextual atualiza apenas a partir da recompensa observada.
Precisa de exploração para evitar ficar preso exibindo apenas itens historicamente bons.
A distribuição muda à medida que usuários mudam, o inventário muda e as estações mudam.

Isso é aprendizado online sob informação parcial, fazendo a ponte em direção ao Aprendizado por Reforço.

Avaliação em aprendizado online

Divisões tradicionais de treino/teste podem ser enganosas sob deriva. Métodos comuns de avaliação online incluem:

Avaliação prequencial (prequential) (test-then-train)

Para cada exemplo:

predizer em (x_t),
registrar perda/métrica,
então atualizar em ((x_t, y_t)).

Isso espelha a implantação e revela desempenho ao longo do tempo.

Métricas por janela deslizante

Acompanhe métricas em uma janela móvel (por exemplo, últimos 10 mil eventos) para refletir o desempenho atual sob deriva. Compare:

janela curta (detecção rápida, ruidosa),
janela longa (estável, reação mais lenta).

Retrospectiva (backtesting) e reexecução (replay)

Se você tem fluxos históricos, pode “reexecutá-los” em ordem de timestamp. Atenção: o modelo pode ter influenciado quais dados foram observados historicamente (viés de seleção), então a reexecução pode superestimar o desempenho no mundo real.

Monitoramento e guardrails

Em produção, sistemas de aprendizado online frequentemente incluem:

implantações canário (canary deployments) ou shadow deployments,
mecanismos de rollback,
monitores de deriva/qualidade (drift/quality monitors) (estatísticas de atributos, distribuição de previsões, calibração),
alertas para quedas de métricas e anomalias no pipeline de dados.

Padrões de engenharia para sistemas de aprendizado online

Arquitetura de treinamento/serving

Uma configuração típica inclui:

Ingestão de eventos (Kafka/PubSub)
Cálculo de atributos (tempo real + possivelmente um repositório de atributos (feature store))
Treinador online (consome eventos, atualiza parâmetros)
Serving do modelo (predições de baixa latência)
Distribuição do modelo (enviar pesos atualizados periodicamente ou transmitir atualizações)
Monitoramento (deriva de dados, atraso de rótulos, desempenho)

Duas escolhas importantes de projeto:

Frequência de atualização: por evento vs. micro-lote (por exemplo, a cada minuto).
Gerenciamento de estado: armazenar o estado do otimizador (por exemplo, acumuladores do AdaGrad) e garantir reprodutibilidade.

Janelamento e mecanismos de esquecimento

Como o modelo “certo” muda, sistemas frequentemente implementam esquecimento de forma intencional:

Decaimento exponencial de gradientes antigos (implícito em alguns otimizadores / cronogramas de taxa de aprendizado)
Janela deslizante de treinamento (treinar apenas nos últimos N dias)
Perda ponderada (dados recentes têm maior peso)

Essas são aproximações práticas para acompanhar um alvo em movimento.

Lidando com rótulos atrasados

Estratégias comuns:

atualizar quando os rótulos chegam, usando IDs de eventos para juntar atributos e desfechos,
manter uma fila de predições sem rótulo,
tratar desfechos não observados com cuidado (não assumir negativo por padrão, a menos que seja justificável).

Relação com outros tipos de problema

O aprendizado online frequentemente ainda é supervisionado (rótulos existem), mas sequencial e não estacionário: ver Aprendizado Supervisionado.
Ele pode ser combinado com estratégias de consulta (query strategies) para decidir o que rotular em seguida, especialmente com orçamento limitado de rotulagem: ver Aprendizado Ativo (Active Learning).
Em cenários em fluxo com rótulos esparsos, você pode aproveitar dados não rotulados para aprendizado de representação ou consistência: ver Aprendizado Semi/Self-Supervisionado (Semi/Self-Supervised Learning).
Quando rótulos são ruidosos, heurísticos ou gerados programaticamente e chegam continuamente: ver Supervisão Fraca (Weak Supervision).

Exemplo mínimo de código: classificação incremental com deriva

Abaixo está uma pequena ilustração usando partial_fit (atualizações incrementais). Ela simula um fluxo de classificação binária em que a fronteira de decisão muda no meio.

import numpy as np
from sklearn.linear_model import SGDClassifier
from sklearn.metrics import log_loss

rng = np.random.default_rng(0)

def stream(T=5000, drift_at=2500):
    for t in range(T):
        x = rng.normal(size=(2,))
        # Concept drift: label rule changes at drift_at
        if t < drift_at:
            y = 1 if (x[0] + 0.5 * x[1]) > 0 else 0
        else:
            y = 1 if (-0.5 * x[0] + x[1]) > 0 else 0
        yield x, y

clf = SGDClassifier(loss="log_loss", alpha=1e-5, learning_rate="optimal")
classes = np.array([0, 1])

# Online evaluation (prequential): predict -> score -> update
losses = []
initialized = False

for t, (x, y) in enumerate(stream()):
    x = x.reshape(1, -1)
    y_arr = np.array([y])

    if initialized:
        proba = clf.predict_proba(x)
        losses.append(log_loss(y_arr, proba, labels=classes))
    else:
        # no prediction before first fit (could also use a default)
        initialized = True

    clf.partial_fit(x, y_arr, classes=classes)

print(f"Mean prequential log loss over stream: {np.mean(losses):.4f}")
print(f"Last-1000 mean log loss: {np.mean(losses[-1000:]):.4f}")

O que você deve observar em um experimento mais completo:

o desempenho melhora antes da deriva,
piora em torno do ponto de deriva,
e então se recupera à medida que o modelo se adapta.

Em sistemas reais, você acompanharia a perda ao longo do tempo e potencialmente acionaria mitigação (aumentar a taxa de aprendizado, resetar parte do modelo, trocar para um modelo de janela curta, etc.).

Armadilhas comuns e boas práticas

Não avalie como ML em lote: a ordem temporal importa; use avaliação prequencial ou janelas deslizantes.
Ajuste a velocidade de adaptação: lenta demais → modelo desatualizado; rápida demais → sensibilidade a ruído e esquecimento.
Cuidado com vazamento e loops de feedback: seu modelo muda os dados que você vê.
Prefira baselines simples e robustas: modelos lineares online e probabilidades calibradas frequentemente superam configurações online excessivamente complexas.
Planeje rollback: atualizações online podem degradar rapidamente sob bugs de pipeline ou choques de distribuição.
Separe responsabilidades: correção de atributos, correção de rótulos e lógica de atualização do modelo devem ser testáveis de forma independente.

Resumo

O aprendizado online aborda a realidade prática de que muitos sistemas de ML operam em fluxos de dados cujas distribuições mudam ao longo do tempo. Ele combina:

um protocolo de treinamento sequencial (predizer-então-atualizar),
ferramentas teóricas como arrependimento e otimização convexa online,
e práticas de engenharia para monitoramento, tratamento de deriva e implantação segura.

Quando bem feito, o aprendizado online permite modelos que se adaptam continuamente, mantêm desempenho sob deriva e respondem rapidamente a novos padrões — muitas vezes com modelos mais simples e garantias mais fortes do que grandes retreinamentos periódicos em lote.