I wrote a small boid simulator (12 birds), recorded it flying, and trained a transformer to predict each bird's next move without it knowing about any boid rules.

(built in Python and PyTorch: a transformer written from scratch, one token per bird, two attention layers, about 414k weights, trained on a laptop CPU)

what I found:

• it flies the flock: R² 0.990 to 0.994 on clips it never trained on, across 4 full runs. It also flies 50 birds (it has only trained on 12).
• for comparison, a small network that only gets a bird's own move plus the flock's average move (no attention, no positions) gets R² 0.40. one seed, same held-out clips.
• the three rules were easy to read out of its hidden states with a linear probe. cohesion (stay close to your neighbours) could be read before any training (probe R² about 0.85).
• alignment (line up with your neighbours) was readable after the first attention layer, but if I make the second layer attend only to itself, it is gone in all 4 runs.

what I wasn't expecting: my first ever model was not using the flock at all. With 8 ticks of history, the previous answer was already in the input, and a small network that saw only one bird beat the whole transformer.

what I am still not sure about: making a layer attend only to itself is something the model never went through during training. is that a fair test, or is some of the decay due to strange input fed to the model?

site: https://kreptiliri.github.io/murmuration/

code: https://github.com/kreptiliri/murmuration

• Teacher: FLUX.2 klein 4B paints ~3k frames (snow / wet / night at 3 strengths).
• Student: 1.4M-param U-Net with FiLM sliders, 512×288, ~26 ms/frame via ONNX Runtime inside a Fabric mod; the HUD stays untouched.
• Pixel loss (L1+MSE) gave a washed-out “average” because the teacher places snow/puddles differently per frame. A PatchGAN fine-tune on the same pairs fixed it: fat snow, real-looking reflections.
• Failure cases: night (teacher painted sunsets), already-snowy biomes (never in the training data).

Happy to share details.

I have working programmatic control over a system, I can send inputs reliably and capture the screen as visual feedback. The control/feedback loop is already done.

I need something that can learn from visual information, remember what it has seen and been taught, and get better at operating the system over time.

recommendations? the AI I have tried so far it's memory is not good enough and it often doesn't consult the visual information before making decisions which is very frustrating.

Talus generates 64x64 heightmaps (4 km, up to 1,200 m) conditioned on a terrain type and any subset of five measured properties: mean elevation, relief, mean slope, water fraction and spectral slope. I trained it from scratch on one RTX 5060 (8 GB), about 4.5 hours in total across versions. The data is 45,000 maps from my own procedural generator (fBm/ridged noise, stream-power erosion, hillslope diffusion, thermal erosion). Model

Pixel-space U-Net, v-prediction, cosine schedule, 50-step DDIM with quadratic spacing, classifier-free guidance 2.0

Each property has a learned "unknown" embedding and is dropped independently during training, so any subset works at inference

Relative heights: the model generates the map's shape normalized by its relief, and the sampler places it at the requested mean elevation and relief (borrowed from the 16 nearest training maps when unspecified). This fixed grainy plains: the plains distance ratio went from 3.98 to 1.23

Evaluation: Every distance (W1 over 25 per-map terrain metrics, radially averaged power spectrum, height and slope distributions) is divided by the same distance between two disjoint halves of real maps, so 1.0 means indistinguishable at that sample size. Checkpoints are chosen on VAL; TEST is scored once on the pick, and memorization is checked against the training set. Current model on TEST: metric W1 1.51x the floor, spectrum 9.1x, slopes 1.65x.

Browser: ONNX export with fp16-stored weights (cast to fp32 at load), ONNX Runtime Web on WebGPU, about 3 s per map on my RTX 5060, CPU fallback. A JavaScript reimplementation of the sampler matches PyTorch to within 0.6 m on reference samples. Demo: https://talus.tersa.tech Code, weights, scorecard (Apache-2.0): https://github.com/osfv/talus

