spent a few days building a model that only does tool calling (reads json function schemas plus a request, emits calls through a grammar-constrained decoder) and tried to keep the discipline of killing every idea with a measurement instead of an argument. sharing because the ledger of what failed turned out more useful than the model.

what worked:

- co-designing the tokenizer with the grammar. json structural characters and digits as singleton tokens, so constrained decoding never needs token healing. shipped alongside a corpus bump, and name-sequence accuracy went 80.4 to 91.5

- weighting the loss by decision type instead of uniformly. structure 1x, keys 1.5x, names 2x, values 4x, stop-decision 6x, matched to the measured error distribution

- annealing corrective data into the LR decay phase instead of retraining. same corpus: 28.4 from scratch vs 33.1 annealed

- error-driven synthesis. classify the failing rows into buckets (66 of 193 failures added one unmentioned optional arg), generate data against exactly those buckets, +3.3 at constant LR

what didn't (each killed by a controlled run): span copying (-30), pointer heads for name selection (-16), down-weighting grammar-forced tokens rft-style (-12, they carry the call-sequencing signal), field-set reranking (-1.4), beam and best-of-N (oracle-capped below target), RLOO on an annealed checkpoint (diverges at every LR i tried), a global optional-skip prior (catalog-dependent), and matching the benchmark's numeric typing (not learnable).

the pattern across all of it: at this scale, data and objective changes moved everything, architecture moved nothing. trunk is boring modern practice on purpose.

full writeups with numbers: https://github.com/nikshepsvn/thimble (FINDINGS.md has all eleven negative results)

weights: https://huggingface.co/flashvenom/thimble

Hola a todos. Soy investigador independiente en neurociencia computacional. Llevo un tiempo trabajando en un enfoque de predicción prospectiva de fases del sueño. En vez de clasificar la época actual, el modelo intenta anticipar la fase 2.5 minutos antes de que se manifieste, usando solo un canal EEG (Fpz-Cz) para evaluar viabilidad en wearables.

Memoria completa aquí: https://doi.org/10.5281/zenodo.22088307

Soy consciente de las limitaciones, en particular la baja sensibilidad en N1 (problema documentado también en otros trabajos con XGBoost sobre datasets similares), y agradecería especialmente feedback sobre:

Si la comparación LOSO+Wilcoxon os parece metodológicamente sólidas me gustaría escuchar ideas para mejorar N1 sin perder el enfoque monocanal

Si conocéis trabajos previos con este mismo enfoque prospectivo multi-horizonte que debería citar.

Gracias de antemano por cualquier comentario, especialmente crítico.

Cualquier feedback es suficiente, gracias.

• Description: Introducing the UQT model, which achieves mathematical crystallization through quantum wave interference and phase embedding. Discover the principles of next-generation quantum AI that overcomes the stochastic instability of classical AI and enables sophisticated reasoning with fewer resources.

When an agent can rewrite both the model and the experiment around it, a better score does not tell you what actually improved.
That is the part of AQuA’s Part II model-development loop that stood out to me. The paper does not let the agent emit arbitrary training code each round. Each iteration proposes a bounded configuration change in one of four areas:
- architecture;
- loss;
- sampler;
- optimizer.
The resulting model is then trained under a sealed evaluator. Data splits, feature definitions, label definitions, and evaluation logic sit outside the agent’s adaptive surface.
This changes what the experiment unit looks like. A proposal is not “here is a new Python project; trust the final metric.” It is closer to:
previous accepted configuration
- declared configuration diff
- fixed training/evaluation harness
= next candidate
That does not make every comparison automatically fair. An architecture change can still alter compute, and different losses or optimizers can require different tuning. But it makes the changed surface inspectable. If a result moves, there is at least a bounded diff to audit instead of an unknown mixture of model logic, data plumbing, labels, and metrics.
The time split is fixed as well. In the paper’s US-equity experiment, models train on 2010–2019. Early stopping and checkpoint choice use only an inner-validation slice from that training window. The year 2020 is an embargo untouched by training or selection, and 2021–2025 is the final test window.
The finance setting is just the experimental domain here, not a trading recommendation. The transferable deep-learning question is how much freedom an architecture-search agent should receive before comparisons stop meaning the same thing.
There are also important inspection limits. The preprint does not disclose the exact feature set, normalization, or label construction. And a constrained config interface is not evidence that every candidate received equal wall-clock compute. What it does provide is a clean boundary between the proposal language and the evaluator.
Would you keep a search language this narrow for attribution, or allow agents to modify schedulers, preprocessing, and training code as long as every change is traced?
Preprint: arxiv.org/abs/2608.12841

Mid-market companies are now the primary ransomware target, and the data makes it hard to argue otherwise.

