1.1 — Da Lógica Simbólica aos Modelos de Linguagem: Uma Trajetória (História da IA)

Objetivo da Aula

Traçar a linha causal entre as descobertas de 1950–2017 e as capacidades dos LLMs que você usa hoje

Identificar os padrões de hype e inverno da IA para antecipar ciclos futuros

Explicar por que a arquitetura Transformer é a fundação de todos os LLMs modernos — não como buzzword, mas mecanicamente

Avaliar o impacto de cada marco histórico na prática de desenvolvimento de software em 2025

Posicionar ferramentas atuais (Claude, GPT, Gemini) dentro da evolução técnica que as gerou

Por que isso importa

Você vai trabalhar com LLMs em produção. Vão aparecer bugs estranhos, limitações inexplicáveis, comportamentos surpreendentes. Quando um LLM “alucina” com confiança, quando falha em contar letras mas acerta raciocínio complexo — esses comportamentos têm causa histórica e arquitetural.

Um desenvolvedor que não conhece a história usa LLMs como caixa preta mágica. Quando a caixa quebra (e vai quebrar), ele não tem onde começar a diagnosticar.

Dois exemplos concretos de por que isso importa:

Custo de ignorar context window: Um time de engenharia construiu um sistema de sumarização que mandava documentos inteiros para a API. Com documentos de 100 páginas, o custo explodia e os resumos pioravam. Por quê? Porque não entendiam que context window tem custo quadrático de atenção na inferência — conceito que vem direto da arquitetura Transformer de 2017. Compreender a história dá o modelo mental para prever esse tipo de problema antes de ir para produção.

Resistência de gestores ao investimento em IA: Em conversas de negócios, você vai encontrar gestores que viveram o segundo inverno da IA nos anos 90 — quando redes neurais foram hypadas como o fim do trabalho humano, falharam nas promessas, e o financiamento secou. Esses gestores têm razões históricas para ceticismo. Saber recontar essa história — “desta vez a diferença é escala + dados + hardware, não apenas algoritmo” — é competência de engenheiro sênior.

A história da IA não é trivial. É o mapa que mostra onde você está no terreno.

Conceitos Fundamentais

O que é IA? Definição operacional

Esqueça definições filosóficas. Para um desenvolvedor/engenheiro/arquiteto em 2026, IA aplicada é: sistemas que tomam decisões ou geram outputs a partir de padrões aprendidos em dados, sem regras explicitamente programadas.

A diferença de uma função if/else é que a “regra” não foi codificada manualmente — foi descoberta pelo treinamento. Isso tem implicações práticas diretas:

Comportamento não é totalmente previsível pela lógica do código

Performance muda com a distribuição dos inputs

Melhorar o sistema significa mudar dados ou arquitetura, não mudar código de negócio

Era Simbólica (1950–1980): A IA como programação sofisticada

Os primeiros sistemas de IA tentavam codificar conhecimento humano como regras lógicas. O projeto Cyc tentou codificar “senso comum” — milhões de regras como “if raining then ground is wet”. Sistemas especialistas médicos dos anos 70 tinham centenas de regras de diagnóstico.

O problema: conhecimento humano não cabe em regras explícitas. Para um sistema de xadrez funcionar, você precisa de 20 regras. Para entender a linguagem natural, você precisaria de milhões — e ainda assim falharia em ambiguidade.

Símbolo: "banco"

Regra simbólica: banco → instituição financeira

Problema: "Eu me sentei num banco na margem do rio" → regra falha

Isso levou ao primeiro inverno da IA (1974–1980): o relatório Lighthill no Reino Unido concluiu que IA simbólica não escalaria para problemas reais. Financiamento foi cortado. O termo “IA” virou palavrão acadêmico.

Relevância hoje: Sempre que você vê um sistema de regras tentando capturar comportamento complexo (filtros de spam por palavras-chave, moderação de conteúdo por lista de palavras proibidas), está olhando para IA simbólica. LLMs resolvem exatamente o problema que matou a era simbólica.

Redes Neurais: A segunda onda (1958–1990)

Perceptron (1958): Frank Rosenblatt criou o primeiro neurônio artificial. Um perceptron recebe N inputs (x), aplica pesos (w), e produz 0 ou 1:

