Liberar a velocidade de inferência: Um tutorial prático sobre otimização de GPU

“`html

Introdução: A busca por uma inferência mais rápida

No ambiente em rápida evolução da inteligência artificial, treinar modelos é apenas metade do trabalho. A verdadeira medida da utilidade de um modelo reside muitas vezes na sua capacidade de realizar inferências — fazer previsões ou gerar saídas — rapidamente e eficientemente. Para muitas aplicações do mundo real, que vão desde a detecção de objetos em tempo real até as respostas de grandes modelos de linguagem, a velocidade de inferência é fundamental. Se a inferência baseada na CPU tem sua utilização, a potência de processamento paralelo das unidades de processamento gráfico (GPU) as torna as campeãs indiscutíveis para a inferência IA de alto throughput e baixa latência.

Este tutorial o guiará por estratégias e técnicas práticas para otimizar o uso das GPUs durante a inferência. Vamos além dos conceitos teóricos e exploraremos passos concretos, acompanhados de exemplos de código, para ajudá-lo a aproveitar ao máximo seus recursos de hardware. No final, você terá uma compreensão sólida de como identificar os gargalos e implementar otimizações eficazes para seus carregamentos de trabalho de inferência em deep learning.

Compreensão dos gargalos de inferência em GPU

Antes de otimizar, é crucial entender o que pode estar retardando sua inferência. A inferência em GPU não é sempre limitada pelo cálculo; frequentemente, outros fatores atuam como gargalos. Os culpados comuns incluem:

• Transferência de dados (Host para Dispositivo/Dispositivo para Host): Mover dados entre a memória da CPU (host) e a memória da GPU (dispositivo) é lento. Minimizar essa etapa.
• Tamanhos de lote pequenos: As GPUs prosperam devido ao paralelismo. Tamanhos de lote muito pequenos podem não utilizar plenamente as unidades de cálculo da GPU.
• Custos de lançamento do kernel: Sempre que um kernel GPU (um pequeno programa executado na GPU) é lançado, há um leve custo adicional. Muitas pequenas operações sequenciais podem acumular um custo significativo.
• Modelos de acesso à memória: Um acesso à memória ineficiente (por exemplo, leituras não contíguas) pode resultar em falhas de cache e desempenho mais lento.
• Unidades de cálculo subutilizadas: A arquitetura do modelo ou a estratégia de inferência podem não aproveitar plenamente a potência de processamento da GPU.
• Formas dinâmicas/Controle de fluxo: Operações que impedem a compilação de grafos estáticos (por exemplo, ramos if-else baseados em dados de entrada) podem atrapalhar a otimização.
• Overhead do framework: O próprio framework de deep learning pode introduzir sobrecargas.

Estratégias práticas de otimização

1. Quantificação do modelo: Reduzir sua pegada e aumentar a velocidade

A quantificação é o processo de redução da precisão dos números usados para representar os pesos e as ativações de um modelo, geralmente de 32 bits em ponto flutuante (FP32) para formatos de precisão reduzida, como 16 bits em ponto flutuante (FP16 ou BFloat16) ou inteiros de 8 bits (INT8). Isso apresenta várias vantagens:

• Pegada de memória reduzida: Modelos menores requerem menos memória, permitindo tamanhos de lote maiores ou o deployment em dispositivos com recursos limitados.
• Cálculo mais rápido: As operações aritméticas de baixa precisão são geralmente mais rápidas e consomem menos energia. As GPUs modernas frequentemente possuem hardware especializado (por exemplo, Tensor Cores) para operações FP16 e INT8.
• Transferência de dados reduzida: Menos dados precisam ser movidos.

Exemplo: Quantificação com PyTorch (FP16)

A maioria das GPUs modernas suporta FP16 (precisão reduzida). O PyTorch torna fácil a conversão do seu modelo.

“““html

import torch
import torch.nn as nn

# Suponhamos que 'model' seja o seu modelo PyTorch treinado (por exemplo, um ResNet)
model = nn.Sequential(
 nn.Linear(784, 128),
 nn.ReLU(),
 nn.Linear(128, 10)
)
model.eval() # Colocar o modelo em modo de avaliação

# Mover o modelo para a GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Opção 1 : Precisão mista automática (AMP) para a inferência
# Isso é geralmente recomendado, pois gerencia a conversão apenas onde é útil
from torch.cuda.amp import autocast

# Exemplo de ciclo de inferência com AMP
input_data = torch.randn(64, 784).to(device)

with autocast():
 output = model(input_data)
print(f"Tipo de saída de inferência AMP : {output.dtype}")

# Opção 2 : Converter explicitamente o modelo inteiro para FP16 (menos comum para a inferência)
# model_fp16 = model.half() # Converte todos os parâmetros e buffers para FP16
# input_data_fp16 = input_data.half()
# output_fp16 = model_fp16(input_data_fp16)
# print(f"Tipo de saída de inferência FP16 explícito : {output_fp16.dtype}")

# Para a quantificação INT8, geralmente você usaria as ferramentas de quantificação nativas do PyTorch
# ou exportaria para um runtime como ONNX Runtime/TensorRT que cuida disso.

2. Otimização do tamanho do lote: Encontrando o balanço adequado

As GPUs alcançam uma alta taxa de transferência processando muitos pontos de dados em paralelo. Aumentar o tamanho do lote permite que a GPU execute mais cálculos simultaneamente, o que frequentemente leva a um melhor aproveitamento do tempo de inferência total, até certo ponto. No entanto, um tamanho de lote muito grande pode levar a erros de memória ou retornos decrescentes se a largura de banda da memória ou as unidades de cálculo da GPU forem saturadas.

Estratégia: Ajuste do tamanho do lote

Experimente com diferentes tamanhos de lote. Comece com um tamanho de lote pequeno (por exemplo, 1, 4, 8) e aumente gradualmente até observar retornos decrescentes na velocidade de inferência ou encontrar limites de memória. Utilize seu modelo para entender como o tamanho do lote afeta a utilização da GPU.

import time

# ... (configuração do modelo e do dispositivo como acima)

batch_sizes = [1, 16, 32, 64, 128, 256]
times = []

print("\nAvaliação de diferentes tamanhos de lote :")
for bs in batch_sizes:
 input_data = torch.randn(bs, 784).to(device)
 
 # Execução de aquecimento
 with autocast():
 _ = model(input_data)
 torch.cuda.synchronize() # Espera a GPU terminar

 start_time = time.time()
 num_runs = 100
 for _ in range(num_runs):
 with autocast():
 _ = model(input_data)
 torch.cuda.synchronize()
 end_time = time.time()
 
 avg_time_per_batch = (end_time - start_time) / num_runs
 times.append(avg_time_per_batch)
 print(f"Tamanho do lote : {bs}, Tempo médio por lote : {avg_time_per_batch:.4f}s")

# A rastreação ou análise da lista 'times' mostraria o tamanho do lote ideal.

3. Compilação de grafos e compiladores JIT (Just-In-Time)

Os frameworks de deep learning como PyTorch e TensorFlow geralmente executam os modelos de forma interpretativa (modo eager). Embora flexível, isso pode introduzir sobrecargas relacionadas ao Python e impedir as otimizações globais que um compilador poderia realizar. A compilação de grafos converte seu modelo em um grafo de computação estático, que pode então ser otimizado e compilado em código de máquina altamente eficiente.

Exemplo: TorchScript com PyTorch

TorchScript é uma maneira de criar modelos serializáveis e otimizáveis a partir do código PyTorch. Pode rastrear um módulo existente ou converte-lo por meio de script.

# ... (configuração do modelo e do dispositivo)

# Opção 1 : Rastreamento (para modelos com um fluxo de controle estático)
# Fornecer uma entrada fictícia para rastrear as operações
example_input = torch.randn(1, 784).to(device)
traced_model = torch.jit.trace(model, example_input)
print("\nTipo de modelo rastreado :", type(traced_model))

# Inferência com o modelo rastreado
start_time = time.time()
num_runs = 100
for _ in range(num_runs):
 with autocast():
 _ = traced_model(example_input)
torch.cuda.synchronize()
end_time = time.time()
print(f"Tempo de inferência do modelo rastreado (por execução) : {(end_time - start_time)/num_runs:.6f}s")

# Opção 2 : Script (para modelos com um fluxo de controle dinâmico, mas requer uma sintaxe específica)
# @torch.jit.script
# def my_scripted_function(x):
# if x.mean() > 0:
# return x * 2
# else:
# return x / 2
# scripted_output = my_scripted_function(torch.randn(10, 10).to(device))

Torch.compile (PyTorch 2.0+)

“““html

O PyTorch 2.0 introduziu torch.compile, um poderoso compilador JIT que utiliza tecnologias como o TorchInductor para acelerar significativamente os modelos sem a necessidade de conversão manual para TorchScript. Esta é geralmente a otimização de nível gráfico mais simples e eficaz.

# ... (configuração do modelo e do dispositivo)

# Compilar o modelo
compiled_model = torch.compile(model)

# Inferência com o modelo compilado
example_input = torch.randn(64, 784).to(device) # Usar um tamanho de lote maior para um melhor efeito

# Execução de aquecimento para a compilação
with autocast():
 _ = compiled_model(example_input)
torch.cuda.synchronize()

start_time = time.time()
num_runs = 100
for _ in range(num_runs):
 with autocast():
 _ = compiled_model(example_input)
torch.cuda.synchronize()
end_time = time.time()
print(f"\nTempo de inferência com Torch.compile (por execução) : {(end_time - start_time)/num_runs:.6f}s")

4. Runtimes de Inferência Dedicados: Além dos Frameworks

Para desempenho máximo e flexibilidade de distribuição, considere runtimes de inferência dedicados. Esses runtimes são otimizados para ambientes de produção e frequentemente incluem otimizações avançadas de gráficos, fusão de kernels e suporte para vários aceleradores de hardware.

• NVIDIA TensorRT: Um otimizador e um runtime de inferência para aprendizado profundo de alto desempenho da NVIDIA. Ele pega uma rede treinada, otimiza (por exemplo, quantização, fusão de camadas, ajuste automático de kernels) e produz um motor de execução otimizado. É projetado especificamente para GPUs NVIDIA.
• ONNX Runtime: Suporta modelos no formato Open Neural Network Exchange (ONNX). Fornece um motor de inferência unificado em vários hardwares e sistemas operacionais, com backend para CPU, GPU (CUDA, ROCm, DirectML) e aceleradores de IA especializados.

Estratégia: Exportar para o formato ONNX e inferência com ONNX Runtime

Exportar seu modelo PyTorch para o formato ONNX é um primeiro passo comum para utilizar runtimes como ONNX Runtime ou TensorRT.

import onnx
import onnxruntime as ort

# ... (configuração do modelo)

# Exportar o modelo PyTorch em ONNX
onnx_path = "model.onnx"
example_input = torch.randn(1, 784).to(device)

torch.onnx.export(
 model.cpu(), # A exportação ONNX geralmente ocorre na CPU primeiro
 example_input.cpu(),
 onnx_path,
 input_names=["input"],
 output_names=["output"],
 dynamic_axes={
 "input": {0: "batch_size"}, # Permitir um tamanho de lote dinâmico
 "output": {0: "batch_size"}
 },
 opset_version=14
)

print(f"Modelo exportado em {onnx_path}")

# Verificar o modelo ONNX
onnx_model = onnx.load(onnx_path)
onnx.checker.check_model(onnx_model)
print("Modelo ONNX verificado com sucesso.")

# Inferência com ONNX Runtime
# Criar uma sessão de inferência
sess_options = ort.SessionOptions()
# Opcional: definir o nível de otimização do gráfico para melhor desempenho
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

# Usar o provedor CUDA para a inferência GPU
providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
ort_session = ort.InferenceSession(onnx_path, sess_options=sess_options, providers=providers)

# Preparar a entrada para o ONNX Runtime
input_name = ort_session.get_inputs()[0].name
output_name = ort_session.get_outputs()[0].name

# Exemplo de inferência com um tamanho de lote de 64
input_data_np = torch.randn(64, 784).cpu().numpy().astype(import numpy as np; np.float32)

start_time = time.time()
num_runs = 100
for _ in range(num_runs):
 ort_outputs = ort_session.run([output_name], {input_name: input_data_np})
end_time = time.time()

print(f"\nTempo de inferência ONNX Runtime (por execução) : {(end_time - start_time)/num_runs:.6f}s")

5. Execução Assíncrona e Pipelining

As operações de GPU são assíncronas. A CPU inicia um kernel e passa imediatamente para outra coisa, enquanto a GPU o executa em segundo plano. Compreender isso é essencial para um pipelining eficaz.

Estratégia: Sobrepor a Transferência de Dados e o Cálculo

Em vez de esperar que um lote esteja completamente finalizado antes de processar o próximo, você pode sobrepor o carregamento de dados para o próximo lote com o cálculo do lote atual. O DataLoader do PyTorch com num_workers > 0 e pin_memory=True ajuda a transferir dados para a memória bloqueada, que é mais rápida para o acesso à GPU.

“““html

import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# Conjunto de dados fictício e DataLoader
transform = transforms.Compose([
 transforms.ToTensor(),
 transforms.Normalize((0.5,), (0.5,))
])
dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# Importante: pin_memory=True para transferências mais rápidas do host para o dispositivo
dataloader = DataLoader(dataset, batch_size=64, shuffle=False, num_workers=4, pin_memory=True)

# ... (configuração do modelo e do dispositivo, por exemplo, utilizando torch.compile ou traced_model)
compiled_model = torch.compile(model)

# Ciclo de inferência com carregamento de dados assíncrono
start_time = time.time()
for i, (images, labels) in enumerate(dataloader):
 images = images.view(images.shape[0], -1).to(device, non_blocking=True) # non_blocking=True é crucial

 with autocast():
 outputs = compiled_model(images)
 
 # Se você precisar utilizar as saídas na CPU, adicione um ponto de sincronização
 # Por exemplo, para calcular métricas após um certo número de lotes
 # if (i+1) % 100 == 0: 
 # torch.cuda.synchronize()
 # # Processar as saídas aqui

torch.cuda.synchronize() # Certifique-se de que todas as operações da GPU estejam completas antes que o cronômetro pare
end_time = time.time()

print(f"\nTempo de inferência assíncrona para {len(dataloader.dataset)} amostras: {end_time - start_time:.4f}s")

6. Gerenciamento e Alocação de Memória

Um uso eficiente da memória é fundamental. Erros de memória insuficiente interrompem a inferência e re-alocações frequentes podem introduzir sobrecargas.

Estratégia: Limpar o Cache e Usar Gerenciadores de Contexto

Limpe periodicamente o cache de memória da GPU, especialmente se você carregar/descarregar modelos ou processar tamanhos de entrada muito diferentes.

import gc

# ... algumas atividades de inferência ...

del model # Eliminar o modelo se não for mais necessário
gc.collect()
torch.cuda.empty_cache() # Limpa o cache de memória da GPU do PyTorch
print("Cache da GPU limpa.")

Estratégia: Pré-alocar os Tensores (para entradas de tamanho fixo)

Se o tamanho do seu tensor de entrada for fixo, pré-aloque os tensores de entrada e saída na GPU para evitar alocações repetidas.

# ... (configuração do modelo e do dispositivo)

# Pré-alocar os tensores de entrada e saída
fixed_batch_size = 64
fixed_input_shape = (fixed_batch_size, 784)

pre_allocated_input = torch.empty(fixed_input_shape, dtype=torch.float32, device=device)
# Execução fictícia para obter a forma da saída
with autocast():
 dummy_output = model(pre_allocated_input)
pre_allocated_output = torch.empty(dummy_output.shape, dtype=dummy_output.dtype, device=device)

# Agora, no seu ciclo de inferência, copie os dados em pre_allocated_input
# e use pre_allocated_output para armazenar os resultados
# Exemplo: (supondo que você tenha o array numpy 'new_batch_data')
# pre_allocated_input.copy_(torch.from_numpy(new_batch_data))
# with autocast():
# model(pre_allocated_input, out=pre_allocated_output) # Alguns modelos/operações suportam o argumento 'out'

Profiling e Depuração de Performance

A otimização é um processo iterativo. Você precisa de ferramentas para identificar onde seu tempo está sendo gasto.

• PyTorch Profiler: Use torch.profiler para obter relatórios detalhados sobre operações de CPU e GPU, tempos de início de kernel, utilização de memória e transferência de dados.
• NVIDIA Nsight Systems / Nsight Compute: Poderosas ferramentas autônomas para profiling aprofundado da GPU, mostrando as linhas do tempo de execução dos kernels, a largura de banda da memória e a utilização dos cálculos.
• Módulo time do Python: Simples, mas eficaz para medir o tempo de blocos de código de alto nível.

Exemplo: Profiling PyTorch

from torch.profiler import profile, schedule, tensorboard_trace_handler, ProfilerActivity

# ... (configuração do modelo e do dispositivo)

with profile(
 schedule=schedule(wait=1, warmup=1, active=3, repeat=1),
 on_trace_ready=tensorboard_trace_handler("./log/profiler_inference"),
 activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
 record_shapes=True,
 with_stack=True
) as prof:
 for step in range(1 + 1 + 3 + 1): # esperar, aquecimento, ativo, atraso de repetição
 input_data = torch.randn(64, 784).to(device)
 with autocast():
 _ = model(input_data)
 prof.step()

print("\nResultados do profiler registrados em ./log/profiler_inference. Veja com 'tensorboard --logdir=./log'")

Conclusão

“`

Otimizar a inferência GPU é um desafio multifacetado, mas aplicando sistematicamente as estratégias descritas neste tutorial, você pode obter ganhos de velocidade significativos. Comece com a quantização, experimente com os tamanhos de lote, utilize compiladores de grafos como torch.compile, e considere runtimes dedicados como ONNX Runtime ou TensorRT para deploys em produção. Nunca se esqueça de perfilar seu código para identificar os verdadeiros gargalos, pois a otimização prematura pode ser contraproducente. Com essas ferramentas e técnicas, você está bem equipado para liberar todo o potencial das suas GPUs para uma inferência AI ultra-rápida.

🕒 Published: April 5, 2026