AI: Arquiteturas de Aprendizado Profundo

Última atualização: 2026-08-26

As três principais arquiteturas de aprendizado profundo—CNNs, RNNs e Transformers—lidam com desafios fundamentais em visão, sequências e linguagem, respectivamente. Este capítulo não deriva fórmulas matemáticas; em vez disso, utiliza intuição e código para ajudá-lo a entender "por que CNNs são boas em reconhecer imagens, RNNs são boas em lidar com séries temporais, e Transformers são bons em compreender linguagem", bem como por que os Transformers estão unificando tudo.

1. O Que Você Vai Aprender

• A Intuição por Trás de Convolução e Pooling em CNNs: Por que "Janelas Deslizantes" Podem Extrair Características
• A Intuição por Trás do Processamento de Sequências em RNNs: Por que a "Memória" é Crucial para Dados Temporais
• A Intuição por Trás do Mecanismo de Auto-Atenção do Transformer: Por que a "Atenção Global" é Superior à "Propagação Gradual"
• Casos de Uso e Critérios de Seleção para as Três Principais Arquiteturas
• O Conceito de Modelos Pré-treinados e Prática com o Hugging Face

2. História: Três Tipos de Missões, Três Tipos de Estruturas

(1) Dor: Uma IA não é suficiente?

A startup do Charlie enfrenta três desafios ao mesmo tempo:

Charlie originalmente pensou que precisaria de três tecnologias de IA diferentes e até considerou contratar três engenheiros. Alice disse a ele: “Existem de fato três arquiteturas, mas você não precisa treiná-las do zero — pode resolver rapidamente usando modelos pré-treinados.”

(2) A Solução de IA: Três Arquiteturas, Uma Plataforma

Usando o pipeline do Hugging Face, Alice completou três tarefas com apenas 30 linhas de código:

• Classificação de Imagens → Modelos pré-treinados usando arquiteturas CNN
• Análise de Sentimento → Modelos pré-treinados baseados na arquitetura Transformer
• Geração de Texto → Grandes modelos de linguagem baseados na arquitetura Transformer

▶ Exemplo: Três tarefas principais, completadas em 30 linhas de código (Dificuldade: ⭐)

# Three tasks, three pipelines, one platform: Hugging Face
from transformers import pipeline

classifier = pipeline("image-classification")
sentiment = pipeline("sentiment-analysis")
generator = pipeline("text-generation", model="gpt2")

# Task 1: Image classification (CNN backbone)
# result = classifier("product_photo.jpg")
# print("Image labels:", [r['label'] for r in result[:3]])

# Task 2: Sentiment analysis (Transformer backbone)
sent = sentiment("This product is amazing! Best purchase ever.")
print("Sentiment:", sent)

# Task 3: Text generation (Transformer/LLM)
text = generator("The stock market today", max_length=30, num_return_sequences=1)
print("Generated:", text[0]['generated_text'])

Sentiment: [{'label': 'POSITIVE', 'score': 0.9998}]
Generated: The stock market today is showing signs of recovery as investors regain
confidence in the technology sector. Analysts predict

(3) Benefícios: Sem Mais Confusão ao Escolher uma Arquitetura

Charlie descobriu que escolher uma arquitetura é o mesmo que escolher uma ferramenta. Assim como um carpinteiro não usaria um martelo para serrar madeira, um engenheiro de IA não usaria uma RNN para classificação de imagens. Ao compreender os princípios de design por trás das três principais arquiteturas, você pode determinar rapidamente “qual arquitetura usar para qual tarefa”.

3. CNN—A Intuição Visual por Trás das Redes Neurais Convolucionais

(1) Por que as Imagens Requerem uma Arquitetura Dedicada?

Uma imagem RGB de 224×224 possui 224 × 224 × 3 = 150.528 valores de entrada. Se uma rede totalmente conectada for usada, apenas a primeira camada exigiria dezenas de milhões de parâmetros—isso não só levaria a uma explosão computacional, mas também resultaria na perda da estrutura espacial da imagem (as relações entre pixels adjacentes).

O insight principal da CNN: Existe uma forte correlação dentro de regiões locais de uma imagem (pixels em um olho estão fortemente correlacionados com pixels adjacentes, mas fracamente com pixels no céu distante), portanto, usar uma "janela deslizante" para extrair características locais é suficiente.