output = 1 se (w1*x1 + w2*x2 + ... + wn*xn) > threshold

output = 0 caso contrário

Parece simples, mas isso é exatamente o que acontece em cada neurônio de um LLM — multiplicado por bilhões de vezes com operações mais sofisticadas.

Backpropagation (popularizado 1986): O algoritmo que permite ajustar pesos de uma rede neural para minimizar erros. A ideia: calcular o gradiente do erro em relação a cada peso (usando regra da cadeia), e ajustar os pesos na direção que reduz o erro.

Perda = função que mede o quão errado está o output

Gradiente = "em que direção mudar cada peso para reduzir a perda?"

Atualização de peso = peso - taxa_aprendizado × gradiente

Backprop funcionou — mas os computadores dos anos 80 eram lentos demais para treinar redes com mais de 2-3 camadas em dados reais. Isso levou ao segundo inverno da IA (1987–1993): as redes neurais foram hypadas demais (novamente), falharam em problemas grandes, e o financiamento foi cortado novamente.

Lição que permanece: Algoritmos corretos + hardware insuficiente = zero resultado prático. Os algoritmos de 1986 são fundamentalmente os mesmos que rodam no treinamento de LLMs em 2026 — o que mudou foi escala e hardware (GPUs paralelas).

Deep Learning e AlexNet (2006–2012): O renascimento com dados

Geoffrey Hinton (o “padrinho do Deep Learning”) passou os anos 90 e 2000 trabalhando em redes neurais quando todo o campo havia desistido. Em 2006, publicou como pré-treinar redes profundas de forma estável.

O momento definitivo foi 2012: AlexNet, uma rede convolucional de Hinton e Krizhevsky, venceu o concurso ImageNet com 84% de precisão contra 74% do segundo lugar. Um salto de 10 pontos percentuais em uma competição que melhorava 1-2 pontos por ano.

O que mudou:

- Hardware: GPUs foram adaptadas para multiplicação de matrizes em paralelo

- Dados: ImageNet tinha 1,2 milhão de imagens rotuladas — escala antes impossível

- Algoritmos: ReLU (função de ativação simples mas eficaz), Dropout (regularização), técnicas modernas de treinamento

Isso disparou uma corrida global. Grandes empresas (Google, Facebook, Microsoft, Baidu) passaram a investir pesadamente em Deep Learning.

Word2Vec e Embeddings (2013): IA começa a entender semântica

Tomas Mikolov (Google) publicou Word2Vec — um método para aprender representações vetoriais de palavras a partir de texto. O resultado chocou a comunidade:

// Word2Vec aprendeu que:

"rei" - "homem" + "mulher" = "rainha"



// Geometria do espaço semântico:

distancia("Paris", "França") ≈ distancia("Roma", "Itália")

Palavras com significado similar ficam próximas no espaço vetorial. Isso não foi programado; emergiu do treinamento.

Importância direta: Embeddings são a base de sistemas de busca semântica e RAG que você vai construir nos próximos módulos. Quando um sistema RAG busca documentos relevantes para uma pergunta, está calculando distância no espaço de embeddings — uma ideia que nasceu com Word2Vec em 2013.

Transformer: A arquitetura que mudou tudo (2017)

“Attention is All You Need” (Vaswani et al., Google, 2017) propôs uma arquitetura que abandonou recorrência (RNNs/LSTMs) e convolução — usando apenas mecanismos de atenção.

Ideia central do Attention:

  Para gerar cada palavra de output, o modelo "olha" para TODAS as

  palavras de input simultaneamente, com pesos de atenção que indicam

  quão relevante cada palavra de input é para a palavra de output atual.



Vantagem vs RNN/LSTM:

  RNN/LSTM: processa sequência palavra por palavra → sem paralelização no treinamento

  Transformer: processa todas as palavras em paralelo → escala com hardware moderno

Esta única mudança arquitetural desbloqueou o treinamento em escala massiva. GPT, BERT, Claude, Gemini, LLaMA — todos são baseados em Transformer.

Aprofundamento Técnico

Por que Transformers escalam e RNNs não?

O problema das RNNs (Redes Neurais Recorrentes, dominantes antes de 2017): elas processam tokens um por vez. Para processar a palavra 100 de uma sequência, você precisa ter processado as palavras 1-99 antes. Isso é inerentemente serial — não dá para paralelizar o treinamento.

