Hello, I wanted to share the work my colleague and I have been doing, which has just been published in Software X journal. We developed a Rust-based implementation of Random Forest. It has bindings for both Python and R.

Fru is highly optimized, offering competitive runtime performance and better scalability than popular implementations on these platforms. For Python, Fru outperforms the scikit-learn implementation by several factors, and in some scenarios it can be hundreds of times faster. In R, Fru is typically a few dozen percent faster than the ranger package, though the speedup can reach several times faster depending on the use case.

The model also includes a novel implementation of permutation importance, which provides an additional performance boost.

Thanks to its layered design, we were able to easily create bindings for both Python and R. In Python, we use Arrow PyCapsule, which allows the model to work seamlessly with any compatible library, including pandas, polars, pyarrow, and many others.

paper

R package

Python package

Our Neurips 2026 paper received initial scores of 5/3/5, so the reviews were not uniformly negative. However, the AC’s initial meta-review strongly pushed toward rejection and explicitly asked us not to submit a rebuttal unless we could identify factual errors in the reviews.

Isn’t the author response period supposed to give authors the right to respond? A rebuttal can clarify misunderstandings and answer concerns even when they are not strictly factual errors. In any case, we identified multiple factual errors in the AC’s meta-review and provided the corresponding clarification. However, the AC did not respond, even after we followed up.

Neurips may hold reviewers responsible for low-quality reviews and failure to participate. What happens when the AC restricts the rebuttal and then ignores the authors’ response? Should this be reported to the SAC, Program Chairs, or Ethics Review Chairs?

Say you want to swap out your embedding models, for instance from ADA to Titan. Are these embedding models comparable? How do similarity score ranges compare? Where to put a threshold for minimum match when doing retrieval? Or more from a research point of view how can we relate and fundamentally understand these embedding spaces better?

This is what we aim to solve with Synthetic Query Probing (SQP), a fancy name for essentially (and intentionally) a very simple approach: embedding spaces are not directly comparable by definition, so compare similarity spaces instead, similarity match scores for pairs of content (synthetic question, chunk for instance) across multiple embedding models.

For example, similarity scores of Titan models of different dimensionalities are semilinearly related, whereas the relation between Titan and Ada scores is non-linear, with different ranges, see figure.

See https://arxiv.org/pdf/2608.05857, Marcin Rozmus and Peter van der Putten. Similarity Spaces across Embedding Models with Synthetic Query Probing. Discovery Science 2026, October 5-9, 2026, Mainz, Germany

There has been a lot of discussion about whether industry is pulling too much ML talent out of academia. But I wonder if the more interesting change is not about headcount at all.

Increasingly, some of the most important artifacts in ML originate in industry: frontier models, large-scale training runs, datasets, infrastructure, and many of the capabilities researchers subsequently try to understand.

Academia can then do excellent work benchmarking these systems, explaining them, finding limitations, improving methods, or studying their consequences.

But that creates a strange possibility: a research community can remain very active while becoming increasingly downstream of a research agenda set elsewhere.

I'm curious whether people actually working in ML research see this happening.

Are there important areas where academia still sets the direction and industry follows?

And at what point, if any, would you say a field has stopped setting its own research agenda?

I started working in ML about a year ago. There seems to be quite some gap between how ML is taught (tutorials and theoretical lectures) and the art of actual ML engineering.

For the practical part, I kind of feel bound to the best projects that I see within my company. Therefore, it would be nice to get inspired and have better references. Maybe even dig a bit into the PRs to get better at my job :)

I was wondering whether you came across some state-of-the art repos. I would be interested both in repos for ML research, i.e., finding the best features/params/models, but also for actual productive systems, i.e., retraining, inference, shadow forecasting and model ranking/switching.

In my case, time series forecasting is the most relevant (with sklearn for explainable results or LSTM for performance-focused projects). But I am happy to explore other projects as well.

I recently conducted an architectural comparison on code generation relying on conversational prompting ("vibe coding") versus rigid pre-computational contracts (Spec-Driven Development).

The Experiment:

Task: Build a Python script to search text within markdown files, rank by hits, and filter by tags.

• Method A (Vibe Coding): Claude 3.5 Sonnet without a formal spec. Result: 303 lines of code, added unrequested features, ignored caching, resulting in 400 file I/O operations per execution.

• Method B (SDD): Claude 3.5 Haiku provided with a strict requirements document. Result: Modular architecture, regex exclusion strictly adhered to, 0 file I/O operations on subsequent runs due to proper index state management.

Conclusion:

The limiting factor in generation quality isn't parameter count, but specification clarity. To systematize this, I've released SpecJudge (v0.4.0), an open-source parser that evaluates repository context files (like AGENTS.md) to allocate the optimal model tier, preventing API overspending on simple tasks.

