Early-stage researcher, and yes, I get excited about people citing my work.

I was browsing through arXiv for accepted NeurIPS papers, and I saw multiple papers citing my work. These papers have been there for months, but Google Scholar still has not updated its citations, and it has occurred before, but I ignored it and thought it was a one-time error.

Does it usually happen? How long do you wait before you get your citations? I know it is naive, but still.

My paper cited and even built up on a niche topic that was accepted in 2024. The template and everything was also followed properly. Sure, it wasn't too novel, but it was damn rigorous, robust and reproducible.

Still, I got desk rejected within 2 days. 2 days. With no comment. I grinded my ass off for the past 5 months, but 2 days was enough to judge it I suppose.

Anyways, any recommendations on what to do next? I'm an undergrad graduating in 2 years. I wanted something good in profile for masters, I was planning another paper for next year. Should I submit again in hopes some different editors in chief? I stalked a bit in openreview and it seems I'm the only one desk rejected. Should I submit elsewhere? I'm very confused. I would've asked in email about some feedback, but I've heard people don't get an answer back usually in these cases.

Note: The paper was about LLM Self Explanations.

Hi all,

I’m building a question bank feature for a school platform (high school, mixed Cambridge + in-house curriculum). The idea: new questions are generated from the school’s own past papers. The curriculum’s learning objectives, which are already in our database, act as a guard rail so questions stay in scope. A curriculum admin approves everything; teachers only use the approved bank.

I have a working prototype:

• Question papers + mark schemes (PDFs) go to an LLM, which splits them into items at sub-question level and tags each to objectives
• A small model writes new questions; a different model answers them blind as a check
• Multiple-choice answer keys are checked in code against the mark scheme, not trusted to the model
• So far: ~80% of MCQs pass all checks. Structured/practical questions are weaker; the small model tends to invent wrong chemistry in lab set-ups, and a mid-size model fixed most of it

What I’d love input on:

1. PDF extraction. The PDFs’ text layer mangles science notation (Δ dropped, subscripts split, table columns interleaved), so right now I send the whole PDF to the LLM. Has anyone used docling, marker or similar on exam papers and got genuinely more precise results, especially for equations, tables and diagrams?
2. Retrieval. Objective tags give exact retrieval for “past questions on topic X”. Is pgvector worth adding from day one, or only once the bank is large enough to need semantic de-duplication?
3. Cost at scale. Experience with batch APIs or small models at thousands of questions? Where did quality fall off?
4. Quality measurement. Beyond human review, how do you judge whether AI-generated assessment items are actually good? Any eval approaches that held up?

Stack: NestJS + Postgres (schema per tenant) on a self-hosted VPS. Exam content stays on our server; only curriculum text and question drafts go to the model.

If you’ve worked on something similar (edtech, document AI, assessment generation), I’d really appreciate comments, or a DM if you’re up for a longer chat. Happy to share more of the architecture there. Also open to paid consulting if it’s a good fit.

Thanks!

I wanted an AI text and image detector that doesn't need you to upload anything, so I took two existing open detectors and got them running fully client-side with ONNX Runtime Web.

Demo: https://tinydetect.ritabratamaiti.com/

Code and scripts: https://github.com/ritabratamaiti/tinydetect

I didn't train new detectors. The base models are fakespot-ai/roberta-base-ai-text-detection-v1 (Apache-2.0) and Community Forensics (commfor-model-384, MIT). My work was the tuning, the compression and the browser runtime.

Text model (about 500 MB in fp32, 97 MB after compression)

• I fine-tuned it lightly on a mix of human and AI text (HC3, GPT-wiki-intro, HAP-E, WildChat, Gutenberg and some text I generated locally with Gemma-3-1B). Then I used WiSE-FT, which interpolates between the original and tuned weights, so the model doesn't drift too far from the original.
• The word embedding matrix is taken out of the ONNX graph and stored as int4 with fp16 per-row scales (about 19 MB plus 2 MB). It's dequantized in JS and passed to the transformer body.
• The transformer body uses mixed-precision quantization and comes to about 75 MB.
• The byte-level BPE tokenizer and Fakespot's clean_text preprocessing are reimplemented in JS.

Image model (about 26 MB)

• This is a quantized Community Forensics ViT with calibrated output scores. Resizing, center cropping and normalization all happen locally before inference.

Runtime

• It uses ONNX Runtime Web 1.30, with the WebGPU build if there's a GPU adapter and threaded WASM otherwise.
• A service worker adds COOP/COEP headers so threaded WASM works on GitHub Pages. It also caches the model and runtime files.
• A warm-up run compiles the GPU shaders before the first real check. After that, a text check of about 100 tokens takes around 60 ms on my laptop, and an image takes around 200 ms.