Transformers processam todos os tokens em paralelo usando self-attention. Isso significa que você pode usar clusters de GPUs de forma eficiente: 1024 GPUs processam a mesma sequência em paralelo, cada uma responsável por um subconjunto dos cálculos de atenção.

Implicação prática: O custo de uma chamada de API de LLM não é linear com o número de tokens — é quadrático com o contexto na atenção. Dobrar o contexto pode quadruplicar o custo de computação. Por isso context caching existe (Anthropic cobra menos por tokens em cache) e por isso sistemas bem projetados minimizam contexto desnecessário.

Leis de Escala (Scaling Laws): por que modelos maiores funcionam melhor

Em 2020, pesquisadores da OpenAI (Kaplan et al.) publicaram leis empíricas: a performance de LLMs melhora de forma previsível com: - Mais parâmetros (tamanho do modelo) - Mais dados de treinamento - Mais compute (FLOPs de treinamento)

Loss ∝ (Parâmetros)^(-0.076)

Loss ∝ (Tokens)^(-0.095)

Loss ∝ (FLOPs)^(-0.050)

No contexto de Aprendizado de Máquina (Machine Learning) e Deep Learning, o Loss (ou função de perda) é a métrica que mede o quão errado o modelo está.

Isso explica por que as grandes empresas continuaram escalando modelos mesmo sem breakthroughs algorítmicos: simplesmente maior = melhor, de forma previsível.

O que muda com isso: Você pode escolher modelos menores (mais baratos, mais rápidos) para tarefas simples e modelos maiores para tarefas complexas. Claude Haiku vs Sonnet vs Opus não é marketing — é uma troca real de capacidade vs custo que você vai gerenciar em produção.

RLHF: Como LLMs aprenderam a ser úteis (2022)

GPT-3 era poderoso mas selvagem — dava respostas incorretas com confiança, completava prompts de formas não intencionais. A breakthrough foi RLHF (Reinforcement Learning from Human Feedback):

Processo RLHF:

1. Treinar LLM base em texto da internet (pré-treinamento)

2. Coletar pares de respostas avaliadas por humanos ("esta é melhor que aquela")

3. Treinar um modelo de reward separado a partir dessas avaliações

4. Usar RL (PPO) para ajustar o LLM base para maximizar esse reward

ChatGPT (novembro 2022) foi a primeira demonstração massiva de RLHF em um produto. Antes de ChatGPT, você precisava de conhecimento técnico para usar LLMs via API. Depois, qualquer pessoa conseguia.

Relevância: Quando você usa system prompt para instruir um LLM a seguir certo comportamento, está aproveitando o RLHF que ensinou o modelo a seguir instruções. Entender isso ajuda a escrever system prompts melhores — e a entender quando o modelo vai “quebrar” o comportamento instruído.

O mapa até 2025: modelos e suas origens

Todos compartilham a mesma fundação (Transformer, 2017). As diferenças estão em: dados de treinamento, técnicas de alinhamento (RLHF, Constitutional AI), tamanho, e otimizações específicas.

Exemplos Anotados

Exemplo 1: Construindo uma timeline com dados estruturados

O starter desta unidade [linklab] usa um array de objetos JavaScript para representar eventos históricos. Vamos entender por que essa estrutura foi escolhida e como estendê-la.

// Por que objeto? Porque cada evento tem múltiplas dimensões que precisamos

// exibir independentemente. Um array de strings perderia essa estrutura.

const marcosIA = [

  {

    ano: 1950,

    evento: 'Teste de Turing',

    // 'descricao' captura o FATO técnico — o que aconteceu

    descricao: 'Alan Turing publica "Computing Machinery and Intelligence" e propõe o Imitation Game.',

    // 'impacto' captura o SIGNIFICADO — por que importa hoje

    impacto: 'Define pela primeira vez o que significa uma máquina "pensar".',

  },

  {

    ano: 1974,

    evento: 'Primeiro Inverno da IA',

    // Descrevemos o CONTEXTO técnico, não só o evento político

    descricao: 'Lighthill Report (UK) e críticas de Minsky/Papert limitam financiamento. Perceptron prova limitações.',

    // O impacto mostra o PADRÃO que se repete — útil para engenheiros entenderem ciclos

    impacto: 'Primeiro ciclo de hype e decepção. Padrão que se repetirá nos anos 90.',

  },

]



