Cuando las compañías tecnológicas alquilan clústeres de cómputo para entrenar redes neuronales de vanguardia, la factura de electricidad y alquiler de racks de servidores asciende a millones de dólares por semana. Miles de procesadores gráficos Nvidia H100 y H200 zumban en las salas de servidores resolviendo ecuaciones matriciales colosales. Pero si miras el perfilador de rendimiento de un clúster así, a cualquier ingeniero le entra un escalofrío: ¡los carísimos núcleos tensoriales de las tarjetas gráficas pasan casi la mitad del tiempo inactivos!
La causa de estas pérdidas monstruosas reside en la arquitectura Mixture of Experts (MoE, mezcla de expertos), que se volvió el estándar en modelos modernos como Qwen 2.5, Qwen 3 y DeepSeek-V3. Para que los tokens lleguen a los «expertos» correspondientes, las tarjetas gráficas se ven obligadas a enviarse continuamente terabytes de datos por la red entre nodos, bloqueando las unidades de cómputo.
El equipo de la plataforma de entrenamiento distribuido Prime Intellect lanzó una solución abierta para este problema: el kernel GPU Prime Mega MoE, publicado en el repositorio abierto prime-kernels bajo licencia Apache 2.0. Gracias a la superposición del intercambio de red y los cálculos matemáticos en el paso hacia atrás (Overlapping Backward Pass), los ingenieros lograron acelerar el paso de entrenamiento de modelos MoE en un fenomenal 55%. Analicemos la mecánica de bajo nivel de este kernel y veamos cómo funciona esta magia en el código.
Anatomía de la inactividad GPU: dónde tropieza Mixture-of-Experts
Veamos en palabras sencillas cómo funciona una capa MoE clásica. A diferencia de una red neuronal densa, donde cada token pasa por una gigantesca matriz totalmente conectada (FFN), en MoE esa capa se divide en decenas de bloques independientes: los «expertos». Para cada palabra entrante, un enrutador dinámico (router) elige entre dos y cuatro expertos más adecuados.
Mientras los expertos viven en una misma GPU física, todo va rápido. Pero cuando el modelo suma cientos de miles de millones de parámetros, los distintos expertos terminan inevitablemente repartidos en diferentes servidores del clúster. Y ahí empieza la pesadilla:
- Operación All-to-All en el paso hacia adelante (Forward Pass): las tarjetas gráficas deben intercambiar tokens para enviar cada palabra a la GPU donde reside el experto necesario;
- Cálculo de productos matriciales (GEMM): los expertos procesan los tokens en los núcleos tensoriales;
- Paso hacia atrás (Backward Pass): al calcular los gradientes de error, los tokens deben devolverse a los servidores originales, calculando a la vez los gradientes respecto a los pesos de los expertos y los gradientes de las activaciones.
En las implementaciones estándar (incluido el popular framework Meta TorchTitan), estas operaciones se ejecutan de forma secuencial: primero la tarjeta gráfica espera a que el adaptador de red (InfiniBand o RoCE) termine de transferir el lote de datos, y recién entonces empieza a mover los núcleos tensoriales. Como consecuencia, la GPU permanece inactiva entre el 40% y el 50% del tiempo de cada paso de iteración.
Overlapping Backward Pass: superposición de red y multiplicaciones matriciales
Los ingenieros de Prime Intellect repararon en una propiedad fundamental del paso hacia atrás. Para calcular los gradientes de activación que deben enviarse de vuelta por la red hacen falta los pesos de los expertos, ¡pero no hacen falta los gradientes de esos mismos pesos! Esto significa que los cálculos pueden dividirse en dos flujos independientes de ejecución.
En el kernel Prime Mega MoE, construido sobre la librería de bajo nivel DeepGEMM, se implementa un mecanismo de superposición asíncrona (overlapping):
- Mientras el procesador gráfico calcula los gradientes de pesos (weight gradients) para el experto actual en los núcleos tensoriales, el módulo de comunicación en un flujo CUDA en segundo plano ya está enviando por la red los gradientes de activación listos hacia los nodos vecinos;
- Y a la inversa: la recepción de paquetes entrantes para el siguiente experto ocurre en paralelo con el cálculo de los bloques matriciales del paso actual.
Así luce la lógica conceptual de separación de flujos y gestión del acelerador tensorial de memoria (TMA) a nivel de código CUDA C++ de bajo nivel:
#include <cuda_runtime.h>
#include <cooperative_groups.h>
namespace cg = cooperative_groups;
// Kernel de paso hacia atrás asíncrono con superposición de cómputo e intercambio de red
__global__ void prime_moe_overlapping_backward_kernel(
const half* __restrict__ grad_output,
const half* __restrict__ weights,
half* __restrict__ grad_input_buffer,
half* __restrict__ grad_weight_accumulator,
int num_tokens, int hidden_dim, int expert_dim
) {
cg::thread_block block = cg::this_thread_block();
// Reserva asíncrona de memoria compartida para tiles TMA
extern __shared__ half smem_tile[];
half* tile_a = smem_tile;
half* tile_b = smem_tile + (hidden_dim * 16);
// 1. Cálculo asíncrono de gradientes respecto a las entradas (activaciones)
#pragma unroll
for (int step = 0; step < expert_dim; step += 16) {
// Carga de pesos mediante el copiador asíncrono de memoria Hopper TMA
asm volatile("cp.async.bulk.tensor.2d.shared::cluster.global.mbarrier::complete_tx::bytes"
" [%0], [%1], [%2];"
: : "r"(tile_a), "l"(weights + step * hidden_dim), "r"(sizeof(half) * hidden_dim * 16));
asm volatile("mbarrier.arrive %0;" : : "r"(0));
// Sincronización de la barrera de transacción y ejecución de multiplicación matricial
asm volatile("mbarrier.try_wait %0, 0;" : : "r"(0));
// Cálculo de gradientes de entrada para envío inmediato en segundo plano vía All-to-All
atomicAdd(&grad_input_buffer[block.thread_rank()], tile_a[block.thread_rank()]);
}
// 2. Acumulación en segundo plano de gradientes de pesos en paralelo a la transferencia de activaciones por red
block.sync();
atomicAdd(&grad_weight_accumulator[block.thread_rank()], grad_output[block.thread_rank()]);
}
Este truco de bajo nivel elimina por completo los tiempos muertos: mientras la tarjeta de red transfiere gigabytes de gradientes, los núcleos tensoriales están ocupados al 100% calculando matrices de pesos.
Mediciones en 128 GPUs: 55% de aceleración del paso para Qwen 3
Los resultados de las pruebas del kernel superaron las expectativas más optimistas de sus desarrolladores:
- A nivel de una sola capa MoE aislada, la aceleración fue de 3.11 veces en el paso hacia adelante (Forward) y de 1.87 veces en el paso hacia atrás (Backward);
- A escala de un ciclo completo de entrenamiento extremo a extremo (End-to-End step) del modelo abierto Qwen 3 235B-A22B en un clúster de 128 GPUs Nvidia H200, el kernel Prime Mega MoE aportó una ganancia total de velocidad del 55% frente al stack de referencia Meta TorchTitan.
Para integrarlo en los frameworks populares de entrenamiento, Prime Intellect entregó una capa envolvente compacta en PyTorch con registro automático de operadores personalizados de autodiferenciación:
import torch
import torch.nn as nn
from prime_kernels import moe_overlapping_backward_op
class PrimeMoELayer(nn.Module):
def __init__(self, num_experts: int, hidden_dim: int, expert_dim: int):
super().__init__()
self.num_experts = num_experts
self.hidden_dim = hidden_dim
self.expert_dim = expert_dim
self.weights = nn.Parameter(torch.empty(num_experts, hidden_dim, expert_dim, dtype=torch.bfloat16))
nn.init.xavier_uniform_(self.weights)
def forward(self, hidden_states: torch.Tensor, router_indices: torch.Tensor):
# Llamada al kernel compilado con soporte de streaming asíncrono
return moe_overlapping_backward_op(
hidden_states,
self.weights,
router_indices,
overlap_comm=True
)
Como ya analizamos en el estudio sobre optimización de inferencia de modelos con mezcla de expertos, acelerar un paso en un 55% ahorra en términos reales cientos de miles de dólares en alquiler de cómputo y reduce el ciclo de reentrenamiento de modelos de dos meses a tres o cuatro semanas. El kernel ya fue integrado en la librería abierta de aprendizaje por refuerzo Prime RL.
Requisitos de hardware y límites de aplicabilidad
Sin embargo, un rendimiento tan alto viene acompañado de una dependencia estricta de hardware:
- Solo Hopper y Blackwell: el kernel depende de forma crítica de las instrucciones de hardware para copia asíncrona de datos TMA (Tensor Memory Accelerator), que aparecieron por primera vez en los chips Nvidia de arquitectura Hopper (H100, H200) y evolucionaron en Blackwell (B200).
- Inaplicable en hardware antiguo o de consumo: en tarjetas de arquitectura Ampere (A100) o placas de consumo RTX 4090 no será posible ejecutar el kernel: carecen físicamente de bloques TMA y el compilador CUDA simplemente arrojará un error de instrucciones.
Prime Mega MoE es un ejemplo brillante de cómo una optimización inteligente de bajo nivel puede superar a la ampliación extensiva de servidores. El código abierto del kernel volvió a demostrar la fuerza de la comunidad Open Source frente a los desarrollos corporativos cerrados.

