Aprendizagem em Contexto (In-Context Learning)

O que é aprendizado em contexto?

Aprendizado em contexto (in-context learning, ICL) é a capacidade de um modelo de linguagem grande (large language model, LLM) de adaptar seu comportamento com base em exemplos incluídos no prompt, sem alterar seus pesos. Você fornece demonstrações de uma tarefa — frequentemente alguns pares de entrada→saída — e o modelo infere o padrão e o aplica a uma nova consulta na mesma janela de contexto.

Isso é surpreendente se você vem do aprendizado de máquina (machine learning, ML) tradicional, em que “aprender” normalmente significa atualizar parâmetros via Descida do Gradiente (Gradient Descent). No aprendizado em contexto, os parâmetros do modelo ficam fixos no tempo de inferência (inference time). O “aprendizado” acontece por condicionamento (conditioning): as ativações (activations) e os padrões de atenção (attention) do modelo incorporam os exemplos, direcionando as previsões do próximo token.

O aprendizado em contexto é uma capacidade central por trás do prompting de poucos exemplos (few-shot prompting), classificadores baseados em prompt, extração guiada por esquema e muitas técnicas de engenharia de prompts (prompt engineering) usadas com modelos de linguagem grandes modernos.

Tópicos relacionados que você pode querer junto com este artigo:

Arquitetura Transformer (Transformer Architecture) (como o mecanismo viabiliza o aprendizado em contexto)
Seguimento de Instruções (Instruction Following) (o que os modelos fazem quando recebem diretivas explícitas)
Ajuste Fino (Fine-Tuning) (como é quando você de fato atualiza pesos)
Janelas de Contexto (Context Windows) (por que o aprendizado em contexto tem um limite de “memória de trabalho”)

Por que exemplos podem direcionar o comportamento sem atualizações de pesos

Em alto nível, um modelo de linguagem grande é treinado para prever o próximo token dados os tokens anteriores. Quando você adiciona exemplos ao prompt, você altera a distribuição condicional:

[ P(\text{próximo token} \mid \text{prompt + exemplos}) ]

Nenhum peso muda, mas o prompt passa a fazer parte da entrada, e a computação interna do modelo pode tratar tokens anteriores como descrição da tarefa + dados de treinamento.

Um modelo mental útil:

Pesos armazenam capacidades gerais de linguagem e resolução de problemas aprendidas durante o pré-treinamento (pretraining) e o alinhamento.
A janela de contexto (context window) funciona como uma memória temporária em que você pode “programar” o modelo fornecendo padrões, restrições e exemplos.
Atenção permite que tokens posteriores “olhem para trás” para demonstrações anteriores e reutilizem sua estrutura.

Em outras palavras, os exemplos no prompt não treinam o modelo; eles o condicionam.

Do pré-treinamento ao aprendizado em contexto: por que essa capacidade existe

A maioria dos modelos de linguagem grandes modernos é pré-treinada em grandes corpora nos quais os textos naturalmente contêm padrões como:

enunciados de problemas seguidos de soluções
threads de perguntas e respostas
código com docstrings e exemplos de uso
tabelas com cabeçalhos e linhas
traduções, resumos e paráfrases

Durante Pré-treinamento e Leis de Escalonamento (Pretraining & Scaling Laws), o modelo aprende a dar continuidade a esses padrões. Se o prompt se parece com “um conjunto de dados de exemplos”, então “continuar o conjunto de dados” frequentemente significa “produzir a saída correta para a próxima entrada”.

Isso explica por que o aprendizado em contexto muitas vezes parece que o modelo está “aprendendo com poucos exemplos”: o modelo aprendeu um prior amplo (broad prior) sobre como tarefas se apresentam e como completá-las quando enquadradas como demonstrações.

O que realmente muda no tempo de inferência?

Embora os pesos estejam fixos, as ativações do modelo não estão. Em um modelo transformer (Transformer), cada camada produz representações para cada token, e a autoatenção (self-attention) mistura informações ao longo do contexto.

Ideia-chave: o modelo pode implementar comportamento específico de tarefa usando seus cálculos intermediários.

Atenção como memória associativa

A autoatenção pode recuperar partes relevantes do prompt:

Ao responder a um novo exemplo, o modelo pode prestar atenção a exemplos anteriores com estrutura semelhante.
Ele pode copiar formatação, convenções de rótulos ou transformações.
Ele pode alinhar “campos de entrada” com “campos de saída”.

Esse é um dos motivos pelos quais a formatação consistente nas demonstrações importa tanto: ela facilita a recuperação via atenção.

Comportamento do tipo indução (continuação de padrões)

Um mecanismo famoso observado empiricamente às vezes é chamado de comportamento de indução (induction behavior): se o prompt contém padrões repetidos como:

“X → Y”
“X₂ → Y₂”
“X₃ → ?”

o modelo pode aprender, dentro da passagem direta (forward pass), a mapear o novo X₃ para uma continuação do tipo Y, usando os pares anteriores como um template. Você pode ver isso como o modelo construindo uma regra temporária em suas ativações.

Aprendizado em contexto como metaaprendizado implícito (e “algoritmos de aprendizado nos pesos”)

Um enquadramento mais teórico: durante o pré-treinamento, o modelo é otimizado para ter bom desempenho em muitas “tarefas” diferentes implícitas em seus dados. Com o tempo, ele pode internalizar uma estratégia geral para inferir uma tarefa a partir do contexto e executá-la — isso se assemelha a metaaprendizado (meta-learning).

Algumas pesquisas sugerem que transformers podem aproximar algoritmos simples de aprendizado (por exemplo, regressão (regression)) na passagem direta. Os pesos codificam um algoritmo que usa tokens do contexto como dados de treinamento.

Uma nuance importante: o modelo não está literalmente executando descida do gradiente em seus parâmetros durante a inferência. Mas, em alguns regimes, ele pode se comportar como se estivesse ajustando um pequeno modelo aos exemplos em contexto — daí expressões como “otimização em contexto (in-context optimization)”.

Prompting com zero, um e poucos exemplos

O aprendizado em contexto costuma ser discutido em termos de quantas demonstrações você fornece:

Zero exemplos (zero-shot): apenas uma instrução (“Classifique o sentimento como positivo/negativo.”)
Um exemplo (one-shot): um exemplo
Poucos exemplos (few-shot): múltiplos exemplos (frequentemente 2–20)

Zero exemplos pode funcionar bem quando a tarefa é comum no pré-treinamento ou reforçada durante o ajuste por instruções (instruction tuning). Poucos exemplos ajuda quando você precisa de:

um conjunto de rótulos muito específico
formatação rígida
uma transformação de nicho
estilo consistente ou convenções de domínio

Exemplos práticos de aprendizado em contexto

Exemplo 1: Classificação de texto com poucos exemplos (sentimento)

Um classificador simples baseado em demonstrações:

Task: Label each review as Positive or Negative.

Review: "The battery lasts all day and the screen is gorgeous."
Label: Positive

Review: "It overheats quickly and the fan is loud."
Label: Negative

Review: "Setup was painless, but the keyboard feels cheap."
Label:

Mesmo sem atualizar pesos, o modelo geralmente continua o padrão e gera um rótulo consistente com as demonstrações. Muitas vezes, você pode melhorar a confiabilidade ao:

manter rótulos curtos e consistentes (Positive/Negative, e não às vezes Pos)
usar 3–8 exemplos representativos
combinar o tom e o comprimento das entradas-alvo

Exemplo 2: Extração de dados guiada por esquema

O aprendizado em contexto é poderoso para “parsear” texto bagunçado em um formato estruturado:

Extract fields as JSON with keys: {"name": ..., "date": ..., "amount": ...}

Text: "Paid to Acme Corp on 2025-03-02: $184.50"
JSON: {"name":"Acme Corp","date":"2025-03-02","amount":184.50}

Text: "2025/04/10 — Transfer to Bright Dental, USD 79.00"
JSON:

O modelo infere o esquema e a formatação a partir dos exemplos. Isso costuma ser mais robusto do que depender apenas de instruções, especialmente quando a formatação precisa ser exata.

Exemplo 3: Imitação de estilo e regras editoriais

Rewrite each sentence in a concise, neutral tone. Prefer active voice. Avoid adverbs.

Original: "Basically, the system kind of failed unexpectedly."
Rewrite: "The system failed."

Original: "The app is incredibly fast and very easy to use."
Rewrite:

Aqui, a “tarefa” inclui preferências editoriais sutis. Exemplos transmitem essas preferências melhor do que uma instrução longa.

Exemplo 4: Síntese de programas com demonstrações

# Convert a list of dicts into a dict indexed by "id".

Input:
[{"id": 2, "name": "B"}, {"id": 5, "name": "E"}]

Output:
{2: {"id": 2, "name": "B"}, 5: {"id": 5, "name": "E"}}

Input:
[{"id": 1, "name": "A"}, {"id": 3, "name": "C"}]

Output:

Em contextos de código, o aprendizado em contexto frequentemente funciona melhor quando os exemplos mostram exatamente a assinatura, a formatação e os casos de borda que você considera importantes. (Veja também: Modelos de Código (Code Models).)

Por que demonstrações às vezes superam instruções

Muitos modelos modernos são otimizados para Seguimento de Instruções (Instruction Following), então direções explícitas frequentemente funcionam. Mas demonstrações trazem benefícios adicionais:

Desambiguação: rótulos e regras de formatação se tornam concretos.
Correspondência de distribuição: exemplos definem como são entradas “típicas”.
Restrições implícitas: o modelo copia estrutura (chaves JSON, capitalização, delimitadores).
Redução de graus de liberdade ocultos: o modelo tem menos “estilos” plausíveis para escolher.

Uma boa prática comum é combinar ambos:

Uma instrução curta declarando o objetivo e as restrições
Um punhado de demonstrações mostrando o comportamento exato desejado

Intuições teóricas: como pensar sobre aprendizado em contexto

Nenhuma teoria única explica completamente o aprendizado em contexto em todas as tarefas, mas algumas perspectivas complementares são úteis.

1) Inferência bayesiana de tarefa (informal, mas útil)

Você pode ver o modelo como tendo um prior sobre tarefas possíveis. As demonstrações atualizam sua crença sobre qual tarefa está sendo solicitada:

Prior: “Este prompt pode ser tradução, classificação, sumarização, …”
Evidência: os exemplos parecem “entrada → rótulo”
Posterior: “Esta é uma tarefa de classificação binária de sentimento com estes tokens de rótulo”

O modelo então gera saídas consistentes com a tarefa inferida.

2) Composição de funções dentro do transformer

O transformer pode representar:

o texto de entrada,
os pares de exemplo,
e um “mapeamento” implícito por esses pares,

e então aplicar esse mapeamento à nova entrada. Isso ajuda a explicar por que:

a ordem dos exemplos importa (ela muda a atenção e as representações),
a recência importa (demonstrações mais recentes frequentemente recebem mais peso),
a consistência de formato importa (ela facilita o alinhamento).

3) Otimização em contexto (quando exemplos agem como dados de treinamento)

Em algumas tarefas sintéticas (por exemplo, aprender uma função linear a partir de pares (x, y)), transformers podem aproximar o ajuste de um pequeno modelo a partir do contexto e prever y para um novo x. Não é atualização de pesos, mas pode se parecer com um otimizador aprendido embutido na rede.

Na prática, para tarefas de linguagem natural, o aprendizado em contexto geralmente é uma mistura de:

conclusão de padrões,
recuperação de priors relevantes do pré-treinamento,
e adaptação limitada “em tempo real” via ativações.

O que afeta o desempenho do aprendizado em contexto?

Qualidade e cobertura dos exemplos

Use exemplos que representem a variedade que você espera.
Inclua casos de borda difíceis se você quiser robustez.
Evite demonstrações contraditórias — modelos podem “fazer média” ou se tornar instáveis.

Formatação e separadores

Estrutura clara melhora a recuperação baseada em atenção:

Input: ...
Output: ...

ou use delimitadores explícitos:

### Example
<INPUT>...</INPUT>
<OUTPUT>...</OUTPUT>

Efeitos de ordem

Os últimos exemplos frequentemente influenciam mais o modelo (um viés de recência (recency bias)). Se você tem um exemplo “ouro” mais semelhante à consulta, colocá-lo por último pode ajudar.

Escolha do token de rótulo

Tokens curtos e comuns podem ser mais fáceis para os modelos lidarem de forma consistente. Para classificação, prefira:

Label: Positive / Label: Negative em vez de
frases longas ou muitos sinônimos.

Restrições de comprimento de contexto

O aprendizado em contexto compete por espaço com:

a consulta do usuário,
instruções de sistema,
documentos recuperados (se houver),
saídas de ferramentas.

Isso é limitado pelas Janelas de Contexto (Context Windows). Muitos exemplos também podem diluir a atenção ou introduzir contradições.

Decodificação e aleatoriedade

Mesmo com demonstrações perfeitas, a saída depende da decodificação (decoding). Para estabilidade:

reduza a temperatura (temperature),
considere decodificação determinística (deterministic decoding).

Veja Estratégias de Decodificação (Decoding Strategies).

Aprendizado em contexto vs ajuste fino vs recuperação: quando usar o quê?

Aprendizado em contexto

Use quando você precisa de:

iteração rápida (sem pipeline de treinamento)
customização por requisição
pequenas mudanças na “definição da tarefa”
controle de formatação via alguns exemplos

Trade-offs:

o custo cresce com o comprimento do prompt
o comportamento pode ser frágil a mudanças no prompt
“memória” limitada (delimitada pelo contexto)

Ajuste fino

Use quando você precisa de:

comportamento consistente em muitas requisições
menor custo de tokens por requisição
especialização mais forte (domínio/estilo)
melhor confiabilidade do que apenas prompting

Veja Ajuste Fino (Fine-Tuning).

Geração aumentada por recuperação (retrieval-augmented generation, RAG)

Use quando você precisa de:

embasamento factual em documentos externos
conhecimento atualizado ou proprietário
citações e rastreabilidade

A geração aumentada por recuperação frequentemente combina bem com o aprendizado em contexto: exemplos recuperados podem ser inseridos como demonstrações. (Preocupações com alucinações permanecem; veja Alucinações (Hallucinations).)

Modos comuns de falha e limitações

Generalização frágil

O aprendizado em contexto pode aprender padrões superficiais:

copiar palavras-chave em vez de aprender a regra subjacente
superajustar ao estilo das demonstrações

Sensibilidade a injeção de prompt e texto não confiável

Se o modelo tratar o contexto como “instruções”, conteúdo malicioso dentro do contexto pode sequestrar o comportamento. Isso é especialmente relevante quando você inclui:

texto fornecido pelo usuário
documentos recuperados
saídas de ferramentas

Mitigações incluem delimitadores rígidos, separação de papéis e filtragem em sistemas que usam ferramentas (veja LLMs com Uso de Ferramentas (Tool-Using LLMs)).

Restrições conflitantes

Se o prompt contém:

uma instrução de sistema,
uma instrução do desenvolvedor,
uma demonstração,
e uma solicitação do usuário

que discordam entre si, o comportamento do modelo pode se tornar inconsistente. Uma hierarquia clara e uma redação consistente importam.

Saturação de contexto

Adicionar mais exemplos nem sempre ajuda. Depois de certo ponto:

exemplos relevantes ficam mais difíceis de receber atenção,
detalhes irrelevantes viram ruído,
custos sobem.

Raciocínio vs imitação

Algumas tarefas exigem raciocínio em múltiplas etapas. Demonstrações que incluem raciocínio intermediário podem ajudar, mas você precisa ponderar isso contra políticas e vazamento de raciocínio sensível. Muitos praticantes usam justificativas concisas ou etapas estruturadas; veja Cadeia de Pensamento e Técnicas de Raciocínio (Chain-of-Thought & Reasoning Techniques).

Padrões práticos de prompting para aprendizado em contexto

Padrão: “Instrução + demonstrações + consulta”

You are a medical coding assistant. Output only the ICD-10 code.

Example:
Diagnosis: Acute appendicitis
Code: K35.80

Example:
Diagnosis: Type 2 diabetes mellitus without complications
Code: E11.9

Diagnosis: Mild intermittent asthma without complication
Code:

Padrão: “Contraexemplos” para definir limites

Se um modelo tende a generalizar demais, inclua um exemplo negativo:

Task: Extract company names. Do NOT extract product names.

Text: "I bought an iPhone from Apple."
Companies: ["Apple"]

Text: "Our team migrated to Kubernetes."
Companies: []

Padrão: “Formatação canônica” para saída estruturada

Demonstre o esquema exato e o imponha:

Return YAML with keys: action, object, due_date.

Request: "Email the report to Dana by Friday."
action: email
object: report
due_date: Friday

Request: "Schedule a meeting with Alex next Tuesday."

Como o aprendizado em contexto se relaciona com alinhamento e ajuste por instruções

Muitos modelos de linguagem grandes implantados não são modelos “brutos pré-treinados”; eles foram ajustados por instruções e alinhados (por exemplo, via otimização por preferências (preference optimization)). Isso altera o aprendizado em contexto de duas maneiras:

Melhor aderência a instruções: menos exemplos podem ser necessários.
Priors mais fortes sobre comportamento útil: o modelo pode resistir a certas demonstrações (por exemplo, solicitações inseguras) ou pode “corrigir” prompts inconsistentes.

Veja Alinhamento (Alignment) e Métodos de Otimização por Preferências (Preference Optimization Methods) para entender como essas etapas de treinamento moldam o comportamento.

Principais conclusões

Aprendizado em contexto é adaptação por condicionamento, não por atualização de pesos.
Exemplos direcionam o comportamento porque transformers conseguem recuperar e reutilizar padrões do prompt via atenção e podem representar hipóteses de tarefa nas ativações.
O aprendizado em contexto funciona melhor com estrutura clara, rótulos consistentes e exemplos representativos, mas tem limites: comprimento de contexto, fragilidade, efeitos de ordem e preocupações de segurança.
Na prática, o aprendizado em contexto é um meio-termo poderoso entre instruções puras e métodos que atualizam pesos, como Ajuste Fino (Fine-Tuning), e frequentemente combina bem com recuperação e uso de ferramentas.

Se você quiser se aprofundar a seguir, um bom próximo passo é entender como o aprendizado em contexto interage com prompts longos e restrições de memória em Janelas de Contexto (Context Windows), e como ele difere de elicitar raciocínio em múltiplas etapas em Cadeia de Pensamento e Técnicas de Raciocínio (Chain-of-Thought & Reasoning Techniques).