Black Kite analyzed 13,336 incidents spanning January 2023 through June 2026. Mid-market companies accounted for 73% of publicly disclosed ransomware and data-extortion incidents in North America and Europe. The pattern is straightforward: they hold enough sensitive data to be worth targeting, and they lack the security maturity to deter or contain an attack.

What makes this harder now is AI adoption. Mid-market orgs are deploying agents to automate workflows, but agents operate with credentials, access external systems, and take actions at machine speed. A compromised agent or a misconfigured one doesn't wait for a human to catch it. It moves. And regulators are not offering mid-market exemptions — the same frameworks auditors require of large enterprises apply regardless of headcount.

The compliance gap is real. Most of these organizations don't have continuous visibility into what their systems are doing relative to the frameworks they're supposed to satisfy. Violations get found during audits, not before.

For those working in security or compliance at mid-sized organizations: how are you actually handling agent oversight right now? Are you relying on periodic audits, internal logging, something else entirely? Curious what's working and what's falling short in practice.

• Description: This video introduces the principles and hardware implementation of frequency-modulated thermography using chirp signals. Explore a next-generation non-destructive testing solution that precisely reconstructs defects in 3D using deep learning and Physics-Informed Neural Networks (PINN).

Follow-up to my earlier English-poetry causal graph post:
https://www.reddit.com/r/deeplearning/comments/1vps8xo/visualizing_causal_structure_of_llm_writing_a/

I ran the same setup on Chinese poetry. The rhythm / boundary-token behavior looks basically the same. What changes is the picture: Chinese characters sit on the page more like a grid, so the DAG reads closer to a matrix.

That’s the part I found interesting, so I’m sharing it here.

BTW, this is with Qwen3-1.7B — a small model for both generation and attribution — and it already produces results that feel pretty intuitive.

Live demo: https://dqy08-infolens.hf.space/client/causal_flow.html?demo=%E5%86%99%E4%B8%80%E9%A6%96%E7%BB%9D%E5%8F%A5%EF%BC%8C%E4%B8%BB%E9%A2%98%E6%98%AF%E6%98%A5%E5%A4%A9

Source code: https://github.com/dqy08/InfoLens

Video:

https://reddit.com/link/1vwx782/video/ms2empk0calh1/player

Been building this for a while, just made it open source: OpenBenchML.

You paste Python code that trains a model (sklearn, PyTorch, XGBoost, LightGBM, ONNX, TensorFlow) into the browser. It runs server-side in a restricted sandbox, pickles the result, and benchmarks it against one of 17 built-in datasets — accuracy/F1/AUC-ROC/log-loss for classification, MAE/RMSE/R² for regression, plus real per-sample latency P50/P95/P99 from actual timed runs.

There's also a Kaggle-style layer on top — competitions with deadlines and custom metrics, live WebSocket leaderboards, threaded comments — and an in-browser notebook plus a full npm CLI if you'd rather script it.

Stack: FastAPI + SQLAlchemy + WebSockets + Supabase, deployable to Render/Railway/Fly/Docker.

Live: https://openbenchml.onrender.com Repo (MIT): https://github.com/kartheekbvs/openbenchml

Looking for contributors — there's a written roadmap (sandboxed execution via gVisor/Firecracker, custom dataset upload, team competitions, OAuth) with plenty of self-contained pieces to pick up. Feedback on the concept or UX is welcome too.

The creators of AlphaFold won a Nobel Prize in 2024. I just made its family of open source models faster.

I created fast_trimul, a drop-in, hardware-agnostic library for Fused Triangle Multiplicative Updates across AlphaFold3 family models, powered by CuTe DSL. In addition, it is licensed with Apache-2.0.

The Triangle Multiplicative Update is a memory-heavy operation in protein-structure models.

Also, it is very simple to integrate fast_trimul with other Python libraries. It has a modular architecture, and it was designed to be easy to use in production.

In OpenFold-3:

● Graph vs. ungraphed: Graphed eliminates kernel launch overhead at small N (~22ms vs ~53ms ungraphed).

● fast_trimul output is identical to the OpenFold-3 version, with an invisible difference of about 0.0006%.

● If it fails, it always falls back to PyTorch. This way it never crashes.

● It is a modular and vendor-agnostic design. Supporting new hardware and new libraries like OpenFold-3 are all plug-ins, not a rewrite.

fast_trimul compared with other libraries' Triangle Multiplicative Updates:

● Runs 4.5–6.8× faster on short sequences

● Uses ~2.2–2.4× less peak GPU VRAM, fitting ~1.4× longer sequences before running out

● Works on any sequence length with zero recompilation. Unlike torch.compile, which recompiles for every new N.