(2) Kernels de Convolução—Detectores de Características

Um kernel de convolução (ou filtro) é um componente central de uma CNN—uma pequena matriz de pesos que desliza sobre a entrada, calculando um produto escalar a cada etapa e produzindo um mapa de características.

Imagem de entrada (5×5)  Kernel (3×3)         Mapa de características (3×3)
┌─┬─┬─┬─┬─┐             ┌──┬──┬──┐           ┌──┬──┬──┐
│1│0│1│0│1│             │ 1│ 0│-1│           │ 2│ 0│ 2│
├─┼─┼─┼─┼─┤      ×     ├──┼──┼──┤    =      ├──┼──┼──┤
│0│1│0│1│0│             │ 1│ 0│-1│           │ 0│ 1│ 0│
├─┼─┼─┼─┼─┤             ├──┼──┼──┤           ├──┼──┼──┤
│1│0│1│0│1│             │ 1│ 0│-1│           │ 2│ 0│ 2│
├─┼─┼─┼─┼─┤             └──┴──┴──┘           └──┴──┴──┘
│0│1│0│1│0│
├─┼─┼─┼─┼─┤   Janela deslizante: o kernel
│1│0│1│0│1│   percorre a imagem
└─┴─┴─┴─┴─┘

Diferentes kernels de convolução detectam diferentes características:

▶ Exemplo: Detecção de Arestas Usando Kernels de Convolução (Dificuldade: ⭐)

import numpy as np
from scipy.signal import convolve2d

image = np.array([
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
], dtype=float)

vertical_kernel = np.array([
    [-1, 0, 1],
    [-1, 0, 1],
    [-1, 0, 1],
], dtype=float)

horizontal_kernel = np.array([
    [-1, -1, -1],
    [ 0,  0,  0],
    [ 1,  1,  1],
], dtype=float)

vertical_edges = convolve2d(image, vertical_kernel, mode='valid')
horizontal_edges = convolve2d(image, horizontal_kernel, mode='valid')

print("Imagem original (quadrado branco em fundo preto):")
print(image)
print("\nArestas verticais detectadas:")
print(vertical_edges)
print("\nArestas horizontais detectadas:")
print(horizontal_edges)

Imagem original (quadrado branco em fundo preto):
[[0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]]

Arestas verticais detectadas:
[[ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]]

Arestas horizontais detectadas:
[[ 0.  0.  0.  0.  0.]
 [ 1.  1.  1.  1.  1.]
 [ 0.  0.  0.  0.  0.]
 [-1. -1. -1. -1. -1.]
 [ 0.  0.  0.  0.  0.]]

(3) Pooling—Redução de Amostragem Preservando Informação Chave

Pooling envolve deslizar uma pequena janela sobre um mapa de características e, em cada etapa, reter apenas o valor máximo (pooling máximo) ou o valor médio (pooling médio) para reduzir o tamanho do mapa de características:

Max Pooling (2×2, stride 2):

Mapa de características (4×4)   Pooled (2×2)
┌──┬──┬──┬──┐                  ┌──┬──┐
│ 1│ 3│ 2│ 1│                  │ 3│ 6│
├──┼──┼──┼──┤        →         ├──┼──┤
│ 2│ 3│ 5│ 6│                  │ 8│ 9│
├──┼──┼──┼──┤                  └──┴──┘
│ 7│ 8│ 1│ 0│
├──┼──┼──┼──┤   Cada bloco 2×2 → valor máximo
│ 4│ 2│ 9│ 3│
└──┴──┴──┴──┘

O papel do pooling: ① Reduz a carga computacional; ② Proporciona invariância a translação (deslocamentos leves no alvo não afetam os resultados); ③ Expande o campo receptivo (camadas subsequentes podem processar uma área maior).

(4) A Estrutura Completa de uma CNN

Uma CNN típica é composta por "blocos de convolução" empilhados, onde cada bloco de convolução consiste em uma camada de convolução, uma função de ativação e uma camada de pooling, seguida por uma camada totalmente conectada para classificação:

4. RNN—A Intuição Sequencial das Redes Neurais Recorrentes

(1) Por que sequências requerem uma arquitetura especializada?

