GPU e Computação para IA
Por que a GPU entrou no centro da IA?
Nos anos 2000, GPUs existiam para uma única função: renderizar pixels em jogos. Em 2012, o modelo de aprendizado profundo AlexNet rodou em duas GPUs NVIDIA GTX 580 e venceu o ImageNet Challenge — revelando que GPUs eram extraordinariamente eficientes para treinar redes neurais.
O motivo é arquitetural: IA e gráficos compartilham a mesma operação central — multiplicação de matrizes em paralelo massivo.
CPU vs GPU — Arquitetura Comparada
CPU — Poucos Cores Rápidos
A CPU é otimizada para latência baixa em tarefas sequenciais:
CPU (Intel Core i9-14900K):
┌────────────────────────────────────────────┐
│ Core 0 │ Core 1 │ Core 2 │ Core 3 │
│ ┌──────┐ │ ┌──────┐ │ ┌──────┐ │ ┌──────┐ │
│ │ ALU │ │ │ ALU │ │ │ ALU │ │ │ ALU │ │
│ │ FPU │ │ │ FPU │ │ │ FPU │ │ │ FPU │ │
│ │Cache │ │ │Cache │ │ │Cache │ │ │Cache │ │
│ └──────┘ │ └──────┘ │ └──────┘ │ └──────┘ │
│ ... mais 20 cores ... │
└────────────────────────────────────────────┘
24 cores · 32 threads · Clock até 6 GHz
Especialidade: 1 tarefa complexa muito rápido
GPU — Milhares de Cores Simples
A GPU é otimizada para throughput alto em tarefas paralelas:
GPU (NVIDIA RTX 5090):
┌────────────────────────────────────────────────────┐
│ SM 0 │ SM 1 │ SM 2 │ SM 3 │ ... │ SM N │
│ ┌────┐ │ ┌────┐ │ ┌────┐ │ ┌────┐ │
│ │128 │ │ │128 │ │ │128 │ │ │128 │ ... │
│ │CUDA│ │ │CUDA│ │ │CUDA│ │ │CUDA│ │
│ │cores│ │ │cores│ │ │cores│ │ │cores│ │
│ └────┘ │ └────┘ │ └────┘ │ └────┘ │
└────────────────────────────────────────────────────┘
21.760 CUDA cores · Clock ~2,4 GHz
Especialidade: 21.760 tarefas simples ao mesmo tempo
Paralelismo: ILP vs DLP
| Tipo | Onde | Como funciona | Ideal para |
|---|---|---|---|
| ILP — Instruction Level Parallelism | CPU | Executa múltiplas instruções de um mesmo programa ao mesmo tempo | Código sequencial com branches |
| DLP — Data Level Parallelism | GPU | Aplica a mesma instrução em milhares de dados simultaneamente | Matrizes, pixels, vetores |
Treinar uma rede neural exige bilhões de multiplicações matriciais. Cada elemento da matriz é independente — perfeito para DLP. Uma CPU faz isso sequencialmente; uma GPU faz tudo de uma vez.
Tipos de Núcleos na GPU NVIDIA
CUDA Cores — Computação Geral
Os CUDA cores são os núcleos de propósito geral da GPU — executam operações de ponto flutuante (FP32, FP16, BF16).
- NVIDIA RTX 5090: 21.760 CUDA cores
- Usados em: renderização, simulações, ML genérico
Tensor Cores — Aceleração de IA
Os Tensor Cores são unidades especializadas em multiplicação matricial de precisão mista (matrix-multiply-accumulate):
Operação de um Tensor Core (por ciclo):
Matriz A (4×4) × Matriz B (4×4) + Matriz C (4×4) = Matriz D (4×4)
Em FP16: uma instrução = 64 operações FP16 + 32 acumulações FP32
Em INT8: uma instrução = 128 operações INT8 (inferência IA)
| Geração | Tensor Cores | Peak AI TOPS (INT8) | GPU |
|---|---|---|---|
| Volta (2017) | 640 | 125 TOPS | V100 |
| Ampere (2020) | 328 | 250 TOPS | RTX 3090 |
| Ada Lovelace (2022) | 512 | 1.321 TOPS | RTX 4090 |
| Blackwell (2025) | 680 | 3.352 TOPS | RTX 5090 |
RT Cores — Ray Tracing
Os RT Cores acceleram a interseção de raios com geometria 3D — específicos para renderização fotorealista em jogos. Não relevantes para IA.
VRAM vs RAM — Comparativo
| Aspecto | RAM (DDR5 Dual Ch.) | VRAM (GDDR7) |
|---|---|---|
| Largura de banda | ~96 GB/s | ~1.792 GB/s |
| Capacidade típica | 16–128 GB | 8–32 GB (consumer) |
| Latência | ~60–80 ns | ~80–120 ns |
| Acessível por | CPU | GPU |
| Protocolo | DDR5 via DIMM | GDDR7 via interposer |
| Função | Sistema operacional, aplicações | Modelos IA, texturas, framebuffer |
Para rodar um modelo de linguagem grande (LLM), todo o modelo precisa caber na VRAM. Não há como usar a RAM do sistema como substituição sem penalidade severa de performance.
| Modelo | Parâmetros | VRAM necessária (FP16) |
|---|---|---|
| Llama 3.1 8B | 8 bilhões | ~16 GB |
| Llama 3.1 70B | 70 bilhões | ~140 GB |
| GPT-4 (estimado) | ~1,8 tri | ~3.600 GB |
GPU para IA — Fluxo de Inferência
Cenário: Usuário faz uma pergunta para um LLM local rodando na GPU.
[Usuário digita prompt]
│
▼
[CPU processa texto → tokenização]
│
▼
[Tokens transferidos: RAM → VRAM via PCIe x16 (~64 GB/s)]
│
▼
[GPU carrega pesos do modelo (VRAM)]
│
▼
[Tensor Cores executam multiplicações matriciais]
(bilhões de operações em milissegundos)
│
▼
[Output token → VRAM → RAM → CPU → decodificação]
│
▼
[Texto exibido ao usuário]
A largura de banda do PCIe x16 (~64 GB/s) é muito menor que a VRAM interna (~1.792 GB/s). Por isso, quanto mais o modelo cabe inteiramente na VRAM sem intervenção da CPU, melhor o desempenho.
Exemplos de Hardware para IA (2025)
| GPU / Plataforma | Tensor TOPS | VRAM | Perfil |
|---|---|---|---|
| NVIDIA RTX 5090 | 3.352 | 32 GB GDDR7 | Entusiasta / IA local high-end |
| NVIDIA RTX 4060 | 242 | 8 GB GDDR6 | IA local modelos pequenos |
| NVIDIA RTX Spark | ~1.000 | 128 GB LPDDR5X (unificada) | Mini-PC para IA profissional |
| AMD Ryzen AI Max+ 395 | ~1.000 | 128 GB HBM3 (unificada) | Workstation portátil para IA |
| Apple M4 Max | ~38 TFLOPS | 128 GB LPDDR5X (unificada) | Edição, inferência local |
| NVIDIA H200 (datacenter) | 3.958 | 141 GB HBM3e | Treinamento em larga escala |
Hierarquia de Velocidade — Atualizada com IA
Tensor Cores (INT8, RTX 5090): 3.352 TOPS ████████████████████████████████████████
VRAM GDDR7 (RTX 5090): 1.792 GB/s ████████████████████████
HBM3 (Ryzen AI Max+): 600 GB/s ████████
PCIe 5.0 × 16 (CPU↔GPU): 64 GB/s █
DDR5 Dual Channel (RAM): 96 GB/s █
PCIe 4.0 × 4 NVMe: 16 GB/s ░
USB 3.2 Gen 2: 1,2 GB/s ░
O abismo entre VRAM e PCIe explica por que manter o modelo inteiro na GPU é fundamental para performance de IA.
Próximo: SoC e Arquiteturas Integradas
A GPU discreta é conectada via PCIe. Mas e quando GPU, CPU e memória estão todos no mesmo chip? Esse é o paradigma das arquiteturas SoC.