Megatron-LM

Kimi K3: cómo Cerebras lo reparte en 59 wafers Kimi K3 tiene 3 billones de parámetros. Guardados en 4 bits pesan 1,5 terabytes, mucho más que los 44 GB de memoria que trae un solo chip wafer-scale de Cerebras. La única forma de servir un modelo así es el paralelismo de modelos: partirlo entre decenas de chips a la vez. No es exclusivo de Cerebras: los mismos principios corren en clústeres de GPU con Megatron-LM, DeepSpeed o vLLM. Esta guía explica cómo se reparten los pesos y la atención entre chips, usando Kimi K3 sobre wafers Cerebras como caso concreto, no como anuncio de producto. TL;DR - Kimi K3 reparte sus 93 capas (69 de atención lineal y 24 densas) entre 59 wafers Cerebras WSE-3T.- Cada capa de Kimi K3 pesa unos 16 GB en 4 bits, así que ningún chip de 44 GB aguanta el modelo completo.- Las capas densas reservan memoria para el cache KV; las lineales no, por eso caben dos por wafer en vez de una.- device_map="auto" de Hugging Face aplica el mismo principio de sharding en una GPU doméstica, sin clúster wafer-scale.- Un pipeline de chips mantiene varias peticiones en vuelo a la vez, así ningún wafer queda ocioso esperando turno. ¿Qué es el paralelismo de modelos? El paralelismo de modelos es el conjunto de técnicas que divide los pesos y los cálculos de una red neuronal entre varios chips cuando el modelo no entra en la memoria de un solo acelerador, repartiendo capas, porciones de cada matriz o grupos de expertos según la arquitectura del hardware disponible. Existen tres variantes principales, y los sistemas grandes casi siempre combinan más de una: paralelismo por pipeline (cada chip ejecuta un grupo de capas distintas), paralelismo de tensor (cada chip ejecuta una porción de la misma capa) y paralelismo de expertos (cada chip guarda un subconjunto de redes especializadas en modelos tipo Mixture of Experts). Kimi K3 sobre Cerebras usa sobre todo la primera. Por qué importa El paralelismo de modelos no es una optimización opcional, sino una condición necesaria para que el modelo cargue. Un modelo de 3 billones de parámetros en 4 bits pesa 1,5 TB, y la GPU más grande del mercado trae decenas de gigabytes de memoria, no terabytes. Sin repartir el modelo, simplemente no entra en el chip. Lo mismo pasa a menor escala. Un modelo de 70.000 millones de parámetros en precisión completa ya pesa unos 280 GB, más que la memoria combinada de varias GPUs de consumo. Por eso cualquier equipo que sirva un modelo grande, sea con wafers Cerebras o con un clúster de GPU, termina resolviendo el mismo problema de reparto. Cómo funciona el sharding de pesos y la atención entre chips Kimi K3 combina 69 capas de atención lineal y 24 densas en 93 capas totales. Antes de repartir nada, hay que saber cuánto pesa cada pieza. El compilador de Cerebras mapea cada capa del modelo a una región física de wafers, y el runtime decide por dónde viajan los tokens entre esas regiones. El siguiente diagrama resume cómo quedan las 93 capas de Kimi K3 repartidas en wafers de 44 GB: flowchart TD A["69 capas de atención lineal"] --> B["2 capas lineales por wafer (32 GB)"] C["24 capas densas"] --> D["1 capa densa + cache KV por wafer (44 GB)"] B --> E["35 wafers para capas lineales"] D --> F["24 wafers para capas densas"] E --> G["59 wafers WSE-3T en total"] F --> G Pipeline: cada chip ejecuta un tramo de capas En paralelismo por pipeline, cada chip guarda un grupo de capas consecutivas y actúa como una estación de una línea de ensamblaje. El wafer 1 ejecuta las capas 1 y 2 y manda sus activaciones al wafer 2, que ejecuta las capas 3 y 4 y las pasa al wafer 3, y así hasta la última etapa. Solo las activaciones cruzan de un wafer a otro, nunca los pesos, porque cada capa ya entera cabe en la memoria del wafer que la hospeda. En el caso de Cerebras, esas activaciones viajan por RDMA sobre Ethernet, con una latencia de unos 2 microsegundos por salto. El siguiente diagrama muestra cómo se llena el pipeline con varias peticiones en simultáneo: sequenceDiagram participant W1 as Wafer 1 participant W2 as Wafer 2 participant W3 as Wafer 3 W1->>W2: activaciones de la petición A W2->>W3: activaciones de la petición A W1->>W2: activaciones de la petición B W2->>W3: activaciones de la petición B Note over W1,W3: cada wafer procesa una petición distinta al mismo tiempo > 💭 Clave: un wafer no espera a que termine la petición completa: procesa una porción distinta de cada petición al mismo tiempo que sus vecinos, así el pipeline nunca corre a lote 1. Tensor: partir una misma capa en pedazos El paralelismo de tensor divide una sola matriz de pesos en fragmentos, y cada chip calcula su fragmento de la multiplicación. Al final hay que combinar los resultados parciales con una operación de sincronización llamada all-reduce, lo que exige una red muy rápida entre chips (normalmente NVLink). Este es el enfoque que usa Megatron-LM para entrenar modelos tipo GPT en clústeres de GPU. Expertos: solo activar una fracción del modelo En modelos Mixture of Experts, cada token se enruta a un subconjunto de redes especializadas (expertos), y cada chip puede guardar solo algunos expertos en vez de una copia completa del modelo. El tráfico de red depende de a qué expertos se enrute cada token, así que no es predecible como en un pipeline fijo. El caso Kimi K3 en los chips Cerebras WSE-3T Kimi K3 tiene 69 capas de atención lineal y 24 capas densas, 93 en total. Si los 3 billones de parámetros se guardan en 4 bits, el peso crudo es de 1,5 TB; dividido entre 93 capas, cada una pesa alrededor de 16 GB, bien por debajo de los 44 GB que trae cada wafer. Ahí aparece la diferencia entre tipos de capa. Una capa densa necesita espacio extra para el cache KV, porque guarda las claves y valores de cada token de cada petición activa; por eso entra solo una capa densa por wafer, dejando el resto de la memoria para ese cache. Una capa de atención lineal, en cambio, guarda un estado de tamaño fijo por petición sin importar cuánto contexto tenga, así que no necesita cache KV y caben dos por wafer (2 × 16 GB = 32 GB de 44 GB disponibles). Con 69 capas lineales a dos por wafer hacen falta 35 wafers (34,5 redondeado hacia arriba), y con 24 capas densas a una por wafer hacen falta 24 wafers más. El total es 59 wafers WSE-3T. Como cada capa entera cabe en un solo wafer, los pesos nunca se dividen entre chips: solo las activaciones cruzan de wafer en wafer. Según el mismo post de Cerebras, Kimi K3 anota 88,3% en Terminal-Bench 2.1 (contra 88,8% de GPT-5.6 Sol) y 91,2% en BrowseComp (contra 90,4% de GPT-5.6 Sol), resultados que lo ubican a la par de modelos propietarios en tareas de codificación y uso de herramientas, pese a ser un modelo de pesos abiertos. Cómo empezar: probar el sharding de pesos con Hugging Face Accelerate Nadie tiene wafers Cerebras en su escritorio, pero el mismo principio de reparto de capas se puede probar con herramientas abiertas. Antes de correr nada, instalá las dependencias (el comando es idéntico en Windows, macOS o Linux): pip install transformers accelerate torch Primero, cargá un modelo chico sin indicarle dónde vivir: from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-1.5B-Instruct") print(model.device) Sin device_map ni una llamada a .to(), Transformers carga los pesos en memoria RAM del proceso. La salida es: cpu Ahora pedile a Accelerate que decida el reparto por vos: from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained( "Qwen/Qwen2.5-1.5B-Instruct", device_map="auto", ) print(model.hf_device_map) Con un modelo chico que entra entero en una sola GPU, Accelerate no reparte nada y la salida es simplemente: {'': 0} Ese diccionario vacío significa "todo el modelo en el dispositivo 0". Con un modelo que no entra en una sola GPU, el mismo atributo hf_device_map devuelve un mapeo capa por capa, algo del estilo {'model.embed_tokens': 0, 'model.layers.0': 0, 'model.layers.14': 1, 'lm_head': 1}: ahí sí se ve el sharding de pesos en acción, cada bloque de capas asignado a una GPU distinta. > 💡 Tip: imprimí siempre model.hf_device_map después de cargar con device_map="auto": es la única forma directa de confirmar si Accelerate repartió el modelo o lo dejó entero en un dispositivo. Casos de uso reales - Cerebras + Kimi K3: inferencia en producción con pipeline de 59 wafers, cada uno con un grupo fijo de capas y memoria dedicada al cache KV.- Entrenamiento con Megatron-LM: NVIDIA combina paralelismo de tensor, pipeline y datos en lo que se conoce como paralelismo 3D, para entrenar modelos tipo GPT en clústeres de miles de GPUs.- DeepSpeed ZeRO: en vez de repartir capas, ZeRO-3 reparte los estados del optimizador y los gradientes entre GPUs, otra forma de resolver el mismo problema de memoria durante el entrenamiento.- Servir con vLLM: el motor vLLM expone el flag --tensor-parallel-size para que un modelo grande se divida entre varias GPUs al momento de servir peticiones, sin tocar el código del modelo. Errores comunes y buenas prácticas - Confundir paralelismo de modelos con paralelismo de datos. El segundo copia el modelo completo en cada chip para atender más peticiones en paralelo; el primero reparte piezas de un único modelo demasiado grande para un chip. Son complementarios, no alternativas.- No medir el tamaño real por capa. Una capa densa con cache KV pesa distinto que una capa de atención lineal sin cache; planear el reparto sin esa distinción sobreestima cuántos chips caben por wafer.- Pipeline mal alimentado. Si solo hay una petición en vuelo, cada chip queda ocioso esperando su turno (el llamado pipeline bubble). La solución es mantener varias peticiones o microbatches corriendo a la vez.- Ignorar la latencia de red entre chips. 2 microsegundos por salto suena insignificante, pero sumado a muchos saltos en un pipeline largo sí pesa en la latencia total de una petición.- Asumir que device_map="auto" siempre reparte algo. Con un modelo chico no hace sharding de pesos real: solo entra en acción cuando el modelo no cabe en un dispositivo. Comparativa con alternativas Ninguna técnica de paralelismo por pipeline, de tensor o de expertos gana siempre; cada una resuelve un cuello de botella distinto del hardware disponible. TécnicaCuándo usarlaVentajaLimitaciónParalelismo de pipelineModelo con muchas capas secuenciales y red entre chips relativamente lentaSolo cruzan activaciones entre chips, tolera redes modestasAgrega latencia por petición: cada token atraviesa todas las etapasParalelismo de tensorRed muy rápida entre chips (NVLink) y capas que ya no entran solas en un chipReduce la latencia de una sola capa al dividir el cálculoExige una sincronización (all-reduce) después de cada capa divididaParalelismo de expertos (MoE)Modelo Mixture of Experts donde cada token solo necesita unos pocos expertosActiva una fracción del modelo por token, ahorra cómputoEl tráfico de red depende de a qué expertos se enruta cada tokenParalelismo de datosEl modelo completo ya entra en un chip, pero hace falta más rendimiento totalEscala el número de peticiones atendidas en paraleloNo resuelve el problema de un modelo demasiado grande para un chip Profundizando Cada wafer Cerebras WSE-3T integra 44 GB de SRAM en una sola pastilla de silicio. El número de peticiones concurrentes que soporta un wafer con capa densa depende del cache KV disponible. Si el wafer tiene 44 GB y la capa densa usa 16 GB, quedan unos 28 GB libres para cache KV. La fórmula general es memoria de cache disponible dividida entre el tamaño del cache KV de una sola petición (que depende de la longitud de contexto, el número de cabezas de atención y la precisión del cache, 8 bits en el caso de Kimi K3). No hay forma de confirmar la cifra exacta de peticiones concurrentes de Kimi K3 sin ejecutar el modelo real: el extracto disponible del post de Cerebras describe el método pero no publica el número final. La cantidad de peticiones en vuelo también depende de cómo se agrupan en microbatches. Según Cerebras, el número de peticiones en vuelo es aproximadamente la cantidad de etapas del pipeline multiplicada por el tamaño del microbatch: microbatches chicos bajan la latencia de cada petición individual, microbatches grandes suben el rendimiento total del sistema. El siguiente diagrama contrasta cómo se estructura un paralelismo por pipeline frente a uno de tensor: flowchart LR subgraph Pipeline["Paralelismo de pipeline"] P1["Capas 1 y 2 en el Chip A"] --> P2["Capas 3 y 4 en el Chip B"] end subgraph Tensor["Paralelismo de tensor"] T1["Mitad de la matriz en el Chip A"] --> T3["All-reduce final"] T2["Mitad de la matriz en el Chip B"] --> T3 end El paralelismo de tensor exige una red rapidísima entre chips, porque cada capa termina con una sincronización. El paralelismo por pipeline tolera redes más lentas, pero agrega latencia por petición, porque cada token tiene que atravesar todas las etapas antes de salir. La elección depende del cuello de botella real del hardware disponible, no hay una opción que gane siempre; por eso las tres variantes de paralelismo de modelos conviven en el mismo clúster cuando el modelo y el hardware lo justifican. 📖 Resumen en Telegram: Ver resumen Tu próximo paso: instalá transformers y accelerate, cargá un modelo abierto con device_map="auto" e imprimí model.hf_device_map para ver con tus propios ojos cómo Accelerate decide el reparto en tu hardware. Preguntas frecuentes ¿El paralelismo de modelos reemplaza al paralelismo de datos? No, son complementarios. El paralelismo de datos copia el modelo completo en cada chip para atender más peticiones en paralelo; el paralelismo de modelos reparte piezas de un único modelo demasiado grande para un chip. Sistemas grandes como Megatron-LM combinan ambos. ¿Por qué Kimi K3 necesita 59 wafers Cerebras WSE-3T? Porque sus 93 capas no entran en un solo wafer de 44 GB. Cada capa pesa unos 16 GB en 4 bits, así que el reparto exige 35 wafers para las 69 capas de atención lineal y 24 wafers más para las capas densas. ¿device_map="auto" de Hugging Face hace sharding de pesos real? Sí, aplica el mismo principio a menor escala: reparte las capas del modelo entre las GPUs disponibles cuando el modelo no entra en una sola. Con un modelo chico, en cambio, no reparte nada. ¿El paralelismo por pipeline hace que un chip espere a que termine la petición anterior? No. Cada etapa del pipeline procesa una petición distinta al mismo tiempo que sus vecinos, así un pipeline bien alimentado nunca corre a lote 1. ¿Qué diferencia hay entre paralelismo de tensor y paralelismo de expertos? El de tensor divide una misma capa densa en pedazos que se ejecutan en paralelo con una sincronización final (all-reduce). El de expertos activa solo un subconjunto de redes especializadas por token, sin tocar el resto del modelo. Referencias - Cerebras: post oficial que detalla cómo reparten Kimi K3 en wafers WSE-3T.- Hugging Face Accelerate: documentación de device_map="auto" y el reparto automático de capas entre dispositivos.- NVIDIA Megatron-LM: repositorio con la implementación de referencia del paralelismo de tensor y pipeline combinados.- vLLM: documentación del motor de inferencia que expone --tensor-parallel-size para servir modelos grandes en producción. 📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.

