IA generativa

O que “IA Generativa” Significa

IA generativa (Generative AI) refere-se a sistemas de aprendizado de máquina (machine learning) que produzem conteúdo novo—texto, imagens, áudio, vídeo, código ou dados estruturados—ao aprender padrões a partir de grandes conjuntos de dados. Em contraste com modelos discriminativos (discriminative models), que aprendem uma fronteira de decisão (decision boundary) (por exemplo, “gato vs. cachorro”), modelos generativos (generative models) aprendem um processo gerador de dados (data-generating process), frequentemente expresso como uma distribuição de probabilidade (probability distribution), como:

  • Geração incondicional (unconditional generation): aprender (p(x)) para criar novas amostras (x)
  • Geração condicional (conditional generation): aprender (p(x \mid c)) para gerar (x) dada uma condição (c) (um prompt, rótulo, imagem ou instrução)

A IA generativa moderna é dominada por:

  • Técnicas de modelagem generativa (generative modeling techniques) (modelos autorregressivos, difusão, VAEs, GANs)
  • Modelos de linguagem de grande porte (large language models, LLMs) construídos sobre a Arquitetura Transformer (Transformer Architecture)
  • Sistemas aumentados por recuperação (retrieval-augmented systems) que conectam modelos a fontes externas de conhecimento
  • Sistemas orientados por prompts (prompt-driven systems), nos quais instruções e exemplos direcionam o comportamento sem alterar os pesos

Esses componentes se combinam cada vez mais em sistemas de produto (chatbots, copilotos, ferramentas criativas, assistentes analíticos) e—quando acoplados ao uso de ferramentas—em fluxos de trabalho semelhantes a agentes relacionados a Agentes e Planejamento (Agents & Planning).

Fundamentos Teóricos da Modelagem Generativa

Modelagem generativa vs. discriminativa

Um enquadramento comum:

  • Discriminativa: aprender (p(y \mid x)) ou um mapeamento direto (f(x) \rightarrow y)
  • Generativa: aprender (p(x)) ou (p(x \mid y)), permitindo a amostragem (sampling) de novos (x)

Modelos generativos podem ser usados para:

  • Síntese: criar conteúdo realista ou estilizado
  • Imputação (imputation): preencher valores ausentes
  • Compressão e aprendizado de representações (representation learning): aprender estrutura latente significativa
  • Simulação: gerar cenários plausíveis para testes e aumento de dados

Aprendizado como máxima verossimilhança

Muitos modelos generativos são treinados maximizando a verossimilhança dos dados observados:

[ \max_\theta \sum_{i=1}^N \log p_\theta(x_i) ]

Na prática, a verossimilhança exata pode ser intratável, levando a aproximações (por exemplo, limites variacionais) ou objetivos alternativos (por exemplo, treinamento adversarial).

Principais famílias de modelos generativos

Modelos autorregressivos (incluindo LLMs)

Modelos autorregressivos (autoregressive models) fatoram uma distribuição conjunta em um produto de probabilidades condicionais:

[ p(x) = \prod_{t=1}^{T} p(x_t \mid x_{<t}) ]

Isso torna o treinamento direto (forçamento do professor (teacher forcing)) e a geração simples (amostrar passo a passo), mas a geração pode ser mais lenta porque os tokens são produzidos sequencialmente.

LLMs são modelos autorregressivos sobre tokens (subpalavras/bytes) e, atualmente, são os modelos generativos mais amplamente implantados.

Modelos de variáveis latentes: Autoencoders Variacionais (VAEs)

Autoencoders Variacionais (Variational Autoencoders, VAEs) assumem que uma variável latente (z) explica os dados:

[ p(x) = \int p(x \mid z)p(z),dz ]

Eles otimizam um limite inferior tratável (ELBO). VAEs são valorizados por espaços latentes estruturados, geração controlável e aprendizado de representações, embora a nitidez bruta das amostras historicamente tenha ficado atrás de GANs e modelos de difusão em algumas tarefas de imagem.

Modelos adversariais: GANs