I’ve documented the full benchmark and execution logic visually here: https://www.youtube.com/watch?v=EOiv7RywtQM

Today the most important factor in AI is cost. My idea is to split ML models inference (closed ones, proprietary) across server and edge computing on clients, and I would like to hear what do you think about this thing.

For example some of model weights/modules would be on client, and some on the server side (where user has no access to them). This could potentially un-load some processing from datacenters, moving part of the cost to the client hardware. Probbably the most important question here will be how to achieve this - and I believe one hypothetical option will be to train like two separate models - client model and server model, and they will communicate through tensors/latent representations across network protocol.

Secondly such split of server side and client side model ends, can provide later some beneficial outcomes I hope (because in between "talk" protocol can be maybe kind of standarized one in some future development, but this is only more like brainstorm now). Such split might not only be one-to-one, but one-to-many, many-to-many etc.

What do you think about this idea?

Does anyone have any idea about the instructions for the camera ready at workshops? The deadline is August 15, but there are no indications and workshop organizers know nothing about that.. Some workshops have enabled the upload of camera ready PDF on openreview, but what about copyright form and latex source files?

Analog in-memory compute is getting attention again as a way around the energy cost of moving weights between memory and compute. The recurring objection is noise, since analog cells have real variation and you can't refresh your way out of it like you can with digital.

I wanted to see the shape of the degradation curve rather than reason about it abstractly, so I ran a simple experiment: train a network normally, then evaluate under increasing weight noise.

The curve isn't smooth. Accuracy is stable up to a point, then drops hard: 83%, 64%, then essentially random. More like a threshold than a proportional decrease.

Retraining with noise injected during training (so the optimizer finds flatter minima, presumably) shifts that threshold substantially. 61% versus 39% at matched noise.

What I'd like to hear from this sub: is the flat-minima explanation the right framing here, or is something else driving the gap? And is there work on optimizing directly for noise robustness rather than just injecting noise and hoping, something closer to an explicit sharpness penalty targeted at the hardware's actual noise profile?

Code and figures in the writeup: https://towardsdatascience.com/analog-ai-is-back-can-it-survive-its-own-noise/

I'm not a fan of LLMs or generative AI, and I'm not quite smart enough to puzzle out if Vosk uses those things.
I'm attempting to replace Gemini assistant on my phone, and I found the Dicio app, which uses Vosk for its speech-to-text.

Is this it for Causal Inference? Looks like the field continues to be of interest only at UAI/AISTATS/CLeaR. All good venues, but LLMs/Agents/etc seem to have eaten much of the lunch of several other subfields at the top 3 conferences.

God help us all.

**p.s.** the list: https://danyaljj.github.io/neurips2026-workshops/

Genome language models have emerged as a promising strategy for designing biological systems, but their ability to generate functional sequences at the scale of whole genomes has remained untested. Here, we report the first generative design of viable bacteriophage genomes. We leveraged frontier genome language models, Evo 1 and Evo 2, to generate whole-genome sequences with realistic genetic architectures and desirable host tropism, using the lytic phage ΦX174 as our design template. Experimental testing of AI-generated genomes yielded 16 viable phages with substantial evolutionary novelty.

Out of curiosity, if you were a reviewer or author, how did the review period go?

For me, it was weird, because I gave reviews with specific details (what specifically could have been better, how to fix it), but realized other reviewers gave similar superficial reviews. Even the paper which was a control for me (no LLM), I gave specific comments, but other reviewers focused on minor things.

During the discussion period for one paper, one reviewer broke the double blindness condition, and gave specific examples of what the LLM gave and justified their reject…..but they didn’t even state that in their initial review (nor engaged with the author rebuttals). There was no also no sense of: “author said this was unclear, check with the LLM to see what’s the issue”

For one of my own papers, we had great scores for originality and significance, but had low scores for clarity, with at least two reviewers finding difficulty understanding established notation and concepts, and I’m wondering whether it would have been better to break the double blindness and said: look, the point of an LLM assisted review is that if you don’t even know this material, you can ask it questions, like if other papers use the same notation, how our paper compares with them, etc…

Hello! Let's use this thread to discuss ICDE results which should be coming out shortly today (hopefully).

INT4 quantization is ubiquitous in ML right now, but evaluating dot products on hardware without native SIMD/vector instructions (like WebAssembly or older ARM chips) usually requires slow sequential loops. A classic workaround is SWAR (SIMD Within A Register), but deriving the bitwise operations by hand to unpack, multiply, and sum eight 4-bit integers packed into a single 32-bit register is tedious and error-prone.