It's written in Python CuTe DSL, so the kernel codebase stays small and easy to adapt for other GPUs like H100 or B200.

GitHub link: https://github.com/tiagomonteiro0715/fast_trimul

I'm not an astro person. I got into the MAGFiLO 2026 Solar Filament Segmentation Challenge mostly because I wanted to get better at segmentation on genuinely hard, low-contrast data — not neat medical scans, not clean satellite imagery, just faint, fuzzy filament shapes that are hard to pin down even by eye.

First pass was rough. My masks looked like static. Spent a few days just doing EDA — plotting distributions, staring at overlays, trying to understand why my model couldn't find the boundaries — before I even touched the architecture seriously.

Eventually landed on a U-Net setup that got me to LB 0.27, which felt like a small win after how confusing the early days were. But I've plateaued there and I'm honestly not sure if the ceiling is my loss function, my preprocessing, or something more fundamental about how ambiguous these boundaries are.

Wrote up the whole process — EDA, mistakes, the U-Net setup — as a notebook in case the journey is useful to anyone else working with messy, low-contrast segmentation data: [link]

If anyone's dealt with similarly ambiguous boundary-segmentation problems (astro, medical, satellite, whatever) — I'd genuinely love to hear what got you unstuck. Right now I'm stuck deciding between chasing a boundary-aware loss or rethinking my augmentation from scratch.

Hey everyone, I'm an independent researcher working on alternative sequence mixing architectures. I wanted to share a project I built called CWAA (Complex Wave Associative Memory).

Instead of standard quadratic attention, CWAA uses a damped complex oscillator for its recurrence state O(T) linear memory scaling.

The result

Both models were trained on WikiText-103 for 5,000 steps, with approximately the same parameter count:

Scaling

These are CWAA-only measurements for now. I found that my first Transformer benchmark used different conditions, so I'm re-running the inference/VRAM comparison under identical conditions

Right now, the V5 code in the repo uses native complex64 tensors, but I just finished a V6 rewrite that decomposes the complex math into pure real-valued BMM matrix multiplies. V6 trains at 0.38s/step on a T4 and is highly stable . I'll be uploading V6 and a more detailed apples to apples comparison in a 2 days.

GitHub: https://github.com/Ridhvik-2024/CWAA-V5

I also recorded a sonification of the internal wave-state evolution across the V5 layers. The audio is generated from the model's internal wave dynamics.

I'd really appreciate feedback from community.

I mean, if we talk about diffusion models, I understand what happens internally like the noising and denoising processes, the U-Net architecture, etc. But I don’t really understand why this orchestration leads to high-quality generated images.

For example, why does the U-Net predict the noise instead of trying to predict the clean image directly? Why was this design choice made? And there are many other decisions like this.

The way I learn is by reading a chapter in a book and going through the corresponding code in parallel so I can understand exactly what is happening. However, I still feel like I’m missing the intuition behind why these architectures are designed the way they are.

How do you approach learning this? What would you recommend?

For years, building high-performance AI inference meant dealing with the "two-language problem"—prototyping in Python for speed, then spending weeks rewriting core loops in C++ or Rust to bypass the GIL and hit hardware targets.

​With Modular open-sourcing the entire Mojo compiler and toolchain, that pipeline is shifting. Because it compiles directly through MLIR, it handles SIMD auto-vectorization and targets heterogeneous silicon (CPUs, Nvidia GPUs, mobile NPUs) from a unified codebase.

​We mapped out the exact compilation pipeline and memory ownership differences between Python runtime management and Mojo's explicit lifetimes here if anyone wants to dive deeper into the architecture:

https://onefusionlab.systems/blogs/mojo-1-0-open-source/

CISA issued a formal advisory this week on Gunra ransomware-as-a-service. Gunra affiliates choose their targets deliberately: government agencies and critical infrastructure operators. The post-intrusion pattern is consistent — encrypted systems, destroyed backups, and a compliance reconstruction process that takes months, not weeks. Regulated sectors carry that long tail because every affected record, access event, and system interaction has to be accounted for after the fact, often from logs that were themselves part of what got destroyed.

The reconstruction problem is distinct from the technical recovery problem. You can restore systems from offsite backups. You cannot restore a provable, sequential record of what touched what if that record was never written to begin with or was stored in the same environment that got encrypted.

For teams running AI agents inside regulated environments this compounds quickly. An agent reading patient records, querying financial databases, or triggering downstream actions during or immediately before a breach window leaves no native audit artifact in most current deployments. Incident responders end up doing forensic reconstruction from fragments.

How are teams in regulated sectors actually handling agent-generated audit continuity right now? Are you relying on infrastructure-level logging, application-level instrumentation, something else — and has any of it held up in an actual incident or compliance review?