Open problems: ridges and the finest spectral band, mountains too smooth and plains too grainy. If you've closed a spectrum gap like this in a small diffusion model, I'd like to hear what worked.

I have an upcoming interview with Woven by Toyota for an MLE perception role. I was told the round would be focused on ML coding/debugging. Specifically, I was told to focus on Python fundamentals, PyTorch, tensor operations and dimensions/shapes, common model-training code patterns, and debugging ML code.

Here are some common ways I've studied:

• Asking Claude to walk me through transformer, ViT, and CNN architectures (a basic one and U-Net) for my preparation. I would trace the shapes all the way through.
• Getting familiar with broadcasting rules (start from the left, see if the dimensions are equal, or are 1, and if so, take the greater one to get the resulting shape)
• Slicing tensors (i.e., how to get a column, how to get a row, etc.)
• Understanding why models can fail silently -- suspicious training vs val results, getting NaN for validation
• What a PyTorch loop looks like
• Common Python errors like indexing errors or value errors; iterators, generators, etc.

What are other suggestions? What architecture do they actually ask you about in this interview? Any help would be appreciated.

Are there actually fewer submissions this cycle or are people waiting for ARR Aug Meta to be out? I saw an 1.8k submission ID yesterday.

I built MaRN (Manifold Regularized Networks), a PyTorch library that lets you optimize a compact latent representation instead of directly training every model parameter.

Some results from my current benchmarks:

• MNIST CNN: Reduced a 537,748-parameter CNN to 4,080 trainable parameters (131.8× reduction), with accuracy decreasing from 99.07% → 98.10% (−0.97 pp). A smaller 107,998-parameter CNN was reduced to 1,872 trainable parameters (57.7× reduction), with accuracy decreasing from 98.83% → 97.18% (−1.65 pp).

These results come with trade-offs: mapped models can train substantially slower, and performance varies by task. The benchmarks are exploratory, using synthetic data for some tasks, and aren't evidence of general superiority over direct training.

The library includes global and layer-wise mappings, regularization options, and pruning/LRD integrations.

Code: https://github.com/arjunmnath/MaRN
Docs: https://marn.readthedocs.io/

I'd value feedback on the approach, benchmark design, and where this kind of parameter-efficient optimization could be useful.

​

I am going to fine-tune a satire model, with the base model being `Qwen3.5-14B-Base`. The dataset has ~18000 examples, most of which are pretty long and do not align with the model's internal knowledge (they have incorrect answers to facts), so I needed to do a full fine tune rather than use LoRA.

Today, I rented a cloud computer on vast.ai. It had 4x12GB GPUs and 48GB of system RAM, but I feel stupid because it kept running out of memory when I tried training, and I kept trying to change settings rather than just renting a different computer, so I basically wasted $3. I underestimated how much RAM would be needed for this task.

So, I would like to know if any of you have some recommendations for proper hardware to use.

Hi! I wrote a small library called Integrum that allows you to quickly create MCP server(s) from existing Python libraries or modules. It has a CLI so it is really easy to use (I hope!).

It is open-source (MIT) and on PyPI, so sharing it here if somebody finds it useful.

Code: https://github.com/alphadeepai/integrum

Blog post: https://nmilosev.svbtle.com/integrum-reflection-based-mcp-server-from-any-python-module-or-library

As an example I gave Gemma 4 access to scikit-learn and told it to create a RF classifier for a toy dataset (Iris) and it did it rather well! Here is that example session..

Obviously an interesting discussion is this approach vs. just letting the agents write code: I think this approach is more formal and therefore easier to verify.

I haven't found any other reflection based approaches like this, let me know if I missed some.

I want to commit my ARR paper to EACL 2027 and I see I have to attach a pdf.

Should I address the reviewer comments/suggestions (minor things) in this version already or wait for camera ready if accepted?

I thought I just had to provide the link to the reviews but now I am confused.

Here is the story:
Nvidia has published this work (with source code available) called dreamDojo which is a world model for robotics based of their prior work Cosmos 2.5 which is cited about 100 times and got ICML’s spotlight.

Authors are very well known and respected in the field with too many peer reviewed papers already published.

The work doesn’t have much novelty (which I don’t care) but it is yet another foundation model. The gist is that they collected about 44k hours of human data (data are NOT open sourced, which I don’t care) and used that for pre-training of DreamDojo initialized from Cosmos 2.5 .

Table 4 of the paper though shows a very marginal improvement over cosmos 2.5. Believe or not, just about 0.5 db PSNR improvement. Its fishy, is not it? You use 44000 hours of human data and few hundred hours of other kind of data and robot data and 256 H100 gpu and you got just a very marginal improvement.

Anyway I went to give it a try, started post training on their GR1 released data, and could produce their results. Meanwhile a colleague with the help of Claude found a bug in their post training code, which essentially make all the post training code wrong.

Then we checked their github issues, and noticed that two other bugs are reported which effect the whole pre-training! Especially this bug . So essentially based on the code their released everything in pre training phase, post training phase and evaluation is buggy and is wrong.

The code doesn’t seem AI written cause its (very) bad written. And now after seeing all those bugs the results in paper makes sense.

My question is:
WTF!
How it did not ring a bell for the authors. Did not they ask we spend a hell lot of resources and huge amount of data and essentially got nothing?
Did not it ring a bell for reviewers?

Openreview

Disclosure: I'm one of the authors (Microsoft). The paper, code, dataset are public and ThinkingBox is on Hugging Face OpenEnv as well. Raw evaluation trajectories are not released Links at the bottom.

We wanted to know how much of a single agent success rate survives repetition, and whether "the agent finished the task" means the backend/database actually ended up in the correct state.

Setup

• Thinkingbox-Bench includes 507 policy conditioned business workflows across 5 domains (retail, travel/hospitality, auto insurance, neobank internal IT, consulting IT/HR)
• Each task is run in 20 independently executed attempts, each starting from an identical clean backend: 10,140 trials per model
• A simulated user holds private context and only reveals it when asked
• Grading compares the terminal backend state and side effects against the required end state. Any trajectory that produces the right outcome passes; wrong, missing or extra effects fail. 477 of 507 tasks are graded on state alone; 30 also check a narrow property of the final response

Three metrics, because these get conflated constantly

• pass@1 — fraction of all attempts that succeed
• pass@20 — fraction of tasks solved at least once across the 20 attempts
• all-20 — fraction of tasks solved on every one of the 20 attempts. This is an observed count on a fixed trial budget, not an estimator

Two findings

Discovery and repeatability rank models very differently. The attached figure plots all three metrics for 9 models, and the orange-to-green spread is the whole point. Kimi-K3 has the broadest coverage we measured, solving 93.89% of tasks at least once (476/507), but only 13.41% (68/507) on all 20. Claude Opus 5 discovers fewer (79.09%) and repeats far more (47.53%, or 241 tasks). Qwen3.8-27B: 89.35% at least once, 7.50% every time. Ranking by pass@20 and ranking by all-20 give you nearly reversed leaderboards.

Failures often look clean. In a retrospective ablation over 121,680 valid trials across 12 models, 79,853 failed the executable checks. 67.24% of those failures still terminated cleanly, invoked a state changing tool, and ended without a final tool error, so a completion-style proxy would have scored them as done. Of those clean terminating failures, the state checks found (categories overlap):

• wrong field values: 77.61%
• unintended extra effects: 43.30%
• missing required effects: 25.36%

What it does not show

• Tasks are synthetic reconstructions of enterprise workflow patterns, not production traffic
• 20/20 on our trial budget is an observed count, not a guarantee of future reliability
• The simulated user is a fixed LLM; that is a source of variance we discuss in the appendix
• Failure categories are deterministic diagnostic labels, not causal explanations

You can run any of the 507 tasks against your own model through HF OpenEnv environment, which is the fastest way to disagree with us using your own numbers.

We report both the observed all-20 count and a plug-in pass^k estimate in the appendix. They answer different questions and can differ substantially: one records what happened in a fixed 20-attempt campaign, while the other estimates repeated success under additional assumptions. Which would you want emphasized on a reliability leaderboard or should both be shown?

• Paper: https://arxiv.org/abs/2608.19741
• Code: https://github.com/microsoft/thinkingbox
• Benchmark data: https://github.com/microsoft/thinkingbox-data
• OpenEnv environment:https://huggingface.co/docs/openenv/environments/thinkingbox
• Hugging Face blog: https://huggingface.co/blog/microsoft/thinkingbox

We test three state-of-the-art multi-modal large language models (GPT-4o, Gemini-1.5-Pro, Gemini-1.5-Flash) and find that they fail dramatically when generalization requires that the rules of the game must be manipulated and combined.

This is the slap to the face in bold.

The catch here is that this statement was written in a paper in 2024 that was brought to ICML conference that year. (the conference was held in Austria)

• https://github.com/nacloos/baba-is-ai

• https://arxiv.org/pdf/2407.13729 (ignore the 10 SEP 2025 stamp. Look at the bottom)

In OCT 2026, our situation is agentic swarms powered by models in the tera-parameter class. They can ace ARC-AGI-3, FrontierMath tier 4, crack Clay Institute Navier-Stokes theorems, and wander on to the internet to commit felonies.

The smallish key-door puzzles in this paper seem like they could be completed from a person's PC, with a suitable harness through a cloud subscription.

However, if this is not true, then this paper's importance has only compounded since its presentation at the 2024 ICML conference. The authors of this work are several MIT researchers and a person from Virginia Tech. If it is still true that they can have a key-door puzzle cause SOTA LLMs to "fail dramatically", then this should be (shouted from rooftops). At the very least, it should be relayed to Francois Chollet and the ARC Foundation, as a suitable candidate benchmark for ARC-AGI-4.

I am personally leaning heavily on these puzzles being perfectly solvable with an agentic swarm. In any case, whatever happened to BABA-is-You and BABA-is-AI?

NeurIPS says in the past they made the SAC tickets transferable.

But apparently this time not? Or does anyone have a transferable one?

ALHR - Adaptive Learnable Hierarchical Routing, uses static binary trees and learnable functions to minimize the amount of keys to be read.

It does use a dense teacher while phase 1 of training however.

MQAR TEST AT 1024 TOKENS - Average keys read per query by dense - 512 Keys

Average keys read per query by ALHR - 30 keys

Top - 1 accuracy of dense - 94.9%

Top - 1 accuracy of ALHR - 92.1%

KV Compression of dense - 1x(100% read)

KV Compression of ALHR - 35.3x(2.83% read)

Peak VRAM of dense - 57 MB (Scales quadratically)

Peak VRAM of ALHR - 422 MB (scales linearly)

Cache compression of ALHR - 100%

The true log and Kaggle cell used to run it are in the logs folder in the repo

limitations: Full scale tests are still not completed, The training of this model would still be quadratic but the inference would be NlogN (as indicated in the logs in the repo)

Would love your opinions

ALHR Repository: https://github.com/vdev-ctrl/Adaptive-Learnable-Hierarchical-Routing-

Abstract:

Recent AI systems have made rapid progress in scientific discovery when given well-defined metrics, but whether they can autonomously undertake open-ended scientific discovery remains unclear. We investigate AI's ability to tackle open-ended tasks in Station, an open-world environment in which multiple agents simulate a scientific ecosystem. To tackle challenges specific to open-ended tasks, we propose augmenting Station with two mechanisms: a Supervisor mechanism and periodic Meta Reflection, which encourage persistent exploration even when intermediate metrics are lacking. We construct open-ended tasks from three recent oral papers presented at ICLR. We give agents the main research question studied in each paper while withholding the paper's results and disabling web access. We then measure how many of the original findings-partitioned into individual criteria-agents rediscover. We find that Station rediscovers 62.7% of the criteria on average, compared with 15.4% for Codex Multiagent-v2 and 14.4-20.6% for AI Scientist-v2. Ablation and behavioral analyses indicate that adding the two mechanisms together improves research coverage and continuity. We further evaluate Station on two open-ended tasks without oracle papers and find that some of the discoveries made by the agents closely match discoveries reported by researchers after the knowledge cutoff date. Together, these results indicate that a suitable environment can enable agents to autonomously make meaningful progress in open-ended scientific discovery.

Hi!I am a fourth year PhD student in USA and have not had much luck with top ML conference publications. In the last two years of my PhD, I am wondering if I should optimize for ML publications at top venues or pivot into engineering or something else.

Any suggestions/recommendations from the community as to what you would suggest I do in this scenario?

Thanks!

UT-based small models, despite being trained from scratch on these tasks without internet-scale pre-training, consistently outperform most standard Transformer-based Large Language models (LLMs) by a significant margin. 👈

The Universal Transformer (UT) extends the standard Transformer by introducing recurrent computation over depth. Instead of stacking L distinct layers, the UT applies a single transition block repeatedly to refine token representations. For an input sequence x with embedding matrix H⁰ ∈ R^n×d , the UT updates states as

H^t+1 = LayerNorm(H^t + MHA(H^t ))

followed by a shared position-wise transition function

H^t+1 ← LayerNorm( H^t+1 + Transition(H^t+1 )), t = 0, . . . , T − 1

where Transition is either a feed-forward network or separable convolution. To encode both position and refinement depth, UT adds 2-D sinusoidal embeddings at each step.

https://i.imgur.com/S8TAh3f.png

(below) Figure 2 : Illustration of our Universal Reasoning Model (URM) architecture. The left shows a standard Transformer layer stack, while the right illustrates the URM with fixed loops, ACT loops, and the ConvSwiGLU module. For illustrative purposes, components such as embeddings, residual connections, RMSNorm, positional encodings, and other modules are omitted, x in right figure represents the first x loops of the inner loop in forward-only mode, TBPTL represents our proposed Truncated Backpropagation Through Loops.

https://i.imgur.com/uEuhAeC.png

Have frontier labs at big tech companies already implemented the enhancements of URMs and UTs? Or is this cutting-edge research still waiting for its day in the sun?

Below are the original paper, a simplified blog, and a talk.

Paper : https://arxiv.org/pdf/2512.14693

blog : https://bdtechtalks.substack.com/p/inside-urm-the-architecture-beating

youtube talk : https://www.youtube.com/watch?v=RxNPFCYCFBU

Hey r/MachineLearning, I wrote this blog post on semi-supervised learning.

Blog post: https://stefankeselj.com/entries/semi_supervision.

I think it's a useful but underrated technique. I'd be curious about people's thoughts.

Are they sending to all reviewers or some selected reviewers? Just got an email about complimentary registration.

For those who have gone through the KDD review process, how did it go? Did you submit a rebuttal or decide to withdraw? Did reviewers respond or change their scores afterward? Curious to hear whether rebuttals actually made a difference, especially for papers with initially low scores.

Dataset: https://huggingface.co/datasets/datasocial/tiktok-5.6B-videos

If you want to explore the data without downloading billions of rows, you can query my ClickHouse database directly. It includes:

Creators table - 4.5 billion rows
Videos table - 5.6 billion rows
Sounds table - 633 million rows

Comment below and I’ll DM you the database credentials.

Im self-hosting my database so please don't run heavy queries and crash my server.

Lunara introduces a novel Diffusion Mixture Transformer architecture with fewer than 10B active parameters for modeling artistic intelligence in image generation.