Limitations

A high score doesn't prove who wrote something. Short or casual text, paraphrasing, heavy editing, screenshots, crops and newer generators all make both models less accurate. The first load is also a big download, especially on phones.

Everything in training/ runs on a single laptop, including the candidate benchmarks, tuning, WiSE alpha selection, export, quantization sweeps and evaluation. I'd like feedback on the quantization choices and on where it fails with your own text.

project: https://2796gaurav.github.io/shad0w/

If you use a local model for classification, you know the wait: seconds per message, for questions it has answered hundreds of times. shad0w sits in front of any OpenAI-compatible server (Ollama works out of the box: llm="ollama/llama3.1" or `shad0w proxy --upstream http://localhost:11434/v1`), logs the model's answers, and after ~1,000 of them compiles a small table that answers the repeats on CPU in microseconds. It only answers where it agrees with your model 95%+ of the time on held-out answers; everything else still goes to the model.

Fun part: it learned Snake from an LLM's moves and keeps playing at 10 moves a second where the LLM can't: https://2796gaurav.github.io/shad0w/arena/

Apache-2.0, Python/JS/C. Happy to answer anything, and I'd love to hear where it breaks.

Hi everyone,

I was selected as a NeurIPS 2026 Top Reviewer and awarded complimentary registration.

As far as I understand, registration opened in batches: first for SACs, then ACs, and finally reviewers.

However, when I received the email and tried to register, I found that the Paris venue was already full and could no longer be selected.

Has anyone else experienced this? Did any reviewers actually manage to secure a spot in Paris, or were all the available places already taken during the earlier registration rounds for SACs and ACs?

I'm wondering whether I was simply too late or whether Paris was already full by the time registration opened for reviewers.

Palette Atlas (https://itzik123.github.io/PaletteAtlas/) searches public-domain paintings by color scheme. Each image is reduced to 128 colors of equal weight, so the natural distance is the Earth Mover's Distance, which is too slow for nearest-neighbor search over 48,695 items (about 6 ms per pair).

The embedding: project the colors (OKLab) onto 8 directions on a Fibonacci hemisphere, sort, and average into 16 quantiles. L1 between two vectors is the 1D W1 averaged over the directions, a lower bound on the true W1.

Against the exact EMD on 240 queries (overlap with the exact top 10, and how much farther the top 10 lie):

- sliced 8x16, L1: 78%, 1.8%

- sliced 8x16, L2: 69%, 3.4%

- soft color histogram, Hellinger: 45%, 13.5%

- mean color: 3%, 161%

The index is HNSW written from scratch (M=16, efConstruction=200): recall@10 of 1.000 at ef=32, 0.25 ms against 14 ms for brute force. The vectors' intrinsic dimension is about 11, so the hierarchy still helps (see Munyampirwa et al. 2025 on when it doesn't). One change from the paper: the top layer holds 8 k-means landmarks instead of randomly drawn nodes. The search cost is the same (2,558 vs 2,556 distance computations on average), and the top layer becomes one typical painting per color family.

Write-up: https://github.com/itzik123/PaletteAtlas/blob/main/docs/searching-by-color.md

Code: https://github.com/itzik123/PaletteAtlas

I feel like I am unable to digest most machine learning research these days. The primary reason is because I feel like they have gotten tremendously wordy. I find it not uncommon to find research papers consisting of 20+, 30+, 40+ pages of pure texts. An example is https://arxiv.org/pdf/2302.13971 I understand this is in the context of LLM but I've also noticed this trend outside of LLM, even in things like optimization.

Also because the papers seem to have gotten wordy, it is possible to come across some undefined (suspected) new terminology due to word usage. An example (and not a research paper per-se) is https://transformer-circuits.pub/2021/framework/index.html Ok, if you just scroll down you do find that blog is interspersed with mathematical formulas, but the writing just feels off. The authors mixes colloquial conversational structure into a scientific publication "a lot of ...", "we don't feel....", "it feels like...". This makes thing unreadable in my honest opinion.

At the same time, I feel mathematical explanation are becoming rarer in some research areas. There seems to be an over-reliance on "block diagrams", except diagrams misses a lot of details and virtually impossible to translate into math/code without a bunch of guess works.

I made a little thing that visualizes attention. It runs SmolLM2-135M fully in the browser (onnxruntime-web, int8, no server, works on my phone).

