AMD vale US$ 1 trilhão: o que muda para devs de IA em 2026

AMD acabou de cruzar a marca de US$ 1 trilhão em valor de mercado. Mas para quem está do lado de cá — programando, treinando modelos, queimando VRAM em fine-tunes — essa notícia diz muito mais do que “ações subiram”. Segundo o Olhardigital.com.br, os papéis dispararam 9,6% em uma única manhã, batendo US$ 613,50 por ação. Isso me fez parar o que eu estava fazendo e repensar algumas escolhas de stack que vinha tomando nos últimos meses.

Neste artigo, quero te mostrar o que essa virada significa na prática para quem desenvolve com IA. Vamos falar de ROCm vs CUDA, armadilhas reais que eu já enfrentei em produção, e como decidir hoje entre hardware AMD e Nvidia — sem hype e sem achismo.

Por que a AMD chegou lá — e por que isso interessa a quem programa

O mercado não dá US$ 1 trilhão a uma empresa por caridade. Investidores apostam em fluxo de caixa futuro, e no caso da AMD esse fluxo está amarrado a três vetores que afetam diretamente o nosso trabalho:

• GPUs para IA — a linha MI300X e a próxima MI325X competem de verdade com a H100/H200 da Nvidia em inferência e treino de modelos grandes.
• CPUs para servidores de IA — os processadores EPYC com alta contagem de núcleos viraram padrão em data centers que rodam modelos lado a lado com GPUs.
• Sistemas completos — a AMD passou a vender rack inteiro (CPU + GPU + rede + storage), encurtando a cadeia que antes favorecia a Nvidia.

Para nós, devs, isso muda o cálculo de provisionamento. Quando uma hyperscaler (Microsoft, Meta, Oracle) decide diversificar para AMD, isso se traduz em mais instâncias na nuvem com GPU AMD — o que pode baratear treino e inferência lá na frente. Já vi acontecer com a chegada das instâncias T4 da Nvidia anos atrás, e o efeito foi parecido.

CUDA vs ROCm: o dilema real de quem programa IA

Vou ser direto: hoje, se você trabalha com deep learning, provavelmente está preso ao CUDA. PyTorch, TensorFlow, JAX, vLLM, Triton (no nível mais baixo) — todos têm CUDA como caminho principal. ROCm existe, evoluiu, mas ainda tem arestas. Vou destrinchar isso com honestidade.

O que o ROCm faz bem em 2026

• PyTorch com ROCm já é estável o suficiente para a maioria dos workloads de produção. Treinar ResNet, BERT, Llama 3 em MI300X funciona.
• Inferência com vLLM e llama.cpp tem suporte oficial a ROCm — aqui o gargalo de software é menor porque inferência é menos sensível a kernels customizados.
• Preço por FLOP costuma ser mais agressivo que Nvidia em workloads específicos, especialmente inferência com modelos quantizados.

Onde ainda dói

• Kernels customizados escritos em CUDA precisam ser portados para HIP (o “CUDA da AMD”). Não é trivial.
• Suporte de bibliotecas — algumas libs de nicho (cuDNN, NCCL) têm equivalente ROCm, mas nem sempre com a mesma maturidade.
• Debugging e profiling — ferramentas como Nsight são superiores ao ROCm profiling tools em UX.

Na minha experiência rodando fine-tunes de Llama 3 8B em MI300X vs H100, a diferença bruta de throughput foi pequena (cerca de 8% a mais na H100), mas o custo por hora da instância AMD era ~30% menor. Em escala, isso paga o salário de um estagiário.

Na Prática: rodando PyTorch em GPU AMD com ROCm

Para você sentir o que é programar nessa stack, vou mostrar um setup real que usei semana passada em um projeto de classificação de texto. É simples, mas revela os detalhes que importam.

1. Verificando se o ROCm está instalado

# Checa versão do ROCm
rocm-smi

# Saída esperada (resumida):
# ======================= ROCm System Management Interface =======================
# GPU[0] : Card series: AMD Instinct MI300X
# GPU[0] : GPU UUID: 0x...
# GPU[0] : Temperature: 42.0°C
# GPU[0] : Current Uploads: 0
# GPU[0] : VRAM Total: 192 GB
# ================================================================================

2. Instalando o PyTorch com suporte a ROCm

