Por que o Design do Modelo é a Próxima Fronteira de Performance
A maioria das discussões sobre engenharia de IA foca na infraestrutura de serviço: mais GPUs, melhores agendadores, caching inteligente. Mas a arquitetura do modelo em si dita silenciosamente o quão eficientemente o hardware pode rodar. Um modelo que ignora as restrições de hardware não roda apenas mais devagar—custa mais, escala pior e frustra usuários com respostas lentas.
A pesquisa recente da NVIDIA, detalhada no post de co-design de modelo de IA, fornece um guia prático para desenvolvedores de modelos. A ideia central: ao alinhar as dimensões e a estrutura do modelo com a forma como as GPUs executam operações, você pode empurrar toda a fronteira de Pareto de throughput vs. latência para fora, sem sacrificar a precisão.
Este guia traduz esses achados em 7 diretrizes acionáveis que você pode aplicar hoje.
O Modelo Roofline: Conheça seu Gargalo
Primeiro, entenda o modelo roofline: a performance é limitada ou por compute (FLOPS) ou por banda de memória. Workloads com baixa intensidade aritmética (operações por byte) são limitados por memória; alta intensidade significa que são limitados por compute. Para throughput, você quer estar no regime de compute. Para decodificação sensível à latência, você geralmente está limitado por memória.
Diretriz 1: Prefira Matrizes de Peso Quase Quadradas
Dimensões pequenas (tamanho oculto H ou tamanho intermediário H') deixam as GPUs subutilizadas. Por exemplo, com H'=512 e H=8192, mesmo com altas contagens de tokens, o GEMM permanece limitado por memória devido à pequena dimensão de redução.
# Exemplo conceitual: dimensões GEMM em uma camada transformer
# FFN-2: (Tokens, H) x (H, H') -> (Tokens, H')
# Se H' é pequeno (ex: 512), o GEMM é limitado por memória.
# Prefira H' próximo de H para melhor intensidade aritmética.
def gemm_arith_intensity(M, N, K):
"""Calcula a intensidade aritmética de um GEMM."""
flops = 2 * M * N * K
bytes_moved = M * K * 4 + N * K * 4 # assumindo FP32
return flops / bytes_moved
# Exemplo: M=2048, N=8192, K=512 -> baixa intensidade
print(gemm_arith_intensity(2048, 8192, 512)) # ~0.5 FLOPs/byte
# Exemplo: M=2048, N=8192, K=8192 -> alta intensidade
print(gemm_arith_intensity(2048, 8192, 8192)) # ~2.0 FLOPs/byte
Diretriz 2: Alinhe Dimensões aos Tamanhos de Tile
GPUs executam GEMMs dividindo a matriz de saída em tiles. Se as dimensões não forem múltiplas dos tamanhos de tile (128, 256 com clusterMMA, 512 com CGA), você desperdiça ciclos com tiles parcialmente preenchidos. Sempre faça as dimensões múltiplas de 128, preferencialmente 256 ou 512.
Mais Largo vs. Mais Profundo, e Outras Alavancas de Paralelismo
Diretriz 3: Prefira Modelos Mais Largos
Para o mesmo orçamento de parâmetros, modelos mais largos (H maior, menos camadas) têm maior intensidade aritmética e menor latência. Eles reutilizam pesos mais e têm um caminho sequencial mais curto. No entanto, a profundidade importa para a precisão, então não sacrifique qualidade por largura.
Diretriz 4: Projete para Quantização
Quantização para NVFP4 (4 bits) pode aumentar drasticamente o throughput e reduzir o tráfego de memória. Projete camadas que tolerem execução de baixa precisão. O Model Optimizer e LLM Compressor da NVIDIA facilitam isso.
Diretriz 5: Escale o Paralelismo de Especialistas
Para modelos Mixture-of-Experts, o paralelismo de especialistas distribui os especialistas FFN entre as GPUs, enquanto a atenção usa paralelismo de dados. Isso evita o overhead de AllReduce do paralelismo de tensor e aumenta o throughput.
Diretriz 6: Use Padrões de Camadas Regulares para Pipeline Paralelo
O Chunked Pipeline Parallelism (CPP) divide as camadas e chunks de entrada entre as GPUs. Para funcionar, os estágios do pipeline devem ser balanceados. Use padrões de camadas regulares e repetíveis.
Diretriz 7: Desacople Atenção e FFN para Latência
Para serviço de baixa latência, paralelize atenção e FFNs independentemente. O Helix Parallelism fragmenta o cache KV na dimensão da sequência, permitindo melhor escalabilidade do que o paralelismo de tensor sozinho.
Juntando Tudo
Essas diretrizes formam um checklist para o design do seu próximo modelo:
- Mantenha as dimensões quase quadradas e alinhadas a 128 (idealmente 256)
- Prefira largura sobre profundidade
- Projete para execução de baixa precisão (NVFP4)
- Use padrões de camadas regulares e repetíveis
- Escale o paralelismo de especialistas para MoE
Pequenas escolhas na arquitetura do modelo têm efeitos desproporcionais no desempenho real. Ao projetar com o hardware em mente, você pode entregar inferência mais rápida, maior throughput e melhores experiências de usuário—sem sacrificar a precisão.
Para um mergulho mais profundo na infraestrutura de serviço, confira nossa análise sobre modal vs. página separada em UX, ou aprenda como a Netflix roteia milhões de requisições de inferência de ML para entender o stack completo de serviço.
Limitações e Próximos Passos
Essas diretrizes são focadas principalmente em GPUs NVIDIA e podem não se aplicar diretamente a outros aceleradores. Além disso, o equilíbrio ideal entre largura e profundidade depende dos seus requisitos específicos de precisão. Como próximo passo, experimente com o TensorRT-LLM e Model Optimizer da NVIDIA em seus próprios modelos para medir o impacto.