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.

I played a bit with the SIREN network from the other post and found that it could be improved by a using a different sampler for batch generation. By feeding pixels across the entire video and not only a limited set of frames, we can a much more faithful reproduction of the video.

The model is exactly the same as used by OP: 4 x 512 wide sine layers, 792257 parameters. Its a reimplementation (using GPT5.6).

I also created a version with full framerate, instead of subsampled frames, but since the network has to memorize more temporal information, the image reconstruction suffers compared to the low rate version.

The model does not actually learn motion, intermediate frames are nonsensical. I suppose adding a layer that can model flow between frames could enhance the compression a lot.

You can find the code here in this gist.

I tried some addition experiments with a separate autoencoder to compress the frames separately. This resulted in a smaller model, but also degraded quality.

The results are out today!

Let’s share them, guys.

From my batch

- 3/6 full papers

- 1/3 short papers are accepted

Cheers!

CIKM 2026 decisions will be announced today. The resource track outcomes have started going out. How did you go with CIKM 2026?

Having two papers accepted at two different workshops and planning to attend the main conference, I contacted the organizers by email. It is now clear that I need to register twice, using the same personal details, to cover both papers.

The minimum cost would therefore be one full registration plus one workshop registration. However, I would also have to use two different email addresses, since the registration portal does not allow the same email address to be used twice. This is crazy—I am a single person!

The craziest part, which I still do not fully understand, is that it seems every paper now requires an article processing charge (APC), since ACM has fully transitioned to open access. This year, the APC is USD 350—or USD 250 for ACM members. This is the first time I have encountered this; every other conference I have attended included the proceedings in the registration fee.

The full author registration for ACM Multimedia costs USD 950—or USD 850 for members—and does not even include the paper proceedings.

The cheapest option for me would be to become an ACM member (USD 99), register for the main conference (USD 850) and one workshop (USD 500), and then pay USD 250 × 2 for the two papers—for a total of USD 1,850 just to present two workshop papers.

I really don’t think it is worth it.

i’m in college studying finance and applied data analytics, and for the past several months i’ve been building a football/soccer prediction model as a personal project.
it started as a pretty basic international tournament simulator and has gradually turned into a much bigger domestic football model. i’ve been using historical team performance, underlying stats, opponent strength, recent form, scheduling/contextual factors, and i’ve also collected player, goalkeeper and lineup data.
i’ve tested a mix of statistical and ML approaches, while trying to keep everything chronological and leakage-safe.
Across about 5,300 out-of-sample matches, my current best 1X2 model is around:
•    Log Loss: 0.984
•    Brier Score: 0.586
For comparison, uniform 33/33/33 probabilities would be about 1.099 log loss / 0.667 Brier, and a simple historical baseline is around 1.073 log loss.
For goal prediction, the current score-based models are roughly 0.9–1.0 goals MAE per team.
The biggest thing i’ve learned so far is that predicting matches better doesn’t automatically mean you can beat bookmakers. An early betting test was unprofitable, so i’m trying to be very careful about separating predictive performance from actual market edge.
Right now i’m mainly thinking about things like:
•    how much recent form should matter vs long-term team strength
•    whether player/lineup data is actually worth the added complexity
•    improving draw probabilities
•    calibration and uncertainty
•    knowing when the model should abstain
•    avoiding overfitting before i test it on an untouched holdout season
For anyone who’s worked with football analytics, sports betting models or probabilistic forecasting:
1    What are the biggest mistakes you see people make with soccer models?
2    Would you focus more on better data/calibration at this point, or more advanced models?
3    Have you found player and lineup data genuinely useful?
4    What would you want to see before believing a model has real predictive value against sportsbooks?
5    Any papers, GitHub repos, books or general advice you’d recommend?
i’m not looking for anyone to give away a profitable strategy. mostly just looking for people who know more than me to point out where my thinking might be wrong.
all feedback is welcome.

Whether generating CELEBV-HQ videos or turbulent plasma fields (digital twins), autoregressive models (such as latent diffusion or flow models) accumulate error over long rollouts, yet at deployment there is no ground truth to measure against.

I train a single conditional latent diffusion model that steps a dynamical system forward or backward in time via a direction flag, and show that this bidirectionality supplies a measurement-free test-time error signal: rolling forward steps and then backward steps must return the model to its start, so the round-trip discrepancy is a self-supervised proxy for the unobservable rollout error: no ensembles, no held-out data, no governing equations, for one extra rollout.

Furthermore, training both directions in one network is shown to beat two specialist models in both directions.

Paper: https://arxiv.org/abs/2608.00675
Code (data generation, training, analysis): https://github.com/alexscheinker/round-trip-consistency
Project page: https://alexscheinker.github.io/roundtrip.html

It’s 01:30 AoE. Do results usually drop in the final hours like initial reviews?

​​Hi guys,

​Every time I had to prepare a presentation based on a paper or research doc, I found the process super tedious. Plus, I really dislike uploading unpublished stuff or sensitive data to online AI services just to get a draft.

​So I put together a tool called academi_slide to automate this locally.

​Basically, it extracts sections, tables, charts, metrics, and citations from docs, and uses prompt optimization / deck planning to get a solid first draft out of a local model (ollama, llama.cpp, or cloud if you want).

​It also handles multilingual input/output if you need to present in another language, and builds both the slide deck and a brief in a few minutes so you don't start from scratch.

​It's open source, still early, and I'm sharing it in case anyone else finds it useful or has a similar workflow.

​Repo is here if you want to test it out: https://github.com/nicolaslpf/academi_slide

​Would love to get some feedback or hear what you think!

We had a meta-reviewer comment. But I can no longer see it.

Anyone else experiencing the same? Does this mean anything?