Dados sequenciais (texto, discurso, preços de ações) possuem uma característica chave: a ordem importa. "Eu te amo" e "Me ame você" contêm as mesmas palavras, mas têm significados completamente diferentes. Redes totalmente conectadas "achata" todas as entradas, perdendo informações sobre a ordem; as CNNs consideram apenas janelas locais e não conseguem modelar dependências de longo alcance.

A ideia central das RNNs: Usar estados ocultos para transmitir informações históricas—a saída em cada etapa depende não apenas da entrada atual, mas também da "memória" de todas as entradas anteriores.

(2) O Processo Computacional de uma RNN

Step 1:  h₁ = tanh(Wₓ·x₁ + Wₕ·h₀ + b)    →  y₁ = softmax(Wᵧ·h₁)
Step 2:  h₂ = tanh(Wₓ·x₂ + Wₕ·h₁ + b)    →  y₂ = softmax(Wᵧ·h₂)
Step 3:  h₃ = tanh(Wₓ·x₃ + Wₕ·h₂ + b)    →  y₃ = softmax(Wᵧ·h₃)
                ↑
         O estado oculto anterior alimenta a etapa atual

Ponto chave: Wₓ, Wₕ e Wᵧ compartilham o mesmo conjunto de parâmetros em todas as etapas temporais—as RNNs processam cada posição em uma sequência usando o mesmo conjunto de pesos, o que é chamado de compartilhamento de parâmetros.

▶ Exemplo: Uma RNN Simples que Prevê o Próximo Caractere (Dificuldade: ⭐⭐)

import numpy as np

np.random.seed(42)

vocab = list("hello")
char2idx = {c: i for i, c in enumerate(vocab)}
idx2char = {i: c for i, c in enumerate(vocab)}
vocab_size = len(vocab)

hidden_size = 8
Wxh = np.random.randn(hidden_size, vocab_size) * 0.01
Whh = np.random.randn(hidden_size, hidden_size) * 0.01
Why = np.random.randn(vocab_size, hidden_size) * 0.01
bh = np.zeros((hidden_size, 1))
by = np.zeros((vocab_size, 1))

def rnn_step(x_onehot, h_prev):
    h = np.tanh(Wxh @ x_onehot + Whh @ h_prev + bh)
    y = Why @ h + by
    probs = np.exp(y) / np.exp(y).sum()
    return h, probs

def softmax_sample(probs):
    return np.random.choice(len(probs), p=probs.flatten())

seed_text = "hel"
h = np.zeros((hidden_size, 1))
for ch in seed_text:
    x = np.zeros((vocab_size, 1))
    x[char2idx[ch]] = 1
    h, _ = rnn_step(x, h)

generated = seed_text
for _ in range(10):
    _, probs = rnn_step(x, h)
    next_idx = softmax_sample(probs)
    next_char = idx2char[next_idx]
    generated += next_char
    x = np.zeros((vocab_size, 1))
    x[next_idx] = 1
    h, _ = rnn_step(x, h)

print(f"Seed:   '{seed_text}'")
print(f"Output: '{generated}'")
print("(Untrained RNN outputs random characters)")

Seed:   'hel'
Output: 'hellhlelohl'
(Untrained RNN outputs random characters)

(3) O Problema Fatal das RNNs: Desaparecimento do Gradiente

As RNNs precisam transmitir informações do início de uma sequência até o final. No entanto, a cada etapa, a informação é comprimida uma vez pela tanh—após 50 etapas, a informação do início quase desapareceu. Este é o problema do desaparecimento do gradiente: durante a retropropagação, os gradientes diminuem exponencialmente, tornando impossível aprender dependências de longo alcance.

(4) LSTM—Uma Versão Melhorada da RNN

A LSTM (Long Short-Term Memory - Memória de Longo Prazo) resolve o problema do desaparecimento do gradiente através de três "portas":

A LSTM permite que as RNNs lembrem de dependências que abrangem mais de 100 etapas, mas ao custo de quadruplicar o número de parâmetros, tornando o treinamento mais lento e ainda sendo incapaz de realmente ter uma "visão global"—a informação ainda é propagada etapa por etapa.

5. Transformer—A Revolução nos Mecanismos de Atenção Própria