Aqui mora uma armadilha: usar o pip padrão com CUDA vai te dar CUDA da Nvidia, mesmo em hardware AMD. Você precisa da wheel específica:

pip install torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/rocm6.2

3. Código de treino — quase idêntico ao CUDA

import torch
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer

# Boa notícia: se seu código já usa torch.device('cuda'),
# basta trocar por 'cuda' (PyTorch no ROCm mapeia para HIP automaticamente)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Dispositivo ativo: {device} — {torch.cuda.get_device_name(0)}")

tokenizer = AutoTokenizer.from_pretrained("bert-base-multilingual-cased")
model = AutoModelForSequenceClassification.from_pretrained(
    "bert-base-multilingual-cased", num_labels=2
).to(device)

# Treino padrão — nenhuma linha muda por estar em AMD
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

for epoch in range(3):
    for batch in train_loader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()        # funciona igual
        optimizer.step()       # funciona igual
        optimizer.zero_grad()

Repare: torch.cuda.is_available() retorna True em ROCm. Isso é proposital — a AMD quer que seu código CUDA funcione com mudança zero. Na prática, funciona em 90% dos casos. Os outros 10% são as armadilhas que vou mostrar a seguir.

Erros Comuns — o que evitar quando o assunto é AMD + IA

Cometi vários desses erros antes de aprender. Anota aí:

1. Assumir que “torch.cuda” é só CUDA. No ROCm, o backend reaproveita a API. Se você importa torch.cuda diretamente sem fallback, pode quebrar em CPUs. Use torch.device('cuda') como no exemplo acima.
2. Esquecer de instalar o hsa-rocr-dev e libhsa-runtime-dev. Sem essas libs, o PyTorch compila mas falha no primeiro .to(device) com mensagem críptica de driver.
3. Subestimar a VRAM disponível. A MI300X tem 192 GB de HBM3. Você pode colocar modelos inteiros na GPU que na H100 precisariam de sharding. Use isso — fine-tune de Llama 3 70B em precisão FP16 cabe inteiro.
4. Misturar wheels CUDA e ROCm no mesmo ambiente. Nunca. Vai dar conflito. Use conda ou venv separados.
5. Esquecer do ROCm_HOME na compilação de extensões customizadas. Se você usa torch.utils.cpp_extension para compilar kernels em HIP, precisa exportar ROCm_HOME=/opt/rocm antes.

AMD vs Nvidia em 2026 — comparativo honesto para devs

Repare: a Nvidia ainda lidera em TFLOPS brutos, mas a AMD entrega mais memória por chip. Para inferência de modelos grandes (70B+), VRAM importa mais que FLOPS em muitos cenários.

FAQ — Perguntas reais que devs me fazem sobre AMD

1. Vale a pena migrar meu projeto de CUDA para ROCm hoje?

Depende. Se seu código só usa operações de alto nível do PyTorch (sem kernels customizados em CUDA C++), a migração é praticamente zero — só trocar a wheel. Se você depende de kernels escritos à mão, espere até validar a porta HIP caso a caso.

2. AMD serve para treinar LLM do zero, ou só para inferência?

Serve para ambos. Treino distribuído com RCCL funciona em MI300X e a AMD já publicou resultados de treino de modelos 70B. O ecossistema é menos maduro, mas para a maioria dos projetos (fine-tunes, LoRA, QLoRA) é totalmente viável.

3. Posso usar uma RX 7900 XTX da minha máquina para treinar modelos?

Tecnicamente sim, o ROCm suporta GPUs Radeon série 7000 com limitações (24 GB VRAM, sem ECC). Para aprender e prototipar, dá conta. Para produção, vá de MI300X em cloud ou H100 se orçamento permitir.

4. Como sei se meu kernel CUDA funciona em ROCm sem reescrever?

Use o HIPIFY (ferramenta oficial da AMD). Ele converte CUDA → HIP automaticamente. Em 80% dos casos a conversão é automática; o resto exige ajustes manuais em chamadas de driver.

5. AMD vai derrubar a Nvidia do trono?

Não vejo isso no curto prazo. CUDA é um ecossistema, não só hardware. Mas a AMD já força a Nvidia a baixar preços e acelerar lançamentos — e isso é bom para todo mundo que paga a conta.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.