Aprendizado Multitarefa (Multi-Task Learning)

Visão geral

Aprendizado Multitarefa (Multi-Task Learning, MTL) é um paradigma de treinamento em que um único modelo é treinado em múltiplas tarefas simultaneamente, com o objetivo de aprender representações compartilhadas que melhorem a generalização, a eficiência de dados e, às vezes, a eficiência de implantação (deployment efficiency) (um modelo em vez de muitos). A ideia central é que tarefas relacionadas contêm sinais sobrepostos sobre a estrutura subjacente dos dados, de modo que aprendê-las em conjunto pode atuar como uma forma de viés indutivo (inductive bias) e regularização (regularization).

O aprendizado multitarefa é amplamente usado no aprendizado profundo (deep learning) moderno: desde sistemas de visão computacional que, conjuntamente, predizem caixas delimitadoras (bounding boxes), classes e máscaras de segmentação (segmentation masks), até modelos de PLN (Processamento de Linguagem Natural, NLP) treinados em misturas de tarefas, e até grandes modelos “fundamentais (foundation)” que são ajustados finamente (fine-tuned) em muitos objetivos a jusante (downstream).

O aprendizado multitarefa está intimamente conectado a Aprendizado de Representações (porque o compartilhamento incentiva características reutilizáveis) e frequentemente complementa estratégias como Aprendizado Auto-Supervisionado (pré-treinamento) e Destilação de Conhecimento (comprimir um professor multitarefa).

O que conta como uma “tarefa”?

Uma tarefa é tipicamente definida por:

  • Um conjunto de dados (dataset) (entradas e rótulos ou alvos)
  • Uma função objetivo/função de perda (objective/loss function)
  • Uma métrica de avaliação
  • Às vezes, um espaço de saída (por exemplo, rótulos de classe, tokens, coordenadas)

Exemplos de tarefas que podem ser aprendidas em conjunto:

  • Visão: classificação, detecção (detection), segmentação (segmentation), estimação de profundidade (depth estimation)
  • PLN: análise de sentimento (sentiment analysis), reconhecimento de entidades nomeadas (Named Entity Recognition, NER), etiquetagem de classes gramaticais (Part-of-Speech tagging, POS tagging), resposta a perguntas (question answering)
  • Fala: reconhecimento automático de fala (Automatic Speech Recognition, ASR), identificação de locutor (speaker identification), reconhecimento de emoção (emotion recognition)
  • Recomendadores: previsão de taxa de clique (Click-Through Rate, CTR), previsão de conversão (conversion prediction), previsão de cancelamento (churn prediction)

Aprendizado multitarefa não é o mesmo que:

  • Classificação multirrótulo (multi-label classification): uma tarefa com múltiplos rótulos ao mesmo tempo.
  • Aprendizado por transferência (transfer learning): treinar na tarefa A e, depois, fazer ajuste fino (fine-tune) na tarefa B (sequencial), enquanto o aprendizado multitarefa é simultâneo.
  • Aprendizado multimodal (multi-modal learning): múltiplas modalidades de entrada (texto+imagem), embora você possa combinar multimodal e multitarefa.

Por que o Aprendizado Multitarefa ajuda (e quando ele atrapalha)

Intuição: estrutura compartilhada e viés indutivo

Se as tarefas são relacionadas, elas frequentemente dependem de fatores latentes comuns. Por exemplo:

  • Reconhecer a classe de um objeto e sua máscara de segmentação exige entender bordas, formas e semântica.
  • Etiquetagem de classes gramaticais e reconhecimento de entidades nomeadas se beneficiam de pistas sintáticas e do significado contextual das palavras.

Ao forçar um modelo a realizar múltiplas tarefas, o aprendizado multitarefa pode:

  • Reduzir sobreajuste (overfitting): camadas compartilhadas precisam satisfazer múltiplas restrições.
  • Melhorar a eficiência amostral (sample efficiency): tarefas auxiliares fornecem sinal de aprendizado adicional.
  • Aprender características mais robustas (features): representações que generalizam entre objetivos.

Esta é uma forma prática de viés indutivo: a suposição de que as tarefas compartilham fatores explicativos é “incorporada” ao modelo e ao procedimento de treinamento.

O principal modo de falha: transferência negativa