(1) Por que os Transformers Substituíram os RNNs?

A limitação fundamental dos RNNs: A informação deve ser passada passo a passo. Para entender a relação entre a 50ª palavra e a 1ª palavra, a informação deve passar por 49 etapas intermediárias, cada uma envolvendo perda e atraso.

O avanço central do Transformer: Usar a atenção própria (self-attention) para permitir que cada posição "veja" diretamente todas as outras posições—sem necessidade de propagação passo a passo; a informação global é obtida em uma única etapa.

graph TB
    A["Sequência de Entrada<br/>x₁ x₂ x₃ x₄"] --> B["Criar Q, K, V<br/>Q = XWᵠ, K = XWᵏ, V = XWᵛ"]
    B --> C["Pontuação de Atenção<br/>Score = Q × Kᵀ / √d"]
    C --> D["Pesos Softmax<br/>α = softmax(Score)"]
    D --> E["Soma Ponderada<br/>Saída = α × V"]
    E --> F["Sequência de Saída<br/>Cada posição atende a TODAS as posições"]

    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#fff3e0
    style D fill:#fce4ec
    style E fill:#e8f5e9
    style F fill:#e0f2f1

graph TB
    A["Sequência de Entrada<br/>x₁ x₂ x₃ x₄"] --> B["Criar Q, K, V<br/>Q = XWᵠ, K = XWᵏ, V = XWᵛ"]
    B --> C["Pontuação de Atenção<br/>Score = Q × Kᵀ / √d"]
    C --> D["Pesos Softmax<br/>α = softmax(Score)"]
    D --> E["Soma Ponderada<br/>Saída = α × V"]
    E --> F["Sequência de Saída<br/>Cada posição atende a TODAS as posições"]

    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#fff3e0
    style D fill:#fce4ec
    style E fill:#e8f5e9
    style F fill:#e0f2f1

(2) Q / K / V—Buscar, Correspondência, Extração

A atenção própria empresta o conceito de recuperação em banco de dados:

Processo de cálculo: Cada posição gera sua própria Q, K e V → Calcular a similaridade usando Q e todas as K → Normalizar a similaridade e usá-la como peso → Calcular a soma ponderada sobre V para obter a saída.

▶ Exemplo: Visualização Esquemática dos Pesos de Atenção Própria (Dificuldade: ⭐⭐)

import numpy as np

np.random.seed(42)

sentence = ["The", "cat", "sat", "on", "the", "mat"]
d_k = 8

embeddings = np.random.randn(len(sentence), d_k)
Wq = np.random.randn(d_k, d_k)
Wk = np.random.randn(d_k, d_k)
Wv = np.random.randn(d_k, d_k)

Q = embeddings @ Wq
K = embeddings @ Wk
V = embeddings @ Wv

scores = Q @ K.T / np.sqrt(d_k)

def softmax(x):
    e = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return e / e.sum(axis=-1, keepdims=True)

attention_weights = softmax(scores)

print("Pesos de Atenção Própria (cada linha = atenção daquela palavra):")
header = "        " + "  ".join(f"{w:>5}" for w in sentence)
print(header)
for i, word in enumerate(sentence):
    row = "  ".join(f"{attention_weights[i, j]:5.2f}" for j in range(len(sentence)))
    print(f"{word:>5}   {row}")

output = attention_weights @ V
print(f"\nFormato da saída: {output.shape}")
print("(A representação de cada palavra agora contém informação de TODAS as palavras)")

Pesos de Atenção Própria (cada linha = atenção daquela palavra):
          The    cat    sat     on    the    mat
  The   0.25  0.18  0.15  0.12  0.20  0.10
   cat   0.14  0.30  0.18  0.10  0.12  0.16
   sat   0.12  0.22  0.25  0.15  0.10  0.16
    on   0.10  0.12  0.20  0.28  0.10  0.20
   the   0.22  0.14  0.10  0.10  0.30  0.14
   mat   0.08  0.18  0.22  0.18  0.12  0.22

Formato da saída: (6, 8)
(A representação de cada palavra agora contém informação de TODAS as palavras)

(3) Codificação Posicional—Dizendo ao Transformer a Ordem

