O que é IA generativa, e por que ela só se tornou viável agora?

Pergunte a um sistema de recomendação o que você vai beber na sexta-feira e ele responderá com algo que você já comprou. Peça a um modelo generativo um conto sobre essa sexta-feira e ele entregará um texto que nunca existiu. Os dois sistemas compartilham boa parte da matemática e, ainda assim, respondem a perguntas diferentes. Este artigo explica o que mudou para tornar o segundo tipo viável, onde fica de fato a linha entre prever e gerar, e no que a tecnologia pode e não pode ser confiada hoje.^[4]

1. Por que agora: três fatores que convergiram

A IA generativa se tornou viável quando três linhas independentes de progresso se encontraram. Nenhuma delas é nova por si só; o que é novo é que as três amadureceram ao mesmo tempo.

• Computação. Treinar uma rede neural é, na maior parte, multiplicação de matrizes, e as placas gráficas foram construídas exatamente para fazer isso em paralelo. Quando uma rede convolucional treinada em duas GPUs de consumo venceu a competição ImageNet de 2012 por larga margem, operações que eram lentas e caras demais para escalar viraram rotina.^[2]
• Dados. O volume de texto, imagens e código digitais cresceu, mas a mudança decisiva foi de forma: dados organizados, rotulados ou ao menos rastreáveis de um jeito que um pipeline de treinamento consegue consumir. O próprio ImageNet — milhões de imagens com rótulos estruturados — foi o molde dessa virada.^[3]
• Arquiteturas. Redes recorrentes modelavam sequências, mas as processavam um passo por vez e sofriam com contextos longos. O Transformer substituiu a recorrência pela atenção, que olha para o contexto inteiro de uma vez e paraleliza ao longo da sequência. Linguagem e contexto finalmente puderam ser modelados em escala.^[1]

Com os três no lugar, um fato empírico assumiu o comando: o desempenho melhora de forma previsível conforme tamanho do modelo, dados e computação crescem juntos — as chamadas leis de escala.^[5] É por isso que o campo passou tão rápido de curiosidade de pesquisa a produto.

Pratique: abrir no Lab: Exercício 1, Três fatores

2. Da IA tradicional para a IA generativa

A IA tradicional trabalha principalmente com reconhecimento de padrões, classificação e previsão sobre dados que já existem. Um sistema de recomendação aprende os hábitos de um usuário e estima a próxima ação provável — vinho em dias frios, cerveja na sexta-feira. A saída é uma escolha entre itens conhecidos, ou um número associado a um deles.

A IA generativa muda o objetivo. Em vez de prever um item existente, ela sintetiza uma saída nova a partir dos padrões que aprendeu: um parágrafo, uma imagem, uma função. A maquinaria por baixo costuma ser a mesma família de redes neurais; o que difere é o que se pede ao modelo e como sua saída é julgada. Essa mudança de objetivo é o que atraiu tanta atenção para o campo.

Tabela 1 — A linha da avaliação é a que importa na prática: um sistema preditivo pode ser pontuado automaticamente contra o gabarito; um generativo produz coisas para as quais não existe gabarito, e é por isso que o julgamento humano volta a entrar no circuito (seção 7).

Pratique: abrir no Lab: Exercício 2, Prever ou gerar

3. Geração não é cópia

Gerar não significa recortar e colar exemplos do conjunto de treinamento. Significa produzir uma combinação nova, coerente com o pedido. Se alguém pede um livro “com base” em muitos livros anteriores, o sistema não deve devolver um trecho copiado; deve devolver um artefato novo, orientado pela instrução.

A originalidade aqui é estatística e composicional, não criação do nada. Um modelo de linguagem aprendeu uma distribuição de probabilidade sobre sequências de palavras; gerar é percorrer essa distribuição um passo de cada vez, condicionado a tudo o que veio antes — inclusive o prompt:

Cada fator à direita é uma distribuição sobre o próximo token dado o prompt e os tokens já produzidos. O modelo nunca armazena frases para recuperar; armazena os parâmetros que dão forma a essas distribuições. A reprodução literal ainda pode acontecer quando uma passagem apareceu muitas vezes no treinamento — um modo de falha conhecido e estudado^[8] —, mas é a exceção para a qual o mecanismo precisa ser empurrado, não seu comportamento normal.

Isso também aproxima a discussão de como as pessoas criam. A criação humana normalmente reorganiza referências, influências e repertório; um romancista leu romances, um designer viu designs. A diferença é de grau e de intenção, não uma linha limpa entre “original” e “derivado”.

4. Criação, inteligência e a discussão filosófica

Chamar esses sistemas de “não inteligentes” porque não criam como um artista humano mistura critérios filosóficos com critérios operacionais. No uso cotidiano, inteligência é inferida pelo comportamento: a capacidade de aprender, de aplicar padrões e de produzir respostas adequadas a um contexto. É exatamente o tipo de comportamento que esses sistemas exibem — e é, não por acaso, o teste operacional que Turing propôs ao trocar “as máquinas podem pensar?” por uma pergunta sobre comportamento.^[9]

Reconhecer isso não torna o sistema equivalente a um ser humano. Ele não tem objetivos próprios, nenhuma experiência do mundo além dos dados de treinamento, e nenhum jeito de conferir sua saída contra a realidade a menos que uma ferramenta lhe dê um. Mas também impede o erro oposto: reduzir seu funcionamento a automação mecânica sem aprendizado. A discussão útil, portanto, não é se o sistema é capaz, e sim que tipo de inteligência e que tipo de criação ele manifesta — e onde fica a responsabilidade pelo resultado.

5. O prompt como mecanismo de controle

O prompt é a especificação de entrada: diz ao modelo o que gerar, em que estilo e sob quais restrições. Como o prompt faz parte do condicionamento na equação (1), ele molda cada token que vem depois. Quanto mais claro o pedido, melhor o sistema consegue alinhar a saída ao objetivo — para texto, imagem ou código igualmente.

Em aplicações reais, “saber promptar” não é um truque superficial. É a habilidade de transformar intenção humana em instrução operacional para o modelo: público, formato, tamanho, tom, o que incluir, o que deixar de fora, e exemplos do resultado esperado. A observação de que alguns exemplos resolvidos dentro do prompt bastam para direcionar um modelo grande a uma tarefa nova — o few-shot — foi uma das descobertas que tornaram a geração atual de modelos útil na prática.^[4] Um prompt ruim produz saídas vagas ou erradas; um prompt bem formulado aumenta utilidade, coerência e aderência ao contexto.

Pratique: abrir no Lab: Exercício 3, O mecanismo de controle

6. Onde já funciona: texto, imagem, vídeo e código

Modelos generativos já produzem livros, e-mails, respostas automáticas e outros artefatos textuais com boa coerência e estilo consistente. O valor prático está num primeiro rascunho útil, adaptado ao formato e ao tom desejados. Como a saída depende do prompt, estratégia, estrutura e nível de formalidade podem ser direcionados. Texto tende a sair mais consistente do que outras mídias, mas ainda exige validação humana.

A geração de imagem passou de resultados visivelmente defeituosos a composições convincentes em poucos anos, em boa parte graças aos modelos de difusão, que aprendem a transformar ruído em imagem guiados por uma descrição em texto.^[6] Um prompt curto já produz capas, cenas e conceitos visuais próximos de referências conhecidas; os modelos vêm com guardrails contra certos usos indevidos, como imagens enganosas ou pessoas reais em contextos problemáticos. A qualidade em vídeo também avançou rápido, mas ainda aparecem erros de finalização, proporções erradas e detalhes inconsistentes. Esses erros mostram que uma saída pode ser impressionante sem ser automaticamente confiável.

Geradores de código — Copilot, Devin e seus pares — já produzem trechos completos de utilidade prática real. Um modelo treinado em código público resolve uma parcela significativa de tarefas de programação só a partir de uma descrição em linguagem natural.^[7] Isso não elimina a necessidade de saber programar: quem não entende o problema tende a pedir errado e a aceitar soluções incorretas. No desenvolvimento de software o modelo acelera implementação, exploração e boilerplate; a revisão de lógica, segurança, arquitetura e aderência ao requisito continua com o engenheiro. Código gerado sem revisão é risco operacional, não produtividade.