O aprendizado multitarefa também pode degradar o desempenho, um fenômeno frequentemente chamado de transferência negativa (negative transfer) ou interferência entre tarefas (task interference). Razões comuns:

  • As tarefas não são relacionadas ou são apenas fracamente relacionadas.
  • Uma tarefa domina os gradientes (gradients) (devido à escala, ao volume de dados ou por ser mais fácil de otimizar).
  • Direções de gradiente conflitantes levam a aprendizado instável ou comprometido.
  • Tarefas diferentes preferem características diferentes (por exemplo, viés por textura vs. viés por forma).

A pesquisa e a prática modernas em aprendizado multitarefa focam fortemente em balancear tarefas, gerenciar conflitos de gradiente e escolher o que compartilhar.

Padrões centrais de projeto em MTL

Compartilhamento rígido de parâmetros (hard parameter sharing) (tronco compartilhado, cabeças separadas)

A arquitetura mais comum é:

  • Um codificador/estrutura-base (encoder/backbone) compartilhado (o “tronco”)
  • Uma cabeça (head) específica por tarefa para cada tarefa

Isso é chamado de compartilhamento rígido porque a maioria dos parâmetros é compartilhada.

Prós

  • Simples e eficiente
  • Forte regularização via representação compartilhada
  • Inferência barata se você precisa de múltiplas saídas

Contras

  • Suscetível à transferência negativa quando as tarefas entram em conflito
  • Difícil customizar capacidade por tarefa

Exemplo (visão): uma rede neural convolucional (Convolutional Neural Network, CNN) ou um Transformador de Visão (Vision Transformer, ViT) compartilhado com cabeças para classificação e segmentação.

Compartilhamento suave de parâmetros (soft parameter sharing) (modelos separados com acoplamento)

Cada tarefa tem seus próprios parâmetros, mas eles são regularizados para serem semelhantes, ou compartilham informação por meio de conexões cruzadas.

Formas comuns:

  • Regularização L2 entre pesos correspondentes
  • Redes cross-stitch (cross-stitch networks), redes sluice (sluice networks) (compartilhamento de características aprendido)
  • Módulos de adaptador (adapter) compartilhados

Prós

  • Menos transferência negativa; tarefas podem divergir quando necessário
  • Padrões de compartilhamento flexíveis

Contras

  • Mais parâmetros e computação
  • Treinamento e ajuste mais complexos

Compartilhamento parcial e modularidade

Um compromisso prático é compartilhar camadas iniciais (características genéricas) e ramificar mais tarde (características específicas de tarefa). Em transformadores (Transformers), isso pode significar:

  • Blocos inferiores compartilhados
  • Blocos superiores ou cabeças específicas por tarefa
  • Adaptadores eficientes em parâmetros (parameter-efficient) (por exemplo, adaptação de baixa ordem (Low-Rank Adaptation, LoRA)/adaptadores) por tarefa para especialização

Isso costuma ser eficaz porque características iniciais (bordas, padrões locais, sintaxe básica) são reutilizáveis, enquanto características finais são mais específicas da tarefa.

Funções objetivo: como combinar tarefas

Um objetivo padrão de aprendizado multitarefa é uma soma ponderada (weighted sum) das perdas (losses) das tarefas:

[ \mathcal{L}(\theta)=\sum_{t=1}^{T} \lambda_t , \mathcal{L}_t(\theta) ]

Onde:

  • ( \mathcal{L}_t ) é a perda para a tarefa (t)
  • ( \lambda_t ) é seu peso

Por que ponderar não é trivial

Tarefas diferentes podem ter:

  • Diferentes escalas de perda (por exemplo, entropia cruzada (cross-entropy) vs. regressão L1 (L1 regression))
  • Diferentes níveis de ruído nos rótulos
  • Diferentes tamanhos de conjunto de dados
  • Diferentes velocidades de aprendizado

Uma escolha ruim de ( \lambda_t ) pode fazer com que uma tarefa domine ou deixe outras “famintas” de sinal.