Redes Adversariais Generativas (Generative Adversarial Networks, GANs) treinam um gerador e um discriminador em um jogo minimax. GANs podem produzir imagens muito nítidas, mas o treinamento pode ser instável (colapso de modo, sensibilidade a hiperparâmetros), e a estimativa de verossimilhança não é direta.

Modelos de difusão e baseados em score

Modelos de Difusão (Diffusion Models) adicionam ruído aos dados ao longo de muitos passos e treinam um modelo para reverter o processo. Eles frequentemente produzem imagens de alta qualidade e se tornaram fundamentais para sistemas de texto-para-imagem.

Em alto nível:

  • Processo direto: corromper gradualmente os dados com ruído
  • Processo reverso: aprender a remover ruído, passo a passo, para gerar amostras

Modelos de difusão exigem muito computação no momento de amostragem (muitos passos de remoção de ruído), embora técnicas de aceleração e destilação ajudem.

Avaliando modelos generativos

A avaliação depende da modalidade e da tarefa:

  • Texto: perplexidade (para modelos de verossimilhança), preferência humana, factualidade, métricas baseadas em tarefa
  • Imagens: FID, CLIPScore, avaliação humana
  • Em nível de sistema: latência, custo, segurança, calibração, robustez

Crucialmente, um modelo generativo pode ter “estilo” forte, mas veracidade fraca—um dos principais motivadores de abordagens aumentadas por recuperação.

Modelos de Linguagem de Grande Porte (LLMs)

Como LLMs geram texto

LLMs modelam uma distribuição de probabilidade sobre sequências de tokens. Dado um prompt, um LLM prevê a distribuição do próximo token:

[ p(x_{t+1} \mid x_{\le t}) ]

Isso é implementado usando o mecanismo de autoatenção (self-attention) do Transformer (veja Arquitetura Transformer), permitindo que o modelo condicione no contexto anterior.

Pré-treinamento e escalonamento

A maioria dos LLMs é pré-treinada em grandes corpora usando um objetivo de previsão do próximo token (next-token prediction). Empiricamente, o desempenho tende a melhorar com:

  • Mais dados
  • Modelos maiores
  • Mais computação
  • Melhor curadoria de dados

Esse comportamento de escalonamento (scaling) é uma razão-chave para os LLMs terem se tornado amplamente capazes em várias tarefas com treinamento mínimo específico por tarefa.

Ajuste por instruções e alinhamento

LLMs base aprendem a dar continuidade ao texto. Para fazê-los seguir instruções de forma mais confiável, desenvolvedores frequentemente aplicam:

  • Ajuste fino supervisionado (supervised fine-tuning, SFT) em conjuntos de dados de instrução/resposta
  • Métodos de otimização por preferências, como Aprendizado por Reforço a partir de Feedback Humano (Reinforcement Learning from Human Feedback, RLHF) ou técnicas relacionadas (por exemplo, treinamento no estilo DPO)

Isso normalmente melhora a utilidade e reduz saídas tóxicas ou inseguras, mas também pode introduzir novos modos de falha (recusa excessiva, verbosidade ou alucinações que “parecem úteis”).

Decodificação: transformando probabilidades em saídas

No momento de geração, você escolhe uma estratégia de decodificação:

  • Decodificação gulosa (greedy decoding): escolher o token mais provável a cada passo (frequentemente repetitivo)
  • Busca em feixe (beam search): explorar múltiplos caminhos de alta probabilidade (comum em tradução)
  • Decodificação baseada em amostragem (sampling-based decoding): trocar determinismo por diversidade
    • Temperatura (temperature): suavizar/acentuar a distribuição de probabilidade
    • Amostragem top-k / top-p (núcleo) (top-k / top-p (nucleus) sampling): restringir a amostragem a tokens plausíveis

Implicação prática: muitos “problemas do modelo” são problemas de decodificação. Por exemplo, temperatura alta pode aumentar criatividade e o risco de alucinações.

Exemplo prático: saída estruturada controlada

