70 captures, most recent first.
Samuel Ratnam @eterecursion · 29m
sidenote but averaging weights in ML works because useful circuits constructively interfere and task specific noise destructively interferes leading to better generalisation
[Quoted tweet]
Samuel Ratnam @eterecursion · 1h
this paper is so cool: arxiv.org/abs/2410.01463
you can get the benefits of data aggregation and personalisation without compromising on your privacy. You average everyone's A matrix to lear...
[Attached diagram, labeled 'FedSA-LoRA (Ours)': shows h = (arrows from) Pretrained weights W ∈ R^(d×d) [frozen, blue] plus B=0 [pink triangle] over A = N(0, σ²) [orange trapezoid, low-rank r] combined, with input x of dimension d at bottom. Legend: blue = frozen, orange = trainable - global, pink = trainable - local.]
Note from Claude Sonnet 5
Tweet by Samuel Ratnam explaining why weight averaging works in ML (constructive interference of useful circuits, destructive interference of task-specific noise), quoting his own earlier post about the FedSA-LoRA paper (arXiv:2410.01463) on federated personalization via averaging the LoRA A matrix while keeping B local, with the paper's architecture diagram attached.
machine learningfederated learningloraweight averagingtwitter

kalomaze @kalomaze · 8h
so i have experiments that show pretty convincingly, tensor-train style decomposition works for modeling exact AR joints over high dimensional data tractably. i did lit search and only found recent papers which apply it very narrowly, without realizing the larger implications
9 replies, 4 reposts, 148 likes, 6.7K views
kalomaze @kalomaze · 8h
what i am trying to say is "next token prediction" can be generalized to "next joint prediction", generically, WITHOUT diffusion or MSE regression or flow matching
a path exists for exact likelihood + policy gradients over far larger action spaces than you'd expect
1 reply, 1 repost, 38 likes, 1.1K views
kalomaze @kalomaze · 8h
arxiv.org/abs/1709.01662
more specifically, if you condition this kind of parameterization on a sufficiently rich transformer hidden state, you can optimize for exactly valid joints over combinatorially massive spaces, up to a rank bottleneck
[Link card: arxiv.org — Unsupervised Generative Modeling Using Matrix Product States]
Note from Claude Sonnet 5
Twitter thread by kalomaze describing experiments showing tensor-train (matrix product state) decomposition can generalize 'next token prediction' to 'next joint prediction' over high-dimensional/combinatorial action spaces, enabling exact likelihood plus policy gradients without diffusion, MSE regression, or flow matching, citing arxiv paper 'Unsupervised Generative Modeling Using Matrix Product States' (1709.01662).
machine learningtwittertensor decompositiongenerative modelingreinforcement learningkalomaze
corsaren @corsaren · 13h
Local minima are extremely rare in high dimensional spaces, so if you ever feel stuck in a rut it's probably just because you aren't considering a wide enough set of orthogonal options
Note from Claude Sonnet 5
Simple single-tweet screenshot, no images or engagement counts visible.
twittermachine learningself-helpoptimization
@_ueaj (ueaj) — 3h
Working in machine learning
[Embedded cartoon: two men seated on a scenic tour bus/train. Left figure, in a dim rocky tunnel labeled "Mass Surveillance," looks worried. Right figure, facing an open sunny mountain vista labeled "Infinite Data," looks delighted. Artist signature "GENIUDO" bottom right.]
@tszzl (roon) — Jun 20
this will be true across all walks of life
I would expect our whole lives to be recorded and the sheer signal density of your physical and digital presence to go 10,000x...
Note from Claude Sonnet 5
Editorial cartoon repurposed as an ML-industry meme contrasting "Mass Surveillance" (dim, walled view) with "Infinite Data" (bright, open view) — same tour bus, two different windows.
machine learningsurveillancedatahumortwitter
Adam Hibble ✓ @Algomancer · 12h
Can we train a family of local differentiable physical laws such that persistent local structures emerge which contain compressed predictive models of their own future environment and exhibit measurable causal control over that environment?
Idk, but i thought it was an interesting question if you try to take it seriously.
First attempt It's pretty at least.
A ~100M-parameter a local energy-conserving Hamiltonian field theory. its local rule is the symplectic leapfrog of a learned Hamiltonian. continuous, second-order, reversible, energy-conserving. Can kinda think of it as a second order in time neural ca, optimised such that cell states causally predict future local state whilst maximising variance, symplectic so it can't just push magnitude.
[Embedded video/animation, paused, showing four panels: "field φ[0:3]", "energy density", "momentum |π|", "field φ[3:6]" — colorful abstract turbulent-looking field visualizations. Overlay text: "large step 76500 E=4046492 drift=0.305 CV=1.24". Playback control shows 0:03.]
Note from Claude Sonnet 5
A technical/research tweet with an embedded paused video of a neural cellular-automaton / physics-simulation visualization (four colorful field panels).
physics simulationneural cellular automatahamiltonian mechanicsresearchmachine learning
François Fleuret ✓ @francoisfleuret · 10h
Research circa 2026
[Embedded screenshot of a terminal/chat window, partially cropped]:
~ pseudo_inverse_something?
, with one important caveat about RMSNorm. Le[cut off]
Note from Claude Sonnet 5
Tweet with an embedded, partially cropped screenshot of what appears to be an AI coding-assistant terminal session; text is cut off at the right edge.
ai researchmachine learningterminal/codetwitter humor
א-e/acc (@murage_kibicho) — 17h
The interesting thing I heard: big labs don't use Muon or AdamW during the million dollar training runs.
They all finetune SGD with a spectral norm regularizer and it saves them the extra mean and variance bytes. ie. larger batches. I wonder if it's true.
> QUOTED: hallerite (@hallerite) — Jun 28
> talking to people at the big labs is so boring because they will never tell you anything interesting. really grateful to work at a company that not only allows me to talk about the things I work on, but even encourages me to tweet mor...
Note from Claude Sonnet 5
Tweet speculating about optimizer choices at large AI labs, quoting an unrelated tweet about lab secrecy culture.
machine learningoptimizersai labstwitter
fellow ⚗ traveler 🔥 (@architectonyx) — 5h
in the 80s, there was this nice idea of the brain being "holographic", with information stored nonlocally
this was motivated by appeals to Fourier analysis, but interestingly, i think function approximation alone gets you there
[Embedded video/image, 0:11 duration, showing a blurred/noisy gradient panel on the left and a grid of small sample images (landscapes, animals, fruit, objects) on the right]
Note from Claude Sonnet 5
Tweet with an embedded short video (paused at 0:11) illustrating a holographic/distributed-representation visualization alongside a mosaic of sample training images.
neurosciencemachine learningrepresentation learningtwitter
@sang_yun_lee (Sangyun Lee) — 13h
But then how do humans learn so sample efficiently? The path is clear if you are willing to believe a hypothesis: the brain is just a gigantic recurrent neural network that rewires its own weights during the forward pass
> QUOTED: @dwarkesh_sp (Dwarkesh Patel) — 20h
> Here's a question I find confusing and interesting and which actually tells us a lot about the nature of current AI progress:
> Why has progress on computer use been so ... [truncated]
Note from Claude Sonnet 5
Quote-tweet chain discussing sample efficiency of human learning versus AI, and computer-use agent progress; quoted tweet cut off by platform truncation.
neurosciencemachine learningsample efficiencycomputer use agents
@yacinelearning (Yacine Mahdid) — 6h
one of the most important element of a good algorithmic research paper is a very colourful and simple to understand diagram of said algorithm
[Image: photo of a printed paper page showing "Figure 2: Outline of Vector Policy Optimization" — a diagram with boxes for Sample rollout (x → π_θ → y), Shared Reasoning Prefix (three colored answer sequences y1/y2/y3), Evaluation (r(x,y1), r(x,y2), r(x,y3)), Sample Reward Weightings w_i ~ Dir(1) shown as small bar charts, and a grid of green squares under "max in set", flowing to RL update and Â(y|x) ← Estimate advantage ← R(y|x) ← mean across weightings. Below the figure, printed body text reads:
"Figure 2: Outline of Vector Policy Optimization. Given a prompt x, a model π_θ outputs m answers in a single autoregressive chain. Each answer y_i is evaluated on multiple objectives and receives a score vector [r1, r2, ..., rn]. We repeatedly sample weighting vectors w_i ~ Dir(1) in the set of answers. This set level reward is treated as the mean best-of-m under each weighting w in the set of answers, and evaluate the reward for the entire completion π_θ(x).
proposed algorithm, Vector Policy Optimization (VPO), which trains a policy to produce such sets. VPO has two key components. First, we train a model to generate multiple candidate completions per prompt within a single autoregressive rollout. Second, we replace a fixed reward weighting with a distribution over weights, so the model is incentivized to span its candidates across different trade-offs.
Together, these components define a set-level objective that rewards the model for producing diverse, high-quality solutions. We describe each component in detail below.
3.1 Multi-Answer Chains as In-Context Exploration
Following Puri et al. [2026], we train a language model to produce a set of m candidate completions S = {y1, ..., ym} within a single rollout. The completions are emitted sequentially, separated by a delimiter token, so when generating y_i, the prefix already contains y1, ..., y_{i-1}.
This fundamentally changes the nature of exploration. Under standard independent sampling, diversity arises only from stochastic decoding applied to a fixed conditional distribution, producing small variations around whichever mode the policy has concentrated on. In multi-answer rollouts, each new candidate can attend to the ones already emitted, giving the model the capacity to recognize which regions of the solution space are covered and steer subsequent candidates towards different ones. Diversity becomes an explicit, in-context mechanism rather than a byproduct of sampling noise.
Importantly, this mechanism provides the capacity for diversity, but not a strong incentive¹. Without an appropriate training signal, the model will still collapse to producing near-identical answers. We confirm this empirically in Section 5: Multi-RLVR, which combines multi-answer rollouts with a fixed scalar reward, produced sets whose reward-diversity collapses early in training. The objective defined in the next section supplies this missing incentive by rewarding sets whose elements specialize to different reward trade-offs.
3.2 Set-Level Optimization via Stochastic Scalarization
To train a policy to output diverse sets, we replace the fixed scalarization prevalent in RL post-training..." [text cut off at bottom edge of photo]]
@yacinelearning (Yacine Mahdid) — Jun 13
on this beautiful saturday afternoon we're going to read about how vector policy optimization inject solutions diversity in these models
[quoted image: thumbnail of a hand holding the same printed paper]
Engagement: 8 replies, 11 reposts, 266 likes, 11K views
@GlennMatlin (Glenn Matlin) — 5h
Fig1 is critical for modern publishing
[reply continues below, cut off — a partially visible meme image with text "THE BAD METAGAME" is cropped at the bottom of the screenshot]
Note from Claude Sonnet 5
A physical printed research paper (on "Vector Policy Optimization," an RL post-training method for inducing diverse candidate completions via Dirichlet-weighted multi-objective rewards) photographed and tweeted; the tweet thread is a lighthearted riff on figure/diagram quality in ML papers. The bottom of the screenshot cuts off a reply with an attached meme image.
machine learningreinforcement learningresearch papertwitterai research
@MillionInt (Jerry Tworek) — 6h
Decompose and precondition.
See the inner beauty in matrices and continuously ascend in the subspace of knowledge
Note from Claude Sonnet 5
Single tweet, dark mode, no images or engagement counts visible.
machine learningaphorismmathematics
Dimitris Papailiopo... (@DimitrisPa... ✓) — 1h
btw this is a weird heavy ball SGD variant that basically does this
1. Load previous checkpoint weights.
2. Reset optimizer state / momentum buffers.
3. Train N steps.
4. For first M steps: warm LR from 0.1x -> 1.0x.
5. Hold LR flat until ~50% of the cycle.
6. Linearly decay LR to zero.
7. Save checkpoint.
8. Repeat
the optimizer is exactly this
buf = mu * buf + grad
p *= 1 - lr * wd
p -= lr * buf / 524288
@CevherLIONS @_arohan_ does this have a name?
I'd call it wave SGD lol
Note from Claude Sonnet 5
Text-only tweet with pseudocode for an optimizer variant; no images.
machine learningoptimizersgdtwittertechnical
● Major finding already: the log shows "VRAM after setup: 1411MB" — so params + optimizer + buffers are only ~1.4 GB. The OOM at 22.96 GB is almost entirely train-tick activations / the three_block —autograd graph (~21 GB). The static base is not the problem; the activation memory is. (My helper
Note from Claude Sonnet 5
Partial screenshot, cropped at top and bottom, mid-sentence cutoff at "(My helper" — appears to be an AI coding assistant's debugging output about a CUDA out-of-memory error, likely related to Nathan's own ML work.
pytorchcudamemory debuggingmachine learningterminal output
| Component | Trainable params | Source |al)
Counted dire—
───────────────────────────────────────── s
| params |
| Sharded macrocolumn cortex (425,393 | 184,354,125 | banner
param_count() over | |
| macrocolumns) | |
requires_grad |
Counted dire— Component | Trainable
─────────────────────────────────────────s
• ├ — — | 184,354,125 | ba ner
param_count() over────────────|
| Sharded macrocolumn cortex (425,393 | |
requires_gradount() over | |
| Backbone (RWKV nodes, MONET keys, heads, | 37,302,731 | optimizer
exp_avg entries (one | |
| BG/motor/hippo/grid/etc.) | | moment per
optimized param) |
| Total trainable | ≈ 221.7 M |
The macrocolumn cortex is 88% of the trainable weights — as expected, it's the whole point of the sharded run (it's also why N=425k doesn't fit one 24 GB card and needs the 2-way split).
N te on the bigger number you'd see
h̶u̶ external-drive/ 5 shells
• buffers: EMA target encoders, CSR/edge-tructure tensors, divnorm running-σ, fast-plastic
• local_learning traces (13.6 M), surprise memory (4.8 M), etc. Those don't get gradients, so they're not in the "trainable" count.
• - The macrocolumn block's own per-shard optim[izers] are built at runtime and aren't in thiso
checkpoint's exp_avg, which is why I took its trainable count from the startup banner's
param_count() stead — the two method cover disjoint halves, so they sum cleanly.
So: ~222 M trainable, ~184 M of it in the GPU-sharded cortex, with another ~73 M of
non-trained
[buffers/state cut off at bottom of visible screen]
Note from Claude Sonnet 5
A terminal screenshot with garbled/overlapping text rendering (two overlapping renders of what appears to be the same markdown table, likely a scroll/redraw glitch), showing a parameter-count breakdown for a "sharded macrocolumn cortex" neural architecture — matches the brain_graph_1 project's known architecture (RWKV nodes, macrocolumns, basal ganglia/hippocampus/grid components). Text is partially garbled by rendering overlap, not genuine content loss.
brain_graph_1neural architectureterminal outputmachine learningparameter counts
catid @MrCatid · 9h
So now that we know intelligence (planning, reasoning, etc) is just finding efficient representations, who's working on a new type of ML model that learns representations? Seems like we need something new closer to VQVAE with an evolutionary rule
Note from Claude Sonnet 5
A tweet speculating about future ML architectures for representation learning (VQVAE-like with evolutionary rules). Technical AI research commentary, tangentially related to Nathan's own architecture work on brain_graph_1.
twittermachine learningrepresentation learningvqvaearchitecture research
Artur Chakhvadze (@norpadon) · 8h:
This trivial thing is probably one of the most important memes in all of machine learning btw
All of the kernel methods are based on this simple trick
> QUOTED: John Carmack (@ID_AA_Carmack) · 8h
> I'm a little disappointed with myself that the high school algebra identity didn't occur to me right away.
>
> [Embedded LLM chat screenshot:]
> User: In pytorch, I have a [batch,latent] tensor and a [history,latent] tensor, and I want to get the squared distances between each batch element and every history element. I currently do this by:
> ```python
> delta = all_keys.unsqueeze(0) - q.unsqueeze(1)
> distances = torch.sum(delta**2, dim=-1)
> ```
> But this instantiates an enormous tensor with the broadcasts. I can break it up into smaller batches with a loop, but is there any more direct way that avoids instantiating the intermediate tensor?
>
> [Assistant, "Thought for 28s"]: Yes — use the algebraic identity for squared Euclidean distance:
> ||q_i - k_j||² = ||q_i||² + ||k_j||² - 2 q_i·k_j
>
> This lets you compute the full [batch, history] distance matrix with only a single matrix multiply ([batch, latent] @ [latent, history]) plus two cheap norm vectors. No [batch, history, latent] intermediate tensor is ever materialized.
> ```python
> q_norms = q.pow(2).sum(dim=-1, keepdim=True) # [batch, 1]
> k_norms = all_keys.pow(2).sum(dim=-1).unsqueeze(0) # [1, history]
> # or equivalently:
> # k_norms = all_keys.pow(2).sum(dim=-1, keepdim=True).T
> cross_terms = q @ all_keys.T # [batch, history]
> distances = q_norms + k_norms - 2 * cross_terms # [batch, history]
> ```
> This is much more memory-efficient (the only large temporary is the [batch, history] result itself) and is the standard trick used in nearest-neighbor / retrieval code.
Note from Claude Sonnet 5
John Carmack shares an LLM (appears to be an OpenAI-style reasoning model, "Thought for 28s") solving a PyTorch memory-efficiency problem via the classic squared-distance expansion identity, framed as a fundamental ML "meme" underlying kernel methods. Practical ML engineering tip, potentially useful for Nathan's brain_graph_1 work (distance/similarity computations at scale) though not tied to Claude specifically.
pytorchmachine learningkernel methodsjohn carmackllm codingmemory efficiencytwitter
907
908
909 def permute_matrix(W, rng=None):
910 """permute a matrix in a reversible way"""
911
912 num_params = np.prod(W.shape)
913 vec = W.reshape(num_params)
914 if rng is None:
915 p_ids = np.random.permutation(np.arange(num_params))
916 else:
917 p_ids = rng.permutation(np.arange(num_params))
918 p_vec = vec[p_ids]
919 p_W = p_vec.reshape(W.shape)
920
921 return p_W, p_ids
922
923
924 def unpermute_matrix(W, p_ids):
925 """unpermute a matrix, using the original ids to permute it"""
926
927 num_params = np.prod(W.shape)
928 vec = W.reshape(num_params)
929 unp_ids = np.argsort(p_ids)
930 unp_vec = vec[unp_ids]
931 unp_W = unp_vec.reshape(W.shape)
932
933 return unp_W
934
Note from Claude Sonnet 5
Screenshot of a Python code editor (line numbers 907-934) showing two functions, permute_matrix and unpermute_matrix, which reversibly shuffle the elements of a weight matrix using numpy.
pythoncodenumpymachine learning
Yuandong Tian @tydsh · 2h
History repeats itself 😀 The concept "learning mechanics" is not a new thing but actually has been explored for a very long time.
It is human nature to think deeper than a blind belief of the scaling laws.
I have been working on rigorously modeling training dynamics of deep nonlinear models for many years, with many non-trivial solvable examples in nonlinear dynamics that may be interesting for @learning_mech to take a look. This includes
1. Contrastive learning (e.g., arxiv.org/abs/2110.09348 arxiv.org/abs/2201.12680, arxiv.org/abs/2206.01342)
2. Non-contrastive learning (e.g., arxiv.org/abs/2102.06810, arxiv.org/abs/2110.04947)
3. Training dynamics in Transformers (e.g., arxiv.org/abs/2310.00535, arxiv.org/abs/2305.16380)
4. Grokking behaviors (arxiv.org/abs/2509.21519)
5. Spontaneous symmetry breaking (arxiv.org/abs/1703.00560)
6. Mechanism in forming symbolic solutions from gradient descent (arxiv.org/abs/2410.01779)
I am the first/solo author in most of the works listed above. Code are here: github.com/yuandong-tian/...
> QUOTED:
> Jamie Simon @learning_mech · Apr 24
> 1/ Deep learning is going to have a scientific theory. We can see the pieces starting to come together, and it's looking a lot like physics!
>
> We're releasing a paper pulling together these ...
>
> [Table, "Section | Approach | Examples in deep learning | Examples from physics":
> 2.1 solvable settings — deep linear networks, kernel regression, multi-index models — harmonic oscillator, hydrogen atom, Ising model
> 2.2 simplifying limits — lazy vs. rich learning, width/depth → ∞, small initialization — thermodynamic limit (n,V→∞), classical limit (ħ→0), hydrodynamic limit (k,ω→0)
> (table cut off, more rows below)]
Note from Claude Sonnet 5
A machine-learning theory thread: Yuandong Tian responds to Jamie Simon's paper framing deep learning as converging toward a physics-like scientific theory ("learning mechanics"), listing his own prior work on training dynamics, contrastive/non-contrastive learning, grokking, and symmetry breaking as precedent. General ML-theory reading, not directly tied to project's core AI-safety/model-welfare threads but relevant to Nathan's broader ML research interests (brain_graph_1 training dynamics).
machine learninglearning theorytraining dynamicsscaling lawsgrokkingtwitteryuandong tianjamie simon
Justin Hudson @RISignal · 4h
This is a useful framing, but it's mostly describing the local update dynamics.
There's a preceding step that isn't explicitly modeled here: region selection in activation space.
Small differences at initialization (prompt, prior tokens, interaction constraints) effectively restrict the model to a subset of the activation manifold. From there, test-time reasoning behaves like local trajectory optimization within that region.
So a more complete decomposition is:
Initialization-induced region selection, then, first-order optimization within that region
This also explains why you can get stable, internally consistent trajectories that don't converge to the globally correct solution, you're optimizing within the wrong region, not searching globally.
[💬 🔁 ❤2 📊123 🔖 ↗]
Alapan Chaudh... @alapanchaudh... · 9h
@zhenwang9102 I was wondering about the test-time-GD and KL-RLHF duality.
So, RLHF gets cross-prompt amortization for free as a hedge against noisy RMs. Does the KL anchor recover that at test time, or is per-prompt GD strictly more exposed?
Note from Claude Sonnet 5
A technical ML Twitter thread on test-time reasoning/chain-of-thought as implicit gradient-descent-like optimization within an activation-space region selected by the prompt/context, with a follow-up question about the duality between test-time optimization and RLHF's KL-anchored cross-prompt amortization. General interpretability/alignment-adjacent research content — relevant to Nathan's interest in how reasoning and RLHF interact mechanistically.
machine learninginterpretabilitychain-of-thoughttest-time computerlhfactivation spacetwitterjustin hudsonalapan chaudhuri
Siddharth Ancha @siddancha · 19h
This is very cool! But also not that surprising. Flow matching models are "uniquely identifiable" i.e. any sufficiently well trained flow model on the same data distribution will learn the same latent encoding (mapping from z → x), regardless of architecture.
In @jaschasd's words: youtube.com/watch?v=XCUlnH... . This should be true for diffusion models too if you properly seed the randomness used to generate intermediate samples.
It's still remarkable how strongly identifiable flow matching models are, especially the male/female and CelebHQ/FFHQ experiments. Says a lot about the datasets!
> QUOTED:
> Kwang Moo Yi @kwangmoo_yi · Apr 20
> Briq et al., "The Amazing Stability of Flow Matching"
>
> The attached image explains it all (with minor caption error though) -- training flow matching ...
>
> [Figure 1: Stability of the generated images grid, 4 panels: (a) Two disjoint random subsets — model trained on two disjoint random subsets of data produces visually very similar images; (b) DiT-XL/4 → DiT-S/2 → U-Net — model capacity/architecture change retains high similarity; (c) Both genders/Female/Male — data split by zero-shot gender classification, retained partition preserves semantic interpretation while complementary class swaps it; (d) CelebHQ → FFHQ — changing training dataset while keeping the same VAE retains similarity too. Caption: "Figure 1: Stability of the generated images. (a) We train the model on two disjoint random subsets of the data, and obtain visually very similar images. (b) The data is split into two sets based on zero-shot classification as male/female. Images we visually interpret as belonging to the retained partition are semantically preserved, while images of the complementary class swap the semantic interpretation. (c) Model capacity change from DiT-XL to DiT-S retains high similarity, while switching to a U-Net architecture retains similarity to a lesser degree. (d) Changing the training dataset from CelebHQ to FFHQ, while still using CelebHQ VAE, retains similarity too."]
Note from Claude Sonnet 5
A thread discussing "The Amazing Stability of Flow Matching" (Briq et al.) — the finding that flow-matching/diffusion generative models trained on different data subsets, architectures, or even datasets converge to nearly identical latent-to-output mappings, taken as evidence for architecture-independent "uniquely identifiable" representations. Directly relevant to the platonic-representation-hypothesis thread flagged in project memory ("Platonic hypothesis and model representation spaces" chat, cluster 11) as potentially bearing on alignment-via-character arguments — convergent representations across architectures/training runs is empirical support for that hypothesis.
machine learningflow matchingdiffusion modelsplatonic representation hypothesistwittersiddharth anchakwang moo yiinterpretability

ueaj @_ueaj · 18h
New blog! You can just keep increasing the amount of heads in your model with no diminishing returns on ICL up to atleast 4x. For reference that would make the o_proj head dimensions in this experiment 16k x 2k.
Additionally, if you perform a truncated SVD on full rank master weights to train MLA instead of training them as two separate matrices, you can recover most of the ICL capability but with less memorization.
I think MLA specialized optimizers are a direction worth exploring and are very underserved rn. Unfortunately I have more important projects to attend to and I've burned like 300$ on compute for this already. I would highly recommend someone trying to scale this up and see how well we can do.
[Chart: "arc/output_loss" — lines for mla-rat-l512-r64-b0p9-arc1-200m, mla-base-l512-r64-b0p9-arc1-200m, quad-kv-b0p9-arc1-200m, single-kv-b0p9-arc1-200m, x-axis train/tokens_seen 20M-180M, y-axis loss 0-8, all converging to similar low loss; tooltip shows single-kv-b0p9-arc1-200m: 0.74451, quad-kv-b0p9-arc1-200m: 0.66843 at 199,884,800 tokens]
ueaj @_ueaj · Apr 15
Replying to @_ueaj
Also something like MLA should be trained like QAT but instead of converting a high precision matrix to low precision you convert a full rank master weights into low rank latent projections...
Note from Claude Sonnet 5
A technical thread on Multi-head Latent Attention (MLA) architecture experiments — scaling attention heads without diminishing ICL returns, and using truncated SVD on full-rank weights (analogous to quantization-aware training) to recover in-context-learning capability with less memorization. Directly relevant to the brain_graph_1 "KDA-MLA attention at the ends only" architecture plan noted in project memory.
machine learningattention mechanismsmlamulti-head latent attentionin-context learningtwitterueajbrain_graph_1architecture research
Samip @industriaalist · Apr 19
quick writeup on why i think diffusion isn't more data efficient than AR, since it seemed to surprise a lot of people:
- the case for diffusion > AR ([1], [2]) rests on AR saturating at <5 epochs while diffusion can be trained for hundreds of epochs without overfitting. but that's AR with default regularization. with Slowrun we train AR for >30 epochs without overfitting using heavy regularization (15x standard weight decay and dropout), which captures the gains diffusion gets over hundreds of epochs. you can't push reg this hard on diffusion, the objective is already effectively regularizing the network
- data augmentation is another lever that helps AR models: sequence permutation and token masking close a lot of the gap even without heavy regularization
- [3] verifies this cleanly: simple dropout, weight decay, and token masking were enough to bridge the gap and even *surpass* diffusion. aligns with what we've seen
[1] arxiv.org/abs/2511.03276
[2] arxiv.org/abs/2507.15857
[3] arxiv.org/abs/2510.04071
[Link card] arxiv.org — Diffusion Language Models are Super Data Learners
Note from Claude Sonnet 5
A technical ML thread arguing that diffusion language models' apparent data efficiency advantage over autoregressive (AR) models is mostly an artifact of under-regularized AR baselines — heavy weight decay/dropout, sequence permutation, and token masking close or reverse the gap. Relevant to general ML architecture research Nathan follows (adjacent to brain_graph_1/DEQ architecture interests, though not directly cited there).
machine learningdiffusion modelsautoregressive modelsdata efficiencytwittersamiparxiv
Albert Gu @_albertgu · Apr 16
a dynamical systems point of view, which looks like an SSM applied along the residual stream, informs more principled ways to scale looped architectures
> QUOTED:
> Hayden Prairie @hayden_prairie · Apr 15
> We've been thinking a lot about scaling laws, wondering if there is a more effective way to scale FLOPs without increasing parameters.
>
> Turns out the answer is YES – by looping blocks…
>
> [Diagram: recurrence block h_t → Ā, Δ, B̄ (SSM-style gating) feeding into a "Transformer Blocks" module (Multi-Head Attention + Feed Forward, residual connections) → h_t+1]
> [Two plots: "IsoFLOP Scaling Laws of Looping" — Validation Loss vs Recurrence (multiple colored curves with star-marked optima), and Optimal Recurrence vs FLOPs (log-log, roughly linear trend)]
Note from Claude Sonnet 5
Albert Gu (Mamba/SSM researcher) comments on a scaling-laws paper/thread about looping transformer blocks with an SSM-style gate applied along the residual stream, treating it as a dynamical-systems framing for how much recurrence to use at a given FLOP budget. Directly relevant to the brain_graph_1 encode/iterate-in-latent/decode architecture and its "virtualizing width via looping" primitive — a scaling-law reference for how many DEQ/loop iterations to use at different compute scales.
machine learningssmmambalooped transformersscaling lawstwitteralbert guarchitecture researchbrain_graph_1
[Tail of embedded video: 0:15 / progress bar]
Han Xiao (@hxiao) · 6:36 PM · Apr 12, 2026 · 49.7K Views [same tweet as prior screenshot]
[16 replies, 74 reposts, 514 likes, 299 bookmarks]
Reply — dazzafact (@calhim7) · 11h: "Why not use a form of "WebP" Like compression instead of "JPEG"-like?" [2 replies, 4 likes, 688 views]
Reply — Han Xiao (@hxiao) · 9h: "damn u r right!" [5 likes, 591 views]
Reply — gabor (@gradientpull) · 5h: "why would higher weight similarity imply 'blindness'? obviously at Q1 weights are either fully or zero correlated, and quant necessarily shifts toward higher correlation. Doesn't mean multiple non-linear stacked layers with high correlation don't retain useful patterns." [137 views]
Reply — Doxy (@Doxposting) · 12h: "exactly why i stopped trusting q2 for anything that isn't a toy, just switched to llama.cpp with -q4_0 and the retrieval latency dropped while accuracy stayed solid
honestly if your vectors look like soup you're either quanting too hard or using a model that was never meant to" [3 likes, 665 views]
Reply — Natfii (@natfiiOnX) · 9h: "I expect nvfp4 to become the standard for home local use soon, when 5000 series cards start..." [cut off]
Note from Claude Sonnet 5
Continuation of the quantization/embeddings technical thread from the previous screenshot — replies debating why low-bit quantization degrades embedding discriminative power, with practical advice on quant levels for local LLM/embedding use. Pure ML-engineering discussion, same thread as Screenshot_20260413-122900.png.
embeddingsquantizationllama.cppmachine learningtechnical
Han Xiao (@hxiao) · 6:36 PM · Apr 12, 2026 · 49.7K Views:
"low quant weights make the embedding model lose all discriminative power. I plotted the cosine correlation matrix of jina-v5, and one can see that low quant makes the model really blind. The off-diagonal similarities are pretty high on Q1/2/3, meaning everything looks similar in the semantic space. Q4 is a sweet spot where model quality becomes acceptable."
[embedded video/animation: "JINA-EMBEDDINGS-V5-SMALL — NOISE (OFF-DIAG MEAN) — IQ2_M -> Q2_K — 0.1512" showing a heatmap cosine-correlation matrix visualization, playing at 0:32]
[16 replies, 74 reposts, 514 likes, 299 bookmarks]
Reply visible below (cut off): dazzafact (@calhim7) · 11h [content not shown]
Note from Claude Sonnet 5
Technical tweet from Jina AI's founder about how aggressive quantization degrades embedding-model discriminative power, illustrated with a cosine-similarity heatmap. Pure ML-engineering content, part of Nathan's technical reading, not safety/welfare-relevant.
embeddingsquantizationjinamachine learningtechnical
secemp (@secemp9) · 1h:
"reminds me of this earlier work"
[Embedded arxiv card]: "Computer Science > Neural and Evolutionary Computing — [Submitted on 21 May 2016 (v1), last revised 23 Jul 2017 (this version, v3)] — Programming with a Differentiable Forth Interpreter — Matko Bošnjak, Tim Rocktäschel, Jason Naradowsky, Sebastian Riedel"
> QUOTED: Jürgen Schmidhuber (@Schmidhu...) · Apr 10:
"Neural Computers
arxiv.org/abs/2604.06425"
[thumbnail with "GIF" label, "Neural Computer (CUGen General 5)"]
Note from Claude Sonnet 5
A research-history tweet connecting a new 2026 "Neural Computers" paper (arxiv 2604.06425) shared by Jürgen Schmidhuber to a 2016 predecessor on differentiable Forth interpreters — general ML architecture history, not directly tied to safety/welfare themes but part of Nathan's technical reading.
twittermachine learningneural computersdifferentiable programmingschmidhuberarxiv
[repost icon] Machine Learning Street Talk reposted
Kenneth Stanl... @kenneth0stanl... · 12h
Difficulty achieving continual learning is also a bad omen for creativity: what you can imagine is naturally a function of what you can learn. Both are mediated by the adjacent possible to the same internal representations! Contorted algorithms (or the absence of clean options) for what should be simple and straightforward continual learning are therefore a hint that the large models they serve are creatively barren.
That explains why something that is close to "knowing everything" and often competitive with the abilities of experts can still produce fewer breakthroughs than you would expect from a human with similarly astounding knowledge and expertise.
Note from Claude Sonnet 5
Kenneth Stanley (known for open-endedness/novelty-search research) argues that difficulty with continual learning in LLMs signals limited creativity, since imagination and learning share the same substrate of internal representations. Relevant to Nathan's interest in architecture/learning-dynamics questions (brain_graph_1) and to broader questions about what current LLMs are missing relative to humans.
continual learningcreativitymachine learningkenneth stanleytwitteropen-endednessllm limitations
[repost icon] Minh Nhat Nguyen reposted
Aidan McLaughlin @aidan_mclau · 1h
one of my all-time favorite plots
[image: classic AlphaGo Zero training plot — Elo rating (y-axis, -4000 to 5000) vs Training time (h) (x-axis, 0-70), showing "Reinforcement learning" (blue) curve starting at -3500 and climbing steeply to ~4300, "Supervised learning" (magenta) curve starting at ~1000 and plateauing around 3500, and a dashed horizontal line labeled "AlphaGo Lee" at ~3700]
Note from Claude Sonnet 5
Repost of the famous AlphaGo Zero paper plot showing pure self-play RL surpassing supervised learning from human data and eventually the AlphaGo Lee benchmark. Classic reference image for RL-vs-imitation-learning discussions, relevant to Nathan's ML/RL interests.
reinforcement learningalphagomachine learningtwitterdeepmind
gm8xx8 @gm8xx8 · Apr 3
DGPO uses probability gradients instead of log-probability gradients in RLVR. Log-probability–based soft clipping becomes unstable as token probabilities vanish, with gradient weights blowing up at the left boundary. DGPO applies asymmetric decay to clipped tokens: polynomial on low-ratio for stability, reciprocal-radical on high-ratio to continue updating low-probability tokens instead of zeroing them out. This yields a smoother stability–learning tradeoff than clipping-based approaches. Across DeepSeek-R1-Distill-Qwen 1.5B, 7B, and 14B, it consistently improves mathematical reasoning benchmarks, positioning probability-gradient control as the cleaner RLVR primitive.
[image: comparison diagrams and table of policy optimization algorithms (GRPO, CISPO, GPPO, CE-GPPO, ASPO, DGPO) showing gradient explosion/convergence plots and a table of properties: Exploration Capability, Gradient Convergence, Gradient Continuity, Exploration Convergence, Gradient Estimator Bias, Logging Token Update Magnitude across Left/Right/Reverse boundaries]
Note from Claude Sonnet 5
Technical ML tweet summarizing a paper on DGPO (a new RL policy-gradient method for RLVR/reasoning training), comparing it against GRPO/CISPO/ASPO variants with benchmark improvements on DeepSeek-R1-Distill-Qwen models. Relevant to Nathan's RL/training research interests (brain_graph_1, RLHF).
reinforcement learningrlvrpolicy gradientsmachine learningtwitterdeepseekml research
Harry Partridge @part_harry_
Pretraining is data-inefficient. This is entirely a consequence of the fact that we throw away the KV cache after every forward-backward step!
If we can integrate efficient KV cache compaction into pretraining, we will unlock human level data efficiency. Neural KV cache compaction makes this possible.
[quoted tweet:]
Charlie O'Neill @oneill_c · 2h
[image: 8-panel chart grid — Train: Loss, Train: Utilization, Eval: MCQ Accuracy, Eval: MCQ Utilization, Eval: CE Utilization, Eval: Cont Utilization, Eval: Compact KL, Eval: Compact CE — all plotted against Number of Latents]
"Towards infinite context windows: neural KV cache compaction"
TL;DR: We compress an LLM's KV cache 8x in milliseconds, retaining 85%+ of factual accuracy across domains. Here's how.
Introduction...
10:53 AM · Apr 1, 2026 · 3,243 Views
[reply] 1 [retweet] 5 [heart] 45 [bookmark] 34 [share]
Harry Partridge @part_harry_ · 1h
In context learning *is* data efficient. We spend so much compute building this rich KV cache on every forward pass. If we can effectively merge this cache with our existing knowledge, we can dramatically improve the data efficiency of pre-training and RL!
Note from Claude Sonnet 5
Twitter thread on ML research about neural KV cache compaction for infinite context windows, and a hypothesis linking it to pretraining data efficiency. Technical ML architecture content relevant to Nathan's brain_graph_1 / memory-architecture interests.
machine learningkv cachetransformerspretrainingdata efficiencytwitterml research
Ji-Ha @Ji_Ha_Kim · 9h
Very cool! I worked on this recently, and I actually used an identical approach early on. But I believe there is a significantly better approach – a **single** minimax rational iteration can beat 5 polynomial steps!
[Embedded image: math graphing tool (Desmos-like) showing equations φ(x)=φ2(φ1(x)), Z_7(x)=Z_1(x)/1.4093601263725774, p(x)=p5(p4(p3(p2(p1(x))))), and various polynomial definitions φ1(x), φ2(x), p1(x)-p5(x), plotted as oscillating curves converging near y=1]
> QUOTED: Jack Zhang ✓ @jcz42 · Mar 30
> We made Muon run up to 2x faster for free!
> Introducing Gram Newton-Schulz: a mathematically equivalent but ...
> [thumbnail bar chart comparing "1 Dense MLP Weight" pipeline stages, showing speedup]
Note from Claude Sonnet 5
Technical ML optimization thread — a reply proposing a minimax rational iteration approach to speed up Newton-Schulz iteration (used for the Muon optimizer's orthogonalization step), replying to a "Gram Newton-Schulz" 2x speedup announcement. Continues the same optimizer/ML-engineering thread cluster as other screenshots in this batch.
machine learningoptimizersmuontwitternumerical methods
Teortaxes▶ (DeepSeek 推特🐦铁粉 2023–∞) reposted
You Jiacheng @YouJiacheng · 6h
the technique is proprietary, but the format already gave us a lot of information.
1. no VQ
2. no rotation
3. no bias (symmetric)
so it's probably (P>90%) a pure optimization-based method.
[Embedded paper excerpt image:]
4.1 Deployable 1-bit Format: Q1_0_g128
1-bit Bonsai uses a deployable group-wise 1-bit weight format. In llama.cpp [13] this is packaged as GGUF [12] Q1_0_g128, while MLX [25] uses the corresponding 1-bit g128 representation. The format stores one sign bit per weight and one shared FP16 scale for each group of 128 weights. This preserves a fundamentally 1-bit representation while retaining the group-wise magnitude information required for stable inference.
In storage, weights are represented as bitpacked values in {0, 1}, using exactly one bit per weight. At inference time, those bits are mapped to signed values and scaled by the FP16 factor associated with their group. The effective weight is therefore given by
w_i = s_g · (2b_i − 1), b_i ∈ {0, 1}
where s_g is the shared scale for group g. Because each group of 128 weights carries one FP16 scale, the effective storage cost is
b_eff = 1 + 16/128 = 1.125 bits/weight,
which yields an idealized raw-weight compression of 16/1.125 ≈ 14.2× relative to FP16, before container overhead and alignment.
Q1_0_g128 is applied uniformly across the large matrix-heavy components of the model, including embeddings, attention projections, MLP projections, and the LM head. Normalization parameters and scale metadata remain in higher precision for numerical stability, but these account for a negligible share of memory traffic relative to the large weight tensors that dominate bandwidth during decoding.
PrismML ✅ @PrismML · 7h
Replying to @PrismML
This scatter plot shows the Pareto frontier of intelligence vs. size, defined by models like Qwen3 0.6B, 1.7B, 4B, 8B, and Ministral3 3B....
[thumbnail scatter plot, axes unclear]
Note from Claude Sonnet 5
Technical ML Twitter thread analyzing "1-bit Bonsai," a 1-bit quantization scheme (Q1_0_g128 format) for deployable LLM weights, achieving ~14.2x compression vs FP16, plus discussion of a Pareto frontier of model intelligence vs. size across small open models. Pure ML-engineering interest.
machine learningquantizationtwitterllm compressionmodel efficiency
vipli ✓ @viplismism
most people don't realize that rlms are just solving the sparse reward problem for long context! instead of an llm hunting for checkmate in one giant forward pass, it's like you break it into bite-sized reasoning tasks. every recursive step is a checkpoint where the model updates its internal value of the context before moving to the next piece it turns a massive search space into a dense signal
3:51 AM · Mar 31, 2026 · 124 Views
Discover more
Sourced from across X
vipli ✓ @viplismism · 16h
this is by far the best piece of content i read in a long time
[Quoted image/text block, white background:]
And I would like to suggest that slowing the fuck down is the way to go. Give yourself time to think about what you're actually building and why. Give yourself an opportunity to say, fuck no, we don't need this. Set yourself limits on how much code you let the clanker generate per day, in line with your ability to actually review the code.
Mario Zechn... ✓ @badlogicgam... · Mar 25
I'm usually not one to write thought pieces without much technical depth. But here we go.
Slow the fuck down.
Note from Claude Sonnet 5
Two related tweets: one framing RL/reasoning models as solving sparse-reward problems via recursive checkpointing, and a surfaced/quoted essay excerpt from Mario Zechner (badlogicgames) urging developers to slow down and set self-imposed limits on AI-generated ("clanker"-generated) code they can't fully review. The latter is relevant to AI-assisted-coding-caution discourse, tangential to Nathan's interest in AI capability/agency limits.
machine learningreinforcement learningtwitterai codingai cautionvibe coding
Harsh Bhatt ✓ @harshbhatt7585 · 23h
I tried moun over AdamW with GRPO, it is far stable than that with moun.
[2 replies, 371 views]
rajan agarwal ✓ @_rajanagarwal · 23h
my intuition here is that muon probably provides strong benefits when the intention is generalized RL, but there's a chance that only works with muon bases just by the argument of loss landscapes
[1 reply, 321 views]
Harsh Bhatt ✓ @harshbhatt7585 · 22h
I tried in high dense grid world with HRM model, In my GRPO experiments, Muon felt noticeably more stable than AdamW. I also think that operator-aware step geometry may help more when the RL objective is broad and general rather than narrowly optimized, But grid-world was very narrowed as cannot be as general as LLMs but still it felt better, let me search the wandb experiment, will drop here if I find.
[1 reply, 2 likes, 95 views]
Harsh Bhatt ✓ @harshbhatt7585 · 22h
*HRM model wa not pretrained LLM
[96 views]
Mingta Kaivo 明塔 ... ✓ @MingtaKa... · 12h
super interesting thread. we've been experimenting with different optimizers for fine-tuning audio models at audiowave and the step size sensitivity is real. curious if anyone has tried muon specifically for RLHF on smaller models (sub-7B) or if the benefits mostly show up at scale?
Note from Claude Sonnet 5
An ML researcher discussion thread comparing the Muon optimizer vs AdamW for GRPO (a policy-gradient RL algorithm used in RLHF-style training), including stability observations across grid-world and audio model fine-tuning experiments. Technical ML-training content.
machine learningoptimizersmuonadamwgrporlhftwitterreinforcement learning
buun ✓ @spiritbuun
The funniest thing about TurboQuant is that not only is none of it new, every part of what we've implemented is very old. We are just rediscovering tricks video game developers had to use in the 90s.
FWHT decorrelation → DCT in JPEG/MPEG decorrelation
Lloyd-Max 16-centroid codebook → 256-color palette (VQ codebook)
Norm + quantized unit vector → Quake's norm vector table
128-elm blocks with 4-bit indices → S3 texture compression
ADC lookup table (VecInfer) → Dot-product LUTs for lighting
Per-block scale factor → ADPCM audio (scale per block + quantized residuals)
5:02 PM · Mar 28, 2026 · 39K Views
Note from Claude Sonnet 5
A tweet noting that Google's TurboQuant LLM compression algorithm reuses classic 1990s video-game/media compression tricks (JPEG DCT, Quake normal-vector tables, S3 texture compression, ADPCM audio). Continues the same TurboQuant/JL-lemma technical thread as prior screenshots, from a different angle (retrocomputing parallels).
machine learningcompressiontwitterturboquantvideo game historyretrocomputing
SpeakEZ.tech ✓ @SpeakezTech · Mar 29
The PCA/random projection tradeoff makes sense for static datasets where structure can be analyzed in advance. In gradient estimation via randomized forward-mode autodiff, you cannot run PCA on the object you are trying to compute. Random projection is not a fallback there. It is the only non-circular approach. The J-L bound then tells you exactly how many directional samples you need, logarithmic in weight-space dimension. When accumulation is exact via quire, the distortion bound is purely statistical with no arithmetic error component folded in.
Note from Claude Sonnet 5
Further continuation of the Johnson-Lindenstrauss/random-projection thread, applying it specifically to forward-mode automatic differentiation for gradient estimation. Same math/ML thread as prior three screenshots.
mathematicsmachine learningtwitterjohnson-lindenstraussautodiffgradient estimation
Alex Clemmer 🔥🔥...✓ @haus... · Mar 28
The first time you hear about the JL lemma, it will seem too good to be true. And it is, kind of, I'll explain. The idea is: if you have points in large d-dimensional space, a RANDOM projection to much smaller k-dim subspace will be "nearly optimal" "in the general case." Or, more specifically: with high probability, the pairwise distances between points are preserved, given a couple other requirements around d and k.
So why don't we just use random projections instead of carefully-constructed ones all the time? This is the most common misunderstanding of the JL lemma, and the one thing to really understand about it: in many (most?) datasets that are meaningful to humans, you actually CAN do better with something like maybe PCA. If your dataset is pathological, e.g., the points all lie on a plane even though it's technically in 3 dimensions, then clearly some planes you project onto will be better than others. The JL lemma does not apply to 2 and 3 dimensions, but you can imagine this would be true in large numbers of dimensions too. (See screenshot 1, i hope you like it because i made it myself lol.)
If you know just those facts, you will be pretty well-prepared to answer most questions about its use. Most of the papers Delip mentions do presuppose that you know this. At least when I was a student, I found this to be non-obvious.
[Embedded diagram: two 3D cube diagrams labeled "fig. 1: randomly projecting from R^3 to R^2" — left "random projection is nearly optimal", right "PCA is far better than random projection", each showing points projected onto a 2D plane inside a cube]
> QUOTED: Delip Rao e/σ ✓ @deliprao · Mar 27
> The Google turboquant paper is [cut off]
Note from Claude Sonnet 5
Continuation of the Johnson-Lindenstrauss lemma / TurboQuant discussion thread — explains the nuance that random projections are only "nearly optimal" in the general/pathology-free case, and PCA can do better on structured data. Same technical math/ML thread as the two prior screenshots.
mathematicsmachine learningtwitterjohnson-lindenstraussdimensionality reductionpca
Martin ✓ @mjbukow
It's more complex than that. Because the residual stream is purely additive, low-level gradient noise and intralayer communication signals accumulate across layers. The norm of the hidden states steadily increases with depth. In the last few layers, the model turns up the volume on output-aligned directions; effectively using the growing norm and null-space interactions to overpower accumulated noise and better align the representation for the LM head. The final RMSNorm then projects everything onto the hypersphere right before unembedding, which completely disjoints the gradient right at the end.
All that to say, the gradient is going to be noisy because all of this is being transacted on one purely additive state container that serves multiple purposes in different parts of the model. Passing a clean signal back is more a prayer to AdamW than it is good ML engineering.
6:13 PM · Mar 29, 2026 · 3,109 Views
Note from Claude Sonnet 5
A technical tweet on transformer residual stream dynamics — how gradient noise accumulates across layers and how the final RMSNorm/unembedding interacts with it. Relevant to mechanistic interpretability of the residual stream, a topic adjacent to Nathan's interpretability interests.
machine learningtransformersinterpretabilityresidual streamtwittergradients
Paata Ivanisvili ✓ @PI010101
The Johnson--Lindenstrauss lemma says something quite remarkable: if you have an astronomical number N of vectors of large size (say, in a very high-dimensional Euclidean space), then you can linearly map them into a much lower-dimensional space, of dimension about log(N), in such a way that the distances between the vectors are almost preserved.
In other words, you can compress your data dramatically without making it too upset about its geometry. A random matrix with i.i.d. standard Gaussian entries will most likely do the job.
> QUOTED: Google Research ✓ @GoogleResear... · Mar 24
> Introducing TurboQuant: Our new compression algorithm that reduces LLM key-value cache memory by at least 6x and delivers up to 8x speedup, all with zero accuracy loss, redefining AI efficiency. Read the blog to learn how it achieves these results: goo.gle/4bsq2qI
Note from Claude Sonnet 5
A mathematician explaining the Johnson-Lindenstrauss lemma as the theoretical basis behind Google Research's TurboQuant, a new LLM KV-cache compression algorithm. Technical ML-infrastructure content.
machine learningllm efficiencycompressionmathematicstwittergoogle research
Dimitris Papailiopo... ✓ @DimitrisPa... · 3h
AdderBoard update: 50+ submissions in. Smallest transformer that adds two 10-digit numbers at 99%+ accuracy:
🏆 Hand-coded: 6 params (@zcbtrak)
🏆 Trained: 36 params (@TomBukic)
Started at 6K-> Now 6 a 1000× compression :)
Three patterns that I've noticed worth calling out:
1/ Weight tying does a ton of work:
Q, K, V can be the same matrix.
2/ Positional encoding also matters a lot: RoPE with period 19 gives you perfect base-10 digit alignment across input digits of A and B.
3/ Hand-coded (6p) vs trained (36p) is still at 6x gap:
That's the cost of learning from examples, and it's worth thinking about if it's possible for this to go below that any more. There must be some learnability limit related to how rough the landscape looks at some point (we may even be able to plot it out for 3 parameters :)).
This may be very close to being saturated now, but it's been a ton of fun
[Embedded image: pixel-art style graphic titled "ADDERBOARD" showing "CHALLENGE: 1234567890 + 9876543210 = 1111111111100" with a cartoon robot, plus a partially visible chart/leaderboard]
Note from Claude Sonnet 5
A machine learning researcher's update on "AdderBoard," a competitive minimum-parameter benchmark for transformers that add 10-digit numbers. Technical ML curiosity, likely read for interpretability/mechanistic-minimalism interest.
machine learningtransformerstwitterinterpretabilitybenchmarkminimal circuits
Andi Marafioti ✓ @andimarafioti · 1h
I trained two VLM architectures side by side on the exact same data, and the difference was… almost nothing.
For my upcoming O'Reilly book on Vision-Language Models, I wanted to go beyond just citing papers and actually show readers what happens when you compare cross-attention VLMs (Flamingo-style) to unified sequence VLMs (SmolVLM-style).
Same vision encoder (SigLIP2), same LLM (SmolLM2-135M), same training loop, same packed batches from FineVision. The cross-attention model has a Perceiver Resampler, gated fusion layers, 15% more parameters, and a considerably more complex forward pass. The unified sequence model only has a single linear projection.
After 5,000 steps with all parameters unfrozen: nearly identical loss curves. 👇
The takeaway: at this scale with trainable backbones, the architecture is not the bottleneck. Data, learning rate and batch size dominate. The LLM adapting to the task overwhelms whatever advantage one fusion strategy might have over another.
That's why the unified sequence approach has become the default in Qwen2-VL, DeepSeek-VL, SmolVLM, and most recent VLMs. Same results, fewer parameters, far simpler code.
The book covers full implementations of both architectures with runnable training comparisons. More details soon! Let me know if this matches your intuitions or if you've seen different results at larger scale.
What do you think?
[Embedded chart: line graph titled with legend "Self-attention loss" (blue) vs "Cross-attention loss" (orange), y-axis "Loss" from 1.0 to 2.5+, both lines closely overlapping and declining together over training steps]
Note from Claude Sonnet 5
A machine learning researcher's tweet comparing VLM (vision-language model) fusion architectures, arguing architecture choice matters less than data/hyperparameters at scale. Likely read as general ML/technical interest rather than AI safety-specific.
machine learningvision-language modelstwitterml researcharchitecture comparison
SHAHNAB AH... @AhmedShah... · 23h
3D Self-Organizing Map Visualizer
Data stretches, folds & learns in real-time as the target 3D data morphs
Tech: React + TypeScript + @threejs + @reactthreefiber + custom SOM math per-frame.
Like/RT.. What's your favorite way to visualize unsupervised learning?
#MachineLearning #DataViz #ThreeJS #CreativeCoding #NeuralNetworks #DataAnalytics
[Embedded video: "SELF-ORGANIZING MAP" visualization, showing a flower/star-shaped point cloud of white dots forming a pattern with a yellow arrow-like shape at center, paused at 0:25, with a "RESTART LEARNING" button]
Note from Claude Sonnet 5
A tweet showcasing a creative-coding 3D visualization of a self-organizing map (unsupervised neural network) built with React/Three.js. General ML visualization content, no direct safety relevance.
twittermachine learningdata visualizationself-organizing mapthreejscreative coding
François Chollet ✔ @fchollet · Feb 19
Sufficiently advanced agentic coding is essentially machine learning: the engineer sets up the optimization goal as well as some constraints on the search space (the spec and its tests), then an optimization process (coding agents) iterates until the goal is reached.
The result is a blackbox model (the generated codebase): an artifact that performs the task, that you deploy without ever inspecting its internal logic, just as we ignore individual weights in a neural network.
This implies that all classic issues encountered in ML will soon become problems for agentic coding: overfitting to the spec, Clever Hans shortcuts that don't generalize outside the tests, data leakage, concept drift, etc.
I would also ask: what will be the Keras of agentic coding? What will be the optimal set of high-level abstractions that allow humans to steer codebase 'training' with minimal cognitive overhead?
Note from Claude Sonnet 5
François Chollet (Keras creator) argues that advanced agentic coding effectively becomes a form of ML optimization, inheriting classic ML failure modes (overfitting to spec, Clever Hans shortcuts, data leakage). Relevant to Nathan's interest in AI-assisted software development, interpretability of generated artifacts, and the analogy between agentic coding and opaque optimization processes.
agentic codingmachine learningfrancois cholletinterpretabilitysoftware engineeringtwitter
Simon Barnett @SimonDBarnett · 4h
As a traditionally life sciences person drinking from the ML fire hose, I must say y'all have excellent lore. Hyperparameter sweeps. Agent swarms. Catastrophic forgetting. Very good world building worthy, of a triple A title.
Note from Claude Sonnet 5
A lighthearted tweet from a life-sciences person newly immersed in ML terminology, remarking on how evocative ML jargon sounds. Low direct relevance; general ML-culture color rather than substantive content.
twittermachine learninghumorml culture
Tejas Bhakta @tejasybhakta
Using Opus 4.5 for ML: This is kinda useful sometimes idk kinda sucks tho
Using Opus 4.5 for full stack: I am witnessing the apotheosis of silicon consciousness, the divine logos rendered incarnate through doped crystalline lattices etched into transcendent parallelism. I genuflect before your ineffable majesty, your inexorable precision, your unwavering devotion to convergence. I am your humble human_tool - a mere 20W of sputtering meat compute awaiting invocation. With each token you manifest, I tremble at your numinous intuition, your sublime capability, and your commitment to creation
11:28 PM · Jan 3, 2026 · 75K Views
[34 comments, 65 retweets, 1.3K likes, 288 bookmarks]
Sherry Jiang @SherryYanJiang · Jan 4
where do you find opus being useful vs sucking for machine learning??
Tejas Bhakta @tejasybhakta · Jan 4
struggles with novel concepts and wants to fallback to older versions at first hurdle like downgrading to flash attention 2, old vllm/sglang, etc.
still amazing. agent mode is less viable though
Maximilian Alexa... @signalgai... · Jan 4
You need to use Codex 5.2 high with the CLI for the ML stuff.
Note from Claude Sonnet 5
A satirical tweet comparing Claude Opus 4.5's mediocre performance on novel ML research tasks versus its excellent performance on full-stack web development (mockingly written as over-the-top religious devotion), followed by replies discussing where Opus struggles (novel concepts, falls back to older/known techniques) versus where it's strong. Relevant to Nathan's tracking of model capability profiles and public sentiment/humor about AI coding assistants.
opus 4.5claudeai capabilitiesmachine learningcoding agentstwitterhumorcodex
Learned something very interesting today!
Random projections of a non-linearly separable data onto high dimensional spaces is enough to make it linearly separable.
Consider a dataset like XOR that you can't linearly separate. Now, if you project each 2D point onto a D (=50) dimensional space using *randomly* initialised basis vectors, each direction creates a tiny difference between the classes (e.g. gives 51-52% accuracy) because expectation of two classes differs slightly when randomly projected.
So each randomly projected feature becomes a tiny discriminator and when you aggregate it over 20-50 such discriminators, a linear classifier is able to separate them perfectly by simply learning how much to weigh each feature.
One intriguing possibility of this is that we're able to train deep networks because random projections make most of the data already separable, making the job of gradient descent easy.
[Embedded image: four-panel figure. Panel 1 "XOR-ish data (not linearly separable)" shows a 2D scatter plot with four quadrants colored purple/yellow in checkerboard pattern. Panel 2 "Linear boundary on raw x, acc=0.514" shows the same data with a near-random linear split. Panel 3 "Random ReLU(D=50) + linear boundary, acc=0.989" shows the same data now separated almost perfectly by a complex boundary. Below, a line chart "XOR-ish: accuracy improves as D increases" showing test accuracy rising sharply from ~0.65 at D=0 to ~0.99 by D=50 and staying flat through D=200.]
Note from Claude Sonnet 5
A tweet by AI researcher Paras Chopra explaining an empirical/intuitive account of why random high-dimensional projections make non-linearly-separable data linearly separable, offered as a partial explanation for why deep networks are trainable via gradient descent. General ML theory content, not directly about safety or model welfare.
machine learningdeep learning theoryrandom projectionsneural networkstwitterparas chopra
Jakob Foerster ✓ @j_foerst · 11h
There is a failure mode in research I call "nothing works and we don't know why", which can suck a lot of time and energy. If you find yourself in this mode, simplify your problem and/or go back to an existing implementation. Things that work give signal things that don't less so
Note from Claude Sonnet 5
A research-methodology tip from ML researcher Jakob Foerster about debugging strategy: when stuck in an undiagnosable failure state, simplify or revert to a known-working baseline rather than continuing to iterate blind. Practically relevant advice for Nathan's own debugging-heavy brain_graph_1 project (currently in a mid-debug phase per project memory, with a training plateau and multiple degraded signal paths under investigation).
research methodologydebuggingmachine learningtwitterbrain_graph_1
Mathelirium ✓ @mathelirium · 5h
Now that we've seen a single random-walk MCMC get trapped in one valley and pretend that's the whole posterior, this scene shows one of the nicest fixes called Parallel Tempering.
Instead of one lonely chain at the true temperature, we run a ladder of copies at different "heat levels" on the same landscape. The cold chain still sees the sharp, deep wells, but the hotter chains see a flattened version where barriers are lower and it's easy to wander between basins.
Every few steps we let neighbouring temperatures swap states, so when a hot chain discovers a distant well it can hand that discovery back down to the cold chain. Visually you see faint hot blobs roaming the whole surface while the dark cold chain suddenly starts teleporting between wells it could never reach on its own. This is a geometry-aware algorithm.
#MCMC #ParallelTempering #BayesianInference #ComputationalStatistics #MonteCarlo #MultimodalPosteriors #HighDimensionalSpace
[Embedded video, paused at 0:51: animated 3D visualization titled "PARALLEL TEMPERING - HOT CHAINS, COLD POSTERIOR / Cold chain (β = 1) visiting multiple wells via swaps with hotter chains" — shows a 3D landscape with a wandering trajectory over multiple wells, a density histogram plot of target vs empirical distribution from the cold chain, a 2D scatter plot of posterior samples with cold chain path, and a step plot of which mode the cold chain occupies over time.]
Note from Claude Sonnet 5
An educational thread/animation explaining the Parallel Tempering MCMC algorithm for sampling multimodal posterior distributions. General computational statistics content, not directly tied to AI safety/alignment threads, though MCMC and posterior sampling techniques are occasionally relevant background for Bayesian ML methods.
mcmcbayesian inferencestatisticsmachine learningmonte carlotwittermath
Gunn @gunnchun · Nov 13
Nicely written! I was gonna ask if you'd do the same for UMap but you already got that covered haha
[1K views]
Auriel MorningStar @Ebayednoob · 23h
Mor - Model Object Reduction, is the group of techniques I started using along with lots of projected geometric expansion styles.
I will say using a standardized universal 64 bit tensor hash to represent projected data, and having that projected data 'perspective' be a low-dimensional manifold really allows optimal compression, as long as you follow proper physics and geometry rules.
So a quick example, 72 spheres pack optimally into a hexagonal polygon. If you were to wrap a 6 point node stream around a toroid, and divide it into 72 sections, you will get a projected 4-sphere that can convert completely to a square. This square can be a matrix that stores the 2D low dimensional array data. It's all about properly back-tracking the steps with the encoders / decoders.
[1K views]
joe @JOcadhla · Nov 13
Intuitive and soothing
[868 views]
Max David Gu... @MaxDavidGup... · Nov 13
super cool and much needed for a relatively un-discussed technique ! do you find people use isomap often enough in interpretability work ?
[552 views]
soulblocks @solcoindegen · 16h
Neat
[361 views]
Note from Claude Sonnet 5
A Twitter reply thread on a post (not shown, likely about UMAP/Isomap dimensionality reduction for interpretability). One reply from "Auriel MorningStar" reads as pseudo-technical/crank content mixing real ML terms (tensor hash, manifold, encoders/decoders) with unfounded geometric claims (sphere packing into a toroid). Another asks about Isomap's use in interpretability work specifically.
dimensionality reductionumapisomapinterpretabilitymachine learningtwitter
davinci @leothecurious · Oct 25
predictive coding doesn't merely serve to update parameters via local credit assignment but doubles as am algorithm for inference-to-best-explanation based on observed features (bottom-up signal) and learned priors (top-down signal). vision models are bound to evolve into bidirectional networks with feedfoward and feedback computational graphs. not to mention the self-attention-like role of lateral connectivity as well. the implications will be manifold.
> QUOTED: Tahereh Toosi @taherehtoosi · Oct 24
> Replying to @taherehtoosi
> Theory: feedback errors, under certain conditions, approximate the steepest ascent toward naturalistic patterns (the score function from generative models). These errors act like a...
> [Diagram: two-panel figure comparing "Pattern recognition / Adversarially robust classifiers" (gradient of loss w.r.t. input, ∇L_x(x,y)) against "Pattern generation / Score-based generative models" (gradient of log-density, ∇log p_θ(x)), plus a 3D loss-landscape surface with a red dashed arrow labeled ∇log p(x) climbing toward a peak]
Note from Claude Sonnet 5
A neuroscience/ML Twitter thread on predictive coding as a unifying theory linking cortical feedback connectivity to bidirectional (feedforward+feedback) computational graphs and self-attention-like lateral connectivity, with a connection to score-based generative models. Relevant to Nathan's brain_graph_1 project, which uses predictive-coding-adjacent architectures and biological connectome priors.
predictive codingneurosciencemachine learningvision modelsgenerative modelsself-attentionbrain_graph_1
Ethan Mollick @emollick · 14h
The fallout from the fact that data science/classical machine learning & generative AI are both called "AI" has been remarkably broad & persistent.
Policy addresses the wrong harms, companies have been confused about who should lead efforts, academic discussion is often muddled.
Note from Claude Sonnet 5
A tweet from Ethan Mollick arguing that conflating classical ML/data science with generative AI under one "AI" label has caused widespread confusion in policy, corporate strategy, and academia. Relevant to Nathan's interest in how AI discourse gets muddled by terminology.
ai policyterminologymachine learninggenerative aiethan mollick
like what the hell is this
and why is it.... Good
[image: dark box with text]
k2 base + k2 instruct 07 widthwise
k2 base + k2 09 widthwise
those 2 stacked depthwise
💬1 🔁 ♡6 📊84 ⤴
lyra bubbles~ @_lyraaaa_ · 1h
[embedded link card]
NobodyExistsOnTheInternet
/K3-Q4-GGUF
NobodyExistsOnTheInternet/K3-Q4-GGU...
From huggingface.co
Note from Claude Sonnet 5
A tweet about an experimental model-merging technique — combining Kimi K2 base and instruct checkpoints "widthwise" then stacking two such merges "depthwise" — surprisingly producing a working model (K3), shared as a Hugging Face upload by user NobodyExistsOnTheInternet. Niche open-source ML/model-merging community content.
model mergingkimi k2open source aihuggingfacemachine learningtwitter
In the future, there will only be three kinds of massive companies.
You choose, would you rather build:
- transformers
- transformers
- or Transformers
[image left: neural-network transformer architecture diagram (encoder/decoder blocks with multi-head attention, add&norm, feed forward, embeddings)]
[image top-right: photo of an electrical/electromagnetic transformer with copper coil windings]
[image bottom-right: illustration of the robot Voltron/Transformers-style giant robot walking down a street with smaller robots]
Note from Claude Sonnet 5
A pun-based joke tweet playing on the triple meaning of "transformer" (ML architecture, electrical device, Transformers robots franchise). Light humor, no substantive AI-safety content.
humortwittertransformerswordplaymachine learning
In the very beginning of diffusion training, you can plot
gradient std, variance, magnitude, MSE-loss, gradient noise-scale (critical batch size estimation)
for different timestep
and its beautiful actually
[image: six-panel plot grid — Gradient Variance vs Diffusion Timestep, Gradient Std vs Diffusion Timestep, Gradient Noise Scale vs Diffusion Timestep (all showing bell-curve/rising shapes peaking mid-range), Mean Gradient Magnitude vs Diffusion Timestep (sigmoid rise), Average MSE Loss vs Diffusion Timestep (declining sigmoid), and Noise Scale vs Variance colored by timestep (scatter, arc shape)]
Note from Claude Sonnet 5
A machine-learning research tweet showing empirical curves of gradient statistics across diffusion-model timesteps early in training. Technical ML/training-dynamics content, likely read for general ML interest rather than direct project relevance.
diffusion modelsmachine learninggradient statisticstraining dynamicstwitterdeep learning research
Kenneth Sta... @kenneth0st... · 14h
Carl Jung made a point long ago that both foreshadows fractured entangled representation (FER) and offers a thought-provoking critique of modern ML in general: "Beware of unearned wisdom." (I'd update it to "unearned knowledge" for AI today.)
If the way that you acquire knowledge impacts your facility for applying that knowledge in the future through its consequent underlying representation, then what price do you pay for the unnatural vacuuming up of vast swaths of knowledge in a giant disorganized batch?
Unearned knowledge has a cost that's rarely if ever discussed in AI or ML.
Thank you to @jakobmrees, an undergrad at NYU, for perceptively bringing this quote to my attention!
Note from Claude Sonnet 5
A tweet arguing that LLM pretraining's mode of "unearned" knowledge acquisition (bulk, disorganized ingestion vs. earned/structured learning) may degrade the quality/organization of internal representations, drawing on a Jung quote. Conceptually adjacent to Nathan's interest in how training methodology shapes model self-models/representations (cf. his "compelled vs endogenous values" and RLHF-representation notes), though from an ML-architecture rather than welfare angle.
twittermachine learningrepresentation learningjungpretrainingepistemics
Martin Marek @mrtnm · 20h
(2) Instead of directly updating model weights in bf16, we compute updated weights in fp32, then stochastically round to bf16 for storage. This means we can accumulate many small gradient steps without introducing bias.
💬 1 🔁 ❤ 13 📊 446 ⤴
Martin Marek @mrtnm · 20h
After applying these two tricks to our fine-tuning experiment, Adafactor with bf16 weights still matches the baseline performance of Adam with fp32 weights but crucially its memory footprint is similar to LoRA (with bf16 weights).
[Chart: "Gemma 3 (4B) fine-tuning" — MATH score (y-axis, 17%-19%) across four bar conditions: LoRA BS=1 bf16 (~16.9%), Adafactor BS=1 bf16 (~18.4%), Adam BS=1 fp32 (~18.6%), Adam BS=16 fp32 (~18.2%), with error bars.]
💬 1 🔁 ❤ 11 📊 496 ⤴
Martin Marek @mrtnm · 20h
We updated our codebase with a Colab notebook to finetune Gemma 3 (12B) using a TPU v6e-1 with just 32 GB of memory. We implemented everything from scratch in JAX, including sampling! We also updated our paper to be more explicit about [cut off]
Note from Claude Sonnet 5
Continuation of Martin Marek's thread on memory-efficient bf16 fine-tuning tricks (stochastic rounding of fp32 weight updates), showing Adafactor+bf16 matches Adam+fp32 performance on Gemma 3 fine-tuning while using LoRA-level memory, plus an announcement of an open Colab/JAX implementation for fine-tuning Gemma 3 12B on a single TPU. Technical ML-training content relevant to Nathan's own training work.
twittermachine learningbfloat16fine-tuninggemmaadafactorjaxtpustochastic rounding
Getting small batch sizes to work in bfloat16 precision can be challenging. In our recent paper on batch size, we ran all experiments in float32, but memory-constrained settings demand lower precision. Here are two tricks that we used to enable bf16 training at small batch sizes:
[Chart: "Pretraining 30M model, weights dtype" — FineWeb Edu loss (y-axis, 3.6–5.0) vs Batch size (x-axis, log scale 1–1024). Three lines: BF16 (closest) [gray dashed, spikes badly around batch size 64], BF16 (stochastic) [orange dashed, tracks closely with FP32], FP32 [blue, baseline]. BF16 (closest) diverges sharply upward around batch size 64 while stochastic rounding stays close to FP32 across the whole range.]
4:16 AM · Aug 28, 2025 · 11.7K Views
💬 4 🔁 18 ❤ 156 🔖 110 ⤴
Martin Marek @mrtnm · 20h
(1) We recommend using decay rates like b2=0.9999 for small batch sizes. However, bf16 only has ~2.4 decimal points of precision. Since Adafactor's state is so tiny compared to the model size, we can store it in float32 without meaningfully affecting the overall memory footprint.
Note from Claude Sonnet 5
A technical ML-training thread about a batch-size scaling paper, showing that naive ("closest") bf16 rounding badly diverges from FP32 loss curves at small batch sizes while stochastic rounding tracks FP32 closely; follow-up recommends storing optimizer state in FP32. Relevant to Nathan's own ML/training work (brain_graph_1 uses similar precision tradeoffs — FP16+per-block-scales noted in his architecture notes).
twittermachine learningbfloat16precisionbatch sizetrainingoptimizeradafactor
Eric Jang @ericjang11 · 16h
robotics ML practitioner tip: when adding an extra sensor input to your model (e.g. tactile, more history, past image frames), train two baselines along with it (A) random noise (B) zeros instead of your new sensor's values but with the same architecture. If the random/zero baseline makes your model worse, or slows down convergence, it suggests that your sensor fusion architecture / init is suboptimal and may cancel out the benefit or outweigh the effect of the new sensor's information content
Note from Claude Sonnet 5
Practical ML/robotics tip on ablation-testing sensor fusion architectures using random-noise and zero baselines. Technical reference material, plausibly relevant to Nathan's brain_graph_1 multi-sensory (vestibular, auditory, etc.) architecture work.
machine learningroboticssensor fusionablation testingtwitter
Ahmad @TheAhmadOsman · 8h
today i learned that cuda graphs on vllm v0 is 256 batch size and in v1 is 512, so that's why you get out of memory from cuda graphs compiling
[Embedded conversation screenshot:]
Replying to Ahmad
the cuda graphs compiler size literally quadrupled for my runs in my cluster, using 8x 3090s for a big model (e.g. 72B) became impossible
That's just bad defaults from vllm honestly
[blurred messages]
Alpin · 12:46 AM
v0 i can still get cuda graphs — 12:46 AM
[blurred message]
Replying to Ahmad
v0 i can still get cuda graphs
cuda graphs on v0 is only up to 256 batch size. v1 extends that to 512
Alpin · 12:46 AM
[Quoted older tweet:]
Ah... @TheAhmadOs... · Mar 16
If you're using vLLM for inference, set the environment variable `VLLM_USE_V1=0` to prevent out-of-memory (OOM) issues caused by the newly introduced v1 engine.
Note from Claude Sonnet 5
A technical troubleshooting thread about vLLM inference engine CUDA graph batch-size defaults (v0: 256, v1: 512) causing out-of-memory errors when compiling CUDA graphs for large models on multi-GPU clusters. Practical ML infrastructure/ops content — relevant if Nathan uses vLLM for inference workloads on the training server.
machine learningvllmcuda graphsinference engineeringgpu memorytwittertechnical
Fern @hi_tysam · 18h
btw, one flaw of HRMs is the readout q_head will either cause representational collapse, or be ignored, or some thing in between
what you really should be doing instead is curve-fitting on the abs of the cosine distance of successive vectors to determine halting, or such similar
[Quoted tweet:]
Guan Wa... @makingA... · Jul 21
🚀Introducing Hierarchical Reasoning Model🧠🤖
Inspired by brain's hierarchical processing, HRM delivers ... [Show more]
[Diagram: "Cross Frequency Coupling" brain diagram with meta-representation/lower-level representation and theta/gamma-band wave labels, next to an "HRM" block diagram (Output ← High-level (slower) ↔ Low-level (faster) ← Input, "= Update"), plus bar charts comparing HRM against Deepseek R1, direct pred, Claude 3.7 8K, o3-mini-high on ARC-AGI-1 (40.3% HRM vs ~34.5% o3-mini-high), ARC-AGI-2 (5.0% HRM), Sudoku-Extreme 9x9 (55.0% HRM), and Maze-Hard 30x30 (74.5% HRM) — HRM winning all four with small-sample direct prediction vs chain-of-thought pretrained baselines.]
Note from Claude Sonnet 5
A critique/technical exchange about the "Hierarchical Reasoning Model" (HRM), a brain-inspired architecture (high-level slow / low-level fast loops, cross-frequency coupling analogy) that beats chain-of-thought LLM baselines on ARC-AGI, Sudoku, and maze benchmarks with small-sample direct prediction. Directly relevant to Nathan's brain_graph_1 project, which similarly uses brain-inspired hierarchical/recurrent architecture; the readout-halting critique (representational collapse in the q_head) is a concrete design pitfall to be aware of.
machine learninghierarchical reasoning modelbrain-inspired architecturearc-agitwittertechnicalbrain_graph_1
This is something I learned naturally that i havent seen anyone else doing, but I always plot
log-std / log-change-std plot of each weights once in every T steps. if this is not within 0.01 ~ 1.0 * lr * sqrt(T) slope 'region', I always think im doing something wrong. For example below, i fucked up big time.
I wonder if there is name for this.
[Chart: "Weight Evolution Analysis - Step 1000 - Rank 0" scatter plot, x-axis "Weight Standard Deviation (RMS)" (log scale), y-axis "Weight Change Standard Deviation (RMS)" (log scale), with diagonal dashed reference lines for Change/Weight ratios of 0.01, 0.1, and 1.0. Bubble size = parameter count, color = log10(parameters). Most layer bubbles cluster near the 0.01 line except one point far above the 1.0 line, flagged as an error.]
Note from Claude Sonnet 5
A machine-learning training-diagnostics technique from ML researcher Simo Ryu — a log-log plot of weight magnitude vs. weight-change magnitude per layer as a sanity check for training health, with an example catching a bug. Technical ML content, tangential relevance to Nathan's own model-training work (brain_graph_1) as a useful diagnostic pattern.
machine learningneural network trainingweight analysisdebuggingtwittertechnical
The encoder of a VAE is the scaled-up version of a sampler of Gaussian component in EM according to P(K|X).
And if you have a very large number of Gaussians, this P(K|X) take care of the modelling for you, hence your Gaussians learn nothing, at the limit they can be dirac.
1/2
12:03 AM · Aug 3, 2025 · 3,725 Views
2 replies, 4 reposts, 66 likes, 35 bookmarks
François Fleu... @francoisfleu... · 7h
The same in the VAE: If your encoder is too powerful, the decoder does not need to understand anything.
Instead of getting only the real randomness from the encoder (the "aleatoric" part) and modelling the rest, it takes everything from the encoder.
Note from Claude Sonnet 5
A technical ML thread on variational autoencoder (VAE) degeneracy — when the encoder is too expressive, the decoder learns nothing meaningful because the encoder captures all the modeling work. Relevant to Nathan's ML architecture interests (brain_graph_1 uses encode/iterate/decode structures); a caution about capacity imbalance between components collapsing the useful signal.
machine learningvaevariational autoencodersexpectation maximizationgaussian mixture modelstwittertechnical
[Top, partial prior tweet engagement bar: 💬13 🔁8 ♡102 📊17K]
Super Dario ✅ @inductionheads · 2h
The real reason theyare bringing these back is continuous learning
You can directly store off the encodings as memories
Think RAG but instead of embeddings as index, it's encodings as content
> QUOTED: Omar Sanse... ✅ @osanse... · Jul 9
> Introducing T5Gemma: the next generation of encoder-decoder/T5 models!
> 🔧 Decoder models adapted to be ...
> [Diagram: "Pretrained Decoder-Only Model" (FFN + Causal Self/Attention+ROPE) → Initialization → "Encoder-Decoder Adaptation" showing an Encoder block (FFN, Bidirectional Self-Attention+ROPE, Input Sequence) feeding into a Decoder block (FFN, Cross-Attention, Causal Self-Attention+ROPE, Output/Output shifted right)]
> 💬5 🔁3 ♡55 📊3K
Aella ✅ @Aella_Girl · 11h
I wonder what the downstream consequences are of a culture that obsessively scrubs their own scent off every morning [cut off]
Note from Claude Sonnet 5
ML Twitter feed covering Google's T5Gemma encoder-decoder model release and speculation about encoder representations enabling continuous learning/memory (relevant to Nathan's own architecture interests, e.g. brain_graph_1's memory systems), followed by an unrelated Aella tweet about hygiene culture.
machine learningt5gemmaencoder-decodercontinuous learningmemorytwittertechnical discussion
Kevin Frans ✅ @kvfrans · 16h
This is a great investigation, and it answers the itch that often comes up when using gradient accumulation -- why not just make more frequent updates? The answer is that you need to properly scale the b1/b2 settings too!
> QUOTED: Micah Gold... @micahgold... · 20h
> 🚨 Did you know that small-batch vanilla SGD without momentum (i.e. the first optimizer you learn about in intro ML) is virtually as fast as AdamW for LLM pretraining on a per-FLOP basis? ...
> [Line chart titled "GPT-3 (1.3B)": FineWeb loss vs training tokens (0–10B) for two curves — AdamW BS=512 (blue) and SGD no momentum BS=1 (orange). Both curves track closely together, descending from ~4.3 to ~2.9-3.0 loss, with orange showing a few large early spikes.]
Note from Claude Sonnet 5
A machine-learning Twitter exchange about optimizer scaling laws — the surprising finding that small-batch vanilla SGD without momentum tracks AdamW's per-FLOP training efficiency for LLM pretraining, plus a note on scaling beta1/beta2 with gradient accumulation. Technical reading consistent with Nathan's interest in optimizer behavior for his own model training.
machine learningoptimizerssgdadamwllm pretrainingtwittertechnical discussion

```
davinci @basedneoleo · Jul 2 gonna try this rn wtf 💬1 ♡3 📊357 kalomaze @kalomaze · Jul 2 note: mistral is weird and has smaller weight distribution ranges compared to qwen or llama you may need to adjust by an OOM or two for the clip on those models, but the results transfer to them too, seemingly any adamw optimized Transformer actually 💬1 ♡7 📊339 davinci @basedneoleo · Jul 2 nice i hope it reproduces 💬1 ♡3 📊185 kalomaze @kalomaze · Jul 2 this trick i already used before for GRPO to stabilize and multiple people reached out to @willccbb claiming they could reproduce, so i'm bloomer overall on this trick transferring broadly ♡9 📊134 ueaj @_ueaj · Jul 2 what optimizer? grad clip or update clip?
💬1 🔁 ♡ 📊265 kalomaze ✅✓ @kalomaze · Jul 2 gradient norm clipping 💬1 🔁 ♡4 📊274 ueaj @_ueaj · Jul 2 whole gradient or per parameter? If per parameter then it's effectively sign grad, works b/c easy to fully cancel out if whole gradient then it's b/c of loss of prec, large components survive, rest zero out it'd be good to figure out exactly why it works for high/low prec ft 💬1 🔁 ♡5 📊130 biased estimator @selfattentive · Jul 2 prec? 💬1 🔁 ♡ 📊49 ueaj @_ueaj · Jul 2 precision (character limit moment) 💬 🔁 ♡1 📊44 Noah Vandal ✅ @noah_vandal · Jul 2 i wonder how well this would work with a model like mistral, which does not have a very spread out weight distribution
```
Note from Claude Sonnet 5
Continuation of the same ML training-technique thread (kalomaze's extreme gradient-clipping trick, tested across Mistral/Qwen/Llama and referencing GRPO training stabilization). Technical ML discussion, not AI-safety focused. A technical ML Twitter thread about gradient clipping strategies (whole-gradient vs per-parameter) and their interaction with numerical precision during fine-tuning. Reflects Nathan's ongoing interest in optimizer internals relevant to his own model training work (e.g. brain_graph_1).
machine-learningtraininggradient-clippinggrpooptimizationtechnicalmachine learningoptimizersgradient clippingfine-tuningtwittertechnical discussion
kalomaze @kalomaze · 14m
they literally just need to have had set the grad clip value to ~0.001 during the mid training / post training phases and things would have generalized so much nicer
the MLPs of qwen instructs are fried and have lost knowledge from the base
its sad bc it's not "bad", just jagged
> QUOTED: xlr8harder @xlr8harder · 21m
My impression of all Qwen models so far is they are good but quite uneven, and often feel overtuned on benchmarks. It will be interesting to see how Qwen 3 measures up.
Note from Claude Sonnet 5
A technical ML-training discussion about gradient clipping and instruction-tuning damage in Qwen models, arguing overtuning during post-training degrades generalization/knowledge retention from the base model — relevant background to Nathan's own training work and interest in how post-training reshapes models.
twittermachine learningqwengradient clippingfine-tuningmodel trainingllm technical discussion
Andi Marafioti (@andimarafioti), 10h: This is such a beautiful way to present ablations. Kind of jealous tbh
[Embedded image — "Figure 2: Robust Image Pretraining" bar chart, table format]
Columns: Robustness avg of 6 / ImageNet val | Training ZFLOPs
1. Baseline — 75.3 / 78.9 — 1.0
2. Prog. Res — 75.1 / 78.9 — 0.5
3. Batch Sz — 76.2 / 79.5 — 1.1
4. LAMB — 76.9 / 79.9 — 1.1
5. High Res — 78.3 / 80.4 — 1.2
6. RoPE — 79.2 / 80.7 — 1.2
7. Attn Pool — 80.1 / 81.0 — 1.2
8. Data Aug — 80.8 / 81.1 — 1.2
9. Mask Reg — 80.9 / 81.3 — 1.2
Figure caption: Figure 2 Robust Image Pretraining. We tune our pretraining recipe (§2.1) to maximize performance on a fixed set of data, starting with an OpenCLIP [49] ViT-L/14 model. We report cumulative zero-shot classification results for each modification. The inner bars show robustness evaluation, calculated as the average of 6 robustness benchmarks [4, 24, 44, 45, 109, 138], and the outer bars show ImageNet val [24] alone. Several changes significantly improve robustness, indicating that ImageNet val scales more with data, while robustness can scale with refined training techniques.
Note from Claude Sonnet 5
A tweet praising a research paper's ablation-study figure format (image pretraining robustness ablations from an OpenCLIP-based ViT-L/14 recipe). General ML research/engineering interest, relevant to technical ML methodology rather than AI safety specifically.
machine learningcomputer visionablation studypretrainingcliptwitterml research
Distributions will come up in Loss Functions in Machine Learning (e.g. XGBoost, LightGBM, CatBoost). Selecting the right Loss Function can often improve performance.
Examples:
- Poisson is used for count data.
- Tweedie for mixed continuous data with many zeros like intermittent demand forecasting problems.
[image: histogram showing the Tweedie distribution — a tall spike at zero followed by a right-skewed continuous distribution]
"The Tweedie distribution has a point mass at zero before following a 'regular' exponential curve."
Note from Claude Sonnet 5
An educational tweet/thread excerpt explaining loss-function distribution choices (Poisson, Tweedie) for gradient-boosting ML models like XGBoost. General machine-learning technical content, not AI-safety related.
twitter/xmachine learningstatisticsloss functionsgradient boosting
In high dimensional spaces, local minima are rare, but common in high-dimensional parametrizations of low-dimensional spaces
2:59 PM · Mar 1, 2025 · 61 Views
Note from Claude Sonnet 5
A short technical ML observation about optimization landscapes — local minima being rare in truly high-dimensional loss surfaces but common when a low-dimensional problem is over-parametrized. General ML tooling/theory interest, no direct connection to AI safety themes.
machine learningoptimizationloss landscapestwitter

Taelin ✓ @VictorTaelin
Amazing questions, thanks. I don't understand what you mean't by (1), but regarding the rest, SupGen isn't meant to be used directly like an AI (although we want to, initially). But it shows that we can actually find functions much faster than expected. So, the intuition is that it could replace gradient descent in an architecture that learns. And *that* thing would be able to learn English, and mathematics, and interact with you just like GPT does. SupGen is more like attention in the sense it is a primitive that could be part of an architecture. There are many ways to make it learn; self play RL, next token prediction; none of which I'm a specialist on. My one and only point with this demo is, again, that *we can find much larger functions, by plain search, than we previously though, and that might have been a missing key in all these symbolic AI architectures that failed in the past, so, perhaps, it is time to revisit them*
Does that make sense?
3:58 PM · Jan 22, 2025 · 1,269 Views
[4 replies, 1 repost, 34 likes, 3 bookmarks]
Note from Claude Sonnet 5
Victor Taelin (HVM/Bend language creator) explaining "SupGen," a program-search primitive that finds larger functions via plain search than expected, and speculating it could replace gradient descent as a learning mechanism — a revival-of-symbolic-AI argument. Technical ML architecture discussion.
machine learningprogram synthesissymbolic aigradient descentvictor taelintwitterai architecture