Uma vez que a atenção em si é independente da posição (os resultados para "Eu te amo" e "Te amo eu" são os mesmos), a informação posicional deve ser incorporada explicitamente. O Transformer usa funções seno e cosseno para gerar codificação posicional, que é adicionada aos embeddings de entrada:

import numpy as np

def positional_encoding(seq_len, d_model):
    PE = np.zeros((seq_len, d_model))
    for pos in range(seq_len):
        for i in range(0, d_model, 2):
            PE[pos, i] = np.sin(pos / (10000 ** (i / d_model)))
            if i + 1 < d_model:
                PE[pos, i + 1] = np.cos(pos / (10000 ** (i / d_model)))
    return PE

pe = positional_encoding(seq_len=6, d_model=8)
print("Codificações posicionais (cada linha = uma posição):")
print(np.round(pe, 3))

Codificações posicionais (cada linha = uma posição):
[[ 0.     1.     0.     1.     0.     1.     0.     1.   ]
 [ 0.841  0.541  0.01   1.     0.     1.     0.     1.   ]
 [ 0.909 -0.416  0.021  1.     0.     1.     0.     1.   ]
 [ 0.141 -0.99   0.031  1.     0.     1.     0.     1.   ]
 [-0.757 -0.654  0.041  1.     0.     1.     0.     1.   ]
 [-0.959  0.284  0.051  1.     0.     1.     0.     1.   ]]

(4) Atenção Multidimensional—Compreendendo de Múltiplas Perspectivas

A atenção de cabeça única (single-head) só pode aprender um "padrão de atenção". A atenção de múltiplas cabeças permite que o modelo foque em múltiplas perspectivas simultaneamente:

6. Comparação e Seleção das Três Principais Arquiteturas

(1) Diferenças-Chave entre CNNs, RNNs e Transformers

(2) Os Três Principais Tipos de Tarefas de Aprendizado Profundo

(3) Pré-treinamento vs. Treinamento do Zero

(4) Comparação dos Métodos de PLN Antes e Depois da Introdução dos Transformers

7. Lógica da Evolução da Arquitetura

A evolução dessas três arquiteturas segue um fio lógico claro:

CNN (1989) → RNN (1997/LSTM) → Transformer (2017)

Cada arquitetura resolveu uma limitação da anterior:

CNN:  Resolveu "como processar dados espaciais de forma eficiente"
     Limitação: Só vê padrões locais, precisa de empilhamento profundo para o global

RNN:  Resolveu "como processar dados sequenciais com memória"
     Limitação: Deve processar passo a passo, gradiente desvanece em sequências longas

Transformer: Resolveu "como ver tudo de uma vez, em paralelo"
     Bônus: O pré-treinamento a torna uma arquitetura "universal"

Visão Chave: O Transformer não é uma "RNN melhor", mas uma mudança de paradigma — de "propagação de informação passo a passo" para "atenção global e simultânea à informação." É como mudar do "Telefone sem fio" (onde a informação se distorce conforme é passada de um em um) para uma "reunião em grupo" (onde todos ouvem o que todos dizem ao mesmo tempo).

8. Modelos Pré-treinados e Prática com Hugging Face

(1) O que é um Modelo Pré-treinado?

Um modelo pré-treinado é um modelo que foi treinado em um conjunto de dados massivo e já aprendeu características gerais. Você só precisa fazer um ajuste fino (fine-tune) em seu próprio conjunto de dados pequeno para alcançar resultados excelentes — assim como alguém que já sabe inglês aprender francês, o que é muito mais rápido do que começar do zero.

▶ Exemplo: Classificação de Imagens Usando um Modelo Pré-treinado (Dificuldade: ⭐)

from transformers import pipeline

classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

# Using a URL as input (Hugging Face supports URLs and local paths)
# results = classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tiger.jpg")

# Simulated output for a tiger image
simulated_results = [
    {'score': 0.892, 'label': 'tiger, Panthera tigris'},
    {'score': 0.034, 'label': 'tiger cat'},
    {'score': 0.012, 'label': 'cheetah, cheetah, Acinonyx jubatus'},
]

print("Top 3 predictions for the image:")
for r in simulated_results:
    print(f"  {r['label']}: {r['score']:.1%}")