Estratégias comuns de ponderação

  1. Pesos manuais

    • Comece igual e depois ajuste com base em métricas de validação (validation metrics).
    • Base razoável, frequentemente surpreendentemente competitiva.

  2. Ponderação baseada em incerteza (uncertainty-based weighting)

    • Pondere tarefas inversamente proporcional ao ruído/incerteza aprendido.
    • Popular em misturas multitarefa de regressão/classificação.

  3. Balanceamento por norma do gradiente (gradient-norm balancing) (por exemplo, GradNorm)

    • Ajuste pesos para igualar magnitudes de gradiente entre tarefas.

  4. Amostragem dinâmica (dynamic sampling)

    • Amostre tarefas ou lotes para controlar a contribuição efetiva (lotes balanceados por tarefa).
    • Útil quando tarefas têm tamanhos de conjunto de dados diferentes.

  5. Otimização multiobjetivo (multi-objective optimization)

    • Trate o aprendizado multitarefa como otimização de uma frente de Pareto (Pareto front); compute atualizações que balanceiem objetivos (por exemplo, variantes de MGDA).
    • Mais complexa, mas fundamentada.

Mitigação de conflito de gradiente (“cirurgia de gradiente”)

Mesmo com boa ponderação, tarefas podem produzir gradientes apontando em direções conflitantes. Métodos como PCGrad modificam gradientes por tarefa para reduzir interferência destrutiva ao projetar componentes conflitantes para fora.

Na prática, esses métodos podem ajudar quando as tarefas são razoavelmente relacionadas, mas ainda competem por capacidade.

Exemplo prático: codificador compartilhado com múltiplas cabeças (no estilo PyTorch (PyTorch-style))

Abaixo está um exemplo mínimo de um modelo multitarefa com um codificador compartilhado e duas cabeças: uma para classificação e outra para regressão (regression). Os elementos-chave são (1) características compartilhadas, (2) cabeças específicas por tarefa e (3) uma perda combinada com pesos.

import torch
import torch.nn as nn
import torch.nn.functional as F