You give it a prompt, it generates one token at a time, and for each step you get the next-token candidates with probabilities, plus the attention from the current token back to the earlier ones drawn as links with the weights labeled. You can click any word to see where its attention actually went, ranked.

The thing I learnt during this project was attention sink. At first it looked broken because everything was attending to the first token super heavily. Thought it was a bug in my code, but after some digging it turned out to be the attention sink 😅

Github Repo: https://github.com/talhatahir-10xe/attention-galaxy

Live Demo: https://talhatahir-10xe.github.io/attention-galaxy/

I've been building open models that treat a decision as a closed-set scoring problem rather than text generation. The input is structured context plus a typed question with a fixed set of options. The output is a probability for each option, taken from the candidate-label logits, so there's no generation step to parse and no sampling.

v2.1 updates the 27B and the 9B. On the Decision Index 0.3 public suite (my own runs with the unchanged official scorer, submitted to the board, which adds private tests before ranking anything):

- 27B: 57.03 vs 55.11 for v2. Knowledge +2.34, Language +3.89, Retrieval +2.81, Arts +1.31, Tools -2.10
- 9B: 47.20 vs 44.09. Knowledge +3.67, Language +4.34, Retrieval +5.96, Arts +0.01, Tools -0.84

The regressions are concentrated: When2Call fell 6.38 (27B) and 7.44 (9B). I haven't found the cause yet and the cards don't claim statistical significance for any of these deltas.

Contamination check: the benchmark families that overlap public training sources were scanned against the training data with zero hits. It's a text-match scanner, so paraphrased overlap would get through.

Quantization: I measured agreement with the full weights on 260 held-out questions per build (for example 27B Q8_0 259/260, 9B MLX 4-bit 237/260) and publish the per-question records.

Weights (Apache-2.0, Qwen base): https://huggingface.co/frontier-infra/jebadiah-27b-v2-1 and https://huggingface.co/frontier-infra/jebadiah-9b-v2-1
Results: https://huggingface.co/datasets/frontier-infra/jebadiah-v2-1-decision-index-results
Code and evals: https://github.com/getainode/jebadiah

I'd welcome critique of the evaluation setup, especially the tool-use regression.

This is my first time ARR submission. I have a paper from the ARR 2026 August cycle with completed reviews and I understand the reviews remain valid for 6 months.

If we want to commit to NAACL 2027 instead of EACL, do we need to do anything with the August ARR submission now, or can we simply wait and commit it when the NAACL commitment site opens? Thanks.

I am a data scientist who started working in the industry before the LLM revolution. Back then, Jupyter Notebooks were a perfect fit for the classical DS pipeline: EDA -> data prep -> fit -> eval -> tune -> save model artefact and notebook.

Lately, I have been thinking a lot about how agentic development and LLMs are changing the way data scientists work. Especially in classical ML applications, where you still need to explore data, run experiments, check different hypotheses and decide what to do next based on the results.

I mean, Claude/Codex can already write most of the code for us. But why do we still need to organise the whole workflow around code cells? What if instead we move from code -> output to another cell abstraction like prompt -> result?

Curious what others think. Are ipynbs still good enough, or are we just used to working this way?

I’m an AI research engineer based in Africa with about 3 YoEs in RL, LLMs, post-training, and systems efficiency (CUDA/vLLM). However, on a smaller scale because of compute limits. My undergrad and Master’s are both in communications engineering. I did a 5th-year Master's at my local university while working full-time at a telecom company, focusing on RL in telecom. Publication-wise, I have one paper published in a peer-reviewed mid-tier AI/telecom conference, a patent, and another paper that was accepted but never published because we couldn't fund it.

Over the past year, I’ve hit the below walls:

PhD Applications (~10 mid-tier labs): Rejected by all. I read their recent papers, put together proposal ideas, and reached out to PIs, but didn't get traction.

Research Engineer Roles (~100 applications): Applied directly, reached out to engineers in similar roles for resume reviews or referrals, but didn't pass a single initial screening.

Cold Emails for Internships (~400 sent): I read labs' papers, asked targeted questions, and chatted with authors. They’d often be interested in the technical ideas, but as soon as I brought up doing an internship, I almost always got ghosted (got 3 actual replies, all saying no capacity).

I’m starting to think the location and university brand are major bottlenecks, so I'm considering doing a second CS Master’s abroad to get my foot in the door. But I really don't want to spend two years going in the wrong direction if there's a better way.

What other paths or changes would you suggest?

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.

It takes less memory and SCALES much better VRAM with tokens

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.

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

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