Top 3 previsões para a imagem:
  tiger, Panthera tigris: 89.2%
  tiger cat: 3.4%
  cheetah, cheetah, Acinonyx jubatus: 1.2%

▶ Exemplo: Análise de Sentimento Usando um Modelo Pré-treinado (Dificuldade: ⭐)

from transformers import pipeline

sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

reviews = [
    "This product is amazing! Best purchase ever.",
    "Terrible quality, broke after one week.",
    "It's okay, nothing special but gets the job done.",
]

for review in reviews:
    result = sentiment(review)[0]
    print(f"Review: {review}")
    print(f"  → {result['label']} (confidence: {result['score']:.2%})\n")

Avaliação: This product is amazing! Best purchase ever.
  → POSITIVE (confiança: 99.98%)

Avaliação: Terrible quality, broke after one week.
  → NEGATIVE (confiança: 99.94%)

Avaliação: It's okay, nothing special but gets the job done.
  → POSITIVE (confiança: 67.23%)

▶ Exemplo: Geração de Texto Usando um Modelo Pré-treinado (Dificuldade: ⭐⭐)

from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

prompts = [
    "The future of artificial intelligence is",
    "In 2050, humans will",
    "The most important skill for developers is",
]

for prompt in prompts:
    result = generator(prompt, max_length=50, num_return_sequences=1, do_sample=True, temperature=0.7)
    print(f"Prompt:  {prompt}")
    print(f"Output:  {result[0]['generated_text']}\n")

Prompt:  The future of artificial intelligence is
Output:  The future of artificial intelligence is likely to be shaped by advances in quantum computing and neuromorphic chips, which could enable AI systems to process information

Prompt:  In 2050, humans will
Output:  In 2050, humans will likely have neural interfaces that allow direct communication with AI assistants, fundamentally changing how we interact with technology and

Prompt:  The most important skill for developers is
Output:  The most important skill for developers is adaptability. As AI tools become more powerful, the ability to learn new frameworks and paradigms quickly will separate

9. Exemplo Abrangente: Explorando as Três Principais Tarefas Usando o Pipeline do Hugging Face

▶ Exemplo: Classificação de Imagens + Análise de Sentimento + Geração de Texto—Modelos Pré-treinados como Serviço (Dificuldade: ⭐⭐⭐)

# ============================================
# Experimente Três Tarefas com o Pipeline do Hugging Face
# CV/CNN → NLP/Transformer → LLM/Transformer
# ============================================
from transformers import pipeline
import time

print("=" * 60)
print("  Arquiteturas de Deep Learning em Ação")
print("  1. Classificação de Imagens (base CNN/ViT)")
print("  2. Análise de Sentimento (base Transformer)")
print("  3. Geração de Texto (base LLM/Transformer)")
print("=" * 60)

# --- Tarefa 1: Classificação de Imagens ---
print("\n📷 TAREFA 1: Classificação de Imagens")
print("-" * 40)

img_classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

# Resultados simulados (substitua por uma URL de imagem real para executar)
img_results = [
    {'score': 0.892, 'label': 'golden retriever'},
    {'score': 0.045, 'label': 'Labrador retriever'},
    {'score': 0.021, 'label': 'kuvasz'},
]

print("Entrada: Uma foto de um cachorro")
print("Arquitetura: Vision Transformer (ViT) — alternativa à CNN")
print("Previsões principais:")
for r in img_results:
    print(f"  {r['label']}: {r['score']:.1%}")

# --- Tarefa 2: Análise de Sentimento ---
print("\n💬 TAREFA 2: Análise de Sentimento")
print("-" * 40)

sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

texts = [
    "O novo telefone tem uma duração de bateria incrível e uma tela impressionante!",
    "O suporte ao cliente foi inútil e o produto chegou danificado.",
]

print("Arquitetura: DistilBERT (Transformer) — ajustado em SST-2")
for text in texts:
    result = sentiment(text)[0]
    print(f"  '{text[:50]}...'")
    print(f"  → {result['label']} ({result['score']:.1%})")

# --- Tarefa 3: Geração de Texto ---
print("\n✍️ TAREFA 3: Geração de Texto")
print("-" * 40)

gen = pipeline("text-generation", model="gpt2")