// Por que ordenar por ano? Para garantir que a linha do tempo seja linear

// mesmo se adicionarmos eventos fora de ordem durante desenvolvimento

const timelineOrdenada = marcosIA.sort((a, b) => a.ano - b.ano)



// Por que forEach em vez de map? Porque estamos produzindo efeito colateral

// (console.log), não transformando em novo array. forEach comunica isso.

timelineOrdenada.forEach((marco) => {

  // Template literal é mais legível que concatenação para múltiplas variáveis

  console.log(`\n[${marco.ano}] ${marco.evento}`)

  console.log(`  → ${marco.descricao}`)

  console.log(`  💡 ${marco.impacto}`)

})

Output esperado:

[1950] Teste de Turing

  → Alan Turing publica "Computing Machinery and Intelligence" e propõe o Imitation Game.

  💡 Define pela primeira vez o que significa uma máquina "pensar".



[1974] Primeiro Inverno da IA

  → Lighthill Report (UK) e críticas de Minsky/Papert limitam financiamento.

  💡 Primeiro ciclo de hype e decepção. Padrão que se repetirá nos anos 90.

Exemplo 2: Adicionando análise de padrões à timeline

Após construir a timeline, podemos adicionar uma camada de análise que mostra padrões — exatamente o tipo de insight que diferencia quem é que “entendeu” a história de alguém que apenas memorizou datas.

// Função que identifica invernos e verões da IA automaticamente

// Por que separar essa lógica? Para poder testar e reusar independentemente

function analisarPadroesIA(timeline) {

  // Filtramos os invernos — queremos ver os períodos de pessimismo

  const invernos = timeline.filter(

    (marco) => marco.evento.toLowerCase().includes('inverno')

  )



  // Calculamos gaps entre invernos para ver se o ciclo acelera

  // Isso é um insight real: os ciclos de hype têm ficado mais curtos

  const gapsEntreInvernos = []

  for (let i = 1; i < invernos.length; i++) {

    gapsEntreInvernos.push(invernos[i].ano - invernos[i - 1].ano)

  }



  return {

    totalMarcos: timeline.length,

    numerodeInvernos: invernos.length,

    // Reduzimos para média — um único número que representa o padrão

    mediaCicloAnos:

      gapsEntreInvernos.length > 0

        ? gapsEntreInvernos.reduce((a, b) => a + b, 0) / gapsEntreInvernos.length

        : null,

  }

}



const analise = analisarPadroesIA(timeline)

console.log('\n📊 Análise de Padrões:')

console.log(`Total de marcos: ${analise.totalMarcos}`)

console.log(`Invernos identificados: ${analise.numerodeInvernos}`)

if (analise.mediaCicloAnos) {

  console.log(`Ciclo médio entre invernos: ${analise.mediaCicloAnos} anos`)

}

Output esperado:

📊 Análise de Padrões:

Total de marcos: 14

Invernos identificados: 2

Ciclo médio entre invernos: 14 anos

Padrões e Armadilhas

Padrões recomendados

Padrão 1: Estruture dados históricos com dimensão de “impacto” separada. Ao modelar qualquer timeline ou base de conhecimento, separe o FATO (o que aconteceu) do SIGNIFICADO (por que importa). Isso permite filtrar, buscar e apresentar cada dimensão independentemente. O campo impacto no starter desta unidade não é decorativo, é uma decisão de modelagem.

Padrão 2: Use eventos históricos para justificar decisões técnicas. Quando você recomendar uma arquitetura ou tecnologia, ancorá-la em contexto histórico aumenta a credibilidade. “Escolhemos embeddings porque Word2Vec demonstrou em 2013 que espaços vetoriais capturam semântica melhor que regras explícitas” é mais convincente que “embeddings são melhores”.

Padrão 3: Identifique se um problema é de algoritmo, dados ou hardware Os dois invernos da IA foram causados por deficit de hardware e dados, não por algoritmos errados. Antes de concluir que uma abordagem de IA não funciona em seu projeto, identifique qual dos três fatores é o gargalo.

Armadilhas comuns