Um caso de uso comum de LLM é produzir JSON estruturado. Você pode combinar prompting com restrições de esquema (schema constraints) (ou chamada de função (function calling), dependendo da plataforma).

Exemplo de trecho de prompt:

You are a data extraction system.
Extract fields from the text and output valid JSON only with keys:
{ "company": string, "date": string, "amount_usd": number }

Text:
"On Oct 12, 2025, Acme Corp raised $18.5 million in a Series A round."

Uma boa saída:

{"company":"Acme Corp","date":"2025-10-12","amount_usd":18500000}

Mesmo aqui, você deve validar as saídas programaticamente (tipos, chaves obrigatórias) e lidar com recusas ou JSON malformado.

Sistemas Orientados por Prompts

Prompts como interface—e como modelo de programação

Um “sistema orientado por prompts” trata o modelo como um gerador condicional de propósito geral. O prompt fornece:

  • Especificação da tarefa (“resuma”, “classifique”, “extraia”)
  • Restrições (“use tópicos”, “cite fontes”, “apenas JSON”)
  • Contexto (documentos, histórico de conversa)
  • Exemplos (aprendizado com poucos exemplos (few-shot learning))

Isso levou a uma disciplina frequentemente chamada de engenharia de prompts (prompt engineering) (veja Engenharia de Prompts).

Padrões comuns de prompts

  • Instrução zero-shot (zero-shot instruction): “Traduza isto para francês.”
  • Exemplos few-shot (few-shot examples): mostrar vários pares de entrada/saída para ensinar formatação ou casos de borda.
  • Papel + objetivo + restrições: “Você é um assistente de conformidade… siga estas políticas…”
  • Decomposição (decomposition): pedir um plano e depois pedir a resposta final (às vezes separado no projeto do sistema em vez de expor a cadeia de pensamento (chain-of-thought)).
  • Autoverificação (self-checking): pedir ao modelo que verifique afirmações contra o contexto fornecido.

Considerações de projeto de sistema

Apenas prompting tem limitações:

  • Alucinações: o modelo pode inventar fatos
  • Limites de contexto: documentos longos podem não caber
  • Injeção de prompt (prompt injection): texto não confiável pode manipular instruções
  • Não determinismo (non-determinism): a amostragem introduz variabilidade

Como resultado, sistemas de produção tipicamente combinam prompting com recuperação, ferramentas, restrições e avaliação.

Recuperação e Geração Aumentada por Recuperação (RAG)

Por que a recuperação importa

LLMs armazenam conhecimento implicitamente nos pesos. Esse conhecimento pode estar:

  • Desatualizado
  • Difícil de atribuir
  • Incompleto para domínios de nicho
  • Difícil de auditar

Recuperação (retrieval) resolve isso ao trazer informações externas relevantes em tempo de execução. Essa é a base da geração aumentada por recuperação (retrieval-augmented generation, RAG) (veja Geração Aumentada por Recuperação).

Arquitetura típica de RAG

  1. Segmentar documentos (chunk documents) (dividir em passagens)
  2. Gerar incorporações (embeddings) dos trechos em vetores usando um modelo de incorporações (veja Incorporações)
  3. Armazenar vetores em um índice (frequentemente um Bancos de Dados Vetoriais)
  4. No momento da consulta:
    • Gerar incorporações da consulta
    • Recuperar os top-k trechos mais similares
    • Opcionalmente reordenar com um modelo mais forte
  5. Fornecer o texto recuperado ao LLM como contexto ancorado
  6. Gerar uma resposta, idealmente com citações das fontes

Exemplo conceitual mínimo (pseudocódigo estilo Python)

# 1) Indexing
docs = load_documents("./policies/")
chunks = chunk(docs, chunk_size=800, overlap=100)

chunk_vectors = embed(chunks)  # returns list of vectors
index = VectorIndex()
index.add(vectors=chunk_vectors, metadata={"text": chunks})

# 2) Query-time retrieval + generation
query = "What is the refund policy for annual subscriptions?"
q_vec = embed([query])[0]