Immich: High performance self-hosted photo; PowerShell | GitHub Curated Picks | 2026-10-22 Chapters: 00:00 2026-10-22 | GitHub Curated Picks 00:05 Pick #1 Immich 00:21 Pick #2 Go Whatsapp Web Multidevice 00:37 Pick #3 PowerShell 00:57 Pick #4 Megatron LM GitHub Curated Picks reviews 4 source-verified repositories selected for developer usefulness, not popularity position. Each pick is checked against its GitHub repository, README, release evidence, and recent commit; pick numbers are editorial order. The compact card keeps rank, signal, why it matters, and next check together while the ledger preserves direct URLs and release evidence. Treat the list as an educational review surface, not software endorsement, and verify license and maintenance before adoption. Published: 2026-10-22 Review window: daily Curated repository picks: - Pick #1 Immich | Latest commit | fix(mobile): keep header image when starting selection (reference 32356) | immich-app/immich - Pick #2 Go Whatsapp Web Multidevice | Latest commit | feat(cmd): add version command that prints only the version (reference | aldinokemal/go-whatsapp-web-multidevice - Pick #3 PowerShell | Latest commit | Localized file check-in by OneLocBuild Task: Build definition ID | PowerShell/PowerShell - Pick #4 Megatron LM | Latest commit | fix(ssm): batch-invariant Mamba decode without a z replay buffer | NVIDIA/Megatron-LM Chapters: 00:00 2026-10-22 | GitHub Curated Picks 00:05 Pick #1 Immich 00:21 Pick #2 Go Whatsapp Web Multidevice 00:37 Pick #3 PowerShell 00:57 Pick #4 Megatron LM 01:11 Watch Next 01:19 Educational Use Only Top comment prompt: Which repository would you verify first, and what release or commit evidence matters most? Source ledger: Direct source URLs: - github.com/trending - api.github.com - immich-app/immich - github.com/immich-app/immich/releases/tag/v3.3.5 - github.com/immich-app/immich/commit/745bdd2edf72c… - api.github.com - aldinokemal/go-whatsapp-web-multidevice - github.com/aldinokemal/go-whatsapp-web-multidevic… - github.com/aldinokemal/go-whatsapp-web-multidevic… - api.github.com - PowerShell/PowerShell - github.com/PowerShell/PowerShell/releases/tag/v7.… - github.com/PowerShell/PowerShell/commit/7962a6ae1… - api.github.com - github.com/NVIDIA/Megatron-LM/blob/main/README.md - github.com/NVIDIA/Megatron-LM/releases/tag/core_v… - github.com/NVIDIA/Megatron-LM/commit/aa46a5722999… - NVIDIA/Megatron-LM Informational and educational purposes only. Not investment advice, product endorsement, or professional guidance. Subscriber reason: Subscribe for the daily AI, GitHub, and market board. Tomorrow watchlist: Tomorrow, check the next tagged release, recent commit, and issue-health signals for the selected projects.