⚠️ Armadilha 1: Tratar LLMs como caixas-pretas infinitamente capazes O que acontece: você confia que o LLM vai resolver qualquer problema se o prompt for “bom o suficiente”, e fica preso em loop de tentativas quando não funciona. Versão correta: LLMs têm limitações arquiteturais (contexto limitado, sem memória persistente, conhecimento com data de corte). Entender essas limitações — que vêm da arquitetura Transformer — permite você trabalhar com elas em vez de lutar contra elas.

⚠️ Armadilha 2: Ignorar o custo quadrático de contexto O que acontece: sistema funciona com documentos pequenos, explode em custo com documentos grandes. Sem entender context window, você não prevê esse problema. Versão correta: projete sistemas que minimizem contexto desnecessário. Use RAG para buscar apenas chunks relevantes em vez de mandar documentos inteiros.

⚠️ Armadilha 3: Acreditar que “mais parâmetros = melhor para meu caso de uso” O que acontece: você escolhe o modelo mais caro para todas as tarefas, assumindo que maior é sempre melhor. Versão correta: Scaling Laws mostram que modelos maiores são melhores em média — mas para tarefas específicas e bem definidas, modelos menores (Haiku, GPT-4o-mini) podem ser equivalentes com 10-100× menos custo. Teste sempre.

⚠️ Armadilha 4: Tratar o hype atual como diferente de todos os ciclos anteriores O que acontece: você super-investe em capacidades de IA que ainda não estão maduras, sem gestão de risco. Versão correta: os LLMs de 2026 são genuinamente mais poderosos que qualquer coisa anterior — mas o padrão de hype ainda existe. Identifique o que está provado em produção (RAG, classificação, sumarização) vs o que ainda é pesquisa (raciocínio causal complexo, planejamento de longo prazo).

Ponte para o Lab

O starter desta unidade tem 5 TODOs. Aqui está como cada um conecta com o conteúdo desta aula:

TODO 1 — Primeiro Inverno da IA (meados dos anos 70) Seção de referência: “Era Simbólica (1950–1980)” e “Redes Neurais: A segunda onda”. O primeiro inverno aconteceu em ~1974, desencadeado pelo Lighthill Report (UK) e pela demonstração de Minsky e Papert de que os perceptrons não resolviam problemas não-lineares. O financiamento governamental dos EUA e UK foi cortado. Dica: inclua tanto o FATO (corte de financiamento) quanto o MOTIVO TÉCNICO (limitações do perceptron provadas por Minsky).

TODO 2 — Segundo Inverno da IA (início dos anos 90) Seção de referência: “Redes Neurais: A segunda onda” e “Padrões e Armadilhas”. O segundo inverno (~1987-1993) foi causado por expectativas excessivas em torno de sistemas especialistas e redes neurais. Computadores ainda eram lentos demais para treinar redes profundas em dados reais. Inclua o contexto: este foi um problema de HARDWARE e DADOS, não de algoritmo — o mesmo backprop de 1986 funciona hoje.

TODO 3 — Word2Vec (2013) Seção de referência: “Word2Vec e Embeddings (2013)”. Este é provavelmente o TODO mais importante para seu trabalho futuro: embeddings são a base de RAG (que você vai construir no Módulo 2+). A “aritmética semântica” (“rei - homem + mulher = rainha”) é o insight central — mostre que isso não foi programado, emergiu do treinamento.

TODO 4 — ChatGPT (novembro 2022) Seção de referência: “RLHF: Como LLMs aprenderam a ser úteis”. ChatGPT não foi um avanço técnico radical — GPT-3 já existia. O que mudou foi RLHF tornar o modelo seguir instruções de forma natural, e a interface ser acessível ao público geral. 1 milhão de usuários em 5 dias, 100 milhões em 2 meses. Inclua esses números — eles explicam por que o mundo corporativo acordou para IA em 2023.

TODO 5 — Evento de 2024/2025 que você considera relevante Este é aberto. Considere: lançamento de Claude 3 Opus (março 2024, primeiro modelo a superar PhD humano em benchmarks), GPT-4o com voz em tempo real, MCP Protocol (outubro 2024), modelos de raciocínio (o1, claude-sonnet thinking), agentes autônomos em produção. Escolha o que você acha que terá mais impacto no trabalho de um profissional no seu trabalho real.

Agora você está pronto para o lab.[linklab1]