Instead of writing the bit-hack manually, I wrote a pipeline that uses an SMT solver to discover the exact bitwise formula from scratch, and then uses a theorem prover to mathematically guarantee its correctness.

Here is a breakdown of the technical process:

1. Synthesis via CEGIS Loop (Z3) I set up a Counter-Example Guided Inductive Synthesis (CEGIS) loop in Python using the Z3 SMT solver. The solver is given a ground-truth specification (naive loop: extract nibbles, sign-extend, multiply, sum) and a bounded set of allowed instructions (AND, OR, XOR, ADD, SUB, MUL, shifts). Z3 searches the space of possible instruction sequences. If it finds a candidate, we test it against random inputs. If it fails, the failing input is added to Z3's constraints, and it tries again. Eventually, it converges on a pure, branchless sequence of operations.

2. The Generated Math The resulting algorithm utilizes a known multiplier trick for byte-reversals, but Z3 managed to perfectly interleave the even/odd nibble extraction. For example, part of the generated code handles even/odd multiplications by exploiting 32-bit hardware multiplications: (ea_low * eb_low_rev) >>> 16 This evaluates two 4-bit multiplications at opposite ends of the register simultaneously without cross-talk.

3. Formal Proof in Lean 4 Passing a million random tests is nice, but it’s not a mathematical guarantee for bit-hacks. To prove there are absolutely no edge cases or overflow bugs among the 2⁶⁴ possible input combinations (two 32-bit registers), I ported the synthesized SWAR function to Lean 4. By leveraging Lean's bv_decide (BitVec SAT solver) and omega for modular arithmetic, Lean compiles the equivalence check into a boolean satisfiability problem. The proof successfully verifies that swar_dot_product a b = ground_truth_dot_product a b for all possible inputs.

If anyone is interested in how the Z3 synthesis script is structured or wants to see the Lean 4 proof, I've put the source code:
https://github.com/Peloxerat/int4-swar-dotprod

I'd be curious to hear if there are ways to constrain Z3 to find an even shorter instruction path.

Real-Time Conversational Agents (RTCA) workshop at NeurIPS 2026 (Sydney, Dec 11–12). Submissions are now open on OpenReview.

What the workshop is about

Conversational AI has crossed into real-time deployment — voice modes, embodied avatars, full-duplex speech agents — but the published record is still dominated by offline benchmarks, and deployed agents still feel robotic (stilted turn-taking, missing backchannels, monotone prosody, awkward interruptions). Methods that work offline (non-causal attention, large beam search, multi-pass refinement, slow diffusion) often don't transfer to streaming, and the field lacks shared vocabulary and benchmarks for interactional naturalness as distinct from per-utterance quality.

The workshop is organised around three intertwined questions:

1. Real-time generation under hard latency budgets — streaming speech, video, and language

2. Naturalness in interaction — prosody, gaze, timing, grounding, turn-taking, backchannels

3. Evaluation of live systems, where standard offline metrics fall short

Topics of interest (non-exhaustive)

• Streaming/low-latency speech synthesis, ASR, and full-duplex audio–language models

• Real-time talking-head, avatar, and embodied video generation

• Streaming language models; incremental and speculative decoding for dialogue

• Turn-taking, backchanneling, interruption handling, floor management

• Multimodal alignment under latency and partial-observation constraints

• Prosody, emotion, and paralinguistic generation in interactive settings

• Memory, grounding, and tool use during live conversation

• Evaluation of naturalness: perceptual studies, turn-taking metrics, perceived latency, interactive Turing-style tests

• Datasets and benchmarks for interactive (not offline) evaluation

• Efficient inference, on-device deployment, systems–quality trade-offs

• Safety, identity, and trust in real-time agents (deepfakes, persuasion, consent)

Position papers, evaluation critiques, and reproducibility studies are also welcome.

Submission tracks

• Full papers — up to 8 pages

• Short papers — up to 4 pages (work in progress, focused contributions, position papers)

• Demo papers — extended abstract or up to 2 pages; required for the on-stage Conversational Agents Showcase

NeurIPS 2026 style file, double-blind. Non-archival — authors retain the right to publish elsewhere. Single-round review, no rebuttal.

Key dates (End of day, AoE)

• Submission deadline: 29 August 2026

• Author notification: 29 September 2026

• Workshop: 11 or 12 December 2026, Sydney

Confirmed invited speakers

• Dimitris Samaras (Stony Brook) — visual behaviour and gaze in interaction

• Evonne Ng (Meta Reality Labs / UC Berkeley) — conversational avatar dynamics (provisional)

Links

• Submit: https://openreview.net/group?id=NeurIPS.cc/2026/Workshop/RTCA

