Técnicas Avançadas para Reduzir Custos de GPU Cloud

Introdução

GPU cloud é caro — mas a maioria das equipes desperdiça 30–60% de seus custos por falta de otimização. Este guia cobre técnicas avançadas que podem reduzir sua conta de GPU significativamente.

Nível 1: Otimizações de Precisão Numérica

BF16 em vez de FP32

```python

Ruim (FP32 padrão)

model = MyModel()

Bom (BF16)

model = MyModel().to(torch.bfloat16)

Ou via autocast (mistura automática)

with torch.autocast(device_type='cuda', dtype=torch.bfloat16):

output = model(input)

```

**Ganho:** 1,5–2x mais rápido, 50% menos VRAM. Sem impacto perceptível na qualidade para a maioria dos modelos.

FP8 com Transformer Engine (apenas H100)

```python

import transformer_engine.pytorch as te

model = te.Linear(in_features, out_features, bias=True)

```

**Ganho:** Até 2x mais rápido que BF16 em H100 para transformer layers.

Nível 2: Flash Attention 2

Flash Attention 2 reescreve o cálculo de atenção para ser IO-bound em vez de compute-bound, reduzindo uso de memória e aumentando velocidade.

```bash

pip install flash-attn --no-build-isolation

```

```python

Via HuggingFace (automático em modelos compatíveis)

model = AutoModelForCausalLM.from_pretrained(

"meta-llama/Meta-Llama-3-8B",

attn_implementation="flash_attention_2",

torch_dtype=torch.bfloat16,

)

```

**Ganho:** 2–4x menos memória de atenção, 30–50% mais rápido em sequências longas.

Nível 3: Gradient Checkpointing

```python

HuggingFace

model.gradient_checkpointing_enable()

PyTorch nativo

from torch.utils.checkpoint import checkpoint

output = checkpoint(expensive_layer, input_tensor)

```

**Trade-off:** -60% VRAM, +20% tempo de computação. Vale sempre quando VRAM é o gargalo.

Nível 4: torch.compile()

Introduzido no PyTorch 2.0, `torch.compile()` usa compilação JIT para otimizar kernels CUDA automaticamente:

```python

model = torch.compile(model, mode="reduce-overhead")

ou para máxima performance:

model = torch.compile(model, mode="max-autotune")

```

**Ganho típico:** 10–30% de speedup sem mudança de código.

**Atenção:** Primeira iteração é lenta (compilação). Use `fullgraph=True` para debugging.

Nível 5: DataLoaders Eficientes

```python

dataloader = DataLoader(

dataset,

batch_size=32,

num_workers=4, # paralelismo de carregamento

pin_memory=True, # transferência CPU→GPU mais rápida

persistent_workers=True, # mantém workers entre epochs

prefetch_factor=2, # pré-carrega 2 batches por worker

)

```

**Ganho:** Elimina o gargalo de I/O que deixa a GPU ociosa entre batches.

Nível 6: Profiling com torch.profiler

```python

from torch.profiler import profile, record_function, ProfilerActivity

with profile(

activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],

record_shapes=True,

with_stack=True,

) as prof:

with record_function("model_forward"):

output = model(input)

print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=15))

```

Identifique as operações que consomem mais tempo e foque otimizações nelas.

Nível 7: Truques de Infraestrutura

Spot + Checkpointing

Como visto em nosso guia de spot instances, combinar preemptíveis com checkpointing a cada 30 minutos pode cortar custos em **40–60%**.

Escolha de Região

Os mesmos provedores podem ter preços diferentes por região:

Reservas Mensais

Combinação de Instâncias

Para pipelines de ML:

Impacto Combinado

Aplicando todas as técnicas em um treinamento típico de LLM:

| Otimização | Redução de tempo | Redução de custo |

|---|---|---|

| BF16 | -40% | -40% |

| Flash Attention 2 | -25% adicional | -25% |

| torch.compile | -15% adicional | -15% |

| Spot instance | 0% no tempo | -50% no preço |

| **Total combinado** | ~-60% tempo | ~-78% custo |

Conclusão

A combinação de otimizações de código (BF16, Flash Attention, torch.compile) com estratégias de infraestrutura (spot + checkpointing, reservas) pode reduzir seus custos de GPU em 60–78% sem sacrificar resultados.

Compare provedores para sua carga otimizada → →