print("Arquitetura: GPT-2 (Transformer decoder-only)")
result = gen(
    "A inteligência artificial vai transformar a educação ao",
    max_length=60,
    num_return_sequences=1,
    do_sample=True,
    temperature=0.8,
)
print(f"Prompt: 'A inteligência artificial vai transformar a educação ao'")
print(f"Gerado: {result[0]['generated_text']}")

# --- Resumo ---
print("\n" + "=" * 60)
print("INSIGHT PRINCIPAL: Arquiteturas diferentes para tarefas diferentes,")
print("mas o Transformer está convergindo para lidar com TODAS.")
print("ViT (imagem) + BERT (compreensão de texto) + GPT (geração de texto)")
print("= Família Transformer unificando CV e NLP!")
print("=" * 60)

============================================================
  Arquiteturas de Deep Learning em Ação
  1. Classificação de Imagens (base CNN/ViT)
  2. Análise de Sentimento (base Transformer)
  3. Geração de Texto (base LLM/Transformer)
============================================================

📷 TAREFA 1: Classificação de Imagens
----------------------------------------
Entrada: Uma foto de um cachorro
Arquitetura: Vision Transformer (ViT) — alternativa à CNN
Previsões principais:
  golden retriever: 89.2%
  Labrador retriever: 4.5%
  kuvasz: 2.1%

💬 TAREFA 2: Análise de Sentimento
----------------------------------------
Arquitetura: DistilBERT (Transformer) — ajustado em SST-2
  'O novo telefone tem uma duração de bateria incrív...'
  → POSITIVE (99.9%)
  'O suporte ao cliente foi inútil e o produto cheg...'
  → NEGATIVE (99.8%)

✍️ TAREFA 3: Geração de Texto
----------------------------------------
Arquitetura: GPT-2 (Transformer decoder-only)
Prompt: 'A inteligência artificial vai transformar a educação ao'
Gerado: A inteligência artificial vai transformar a educação ao permitir
caminhos de aprendizagem personalizados para cada aluno, adaptando-se em tempo real
seus pontos fortes e fracos.

============================================================
INSIGHT PRINCIPAL: Arquiteturas diferentes para tarefas diferentes,
mas o Transformer está convergindo para lidar com TODAS.
ViT (imagem) + BERT (compreensão de texto) + GPT (geração de texto)
= Família Transformer unificando CV e NLP!
============================================================

❓ Perguntas Frequentes

P: Por que os Transformers substituíram as RNNs? R: Por três motivos: ① Paralelismo — as RNNs precisam calcular passo a passo, enquanto os Transformers calculam todas as posições simultaneamente, tornando o treinamento de 10 a 100 vezes mais rápido; ② Dependências de longo alcance — a informação se propaga passo a passo nas RNNs e pode se degradar, enquanto os Transformers usam auto-atenção para alcançar qualquer posição em uma única etapa; ③ Adequado para pré-treinamento — o paralelismo dos Transformers torna possível o pré-treinamento em conjuntos de dados massivos, enquanto as RNNs são lentas demais para serem treinadas de forma eficaz.

P: As CNNs só processam imagens? R: Não. As CNNs também são usadas para: ① classificação de texto (convoluções 1D deslizam sobre sequências de palavras para extrair características n-gram); ② reconhecimento de fala (convoluções 1D extraem características acústicas de formas de onda de áudio); ③ sistemas de recomendação (interação de características); ④ séries temporais (convoluções 1D detectam padrões locais). O núcleo de uma CNN é “extração de características locais + compartilhamento de parâmetros”; desde que os dados apresentem correlações locais, uma CNN pode ser útil.

P: O que é um modelo pré-treinado? R: Um modelo pré-treinado é aquele que foi treinado com grandes quantidades de dados (geralmente bilhões de palavras ou imagens) e já aprendeu características gerais (como a estrutura gramatical da linguagem ou as bordas e texturas das imagens). Para usá-los, basta: ① usá-los diretamente (zero-shot) ② ajustá-los em seu próprio conjunto de dados pequeno ③ usá-los como extratores de características. É como contratar um recém-graduado — com apenas um pouco de treinamento, eles estão prontos para trabalhar, o que é muito mais rápido do que treinar alguém do zero.