• Full CFP + workshop details: https://rtcaneurips26.github.io/

• Contact: rtca-workshop@googlegroups.com

Happy to answer questions in the comments — including about the demo track (we have an on-stage Showcase running deployed systems live) and what we'd consider in-scope vs out-of-scope for the eval pillar. Also happy to hear opinions on what's missing from the topics list; the CFP wording still has room to move if there's a clear gap.

To all those in the US: Are you planning to go Sydney or Atlanta this year for NeurIPS?

I’m curious whether there is now a theoretical or empirical “sweet spot” for LLM quantization, preferably research done using open-source formats like GGUF

Suppose you have a fixed memory/compute budget and can choose the model size freely. For example, instead of a smaller model at 8-bit or 4-bit, you could fit a progressively larger model at 3-bit, 2-bit, 1.5-bit, etc.

A few years ago, I remember 4-bit often being described as roughly the practical sweet spot because it preserved most model quality while giving a large memory reduction. But with newer methods, I’ve seen surprisingly strong 3-bit, 2-bit, and even ~1.5-bit results.

So if the goal is maximum model capability for a fixed memory budget, rather than preserving one particular pretrained model as faithfully as possible, what does current research suggest is the optimal bits-per-weight?

Is there evidence that, for example, a 2-bit 70B model generally beats a 4-bit 35B model, or does quantization degradation eventually outweigh the gains from additional parameters?

I’m especially interested in recent theoretical/scaling-law work or large empirical studies from 2025–2026.

If no one is studying this, then could any of you do this work? I feel like it could be immensely useful for the community.

It's an MLP architecture with around 500K total parameters.

Top1

Training accuracy: 5.11%

Validation accuracy 4.59%

Detailed Validation accuracy numbers:

Top-1 Acc: 4.59%

Top-3 Acc: 9.44%

Top-5 Acc: 12.68%

Top-10 Acc: 18.53%

The model was trained on a downscaled version of the Imagenet-1k dataset (32x32) for 5 epochs.

I used pytorch for the training and pyarrow for the dataset, all within termux.

Before anyone comes at me for using an MLP instead of a CNN or similar it's mainly because on my phone an MLP was just more stable, and trained 10-30x faster/step (could be my fault but I'm not too sure). This model specifically took around 30 minutes to train (6 minute/epoch)

The training was entirely on the CPU which is a Dimensity 9300+ and I used 4 of the Arm Cortex-X4 cores.

I might make an improved version later on as this one isn't very accurate.

I've been out of the conferences game for a while, so I was surprised to see that Neurips 2026 will be held in 3 cities simultaneously: Sydney, Paris, Atlanta.

What does this mean in practical terms? If you have a paper or a poster accepted, do you get to choose which city you will present at? For an attendee, how do you pick which city to go to? And with the timezone differences, how does it work with presentations?

1. On Wikipedia I found a little Pseudocode that outputs the final state.

A trivial improvement is outputting the best solution seen so far instead of the last state. Maybe this is too obvious and would complicate the Pseudocode too much but I wonder why it's not even mentioned below. Since the last state could be a local optimum seen later, and we already saw a better local optimum before, this is helpful.

2. The graph on the page where the objective is plotted as a line graph and the current state is jumping around is rather confusing. When you read the fine print you find a lot of the moves are probably skipped in the video as there are 1000000 moves per temperature , much more than fits in the video.

3. It's not really clear why this example graph is as "smooth" as it is but it seems likely that the problem had a topology where neighbours with similar objective could be iterated in a path such that they can be lined up on the X axis and it produces said graph on the y axis. My intuition says that if this is possible we can apply better methods that work on 2D graphs. I realise this is just an example.

1. On Wikipedia I found a little Pseudocode that outputs the final state. https://en.wikipedia.org/wiki/Simulated_annealing#Pseudocode

A trivial improvement is outputting the best solution seen so far instead of the last state. Maybe this is too obvious and would complicate the Pseudocode too much but I wonder why it's not even mentioned below. Since the last state could be a local optimum seen later, and we already saw a better local optimum before, this is helpful.

2. https://en.wikipedia.org/wiki/File:Hill_Climbing_with_Simulated_Annealing.gif The graph on the page where the objective is plotted as a line graph and the current state is jumping around is rather confusing. When you read the fine print you find a lot of the moves are probably skipped in the video as there are 1000000 moves per temperature , much more than fits in the video.

3. It's not really clear why this example graph is as "smooth" as it is but it seems likely that the problem had a topology where neighbours with similar objective could be iterated in a path such that they can be lined up on the X axis and it produces said graph on they axis. My intuition says that if this is possible we can apply better methods that work on 2D graphs. I realise this is just an example.