hits = index.search(q_vec, top_k=5)          # nearest neighbors
context = "\n\n".join(hit["text"] for hit in hits)

prompt = f"""Answer using ONLY the context. If not found, say "Not in provided context".

Context:
{context}

Question: {query}
Answer:"""

answer = llm.generate(prompt)
print(answer)

Esse padrão é enganosamente simples; a qualidade depende da segmentação, das incorporações, das configurações de recuperação e do prompting.

Armadilhas de RAG (e mitigações práticas)

  • Segmentação ruim: separa definições de exceções
    Mitigação: segmentação semântica, sobreposição, consciência da estrutura do documento
  • Falhas de recuperação: texto relevante não é recuperado
    Mitigação: busca híbrida (palavra-chave + vetorial), reescrita de consulta, incorporações melhores
  • Enchimento de contexto (context stuffing): contexto demais reduz a relação sinal-ruído
    Mitigação: reordenação, top-k menor, sumarização
  • Desalinhamento de citações: o modelo cita passagens irrelevantes
    Mitigação: impor respostas baseadas em trechos citados; verificar spans; usar geração restrita
  • Injeção de prompt em texto recuperado: texto malicioso sobrepõe instruções
    Mitigação: tratar conteúdo recuperado como não confiável; usar prompts de sistema robustos; isolar ferramentas; filtragem de conteúdo

RAG é uma das técnicas práticas mais importantes para tornar sistemas de LLMs úteis em empresas, onde correção, proveniência e capacidade de atualização importam.

IA Generativa Além de Texto

Embora LLMs sejam centrais, a IA generativa abrange modalidades:

  • Texto-para-imagem (text-to-image) / edição de imagens: sistemas baseados em difusão podem gerar imagens a partir de prompts, realizar inpainting/outpainting, transferência de estilo e edição guiada.
  • Áudio e fala: vozes de texto-para-fala, geração de música, aprimoramento de fala.
  • Vídeo: texto-para-vídeo e edição de vídeo estão avançando rapidamente, frequentemente combinando difusão com técnicas de consistência temporal.
  • Modelos multimodais (multimodal models): modelos que aceitam e geram combinações de texto, imagens e mais, permitindo resposta a perguntas visuais, compreensão de diagramas e interação ancorada.

Entre modalidades, problemas semelhantes reaparecem: controlar saídas, respeitar restrições e prevenir uso indevido.

Aplicações Práticas

Áreas comuns de aplicação, com alto impacto, incluem:

  • Elaboração de conteúdo (content drafting): textos de marketing, documentação, planos de aula—frequentemente com revisão humana.
  • Desenvolvimento de software: completamento de código, geração de testes unitários, refatoração, explicação de bases de código.
  • Atendimento ao cliente: elaboração de respostas, triagem de tickets, consulta a bases de conhecimento (frequentemente com base em RAG).
  • Trabalho com dados: geração de SQL, sugestões de limpeza de dados, documentação de esquema, sumarização de logs.
  • Educação: tutoria e geração de prática (é preciso ter cuidado com a correção).
  • Design e criatividade: geração de imagens, exploração de conceitos, edição iterativa.
  • Ciência e engenharia: assistência em revisão de literatura, geração de hipóteses, extração a partir de artigos (melhor com recuperação e citações).

Uma boa prática recorrente: usar IA generativa para redigir e propor, e depender de verificação e supervisão humana em decisões de alto risco.

Riscos, Limitações e Uso Responsável

Alucinações e excesso de confiança

LLMs podem produzir afirmações fluentes, porém incorretas, porque otimizam por texto provável, não por verdade. Mitigações incluem:

  • Ancoragem via RAG e citações
  • Tratamento explícito de incerteza (“se não estiver no contexto, diga isso”)
  • Verificação via ferramentas (calculadoras, bancos de dados)
  • Revisão humana para saídas sensíveis

Viés, toxicidade e danos representacionais

Modelos refletem vieses nos dados de treinamento. Mitigações:

  • Filtragem de dados e conjuntos de dados balanceados
  • Treinamento de segurança e red-teaming
  • Monitoramento de saídas e ciclos de feedback

Privacidade e vazamento de dados

Riscos incluem memorização de dados de treinamento e divulgação acidental via prompts. Mitigações:

  • Evitar enviar dados sensíveis para APIs de terceiros sem acordos
  • Controles de acesso, higiene de logs e políticas de retenção
  • Implantações locais ou privadas para ambientes regulados

Segurança: injeção de prompt e abuso de ferramentas

Quando LLMs podem chamar ferramentas (busca, e-mail, sistemas de arquivos), ataques podem enganar o modelo para executar ações prejudiciais. Mitigações:

  • Tratar texto externo como entrada não confiável
  • Usar permissões estritas de ferramentas e isolamento (sandboxing)
  • Implementar listas de permissão (allowlists), esquemas e aprovação humana para ações de alto risco

Essas preocupações se tornam mais agudas à medida que os sistemas caminham para comportamento agêntico (veja Agentes e Planejamento).

De Geradores a Sistemas: Agentes, Ferramentas e Planejamento

Modelos de IA generativa são cada vez mais usados não apenas para gerar conteúdo, mas para conduzir ações:

  • Decidir o que fazer a seguir (planejar)
  • Chamar ferramentas (busca, bancos de dados, compiladores, navegadores)
  • Manter estado (memória, scratchpads, contexto de tarefa)
  • Iterar ao longo de múltiplos passos com feedback

Isso conecta a IA generativa a tópicos de projeto de sistemas agênticos em Agentes e Planejamento. Na prática, muitos “agentes” são controladores centrados em LLMs envolvidos por:

  • Uma camada de API de ferramentas
  • Uma camada de recuperação (RAG)
  • Barreiras de proteção (guardrails) (políticas, validadores)
  • Estruturas de avaliação (sucesso na tarefa, segurança)

A mudança-chave é de “conclusão em uma única tentativa” para tomada de decisão em ciclo fechado (closed-loop decision-making)—o que eleva tanto capacidade quanto risco.

Considerações de Implementação (O que Importa na Prática)

Escolha do modelo

Trade-offs incluem:

  • Modelos fechados vs. modelos de pesos abertos (open-weight models): capacidade, custo, controle de hospedagem, conformidade
  • Tamanho da janela de contexto: afeta o quanto você consegue incluir sem recuperação
  • Latência e throughput: experiência do usuário e custo operacional
  • Suporte multimodal: se você precisa de entradas de imagem/áudio

Ajuste fino vs. prompting vs. recuperação

Uma regra prática útil:

  • Use prompting para formatação, tom e adaptação simples de tarefas
  • Use RAG para ancoragem factual e conhecimento proprietário
  • Use ajuste fino (fine-tuning) para padrões de comportamento estáveis, estilo de domínio ou tarefas especializadas (quando você tem dados rotulados de qualidade)

Muitos sistemas bem-sucedidos usam os três.

Garantia de qualidade

Sistemas generativos em produção se beneficiam de:

  • Conjuntos de avaliação offline (perguntas/respostas de referência, testes de extração)
  • Testes de regressão para mudanças em prompts e recuperação
  • Monitoramento de alucinações, taxas de recusa e violações de segurança
  • Revisão humano no ciclo (human-in-the-loop) para saídas de alto impacto

Direções Futuras

Áreas ativas de progresso incluem:

  • Ancoragem mais confiável e fidelidade de citações
  • Melhor raciocínio de longo contexto e memória
  • Melhor uso de ferramentas e robustez de planejamento
  • Inferência eficiente (quantização, destilação)
  • Compreensão e geração multimodal
  • Alinhamento mais forte e garantias de segurança

A IA generativa é melhor entendida não como um único modelo, mas como uma pilha (stack): modelagem generativa + LLMs + recuperação + orquestração de prompts/ferramentas. Os sistemas reais mais capazes são combinações projetadas dessas partes, desenhadas para serem precisas, controláveis e seguras sob restrições práticas.