Tabela 2 — Maturidade descreve com que frequência a primeira saída é aproveitável, não com que frequência está correta. A última coluna é o ponto da seção 7: quanto mais consequente a mídia, menos opcional a revisão.

7. Revisão humana não é opcional

Saídas generativas podem parecer corretas e ainda conter erros sutis. Em imagens isso aparece como texto com acentuação errada, proporções estranhas ou detalhes anatômicos inconsistentes; em vídeo, como artefatos de movimento e finalização; em texto e código, como incoerências ou respostas plausíveis, porém erradas. A falha raramente é barulhenta. Ela é fluente.

O fluxo correto, então, não é “gerar e publicar”, mas “gerar, inspecionar e corrigir”. A IA generativa é mais útil quando entra no processo como coprodutora sob supervisão humana: ela rascunha, a pessoa julga, e a correção alimenta o pedido seguinte. O ganho de produtividade é real, mas se realiza na etapa de inspeção, não na de geração.

Pratique: abrir no Lab: Exercício 4, Revisão humana

8. Por baixo do capô: deep learning, atenção e contexto

Deep learning permite que um sistema aprenda representações complexas a partir de grandes volumes de dados, em vez de depender apenas de regras explícitas: ninguém escreve o que torna uma frase coerente ou uma imagem plausível; a rede aprende isso dos exemplos, camada por camada.^[10]

Em modelos modernos, mecanismos de atenção decidem quais partes do contexto importam mais para gerar a próxima parte da saída.^[1] É por isso que o sistema consegue distinguir os sentidos de uma mesma palavra — manga como fruta ou como parte da camisa — pesando o restante da frase. Contexto e atenção são o que transforma uma previsão local (o próximo token) em uma geração coerente (um parágrafo que mantém o assunto).

A equação (1) e a Figura 4 se encontram num pequeno trecho de código. Dadas as pontuações que um modelo atribui a cada próximo token possível, isso é tudo o que a geração faz a cada passo:

import numpy as np

def amostrar_proximo_token(logits, temperatura=1.0, rng=np.random.default_rng()):
    """logits: uma pontuação por entrada do vocabulário, produzida pelo modelo para o contexto atual.
    Devolve o índice do token escolhido para este passo."""
    # 1. a temperatura remodela a distribuição: < 1 afina, > 1 achata
    z = logits / max(temperatura, 1e-6)

    # 2. o softmax transforma pontuações em probabilidades que somam 1 (isto é p(x_t | prompt, x_<t))
    z = z - z.max()                       # estabilidade numérica
    p = np.exp(z) / np.exp(z).sum()

    # 3. amostragem: o mesmo contexto pode produzir continuações diferentes
    return rng.choice(len(p), p=p)


# Gerar uma sequência é este passo em laço: cada token escolhido entra no contexto do próximo.
def gerar(modelo, tokens_do_prompt, max_novos_tokens, temperatura=0.8):
    tokens = list(tokens_do_prompt)
    for _ in range(max_novos_tokens):
        logits = modelo(tokens)           # pontuações do próximo token, dado tudo até aqui
        tokens.append(amostrar_proximo_token(logits, temperatura))
    return tokens

Pratique: abrir no Lab: Exercício 5, Amostrar o próximo token

9. Conclusão

IA generativa não é mágica nem máquina de copiar. É uma distribuição de probabilidade aprendida sobre artefatos, amostrada um passo de cada vez sob a orientação de um prompt — viabilizada pela convergência de computação paralela, dados organizados e uma arquitetura que lê contexto em escala. Suas saídas são novas, coerentes e úteis, e também fluentes quando estão erradas; é por isso que o prompt carrega a intenção e o humano carrega o julgamento. O próximo artigo traça essa linha em detalhe: o que a IA tradicional faz com dados rotulados, por que seu espaço de respostas é fechado e onde começa a composição generativa.