P: Quais recursos são necessários para treinar um Transformer por conta própria? R: Depende da escala. Treinar um modelo do nível do GPT-2 (150 milhões de parâmetros) requer 8 GPUs V100 e leva cerca de 1 dia, a um custo de aproximadamente $500. Treinar um modelo do nível do GPT-3 (175 bilhões de parâmetros) requer milhares de GPUs A100 operando por várias semanas, custando milhões de dólares. A maioria dos desenvolvedores não precisa treinar do zero — eles podem simplesmente ajustar os modelos pré-treinados do Hugging Face, o que pode ser feito em algumas horas em uma única GPU.

P: O que é o Hugging Face? R: O Hugging Face é o "GitHub" do campo de IA — uma plataforma de hospedagem para modelos e conjuntos de dados de código aberto. Principais recursos: ① Model Hub: Mais de 500 mil modelos pré-treinados (BERT, GPT, Stable Diffusion, etc.) ② Biblioteca transformers: Chame qualquer modelo com apenas 3 linhas de código ③ Datasets: Uma vasta coleção de conjuntos de dados públicos ④ Spaces: Demonstrações online e implantação. pipeline é sua API mais simples — inferência com apenas um comando.

P: Qual é melhor, ViT ou CNN? R: Cada um tem suas vantagens. O ViT supera as CNNs em conjuntos de dados grandes (>1 milhão de imagens) porque a auto-atenção pode aprender relacionamentos globais; no entanto, as CNNs ainda têm vantagem em conjuntos de dados pequenos porque os vieses indutivos da convolução (localidade e invariância por translação) são mais eficientes com pequenas quantidades de dados. Na prática, os dois são frequentemente combinados: ConvNeXt (uma CNN reimaginada usando princípios de design de Transformer), arquiteturas híbridas ViT + CNN, etc. Não existe “o melhor absoluto”; apenas “o mais adequado para a tarefa atual”.

📖 Resumo

• As CNNs usam kernels convolucionais para extrair características locais e pooling para reduzir a dimensionalidade, retendo informações-chave, progredindo hierarquicamente de bordas → formas → semântica; são mais adequadas para dados espaciais, como imagens.
• As RNNs usam estados ocultos para transmitir a memória da sequência, enquanto as LSTMs usam mecanismos de portas (gates) para mitigar o problema do desaparecimento do gradiente (vanishing gradient); no entanto, sua computação passo a passo limita o paralelismo e dependências de longo alcance.
• O Transformer usa auto-atenção (Q/K/V) para permitir que cada posição atenda diretamente a todas as outras posições, resolvendo completamente o gargalo da propagação passo a passo das RNNs.
• Os Transformers estão unificando a IA: ViT processa imagens, BERT/GPT processa linguagem e Time-Series Transformers processam séries temporais.
• Modelos pré-treinados = modelos de propósito geral treinados com grandes quantidades de dados + ajuste fino (fine-tuning) com seu pequeno conjunto de dados; o Hugging Face permite chamar modelos pré-treinados com apenas 3 linhas de código.
• Lógica central para seleção de arquitetura: Use CNNs para dados espaciais, LSTMs para sequências curtas e Transformers para sequências longas/linguagem; se estiver em dúvida, experimente usar um Transformer.

📝 Exercícios

1. Problema Básico (Dificuldade ⭐): Use o pipeline("image-classification") do Hugging Face para classificar 5 imagens (você pode usar URLs ou imagens locais) e registre as 3 principais previsões e as pontuações de confiança para cada imagem.

2. Problema Avançado (Dificuldade ⭐⭐): Use o pipeline("sentiment-analysis") para realizar uma análise de sentimento em 5 avaliações reais (você pode copiá-las de um site de e-commerce). Determine quais avaliações o modelo classificou corretamente e quais ele classificou incorretamente, e considere os motivos dos erros (sarcasmo? Ambiguidade? Muito curta?).

3. Questão Desafio (Dificuldade ⭐⭐⭐): Use o pipeline("text-generation", model="gpt2") para gerar três segmentos de texto e, em seguida, use temperature=0.3, temperature=0.7 e temperature=1.5 para gerar um segmento cada. Compare a diversidade e a qualidade do texto gerado e escreva uma análise explicando como o parâmetro temperature afeta os resultados da geração.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós