Memory-first design achieves more with fewer parameters and faster inference.

In "Structure Over Scale," we explore the innovative Seed architecture, highlighting its ability to identify smaller, efficient models that maintain competitive performance across various datasets.

March 31, 20263 min readMachine Learning

Memory-first design achieves more with fewer parameters and faster inference. — [R] Structure Over Scale: Memory-First Reasoning and Depth-Pruned Efficiency in Magnus and Seed Architecture Auto-Discovery

**Our Take: Structure Over Scale Is the Practical Insight That Deserves Attention**

The clearest finding in this experiment is that model architecture matters more than model size. On Banking77, the Dynamic Seed distilled model achieved 93.53% accuracy with just 12,648 parameters, that's five times smaller than the logistic TF-IDF baseline at 64,940 parameters, and it actually outperformed it by over a full percentage point. This isn't a marginal efficiency gain; it's a direct demonstration that smarter structural search can replace brute-force scaling. For anyone building production systems where inference speed and memory footprint are real constraints, this shifts the conversation from "how big can we make it" to "how efficient can we make it."

The results across the other datasets reinforce the pattern, though they also show the limits. On MASSIVE-20, the static seed model at 52,052 parameters beat both the logistic baseline and the dynamic seeds, proving that structure alone isn't a magic wand. But even there, the dynamic seed distilled model used 11,851 parameters, roughly six times fewer than the logistic model, while staying within one percentage point on accuracy. On CLINC150 and HWU64, the dynamic seeds didn't win on accuracy, but they delivered four-to-five-times smaller models with competitive scores. The tradeoff is clear: if your priority is deploying reliable classification at low cost, these architectures give you a real option that doesn't force you to sacrifice quality.

What makes this work worth watching is the practical payoff. Inference on the Banking77 dynamic seed model took 0.232 milliseconds, compared to 0.473 milliseconds for the logistic baseline, roughly half the time. The static seed model, despite being larger, was faster at 0.264 milliseconds, but it also required 94.56 million training steps versus the dynamic seed's 70.46 million. When you factor in total compute, parameter count, and inference speed, the dynamic approach creates a better efficiency frontier. It's not the right choice for every dataset, audio failed outright due to weak representation, but for text classification tasks, this method offers a concrete path to smaller, faster, and occasionally more accurate models. That's a signal worth acting on, not a headline to file away.

From Machine Learning

TL;DR: I built a system that finds much smaller models that stay competitive — and sometimes outperform larger baselines.
Built a small experiment around Seed (architecture discovery).

Read the original at Machine Learning

Briefing

Source: Machine Learning
Published: March 31, 2026

Exploring how far AI-driven log analysis can go with a 0.9975 F1 score
Experiment #324 ended well. ;) This time I built a small project around log anomaly detection. In about two days, I went from roughly 60% effectiveness in the first runs to a final F1 score of 0.9975 on the HDFS benchmark. Under my current preprocessing and evaluation setup, LogAI reaches F1=0.9975, which is slightly above the 0.996 HDFS result reported for LogRobust in a recent comparative study. What that means in practice: on 3,368 anomalous sessions in the test set, it missed about 9 (recall = 0.9973) on roughly 112k normal sessions, it raised only about 3 false alarms (precision = 0.9976) What I find especially interesting is that this is probably the first log anomaly detection model built on top of Mamba-3 / SSM, which was only published a few weeks ago. The model is small: 4.9M parameters trains in about 36 minutes on an RTX 4090 needs about 1 GB of GPU memory inference is below 2 ms on a single consumer GPU, so over 500 log events/sec For comparison, my previous approach took around 20 hours to train. The dataset here is the classic HDFS benchmark from LogHub / Zenodo, based on Amazon EC2 logs: 11M+ raw log lines 575,061 sessions 16,838 anomalous sessions (2.9%) This benchmark has been used in a lot of papers since 2017, so it’s a useful place to test ideas. The part that surprised me most was not just the score, but what actually made the difference. I started with a fairly standard NLP-style approach: BPE tokenizer relatively large model, around 40M parameters That got me something like 0.61–0.74 F1, depending on the run. It looked reasonable at first, but I kept hitting a wall. Hyperparameter tuning helped a bit, but not enough. The breakthrough came when I stopped treating logs like natural language. Instead of splitting lines into subword tokens, I switched to template-based tokenization: one log template = one token representing an event type. So instead of feeding the model something like text, I feed it sequences like this: [5, 3, 7, 5, 5, 3, 12, 12, 5, ...] Where for example: "Receiving block blk_123 from 10.0.0.1" - Template #5 "PacketResponder 1 terminating" - Template #3 "Unexpected error deleting block blk_456" - Template #12 That one change did a lot at once: vocabulary dropped from about 8000 to around 50 model size shrank by roughly 10x training went from hours to minutes and, most importantly, the overfitting problem mostly disappeared The second important change was matching the classifier head to the architecture. Mamba is causal, so the last token carries a compressed summary of the sequence context. Once I respected that in the pooling/classification setup, the model started behaving the way I had hoped. The training pipeline was simple: Pretrain (next-token prediction): the model only sees normal logs and learns what “normal” looks like Finetune (classification): the model sees labeled normal/anomalous sessions Test: the model gets unseen sessions and predicts normal vs anomaly Data split was 70% train / 10% val / 20% test, so the reported F1 is on sessions the model did not see during training. Another useful thing is that the output is not just binary. The model gives a continuous anomaly score from 0 to 1. So in production this could be used with multiple thresholds, for example: > 0.7 = warning > 0.95 = critical Or with an adaptive threshold that tracks the baseline noise level of a specific system. A broader lesson for me: skills and workflows I developed while playing with AI models for chess transfer surprisingly well to other domains. That’s not exactly new - a lot of AI labs started with games, and many still do - but it’s satisfying to see it work in practice. Also, I definitely did not get here alone. This is a combination of: reading a lot of papers running automated experiment loops challenging AI assistants instead of trusting them blindly and then doing my own interpretation and tuning Very rough split: 50% reading papers and extracting ideas 30% automated hyperparameter / experiment loops 20% manual tuning and changes based on what I learned Now I’ll probably build a dashboard and try this on my own Astrography / Astropolis production logs. Or I may push it further first on BGL, Thunderbird, or Spirit. Honestly, I still find it pretty wild how much can now be done on a gaming PC if you combine decent hardware, public research, and newer architectures quickly enough. Curious what people here think: does this direction look genuinely promising to you? has anyone else tried SSMs / Mamba for log modeling? and which benchmark would you hit next: BGL, Thunderbird, or Spirit? If there’s interest, I can also share more about the preprocessing, training loop, and the mistakes that got me stuck at 60-70% before it finally clicked. P.S. I also tested its effectiveness and reproducibility across different seeds. On most of them, it actually performed slightly better than before. https://preview.redd.it/3hrr4prgbzsg1.png?width=1794&format=png&auto=webp&s=d50ff21226e9aa97c2c0bbefed77be5dd8389cb8 submitted by /u/Adam_Jesion [link] [comments]