Why Long bf16 Training Runs Stall: The Residual Stream Has No Room for Small Updates TL;DR bf16 keeps 8 significant bits. Once a residual-stream value grows to around 600, the gap between neighbouring bf16 numbers is 4, so any single update smaller than 2 is rounded away completely. Matrix multiplies tolerate this. The running sum that carries the residual stream does not, because it adds many small updates to one large number. In a simulation (illustrative, code below) a bf16 residual received between 0.3% and 43% of the drift an fp32 residual received over 4,000 steps, depending on the noise level, and in one setting it stopped moving entirely. The fix used by mainstream training code is cheap: keep the residual path in fp32, keep the matmuls in bf16. If you cannot, stochastic rounding recovers the average in expectation. Whatever you choose, watch residual and gate maxima over time, not just loss. Why does a bf16 residual stream lose small updates? A bf16 number has 1 sign bit, 8 exponent bits and 7 stored mantissa bits, which is 8 significant bits including the implicit leading one. The relative resolution is therefore about 2^-8 to 2^-7, roughly 0.4% to 0.8%. That is fine for a weight or an activation that gets consumed once. A transformer's residual stream is different. Each block computes x = x + f(x). The same tensor is read-modified-written once per block, for dozens of blocks, and the quantity you care about is the sum. Floating-point addition rounds the result to the nearest representable number. If the update is smaller than half the gap at the current magnitude, the sum rounds back to the old value and the update has no effect. I measured the gaps with torch.nextafter on bf16 tensors: !bf16 spacing by magnitude | Magnitude of the value | Gap to the next bf16 number | Smallest update that registers | |---|---|---| | 1 | 0.0078 | above 0.0039 | | 64 | 0.5 | above 0.25 | | 128 | 1 | above 0.5 | | 256 | 2 | above 1 | | 600 | 4 | above 2 | | 1,024 | 8 | above 4 | | 4,096 | 32 | above 16 | Round-to-nearest-even resolves an exact tie toward the even mantissa, so an update of exactly half the gap is also lost. At 600 an update of 2.0 does nothing, while 2.1 jumps the value by 4. Are residual values really that large? Yes, in specific dimensions. Sun et al. (Massive Activations in Large Language Models) report a handful of activations that are up to 100,000 times larger than typical ones, stable across inputs, and acting as implicit biases that shape attention. These live in the hidden states that flow between layers, which is the residual stream. Any model whose stream norm grows with depth can push some coordinates into the hundreds. A median coordinate near 1 and a few coordinates near 600 can coexist in the same tensor, and the large ones are exactly the ones that gate behaviour. The consequence is a precision profile that is invisible in loss curves. A coordinate near 600 only moves in steps of 4. If the true gradient-driven drift on that coordinate is 0.3 per step, it takes a long run of same-direction updates before anything registers, and what registers arrives in lumps. What does the failure look like in a simulation? The numbers below are an illustrative simulation, not a model run. Each of 4,096 coordinates starts at 600. Every step adds mu + sigma * noise, with mu the small coherent drift and sigma the per-step noise. I compare three residual paths: a full fp32 residual, an fp32 residual that receives bf16-rounded updates (what you get when only the matmul output is bf16), and a fully bf16 residual. import torch def run(mu, sigma, steps=4000, d=4096, start=600.0): g = torch.Generator().manual_seed(1) x32 = torch.full((d,), start) # fp32 residual xmix = torch.full((d,), start) # fp32 residual, bf16 updates xb = torch.full((d,), start).to(torch.bfloat16) # bf16 residual for _ in range(steps): u = mu + sigma * torch.randn(d, generator=g) x32 = x32 + u xmix = xmix + u.to(torch.bfloat16).float() xb = xb + u.to(torch.bfloat16) return [float((x - start).mean()) for x in (x32, xmix, xb.float())] print(run(0.5, 1.0)) # [2000.5, 2000.4, 427.5] !Drift after 4,000 steps for three residual paths | Per-step update | fp32 residual | fp32 residual, bf16 updates | bf16 residual | |---|---|---|---| | mean 0.2, sd 0.5 | 800.2 | 800.2 | 2.4 | | mean 0.2, sd 1.0 | 800.5 | 800.5 | 348.5 | | mean 0.5, sd 1.0 | 2000.5 | 2000.4 | 427.5 | Three things stand out. First, the bf16 residual is not just noisy, it is biased. With a mean of 0.2 and a standard deviation of 0.5, almost no single update exceeds the rounding threshold, so the coherent drift of 800 collapses to 2.4. The signal is the small part, and it is the part that gets deleted. Second, noise can hide the problem. With a standard deviation of 1.0 the bf16 residual still drifts, because occasional large noise draws cross the threshold and get rounded up to a full step of 4. It recovers 43% of the fp32 drift for mean 0.2 and 21% for mean 0.5. The result looks like progress, but it is progress that depends on how noisy the updates happen to be, which is not a property you want in an optimizer. Third, in the third row the bf16 residual flattens at about 427. That is where the running value crosses 1,024 and the gap doubles to 8. At that point the updates of roughly 1 are far below half the gap and nothing registers. The residual freezes. !Applied update versus intended update at a residual of 600 The middle column is the important control. Rounding the update itself to bf16, which is what a bf16 matmul output does, costs almost nothing as long as the accumulator is fp32. The loss comes from rounding the sum. How do production training stacks handle this? They keep the residual path wide. Megatron-LM exposes an fp32 residual connection option that is only valid together with fp16 or bf16 (its argument validation asserts exactly that), see NVIDIA/Megatron-LM. The Mamba reference implementation has a residual_in_fp32 flag that casts the residual to float32, see state-spaces/mamba. Both choices say the same thing: matmuls can be narrow, the running sum cannot. The pattern in PyTorch is short. This block was run on CPU (PyTorch 2.4 or newer for nn.RMSNorm) to confirm it returns an fp32 residual: import torch, torch.nn as nn class Block(nn.Module): def __init__(self, d): super().__init__() self.norm = nn.RMSNorm(d) self.ff = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d)) def forward(self, x): # x is fp32 and stays fp32 h = self.norm(x).to(torch.bfloat16) with torch.autocast(x.device.type, dtype=torch.bfloat16): u = self.ff(h) return x + u.float() # the sum happens in fp32 The cost is memory and bandwidth on one tensor per block boundary, not on the weights or the matmul inputs. For most training setups that is a small price compared with the weights, optimizer state and attention activations, though you should measure it on your own batch shape. The same idea applies on any low-precision backend: FP8 matmuls, fp16 on older GPUs, and accelerators with narrow accumulators. What if you cannot keep the residual in fp32? Use stochastic rounding for the residual add. Instead of rounding to the nearest bf16 value, round up with probability proportional to the fractional distance. The expected value of the result equals the true sum, so small updates survive on average, at the price of extra variance. A reference implementation in PyTorch adds random bits below the bf16 cutoff and truncates: def sr_bf16(x32, g): b = x32.contiguous().view(torch.int32) r = torch.randint(0, 1 << 16, b.shape, generator=g, dtype=torch.int32) return ((b + r) & ~0xFFFF).view(torch.float32).to(torch.bfloat16) In the same simulation, stochastic rounding of the bf16 residual recovered a drift of 797.5 against 800.2 for fp32 (mean 0.2, sd 0.5) and 1,998.8 against 2,000.5 (mean 0.5, sd 1.0). That is the average over 4,096 coordinates. Individual coordinates are noisier, so check that the variance is acceptable for your task. Hardware support for stochastic rounding varies, and a software version like the one above is slower than a plain add. How do you catch this before the run is lost? The trap is that nothing breaks early. The loss falls normally for thousands of steps, then a gate or norm starts creeping, and by the time the loss reacts the run is hard to recover. Three signals are worth logging: 1. Per-layer residual maxima. Log the max absolute value of the stream at each layer every N steps. A steady climb in a few coordinates is the warning that your resolution is shrinking. 2. Gate and router maxima. Anything that multiplies the residual (learned gates, per-channel scales, MoE router logits) amplifies a quantization bias. Track the max, not only the mean. 3. Gradient norm trend. A slow, monotone rise in the global gradient norm without a matching loss change is the typical signature of a stalled or biased state. One more caution from experience: a single-step check will not find this. Compare the fp32 and bf16 gradient for one step and the cosine similarity looks excellent, because one rounding error per step is tiny. The failure is an accumulation effect over thousands of steps, so it needs a long-horizon test: run a short reference in fp32 and compare residual and gate maxima along the trajectory. At VIDRAFT we saw a long low-precision run drift with exactly this signature, and it disappeared when the residual path was held in fp32 while the matrix multiplies stayed in bf16. This post stays on the general mechanism and the public evidence rather than our run details. FAQ Does this affect inference? Much less. At inference each residual add happens once per layer on a fixed-length path, and errors do not accumulate across thousands of optimizer steps. Very deep models or long generations can still show small drift, so some inference stacks keep the residual in higher precision too. Is fp16 better than bf16 here? fp16 has 11 significant bits, so its gap at 600 is 0.5 instead of 4, which is better on resolution but has a much smaller range (maximum 65,504) and needs loss scaling. bf16 trades resolution for range. Neither is safe for an unbounded running sum, which is why the sum belongs in fp32. Do I need fp32 for the weights too? Separate question. Master weights in fp32 for the optimizer step is the standard defense against the same effect in parameter updates (a learning-rate-sized update added to a large weight). The residual stream is the activation-side version of the same arithmetic. Will this show up as NaN? Usually not. The typical outcome is silent: stuck coordinates, creeping gates, a loss curve that flattens or diverges slowly. NaN comes later or not at all. How large is the memory cost of an fp32 residual? One tensor of shape batch x sequence x hidden at each block boundary doubles from 2 to 4 bytes per element. If you use activation checkpointing the stored boundaries are exactly these tensors, so measure with your configuration rather than trusting a general estimate. Can I reproduce your numbers? Yes. Both scripts are about 20 lines, need only PyTorch on CPU, and use fixed seeds. The values above are from torch 2.12 on CPU. The simulation is illustrative: it shows the arithmetic, not the training dynamics of any particular model. Further reading - Model-Level RSI: What It Means When a Model Improves Its Own Weights - A Decision Model That Writes Nothing Just Took #1 on a 137-Benchmark Board

