Inteligência Artificial sem Mistério
Dos conceitos básicos aos modelos generativos
Quem sou eu
Lucas de Oliveira Teixeira
Chief data scientist
Professor/pesquisador universitário
Trajetória
O que vamos construir hoje
Nossa jornada
Módulo 1
Fundamentos
O que é IA · História · Tipos de Aprendizado · Anatomia de um problema de ML
O que é Inteligência Artificial?
“A ciência e engenharia de construir máquinas inteligentes”
John McCarthy, 1956
Na prática: sistemas computacionais que realizam tarefas que normalmente exigiriam inteligência humana, reconhecer padrões, entender linguagem, tomar decisões.
1950-1970: O Nascimento
- 1950: Alan Turing propõe o “Teste de Turing”
- “Máquinas podem pensar?”
- 1956: Conferência de Dartmouth
- Nasce o termo “Inteligência Artificial”
- 1957: Frank Rosenblatt propõe o Perceptron
- Primeiro modelo de neurônio artificial
O Teste de Turing
Se um humano não consegue distinguir as respostas de uma máquina das de outro humano, a máquina pode ser considerada “inteligente”.
1969–2012: limites, invernos e o retorno das redes
Redes neurais existiam há décadas. O avanço veio quando algoritmos, dados e hardware finalmente se encontraram:
uma camada não resolve XOR
promessas > recursos
treinar redes multicamada
especialistas caros e frágeis
DBNs + GPUs + mais dados
A IA nunca cresceu em linha reta: cada inverno nasceu de expectativas exageradas, e cada retomada combinou avanços técnicos, mais dados e mais poder computacional. Vale lembrar disso hoje.
2012–Hoje: A Explosão
- 2012: AlexNet vence ImageNet
- CNNs dominam visão computacional
- 2017: “Attention Is All You Need”
- Nasce a arquitetura Transformer
- 2022: ChatGPT (OpenAI)
- IA generativa vai ao público
O que mudou?
| Fator | Antes | Hoje |
|---|---|---|
| Dados | Escassos | Bilhões de exemplos |
| Hardware | CPU lento | GPUs massivas |
| Algoritmos | Limitados | Transformers |
| Acesso | Acadêmico | Qualquer pessoa |
IA vs. Machine Learning vs. Deep Learning
O Diagrama Fundamental
CNNs · LLMs
IA vs. ML vs. DL
O paradigma mudou
Essa é a ideia central de ML: em vez de programar regras explicitamente, fornecemos exemplos e deixamos o algoritmo aprender.
Tipos de Aprendizado
Aprendizado Supervisionado
O modelo aprende a partir de exemplos rotulados:
- Recebe pares \((x, y)\): entrada e saída esperada
- Aprende a mapear \(f: X \rightarrow Y\)
- Objetivo: generalizar para dados novos
Dois tipos principais:
- Regressão: saída é um número contínuo
- Prever o preço de um imóvel
- Classificação: saída é uma categoria
- E-mail é spam ou não?
Aprendizado Não-Supervisionado
O modelo recebe apenas dados, sem rótulos:
- Busca padrões, estruturas e agrupamentos
- Não há resposta “certa” a priori
Exemplos:
- Clustering: agrupar clientes similares
- Redução de dimensionalidade: comprimir dados preservando informação
- Detecção de anomalias: encontrar fraudes em transações
Analogia: é como organizar uma estante de livros sem saber as categorias, você agrupa por semelhança (capa, tamanho, tema) e os padrões emergem naturalmente.
Aprendizado por Reforço
Um agente aprende por tentativa e erro:
- Executa ações em um ambiente
- Recebe recompensas (+) ou penalidades (−)
- Objetivo: maximizar recompensa acumulada
Ciclo do Reforço
- Agente observa o estado
- Agente escolhe uma ação
- Ambiente retorna recompensa + novo estado
- Agente atualiza sua estratégia
- Repete ♻️
Comparação rápida
| Supervisionado | Não-Supervisionado | Reforço | |
|---|---|---|---|
| Dados | Rotulados (x, y) | Sem rótulos (x) | Interação com ambiente |
| Objetivo | Prever y | Encontrar padrões | Maximizar recompensa |
| Feedback | Direto (rótulos) | Nenhum | Indireto (recompensas) |
Aqui o foco principal em aprendizado supervisionado, que é a base para entender todo o resto.
Anatomia de um Problema de ML
O Pipeline de Machine Learning
1. Dados: a matéria-prima
Tipos de dados
- Tabular: planilhas, bancos de dados
- Imagens: fotos, raio-X, satélite
- Texto: documentos, e-mails, redes sociais
- Áudio: fala, música
- Séries temporais: ações, sensores, clima
Qualidade importa!
“Garbage in, garbage out”
O melhor algoritmo do mundo não resolve dados ruins. 80% do trabalho em ML é preparar dados.
Problemas comuns:
- Dados faltantes
- Dados desbalanceados
- Ruído e outliers
2. Features e Labels
| Área (m²) | Quartos | Bairro | Preço (R$) |
|---|---|---|---|
| 70 | 2 | Centro | 350.000 |
| 120 | 3 | Jardins | 580.000 |
| 45 | 1 | Periferia | 180.000 |
| 200 | 4 | Jardins | 950.000 |
Features e Labels
Features (características)
As variáveis de entrada que descrevem cada exemplo:
- Área do imóvel
- Número de quartos
- Localização
- Idade do imóvel
São os atributos que o modelo usa para fazer previsões.
Label (rótulo)
A variável de saída que queremos prever:
- Preço do imóvel (regressão)
- Spam ou não spam (classificação)
- Diagnóstico (classificação)
Em aprendizado supervisionado, sempre temos features e labels nos dados de treino. O objetivo é prever o label de dados novos.
3. O ciclo treino → teste
Por que separar? Se avaliarmos no mesmo dado que treinamos, o modelo pode ter decorado os exemplos em vez de aprender padrões gerais.
Overfitting vs. Underfitting
● Treino ● Teste ╌╌ Padrão real
Underfitting
Reta ignora a curva real. Erra treino e teste.
“Estudou pouco para a prova”
Bom ajuste ✓
Curva acompanha o padrão real. Acerta treino e teste.
“Entendeu a matéria”
Overfitting
Zigue-zague cola nos azuis, foge do real. Acerta treino, erra teste.
“Decorou o gabarito”
Recapitulando o Módulo 1
O que vimos:
- IA > ML > DL (subconjuntos)
- ML aprende padrões a partir de dados
- Paradigmas: supervisionado, não-supervisionado, reforço
- Todo ML tem: dados, features, labels, modelo, avaliação
Próximo módulo:
Modelos Lineares
- Regressão Linear
- Gradient Descent
- Regressão Logística
- Demo ao vivo! 🎮
Cada conceito constrói sobre o anterior, a intuição da regressão linear reaparece em redes neurais!
Módulo 2
Modelos Lineares
Regressão Linear · Gradient Descent · Regressão Logística
O modelo mais simples do mundo
Regressão Linear
A ideia: encontrar a reta que melhor se ajusta aos dados.
Aplicações reais:
- Prever preço de imóvel pela área
- Prever nota pelo tempo de estudo
- Prever vendas pelo investimento em marketing
Por que começar aqui?
A regressão linear é a base de tudo. A mesma ideia de pesos, bias e função de custo aparece em redes neurais e até em LLMs!
Intuição geométrica
Os traços vermelhos são os resíduos, a distância entre cada ponto e a reta. O objetivo é minimizar esses resíduos.
A fórmula: \(y = wx + b\)
Parâmetros: w e b
\(w\): Peso (slope)
- Controla a inclinação da reta
- \(w > 0\): reta sobe (correlação positiva)
- \(w < 0\): reta desce (correlação negativa)
- \(w = 0\): reta horizontal (sem relação)
\(b\): Bias (intercepto)
- Controla onde a reta cruza o eixo y
- É o valor de \(y\) quando \(x = 0\)
- “Deslocamento” vertical da reta
\[\hat{y} = wx + b\]
O objetivo do modelo é aprender os melhores valores de \(w\) e \(b\) a partir dos dados.
Como medir “melhor”? A função de custo
MSE: Mean Squared Error
\[MSE = \frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2\]
Por que ao quadrado?
- Penaliza erros grandes mais que erros pequenos
- Remove sinais negativos (erros para cima e para baixo contam igual)
- Tem derivada contínua (útil para otimização)
O MSE define uma superfície de custo: um “terreno” onde queremos encontrar o ponto mais baixo.
Gradient Descent
Gradient Descent
Analogia: descida do morro
Imagine que você está no topo de um morro com os olhos vendados:
- Sinta a inclinação do chão (gradiente)
- Dê um passo na direção que desce mais
- Repita até chegar ao vale (mínimo)
Matematicamente:
\[w_{novo} = w_{atual} - \alpha \cdot \frac{\partial MSE}{\partial w}\]
Onde \(\alpha\) é o learning rate (tamanho do passo).
O gradiente aponta na direção de maior subida. Subtraímos o gradiente para descer.
O mesmo algoritmo é usado em redes neurais e LLMs, exatamente a mesma ideia, só com mais dimensões!
O efeito do Learning Rate
Escolher o learning rate certo é um dos hiperparâmetros mais importantes em ML.
Regressão Linear Múltipla
E se tivermos mais de uma feature?
\[\hat{y} = w_1 x_1 + w_2 x_2 + ... + w_n x_n + b\]
- Em vez de uma reta, temos um plano (2 features) ou hiperplano (n features)
- A mesma lógica de MSE + Gradient Descent se aplica!
🎮 DEMO 1: Regressão Linear Interativa
Regressão Logística
Regressão Logística
A regressão linear pode dar valores fora de [0, 1], não serve para probabilidades!
A função sigmoid resolve isso.
A função Sigmoid
Regressão Logística: como funciona
Passo a passo:
- Calcula a saída linear: \(z = wx + b\)
- Aplica a sigmoid: \(P(y=1) = \frac{1}{1 + e^{-z}}\)
- Classifica:
- Se \(P \geq 0.5\) → Classe 1
- Se \(P < 0.5\) → Classe 0
Apesar do nome…
Apesar de se chamar “Regressão” Logística, é um modelo de classificação!
O nome vem do fato de que internamente ela faz uma regressão linear, seguida da transformação sigmoid.
Fronteira de decisão (decision boundary)
A fronteira de decisão é a linha onde \(P(y=1) = 0.5\).
De um lado, o modelo prevê classe 0; do outro, classe 1.
Métricas de avaliação
Antes de classificar ao vivo, o mapa completo de como medimos um modelo:
🎮 DEMO 2: Classificação com Regressão Logística
Limitação importante: a regressão logística só cria fronteiras lineares (retas/planos). Dados não-lineares precisam de modelos mais complexos.
Recapitulando o Módulo 2
O que vimos:
- Regressão Linear: \(y = wx + b\), melhor reta
- MSE: medir qualidade do ajuste
- Gradient Descent: otimizar os pesos
- Learning Rate: tamanho do passo importa
- Sigmoid: transformar saída em probabilidade
- Regressão Logística: classificação com fronteira linear
Conceitos-chave que voltam:
Estes conceitos são a base de tudo que vem a seguir:
- Pesos e bias → aparecem em redes neurais
- Função de custo → toda rede neural otimiza uma
- Gradient Descent → treina qualquer modelo de ML
- Sigmoid → é uma função de ativação neural
Módulo 3
Modelos Clássicos de ML
Árvores · Random Forest · kNN · SVM
Além da linha reta
Como vimos no módulo anterior, a regressão logística só cria fronteiras lineares, mas muitos problemas reais são não-lineares!
Existem outros modelos “clássicos” (anteriores ao deep learning) que lidam bem com isso:
- Árvores de Decisão
- Random Forest
- k-Nearest Neighbors
- Support Vector Machines
Estes modelos são usados até hoje em muitas aplicações práticas, especialmente com dados tabulares (planilhas, bancos de dados). Nem tudo precisa de deep learning!
Árvores de Decisão
Como funciona
- Faz uma pergunta sobre uma feature (ex.: “estudou > 3h?”)
- Divide os dados conforme a resposta (sim / não)
- Escolhe a pergunta que mais reduz a impureza (Gini / Entropia)
- Repete até os grupos ficarem “puros” → folha = decisão
- Muito interpretável
- Numéricos e categóricos
- Não precisa normalizar
- Tende a overfitting
- Instável: muda com poucos dados
- Fronteiras retangulares
Árvores: Uma sequência de perguntas
O percentual é a proporção de alunos daquele grupo, ex.: entre os que estudaram mas não fizeram exercícios, 75% foram aprovados. Quanto maior, mais confiança na previsão.
Árvores: fronteiras retangulares
Random Forest
Como funciona
- Cria N amostras aleatórias (bootstrap) dos dados
- Treina uma árvore em cada amostra
- Cada árvore vê um subconjunto de features
- Predição final: voto majoritário das árvores
- Reduz overfitting drasticamente
- Mais estável e preciso que 1 árvore
- Um dos mais usados na prática
- Menos interpretável que 1 árvore
- Mais pesado (muitas árvores)
- Predição mais lenta
Random Forest: Muitas árvores votando
Primo do Random Forest: Gradient Boosting
Outra forma de combinar árvores:
Em vez de árvores em paralelo (votação), treina árvores em sequência:
XGBoost / LightGBM dominam competições de ML com dados tabulares até hoje.
O nome vem de usar o gradiente do erro para decidir o que a próxima árvore deve corrigir, o mesmo gradiente do Módulo 2!
k-Nearest Neighbors (kNN)
Como funciona
Para classificar um novo ponto:
- Calcule a distância a todos os pontos do treino
- Encontre os k mais próximos (vizinhos)
- Vote: a classe majoritária entre eles vence
- Zero treinamento (“lazy learner”)
- Bom com poucos dados
- Fronteira flexível
- Predição lenta (calcula todas as distâncias)
- Sofre em alta dimensão
- Sensível à escala das features
kNN: O valor de k muda a predição
Support Vector Machines (SVM)
Como funciona
- Busca o hiperplano que separa as classes
- Com a maior margem possível
- Vetores suporte: os pontos que definem a margem
- Kernel trick: projeta em dimensão maior para casos não-lineares
- Margem máxima → boa generalização
- Kernel trick para não-linear
- Forte em alta dimensão
- Escala mal com muitos dados
- Sensível a kernel / hiperparâmetros
- Pouco interpretável
SVM: Margem máxima e kernel
Comparando todos os modelos
Mesmo dataset, modelos diferentes → fronteiras de decisão completamente diferentes!
🎮 DEMO 3: Arena de Classificadores
Recapitulando o Módulo 3
O que vimos:
- Árvores de Decisão: perguntas encadeadas
- Random Forest: ensemble de árvores, votação
- kNN: classifica pelos vizinhos mais próximos
- SVM: margem máxima + kernel trick
Próximo módulo:
Redes Neurais: a revolução do deep learning!
- Do Perceptron ao MLP
- Funções de ativação
- Backpropagation
- Demo ao vivo! 🎮
Lembre-se: a regressão linear e o gradient descent que vimos no Módulo 2 são exatamente os mesmos usados em redes neurais!
Módulo 4
Redes Neurais
Do Perceptron ao Multi-Layer Perceptron
O neurônio biológico
A seguir: o neurônio artificial é uma simplificação radical desta ideia (inspirada, não uma cópia).
O neurônio artificial
Inspirado no neurônio biológico, mas uma simplificação radical, não uma cópia. Cada entrada tem um peso (≈ força da sinapse); o aprendizado por backpropagation, aliás, não tem equivalente conhecido no cérebro.
O Perceptron (1957)
O modelo de neurônio mais simples:
- Recebe entradas \(x_1, x_2, ..., x_n\)
- Multiplica cada uma por um peso \(w_i\)
- Soma tudo e adiciona bias \(b\)
- Aplica uma função de ativação \(f\)
\[y = f\left(\sum_{i=1}^{n} w_i x_i + b\right)\]
Parece familiar?
É exatamente a regressão linear com uma função de ativação por cima!
\[z = wx + b \quad \text{(linear)}\] \[y = f(z) \quad \text{(ativação)}\]
A regressão linear é um caso especial onde \(f\) é a identidade.
Funções de ativação
Por que precisamos de ativações?
Sem ativação (linear):
Empilhar camadas lineares = uma operação linear
\[\begin{aligned} f(g(x)) &= W_2(W_1 x) \\ &= (W_2 W_1)\,x \\ &= W'x \end{aligned}\]
Não importa quantas camadas, o resultado é sempre linear!
Com ativação (não-linear):
A função de ativação quebra a linearidade, permitindo que a rede aprenda padrões complexos.
Multi-Layer Perceptron (MLP)
3 features
5 neurônios
4 neurônios
2 classes
Anatomia de um MLP
Camadas:
- Entrada: recebe os dados (features)
- Ocultas: onde a “magia” acontece, aprendem representações internas
- Saída: gera a predição final
Cada neurônio:
- Recebe saídas da camada anterior
- Multiplica pelos pesos
- Soma + bias
- Aplica função de ativação
Representações internas
Cada camada oculta aprende uma representação diferente dos dados:
- Camada 1: detecta padrões simples
- Camada 2: combina padrões em conceitos mais abstratos
- Camada N: representações cada vez mais complexas
É como se a rede criasse suas próprias features automaticamente!
Forward Propagation
Como a rede aprende?
loss é a função de custo do Módulo 2 (só muda o nome em deep learning). E é o mesmo gradient descent de lá, agora com muito mais variáveis.
Epochs, Batches e Learning Rate
Batch Size
Em vez de atualizar pesos a cada exemplo, processamos um lote (batch) de exemplos e calculamos a média dos gradientes.
- Batch grande: mais estável, mais lento
- Batch pequeno: mais ruidoso, mais rápido
- Mini-batch (32–256): o padrão na prática
Epoch
Uma passagem completa por todos os dados de treino.
- Epoch 1: primeira vez vendo todos os dados
- Epoch 100: centésima passagem
- Treinar por muitas epochs → risco de overfitting
Learning Rate
- Muito alto → oscila / não converge
- Muito baixo → muito lento
- Ideal → converge de forma estável
Overfitting em redes neurais
Combatendo overfitting
Dropout
- Durante o treino, desativa neurônios aleatoriamente (ex: 20–50%)
- Força a rede a não depender de um único caminho
- No teste, usa todos os neurônios
Outras técnicas:
- Regularização L2: penaliza pesos grandes
- Early stopping: para quando a validação piora
- Data augmentation: mais variações dos dados
Analogia do estudo em grupo:
Se toda vez você estuda com colegas diferentes, aprende a resolver por conta própria. Se sempre estuda com o mesmo grupo, fica dependente.
Dropout faz a mesma coisa: cada “rodada” de treino usa neurônios diferentes, forçando generalização.
O Teorema da Aproximação Universal
Por que redes neurais são poderosas?
Teorema (Cybenko, 1989):
Uma rede neural com uma única camada oculta e neurônios suficientes pode aproximar qualquer função contínua com precisão arbitrária.
Na prática:
- “Qualquer função” = qualquer relação entre entrada e saída
- Mas pode precisar de muitos neurônios em uma camada
- Redes profundas (várias camadas) são mais eficientes
- Mais camadas = representações mais hierárquicas
Atenção: o teorema diz que a solução existe, mas não garante que o gradient descent vai encontrá-la!
Na prática, arquitetura, dados e treinamento importam muito.
É por isso que redes neurais dominam tantos campos: elas podem aprender qualquer padrão, desde que tenham dados e capacidade suficientes.
🎮 DEMO 4: Playground de Rede Neural
Recapitulando o Módulo 4
O que vimos:
- Neurônio artificial = perceptron = regressão linear + ativação
- O problema XOR motivou redes multi-camada
- Funções de ativação introduzem não-linearidade
- MLP: camadas de neurônios empilhadas
- Backpropagation: como a rede aprende
- Dropout: prevenir overfitting
- Teorema da Aproximação Universal: redes podem aprender qualquer função
Próximo módulo:
Deep Learning e CNNs: redes neurais para imagens!
- O que torna “deep” o deep learning
- Convolução: a operação que revolucionou visão computacional
- Classificar dígitos desenhados à mão
- Demo ao vivo! 🎮
Até agora trabalhamos com dados tabulares 2D. No próximo módulo, vamos ver como redes neurais processam imagens!
Módulo 5
Deep Learning e CNNs
Ensinando Máquinas a Ver
O que torna “Deep” o Deep Learning?
Profundidade = muitas camadas
- Shallow: 1-2 camadas ocultas → MLP clássico
- Deep: dezenas, centenas ou até milhares de camadas
Por que profundidade importa?
Cada camada aprende uma representação diferente dos dados, do simples ao complexo:
- Camada 1: bordas, gradientes
- Camada 2: texturas, cantos
- Camada 3: partes (olho, roda)
- Camada N: objetos completos (rosto, carro)
Por que Deep Learning agora?
Como computadores “veem” imagens
Cada pixel é só um número (0 a 255). Uma imagem colorida são 3 matrizes empilhadas: o tensor (3, H, W) que a CNN recebe de entrada.
Uma imagem é informação demais para um MLP
Pesos só na 1ª camada densa (1000 neurônios):
E são dois problemas, não um:
Explode: e isso é só a primeira camada. A rede inteira chegaria a bilhões de pesos.
Joga fora a estrutura: o flatten achata a imagem numa lista solta de pixels. A vizinhança 2D some, e deslocar o objeto 1 pixel vira uma entrada completamente diferente.
Precisamos de uma operação que reaproveite pesos e respeite a vizinhança.
A convolução: um filtro que desliza
O mesmo filtro percorre a imagem inteira: só 9 parâmetros, reaproveitados em toda parte.
Por que a convolução funciona
O que os filtros detectam?
- Borda vertical:
[+1, 0, -1] - Borda horizontal: o transposto
- Blur: a média dos vizinhos
- E o melhor: a CNN aprende os filtros sozinha, não somos nós que definimos
Três vantagens de peso:
Compartilhamento de pesos: o mesmo filtro varre a imagem toda → pouquíssimos parâmetros
Invariância à posição: acha o padrão em qualquer lugar
Estrutura local: usa a vizinhança dos pixels, não os trata como lista solta
Um filtro 3×3 tem 9 parâmetros, contra os 784 de um único neurônio denso sobre a imagem 28×28.
Pooling: reduzindo dimensões
O objetivo é encolher o mapa mantendo o que há de mais forte em cada região.
O que ganhamos com o pooling
Benefícios:
- Menos parâmetros e menos conta
- Mantém as features mais importantes
- Invariância a pequenas translações
- Ajuda a evitar overfitting
A cada bloco Conv + Pool:
- A resolução diminui (28 → 14 → 7…)
- O número de features aumenta (1 → 16 → 32…)
- A informação fica mais abstrata
Começa em pixels, termina em “conceitos”.
Representações hierárquicas
Ativações reais de uma AlexNet: as camadas rasas pegam bordas; as profundas, conceitos. É exatamente o que empilhar Conv + Pool constrói.
Arquitetura CNN completa
Duas fases: as camadas Conv + Pool extraem features cada vez mais abstratas; as camadas densas classificam nos 10 dígitos.
Entendendo a arquitetura
Duas fases principais:
1. Feature Extraction (convolução):
- Bloco repetido: Conv → ReLU → Pool
- Extrai features cada vez mais abstratas
- Poucos parâmetros (compartilhamento de pesos)
2. Classificação (fully connected):
- Flatten: achata o tensor em vetor
- Camadas densas (como um MLP)
- Softmax na saída: transforma os 10 números finais em probabilidades que somam 100%, uma por classe
Nossa CNN (demo):
| Camada | Dimensão | Params |
|---|---|---|
| Input | 1×28×28 | 0 |
| Conv(16, 3×3) | 16×28×28 | 160 |
| Pool 2×2 | 16×14×14 | 0 |
| Conv(32, 3×3) | 32×14×14 | 4.640 |
| Pool 2×2 | 32×7×7 | 0 |
| Dense(128) | 128 | 200.832 |
| Dense(10) | 10 | 1.290 |
| Total | ~207K |
A evolução das arquiteturas
LeCun · 60K parâmetros
dígitos postais
erro ~1% (dígitos)
Krizhevsky · 60M parâmetros
breakthrough no ImageNet
erro 16% (ImageNet)
Simonyan · 138M parâmetros
16 camadas
He et al. · skip connections
152 camadas!
erro 3,6% (super-humano!)
Tan & Le · escala balanceada
estado da arte
De LeNet a ResNet
A revolução AlexNet (2012):
- Venceu o ImageNet por margem enorme
- Usou GPUs pela primeira vez
- ReLU em vez de sigmoid
- Dropout para regularização
- Marcou o início da era Deep Learning
Skip Connections (ResNet):
O segredo para treinar redes muito profundas: permitir que o gradiente “pule” camadas.
\(F(x) + x\) em vez de apenas \(F(x)\)
Por que ResNet é tão importante?
Redes muito profundas tinham o problema do vanishing gradient: o gradiente ficava tão pequeno que as primeiras camadas não aprendiam.
Skip connections resolvem isso: o gradiente tem um “atalho” direto para as camadas anteriores.
Resultado: redes com 152 camadas que superam o desempenho humano no ImageNet!
Transfer Learning
• Treina em minutos, não dias
• Reaproveita features genéricas (bordas, texturas)
Na prática: Transfer Learning
A ideia:
- Pegue uma rede pré-treinada (ex: ResNet treinada no ImageNet com milhões de imagens)
- Congele as camadas convolucionais (features genéricas já aprendidas)
- Substitua apenas a última camada densa pela sua tarefa
- Treine com poucos dados da sua tarefa específica
Resultado:
- Funciona com poucas centenas de imagens
- Treina em minutos em vez de dias
- Performance excelente
Exemplo real:
Classificar radiografias de tórax:
- Pegar ResNet pré-treinada no ImageNet (fotos de gatos, carros, etc.)
- Trocar última camada: 1000 → 2 classes (normal/pneumonia)
- Treinar com 5.000 radiografias
- Resultado: 94% de acurácia!
As features de baixo nível (bordas, texturas) são universais entre domínios visuais.
Transfer learning é a técnica mais usada na prática: raramente treina-se uma CNN do zero.
🎮 DEMO 5: Classificador de Dígitos
Recapitulando o Módulo 5
O que vimos:
- Deep Learning = redes com muitas camadas + representações hierárquicas
- Imagens são tensores de números
- Convolução: filtros que deslizam detectando padrões
- Pooling: reduz dimensionalidade preservando informação
- CNN = Conv + Pool + Dense
- Arquiteturas famosas: LeNet → AlexNet → ResNet
- Transfer learning: reutilizar conhecimento pré-treinado
Próximo módulo:
NLP e Embeddings: processando linguagem natural!
- Como representar palavras como vetores
- A mágica do Word2Vec
- “Rei - Homem + Mulher = Rainha”
- Demo ao vivo! 🎮
Até agora trabalhamos com números e imagens. No próximo módulo, entramos no mundo do texto: o domínio que deu origem aos LLMs!
Módulo 6
NLP e Embeddings
Ensinando Máquinas a Entender Texto
O desafio fundamental
O problema:
Modelos de ML trabalham com números. Mas texto é composto de palavras.
Como converter “O gato sentou no tapete” em algo que um modelo entenda?
A jornada:
- Bag of Words: contar palavras
- TF-IDF: ponderar importância
- Word Embeddings: capturar significado
- Sentence Embeddings: representar frases inteiras
Bag of Words e TF-IDF
| gato | 1 |
| sentou | 1 |
| no | 1 |
| tapete | 1 |
| cachorro | 0 |
| correu | 0 |
Limitações: palavras como símbolos isolados
Contar palavras perde:
- Ordem: “cachorro mordeu homem” = “homem mordeu cachorro”
- Semântica: “bom” e “excelente” são completamente diferentes
- Contexto: “banco” (assento) = “banco” (financeiro)
TF-IDF melhora os pesos, mas ainda não captura significado.
O problema central:
BoW e TF-IDF tratam palavras como símbolos isolados, sem relação entre si.
“gato” e “felino” são tão diferentes quanto “gato” e “avião”.
Precisamos de uma representação em que: palavras similares tenham representações similares.
A grande ideia: Word Embeddings
A frase que mudou tudo:
“You shall know a word by the company it keeps” J.R. Firth, 1957
Palavras que aparecem em contextos similares têm significados similares.
“gato” e “cachorro” aparecem perto de “ração”, “veterinário”, “brincar”: devem significar coisas parecidas!
A proposta:
Aprender, a partir dos contextos, um vetor denso para cada palavra (ex.: 300 dimensões).
gato = [0.2, −0.5, 0.8, …]
Similaridade de significado vira proximidade no espaço vetorial.
Word2Vec (Mikolov et al., 2013)
Como funciona:
- Percorre um corpus de texto (Wikipedia, livros, web)
- Para cada palavra, olha o contexto (palavras vizinhas)
- Treina uma rede neural para prever contexto → palavra ou palavra → contexto
- Os pesos da rede = embeddings!
O gato sentou no tapete macio
Dois métodos:
Skip-gram: Dada a palavra “sentou”, prever que “gato” e “tapete” estão perto.
Melhor para palavras raras.
CBOW (Continuous Bag of Words): Dado o contexto [“gato”, “_“,”tapete”], prever “sentou”.
Mais rápido para treinar.
Word2Vec: o espaço aprendido
A mágica: aritmética de vetores
paris − frança + itália = roma
maior − grande + pequeno = menor
andando − andar + nadar = nadando
Por que isso funciona?
Direções no espaço vetorial:
Os embeddings organizam conceitos como direções:
- A direção “gênero”: homem → mulher
- A direção “país → capital”: França → Paris
- A direção “verbo conjugação”: andar → andando
Isso emerge naturalmente!
Ninguém ensinou essas relações à rede: ela aprendeu apenas de co-ocorrências de palavras.
A similaridade é medida pelo cosseno:
\[\text{sim}(a, b) = \frac{a \cdot b}{\|a\| \|b\|}\]
- 1.0 = idênticos
- 0.0 = sem relação
- -1.0 = opostos
Exemplos:
- sim(gato, cachorro) ≈ 0.8
- sim(gato, avião) ≈ 0.1
- sim(rei, rainha) ≈ 0.7
Variações de embeddings
GloVe (Stanford, 2014)
- Global Vectors
- Usa estatísticas globais de co-ocorrência
- Mais estável que Word2Vec
- Pré-treinado na Wikipedia + Common Crawl
FastText (Facebook, 2016)
- Usa subpalavras (n-grams)
- “futebol” → “fut”, “ute”, “teb”, “bol”
- Funciona com palavras fora do vocabulário
- Ótimo para português!
Embeddings Contextuais (2018+)
- ELMo, BERT, GPT
- A mesma palavra tem vetores diferentes dependendo do contexto
- “banco” (sentar) ≠ “banco” (dinheiro)
- Estado da arte atual!
De palavras a frases
O gato sentou no tapete
🎮 DEMO 6: Explorador de Embeddings
Modelo usado:
GloVe pré-treinado (50 dimensões), treinado na Wikipedia em inglês. Vocabulário de ~400K palavras.
Recapitulando o Módulo 6
O que vimos:
- Texto precisa ser convertido em números para ML
- Bag of Words/TF-IDF: simples, mas perde semântica
- Word Embeddings: vetores densos que capturam significado
- Word2Vec: aprender embeddings de co-ocorrências
- Aritmética vetorial: rei - homem + mulher ≈ rainha
- GloVe, FastText: variações com vantagens
- Sentence embeddings: representar frases inteiras
Próximo módulo:
Transformers e LLMs: a revolução que criou o ChatGPT!
- O mecanismo de atenção
- A arquitetura Transformer
- Como LLMs geram texto
- Demo ao vivo! 🎮
Agora que entendemos como representar texto como vetores, estamos prontos para o passo final: os Transformadores que deram origem aos modelos de linguagem modernos!
Módulo 7
Transformers e LLMs
De “Attention Is All You Need” ao ChatGPT
O desafio: entender sequências
A peça que falta:
No Módulo 6, palavras viraram vetores com significado. Mas linguagem é sequência:
- Ordem: “o gato caçou o rato” ≠ “o rato caçou o gato”
- Contexto: o vetor de “banco” deveria depender dos vizinhos
- Dependências longas: o sujeito pode estar 20 palavras antes do verbo
Como um modelo lê uma frase inteira?
Primeira tentativa: RNNs
Redes Recorrentes leem palavra por palavra, carregando um “estado oculto” com o que já foi lido
“Attention Is All You Need” (2017)
O paper que mudou tudo:
- Vaswani et al., Google Brain, 2017
- Propôs uma arquitetura sem recorrência
- Baseada inteiramente em atenção
- Processamento paralelo de toda a sequência
A ideia central:
Em vez de processar palavra por palavra, cada palavra “olha” para todas as outras simultaneamente e decide quais são relevantes.
Impacto:
- 2017: Transformer supera RNNs em tradução
- 2018: BERT (Google) revoluciona NLP
- 2019: GPT-2 gera texto convincente
- 2020: GPT-3 surpreende com Few-shot
- 2022: ChatGPT muda o mundo
- 2023-25: GPT-4, Claude, Gemini, DeepSeek…
Tudo começou com esse paper de 2017!
Self-Attention
O gato sentou no tapete
Arquitetura Transformer
The cat sat
sentou ← próxima palavra (volta para a entrada e o ciclo repete)
O gato
BERT vs GPT
O [MASK] sentou no tapete
✓ extração de entidades (NER)
✓ perguntas e respostas
✓ similaridade de frases
O gato sentou no ???
✓ chatbots (ChatGPT)
✓ completar código (Copilot)
✓ raciocínio e agentes
Tokenização: texto → números
Int5765 elig14854 ência9870 artificial11666 é304 fasc18932 in259 ante4630
GPT-2: ~50 mil tokens no vocabulário
• Nenhuma palavra fica “fora do vocabulário”
• Equilíbrio entre tamanho e expressividade
Next-Token Prediction
O único objetivo: prever o próximo token dado os anteriores, \(P(x_{t+1} | x_1, ..., x_t)\)
O gato sentou no
Como LLMs geram texto
Autoregressivo: escolhe um token, anexa ao contexto e repete
. . .
É só isso: todo texto do ChatGPT nasce desse ciclo, um token por vez.
Controlando a geração: Temperature, Top-k e Top-p
Temperature
Controla a aleatoriedade da escolha:
Temperature = 0: sempre escolhe o mais provável → determinístico, repetitivo
Temperature = 0.7: balanceado → criativo mas coerente
Temperature = 1.5: muito aleatório → criativo mas pode ser incoerente
Top-k e Top-p
Limitam os candidatos antes da escolha:
- Top-k=50: considera apenas os 50 tokens mais prováveis
- Top-p=0.9: considera tokens até somar 90% de probabilidade
Você vai ver o efeito da temperatura ao vivo na demo deste módulo!
Scaling Laws e capacidades emergentes
Capacidades emergentes:
Modelos maiores não são só “melhores”: habilidades novas (few-shot, raciocínio passo a passo, código) surgem a partir de um certo tamanho.
GPT-2 (124M) → completa texto simples
GPT-3 (175B) → few-shot, raciocínio básico
GPT-4 (~1.8T?) → raciocínio complexo, multimodal
Hoje (GPT-5, Claude Opus/Fable, Gemini) → raciocínio longo, agentes autônomos
Daí a corrida atual: GPT-5, Claude e Gemini (proprietários) vs DeepSeek, Llama, Qwen e Kimi (pesos abertos). E a escala hoje não é só tamanho: modelos também melhoram “pensando” por mais tempo antes de responder.
🎮 DEMO 7: Preditor de Próxima Palavra
Modelo:
GPT-2 Small (124M params, ~500MB). Roda em CPU com inferência em ~1-2s por token.
Recapitulando o Módulo 7
O que vimos:
- RNNs/LSTMs: processamento sequencial, memória limitada
- Self-Attention: cada palavra olha para todas as outras
- Transformer: a arquitetura que substituiu RNNs
- BERT vs GPT: encoder (entender) vs decoder (gerar)
- Tokenização BPE: texto → subpalavras → números
- Next-token prediction: como LLMs geram texto
- Scaling laws: mais = melhor (+ emergent abilities)
- RLHF: de modelo base a ChatGPT
Próximo módulo:
Encerramento: a jornada completa!
- De \(y = wx + b\) até LLMs
- IA na educação
- Ética e responsabilidade
- Recursos para continuar
Percorremos toda a jornada: de uma simples reta até modelos com centenas de bilhões de parâmetros que conversam conosco. No próximo módulo, vamos juntar tudo!
Obrigado!
Inteligência Artificial sem Mistério Dos conceitos básicos aos modelos generativos
Perguntas?
Os demos e materiais estão disponíveis para uso e experimentação em: lucasai@sporedata.com