GPU (Graphics Processing Unit)

Uma unidade de processamento gráfico (GPU) é um processador com milhares de núcleos simples que executam a mesma operação em muitos dados ao mesmo tempo. As GPUs foram criadas para renderizar gráficos 3D, o que envolve calcular milhões de pixels e vértices em paralelo, e se tornaram o principal hardware de aprendizado profundo porque o treino e a inferência de redes neurais são dominados por multiplicações de matrizes que se paralelizam da mesma maneira. A plataforma CUDA da NVIDIA, lançada em 2007, tornou suas GPUs programáveis para computação de uso geral; em 2012, a rede AlexNet, treinada durante cinco a seis dias em duas GPUs NVIDIA GTX 580, venceu o desafio ImageNet com um erro top-5 de 15.3%, contra 26.2% do segundo colocado. Hoje, PyTorch, TensorFlow e JAX são executados em GPUs NVIDIA por meio de CUDA, em GPUs AMD por meio do ROCm e no Apple Silicon por meio do Metal; clusters com milhares de GPUs treinam os maiores modelos de base.

Como as GPUs aceleram o aprendizado profundo#

Uma CPU dedica a maior parte da área do chip a caches e lógica de controle para que alguns núcleos executem código com desvios rapidamente. Uma GPU usa essa área para operações aritméticas: uma GPU NVIDIA é dividida em multiprocessadores de streaming, cada um executando grupos de 32 threads, chamados warps, que executam a mesma instrução em dados diferentes. Enquanto alguns warps aguardam a memória, outros calculam, mantendo o chip ocupado desde que haja trabalho paralelo suficiente. Desde a geração Volta, em 2017, as GPUs NVIDIA também incluem Tensor Cores, unidades que multiplicam pequenas matrizes em uma única etapa com precisão reduzida, incluindo agora FP8 e, desde Blackwell, FP4. Uma NVIDIA A100 atinge um pico de 19.5 TFLOPS em operações padrão FP32 e 312 TFLOPS em BF16 nos Tensor Cores, por isso a maioria dos treinos em GPU usa precisão mista. Este código mede o tempo da mesma multiplicação de matrizes na CPU e na GPU:

import time

import torch

gpu = torch.accelerator.current_accelerator()  # cuda, mps, or xpu device on this machine
a = torch.randn(4096, 4096)
b = torch.randn(4096, 4096)

for device in (torch.device("cpu"), gpu):
    x, y = a.to(device), b.to(device)
    x @ y  # warm-up run
    torch.accelerator.synchronize()
    start = time.perf_counter()
    for _ in range(10):
        x @ y
    torch.accelerator.synchronize()  # GPU calls return immediately, so wait for them to finish
    seconds = (time.perf_counter() - start) / 10
    print(f"{device.type}: {seconds * 1000:.1f} ms per multiply, {2 * 4096**3 / seconds / 1e12:.1f} TFLOPS")

Em um laptop com Apple M5 Pro, o código exibe cpu: 80.0 ms per multiply, 1.7 TFLOPS e mps: 18.3 ms per multiply, 7.5 TFLOPS, então a GPU integrada do laptop é cerca de 4.4 vezes mais rápida em FP32. As GPUs de centros de dados ampliam ainda mais a diferença, tanto pelo maior número de núcleos quanto pela memória de alta largura de banda (HBM), que oferece vários terabytes por segundo — o suficiente para fornecer pesos e ativações aos núcleos. A memória da GPU, frequentemente chamada VRAM, também determina o tamanho do modelo e o tamanho do lote que cabem em um dispositivo; técnicas como checkpointing de gradientes e treino distribuído ajudam a contornar esse limite.

Treinar e implantar modelos em GPUs#

Um trabalho de treino só mantém a GPU ocupada se o restante do pipeline acompanhar o ritmo: os processos da CPU precisam decodificar e aumentar as imagens com rapidez suficiente, os lotes precisam ser grandes o bastante para ocupar os núcleos e as operações devem usar precisão reduzida nos Tensor Cores. Uma baixa utilização da GPU geralmente aponta para uma destas etapas:

O Ultralytics YOLO treina na primeira GPU CUDA por padrão quando uma está disponível, aceita device=[0, 1] para treinamento com várias GPUs e, com batch=-1, executa o AutoBatch, que mede a memória livre da GPU e escolhe um tamanho de lote que usa cerca de 60% dela. As equipes sem hardware local podem escolher uma GPU na nuvem na Ultralytics Platform para cada execução de treinamento. Para inferência, um modelo YOLO26n exportado para TensorRT processa uma imagem de 640 pixels em 1,7 ms em uma GPU NVIDIA T4, em comparação com 38,9 ms usando ONNX em uma CPU. Este código treina YOLO26 na primeira GPU com o AutoBatch:

from ultralytics import YOLO

# Carrega o menor modelo de deteção YOLO26
model = YOLO("yolo26n.pt")

# Treina na GPU 0 e deixa o AutoBatch ajustar o tamanho do lote à memória da GPU
results = model.train(data="coco8.yaml", epochs=3, imgsz=640, device=0, batch=-1)

GPU versus CPU, TPU e NPU#

• CPU: Alguns núcleos potentes para código de uso geral com desvios. As CPUs executam o carregamento e o pré-processamento de dados na maioria dos pipelines de treino e processam inferências quando não há acelerador disponível.
• GPU: Milhares de núcleos programáveis e Tensor Cores. As GPUs executam quase qualquer modelo e framework, são produzidas por vários fabricantes e estão disponíveis em todas as principais nuvens.
• TPU: Chip do Google específico para aplicações, baseado em grandes unidades de multiplicação de matrizes. As TPUs trocam a flexibilidade de uma GPU por eficiência em cargas de trabalho densas de matrizes de grande porte e estão disponíveis no Google Cloud.
• NPU: Acelerador de redes neurais de baixo consumo em celulares, laptops e dispositivos de borda, usado para inferência em vez de treino.

Aplicações no mundo real#

• Treino de modelos grandes: Modelos de linguagem e visão com bilhões de parâmetros são treinados em clusters de milhares de GPUs de centros de dados conectadas por links de alta velocidade, como NVLink e InfiniBand.
• Análise de vídeo em tempo real: Uma única GPU pode executar deteção e rastreamento de objetos em vários fluxos de câmeras ao mesmo tempo para monitoramento de tráfego, análise de varejo ou inspeção fabril.
• Robótica e veículos autônomos: Módulos de GPU integrados, como o NVIDIA Jetson, executam modelos de percepção a bordo, onde enviar os dados das câmeras a um servidor causaria atraso excessivo.
• Imagens médicas: As GPUs processam grandes volumes 3D de TC e RM para segmentar órgãos e tumores em segundos, em vez de minutos.