N8N: Fair-code workflow automation platform, Neovim, Supabase | GitHub Curated Picks | 2026-10-15 GitHub Curated Picks reviews 11 source-verified repositories selected for developer usefulness, not popularity position. Each pick is checked against its GitHub repository, README, release evidence, and recent commit; pick numbers are editorial order. The compact card keeps rank, signal, why it matters, and next check together while the ledger preserves direct URLs and release evidence. Treat the list as an educational review surface, not software endorsement, and verify license and maintenance before adoption. Chapters: 00:00 2026-10-15 | GitHub Curated Picks 00:05 Pick #1 N8N 00:33 Pick #2 Neovim 00:48 Pick #3 Supabase 01:03 Pick #4 Ruff 01:13 Pick #5 Nest 01:27 Pick #6 Compose 01:40 Pick #7 Transformers 01:56 Pick #8 Svelte 02:08 Pick #9 Paperless Ngx 02:23 Pick #10 Sqlfluff 02:37 Pick #11 Megatron LM Source ledger: github.com/trending api.github.com github.com/n8n-io/n8n/blob/master/README.md github.com/n8n-io/n8n/commit/50c4ced2241430e13fa7… github.com/n8n-io/n8n/releases/tag/stable api.github.com github.com/neovim/neovim/blob/master/README.md github.com/neovim/neovim/commit/f505b0636e0e0010f… api.github.com github.com/supabase/supabase/blob/master/README.md github.com/supabase/supabase/commit/4215b6ca32a3b… api.github.com github.com/astral-sh/ruff/blob/main/README.md github.com/astral-sh/ruff/commit/83a3afc3156d73ae… api.github.com github.com/nestjs/nest/blob/master/Readme.md github.com/nestjs/nest/commit/b461186f20c245d5238… api.github.com github.com/docker/compose/blob/main/README.md github.com/docker/compose/commit/89e818966a5c2110… api.github.com huggingface/transformers github.com/huggingface/transformers/commit/e24eb5… api.github.com github.com/sveltejs/svelte/blob/main/README.md github.com/sveltejs/svelte/commit/79e7c3bd346bec0… api.github.com paperless-ngx/paperless-ngx github.com/paperless-ngx/paperless-ngx/commit/14a… api.github.com sqlfluff/sqlfluff github.com/sqlfluff/sqlfluff/commit/8b68456e30eec… api.github.com NVIDIA/Megatron-LM github.com/NVIDIA/Megatron-LM/commit/9131593673d0… n8n-io/n8n neovim/neovim supabase/supabase astral-sh/ruff nestjs/nest docker/compose sveltejs/svelte Informational and educational purposes only. Not investment advice, product endorsement, or professional guidance.