class MultiTaskNet(nn.Module):
    def __init__(self, in_dim=128, hidden=256, num_classes=10):
        super().__init__()
        # Shared trunk
        self.encoder = nn.Sequential(
            nn.Linear(in_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
        )
        # Task-specific heads
        self.class_head = nn.Linear(hidden, num_classes)  # classification
        self.reg_head   = nn.Linear(hidden, 1)            # regression

    def forward(self, x):
        h = self.encoder(x)
        logits = self.class_head(h)
        y_hat = self.reg_head(h).squeeze(-1)
        return logits, y_hat

model = MultiTaskNet()

def multitask_loss(logits, y_hat, y_class, y_reg, w_cls=1.0, w_reg=1.0):
    loss_cls = F.cross_entropy(logits, y_class)
    loss_reg = F.smooth_l1_loss(y_hat, y_reg)
    return w_cls * loss_cls + w_reg * loss_reg, {"cls": loss_cls, "reg": loss_reg}

# Example training step
opt = torch.optim.AdamW(model.parameters(), lr=3e-4)

x = torch.randn(32, 128)
y_class = torch.randint(0, 10, (32,))
y_reg = torch.randn(32)

logits, y_hat = model(x)
loss, parts = multitask_loss(logits, y_hat, y_class, y_reg, w_cls=1.0, w_reg=0.5)

opt.zero_grad()
loss.backward()
opt.step()

Em sistemas reais, você também precisa de:

  • Carregadores de dados (dataloaders) separados por tarefa (frequentemente conjuntos de dados diferentes)
  • Uma estratégia de amostragem de lote/tarefa
  • Acompanhamento cuidadoso de métricas por tarefa
  • Possivelmente tratamento de conflito de gradiente ou ponderação dinâmica

Dados e logística de treinamento em sistemas reais de MTL

Cenário A: um conjunto de dados, múltiplos rótulos

Exemplo: um conjunto de dados de direção autônoma em que cada imagem tem caixas delimitadoras, máscaras de segmentação e profundidade.

Isso é o mais simples logisticamente: o modelo consome um lote e calcula todas as perdas.

Cenário B: múltiplos conjuntos de dados (comum em PLN e na indústria)

Exemplo: um conjunto de dados para sentimento, outro para reconhecimento de entidades nomeadas, outro para QA (question answering).

Você precisa escolher como intercalar tarefas:

  • Lotes round-robin (round-robin batching): alternar entre tarefas
  • Amostragem proporcional (proportional sampling): amostrar tarefas proporcionalmente ao tamanho do conjunto de dados
  • Amostragem baseada em temperatura (temperature-based sampling): suaviza desequilíbrios extremos (comum em ajuste fino multitarefa em larga escala)
  • Currículo (curriculum): começar com tarefas mais fáceis/de alto sinal e depois adicionar as mais difíceis (relacionado a Aprendizado por Currículo)

Uma dica prática: trate a “mistura de tarefas” como um hiperparâmetro de primeira classe. Muitas falhas do aprendizado multitarefa são simplesmente devidas a proporções de mistura ruins.

Rótulos ausentes e supervisão parcial

Frequentemente, nem todo exemplo tem todo rótulo. Abordagens comuns:

  • Computar a perda de uma tarefa apenas quando seu rótulo existe (mascaramento (masking))
  • Usar perdas auxiliares semi-supervisionadas (semi-supervised) ou auto-supervisionadas para preencher lacunas (veja Aprendizado Auto-Supervisionado)

Fundamentos teóricos (modelos mentais úteis)

MTL como regularização

Compartilhar parâmetros restringe o espaço de hipóteses (hypothesis space): o modelo precisa encontrar representações que funcionem para múltiplas tarefas, o que reduz a variância (variance) e pode melhorar a generalização — especialmente quando cada tarefa tem poucos dados.

Transferência indutiva e fatores latentes compartilhados

Se as tarefas dependem de variáveis latentes compartilhadas (z) (por exemplo, “identidade do objeto”, “sintaxe”), então aprender múltiplas tarefas pode ajudar a inferir (z) com mais precisão. O codificador compartilhado aproxima o aprendizado de uma representação desses fatores latentes.

MTL como otimização multiobjetivo

Cada tarefa é um objetivo. Em geral, pode não existir uma única solução que minimize simultaneamente todas as perdas. Em vez disso, há uma fronteira de Pareto (Pareto frontier) de compromissos. Esquemas de ponderação escolhem um ponto nessa fronteira.

Esse enquadramento ajuda a explicar por que:

  • Alguns compromissos são inevitáveis (melhorar uma tarefa pode piorar outra)
  • Ajustar pesos muda a solução de compromisso resultante

Arquiteturas comuns e onde elas aparecem

Visão computacional: predição multi-cabeça

  • Detecção + classificação + regressão de caixa (box regression) (objetivo multitarefa clássico em detectores)
  • Segmentação + profundidade + normais em entendimento de cena
  • Estrutura-base compartilhada + pirâmide de características (feature pyramid) + cabeças especializadas

Aqui, o aprendizado multitarefa costuma ser essencial: modelos de detecção rotineiramente combinam múltiplos termos de perda.

PLN: codificador transformador compartilhado com cabeças de tarefa

Um codificador compartilhado (por exemplo, do tipo BERT) com cabeças para:

  • Classificação (sentimento)
  • Rotulagem por token (token labeling) (reconhecimento de entidades nomeadas)
  • Predição de span (span prediction) (QA)

A prática moderna frequentemente usa:

  • Codificador compartilhado + camadas classificadoras por tarefa
  • Ou adaptadores eficientes em parâmetros por tarefa para especialização

Fala e áudio

Codificador acústico compartilhado com cabeças para:

  • Reconhecimento automático de fala (CTC ou seq2seq)
  • Identificação de locutor
  • Detecção de palavra-chave (keyword spotting)

Sistemas de recomendação

O aprendizado multitarefa é extremamente comum em recomendadores industriais:

  • Prever CTR e conversão conjuntamente
  • Prever engajamento de curto prazo e retenção de longo prazo
  • Embeddings de usuário/item compartilhados, torres de tarefa (task towers) separadas

Isso pode reduzir custos de treinamento/inferência e melhorar a robustez do ranqueamento.

Robótica e controle (política + tarefas auxiliares)

Agentes frequentemente aprendem tarefas auxiliares (por exemplo, profundidade, predição de recompensa, dinâmica inversa (inverse dynamics)) para melhorar representações para controle. Essas tarefas auxiliares podem estabilizar e enriquecer sinais de aprendizado.

Benefícios práticos e trade-offs

Benefícios

  • Melhor generalização via representações compartilhadas
  • Melhor desempenho em tarefas com poucos recursos (dados auxiliares ajudam)
  • Eficiência operacional: um modelo pode servir múltiplas saídas
  • Consistência: previsões compartilhadas podem ser mais coerentes (por exemplo, detecção alinhada com segmentação)

Trade-offs

  • Complexidade de otimização: balancear tarefas é difícil
  • Transferência negativa: tarefas não relacionadas podem prejudicar umas às outras
  • Complexidade de depuração: muitas partes móveis (mistura, pesos, métricas)
  • Restrições de serving: se uma tarefa precisa de baixa latência (low latency) mas outra exige computação pesada, um único modelo compartilhado pode ser inconveniente

Armadilhas comuns e como lidar com elas

Armadilha 1: uma tarefa domina o treinamento

Sintomas

  • Uma perda diminui rapidamente; outras estagnam
  • O codificador compartilhado se hiperespecializa

Correções

  • Normalizar ou reescalar perdas
  • Usar ponderação dinâmica (GradNorm/ponderação por incerteza)
  • Ajustar as proporções de amostragem de tarefas

Armadilha 2: transferência negativa entre tarefas

Sintomas

  • Treinamento conjunto pior do que treinamento separado
  • Melhorias em uma tarefa se correlacionam com regressões em outra

Correções

  • Reduzir compartilhamento (ramificar mais cedo, adicionar camadas específicas por tarefa)
  • Usar módulos de adaptador para especialização
  • Tentar mitigação de conflito de gradiente (por exemplo, ideias ao estilo PCGrad)
  • Reavaliar se as tarefas são realmente relacionadas

Armadilha 3: desequilíbrio de conjuntos de dados e “fome” de tarefa

Sintomas

  • A tarefa pequena nunca melhora
  • Métricas flutuam dependendo da mistura

Correções

  • Superamostrar a tarefa pequena (oversample)
  • Usar amostragem baseada em temperatura
  • Usar cronogramas de taxa de aprendizado por tarefa (learning rate schedules) (com cuidado) ou otimizadores separados (optimizers) para as cabeças

Armadilha 4: ambiguidade de avaliação

Sintomas

  • “Melhor” não é claro porque as tarefas têm prioridades diferentes

Correções

  • Definir um objetivo-alvo: métrica ponderada, limites mínimos aceitáveis ou restrições de negócio
  • Acompanhar trade-offs de Pareto em vez de um único escalar

Relação com ideias próximas

  • Pré-treinamento + ajuste fino multitarefa: uma receita comum é pré-treinamento auto-supervisionado (veja Aprendizado Auto-Supervisionado) seguido de ajuste fino multitarefa em conjuntos de dados supervisionados.
  • Aprendizado de representações: o aprendizado multitarefa é um mecanismo direto para moldar características compartilhadas úteis (veja Aprendizado de Representações).
  • Destilação de conhecimento: um grande modelo multitarefa pode destilar em modelos especializados menores ou em um estudante multitarefa compacto (veja Destilação de Conhecimento).
  • Treinamento em escala: grandes misturas multitarefa exigem pipelines de dados cuidadosos, mistura de tarefas e técnicas de estabilidade (veja Treinamento em Escala).

Quando usar Aprendizado Multitarefa (um checklist de decisão)

O aprendizado multitarefa é um forte candidato quando:

  • As tarefas são significativamente relacionadas e provavelmente compartilham características.
  • Você quer melhorar uma tarefa com poucos recursos usando tarefas relacionadas com muitos recursos.
  • Você precisa de um modelo que produza múltiplas previsões.
  • Você consegue tolerar ou gerenciar trade-offs entre tarefas.

Considere alternativas quando:

  • As tarefas não são relacionadas ou têm requisitos conflitantes.
  • Você precisa do melhor desempenho possível em uma única tarefa e as demais são secundárias (um modelo especializado pode vencer).
  • As restrições de serving diferem significativamente entre tarefas.

Resumo

O Aprendizado Multitarefa treina um modelo em múltiplos objetivos simultaneamente, aproveitando representações compartilhadas para melhorar generalização e eficiência. Os principais desafios práticos são o que compartilhar, como ponderar tarefas e como gerenciar interferência. Com escolhas cuidadosas de arquitetura (tronco compartilhado + cabeças de tarefa, compartilhamento parcial, adaptadores), mistura sensata de tarefas e técnicas modernas de otimização (ponderação dinâmica, mitigação de conflito de gradiente), o aprendizado multitarefa pode entregar ganhos substanciais — especialmente em cenários com tarefas relacionadas, poucos rótulos ou implantações com múltiplas saídas.