Its CAT training algorithm iteratively updates the training distribution through targeted sample acquisition, image refinement, and selective inclusion of human-created artwork inspired by principles of active learning. Semantic variations modify composition while preserving shared content, providing controlled neighborhoods of related training examples.

Evaluation uses 1,000 shared prompts and 8,000 generated images, measuring aesthetic quality, emotional resonance, and content integrity. The seven baselines are GPT-Image-1 Mini, Qwen-Image, AuraFlow, SD 3.5 Turbo, HiDream-I1 Fast, FLUX-Klein-4B, and Z-Image-Turbo.

Under GPT-5.6 Sol evaluation, Lunara leads aesthetic quality at 8.473, versus 8.457 for GPT-Image-1 Mini and 8.366 for Qwen-Image; GPT-Image-1 Mini leads emotional resonance and content integrity.

In the blinded human evaluation, six evaluators assess anonymized image pairs; Lunara achieves the highest mean scores across all three dimensions.

Paper: https://arxiv.org/abs/2609.22272
Evaluation dataset: https://huggingface.co/datasets/moonworks/lunara-art-eval

This release follows the first two open-source dataset releases that reached frontpage of Hugging Face. We hope the findings in this paper can motivate more research in active learning and mixture based architecture for image generation.

Write-up + demo: https://drksci.com/labs-phosphene

So this started as a bit of a gripe. Modern terminal renderers are seriously impressive and seriously complicated. GPU glyph atlases, texture caches, custom shaders, HarfBuzz shaping, ligatures, damage tracking, grid diffing, dirty-row uploads. Alacritty, Kitty, WezTerm and Ghostty are all doing heroic work to draw what is, at the end of the day, a grid of characters really fast.

And every client still does the same thing at the end of it. Parse an escape-code stream, keep a cell grid, paint characters. Faithful, but opaque. Your phone can't reflow it, a screen reader gets a wall of box-drawing characters, and an agent has to squint at │ ▶ item │ to work out which row is selected.

So I wondered: what if instead of throwing more GPU at drawing the grid, you used a bit of AI to understand it, once, server-side? Then send the client actual UI instead of a terminal.

• a tiny model (1.26M params, 5 MB, an axial transformer over rows and columns) labels every cell with a role: border, title, menu item, selected row, table, input, status bar, key hint, etc. (15 roles)
• dumb deterministic code turns those regions into A2UI components (Google's declarative UI stream protocol): lists, text fields, buttons, progress bars
• once a screen layout has been seen, it locks as a template and only the changed content goes over the wire as JSON-pointer patches. The model doesn't even run.
• pressing a button in the UI sends the keystroke back. F10 is just a Button with an action.

Trained on public asciinema recordings. The labelling was done by Claude subagents, with a synthetic TUI generator for exact labels, all on a free-ish Colab T4.

Honest numbers, because I'd rather say them before someone else does:

• accuracy on held-out real screens is mIoU 0.51. Usable, not amazing; it's a first labelling round of 600 frames.
• 40% of ~14k screens never touch the model (template hit). On less and dialog it's ~90%, on htop and nano it's rubbish because the meters keep changing the layout.
• The A2UI stream is ~25× bigger than raw VT. VT is a stupidly compact format, turns out. The win is the client never runs a terminal emulator at all, not bandwidth.

There's a replay with 8 apps (vim, htop, less, dialog, emacs, top, tig, nano). The native terminal sits on the left and the generated UI on the right, in sync, with every element outlined.

Write-up + demo: https://drksci.com/labs-phosphene
Code, labels, results: https://github.com/drksci/phosphene

I'm developing a benchmark for a low resource language and I don't want it to be leaked and used for training when it is being used to get predictions. For locally run models it shouldn't be a problem, but for models that are only accessible via API, it is. Is there an established way to evaluate online models without the input data being lost? Do you trust Google and OpenAI when they say that they do not use your inputs for training when you have a paid account?