HAMi: Heterogeneous GPU Sharing on Kubernetes, Megatron LM | GitHub Curated Picks | 2026-10-14 Chapters: 00:00 2026-10-14 | GitHub Curated Picks 00:04 Pick #1 HAMi 00:32 Pick #2 Megatron LM GitHub Curated Picks reviews 2 source-verified repositories selected for developer usefulness, not popularity position. Each pick is checked against its GitHub repository, README, release evidence, and recent commit; pick numbers are editorial order. The compact card keeps rank, signal, why it matters, and next check together while the ledger preserves direct URLs and release evidence. Treat the list as an educational review surface, not software endorsement, and verify license and maintenance before adoption. Published: 2026-10-14 Review window: daily Curated repository picks: - Pick #1 HAMi | Latest commit | build(deps): bump golang.org/x/tools from 0.51.0 to 0.52.0 Bumps | Project-HAMi/HAMi - Pick #2 Megatron LM | Latest commit | Add the min-memory DSA attention kernels (reference 7152) | NVIDIA/Megatron-LM Chapters: 00:00 2026-10-14 | GitHub Curated Picks 00:04 Pick #1 HAMi 00:32 Pick #2 Megatron LM 00:45 Watch Next 00:52 Educational Use Only Top comment prompt: Which repository would you verify first, and what release or commit evidence matters most? Source ledger: Direct source URLs: - github.com/trending - api.github.com - github.com/Project-HAMi/HAMi/blob/master/README.md - github.com/Project-HAMi/HAMi/releases/tag/v2.10.0 - github.com/Project-HAMi/HAMi/commit/c2ca851430d9c… - Project-HAMi/HAMi - api.github.com - github.com/NVIDIA/Megatron-LM/blob/main/README.md - github.com/NVIDIA/Megatron-LM/releases/tag/core_v… - github.com/NVIDIA/Megatron-LM/commit/1e3c0c62fbb7… - NVIDIA/Megatron-LM Informational and educational purposes only. Not investment advice, product endorsement, or professional guidance. Subscriber reason: Subscribe for the daily AI, GitHub, and market board. Tomorrow watchlist: Tomorrow, check the next tagged release, recent commit, and issue-health signals for the selected projects.