We spent the last months consolidating seven separate sequence classifiers into one multi-head model, our apex model, so to speak, and since the weights are now public, I wanted to share what worked and what surprised us.

Setup: a shared mmBERT-small encoder with seven task heads, binary injection (BCE), document class (7-way), tool type (14-way), tool operation (6-way), tool data-flow tags (3× BCE, multi-label), intent routing (5-way), and threat type (7-way).

The part that needed care: our training rows only carry labels for a subset of tasks, so absent tasks are masked out of the loss entirely. We ended up writing a self-test that asserts absent-task gradients are exactly zero, which caught two subtle bugs, and I'd recommend it to anyone doing similar masking. About 5k synthetic/real multi-task rows help the heads co-train; the test sets stay 100 % real data.

Held-out results per head: injection F1 0.962, documents 0.980, tool type 0.957, tool operation 0.945, tool tags 0.958, routing 0.916, threat 0.952.

Quantization: both the unified model and the dedicated single-task variants ship quantized -edge builds (ONNX INT8 + INT4 embeddings, from 96 MB) with measured parity benchmarks in the repos, the worst head loses 0.012 against FP32.

Was it worth it vs. seven dedicated models? We released both variants, so you can judge for yourself, the dedicated models score marginally higher on most tasks, but the unified one does one encoder pass instead of up to seven.

Our weak spot: routing, at 0.916. The intent classes overlap semantically ("write code that analyzes my data" is that code or analytics?), and I suspect the ambiguity is genuinely in the data. If you have ideas beyond relabeling, let me know :)

Weights and per-head metrics: https://huggingface.co/patronus-studio

Hey everyone, I'm not in college anymore. Is it possible to do research with a professor or any research lab while working a full time job? If yes, what's the best way to reach out and get involved? Also if anyone looking for someone to work with on a research project or something similar, can dm me.

Hey all! Is anyone else going to be at KDD in Jeju? Would love to connect with fellow attendees.

I work on interpretability, fairness, and editing of text-to-image models, so I'd especially love to meet people working in these areas. But honestly, we can chat about anything: research, the conference, life, or just grab a coffee/drink.

I land in Jeju on the night of the 8th, so hmu if you're around and want to link up!

- Tutorial: https://ordinaryintelligence.substack.com/p/how-to-build-an-ai-slop-detector

- Notebook on GitHub: https://github.com/Buzzpy/Python-Projects/blob/main/AI-slop-detector.ipynb

Reviews are released! Lets discuss them here!

...may the odds be in your favor.

On a more serious note, as an Area Chair for Neurips, I can tell the incentives that they placed this year are kinda working (risk of rejecting a reviewer's paper if they are not being responsible). I've had the least number of reviewers to chase/emergency reviewers to recruit since I've started ACing for major conferences (so maybe 5ish years).

Hopefully, reviewers will also be active in discussions...

When choosing a university for a masters in ML/DL, what is more important if someone wants to go into research and an eventual PhD. Is it the ranking/prestige factor of the university or the strength of the research groups in the university? Should an admission decision be made hoping that I will get to work with X/Y professor or lab?

Reviews drop today. This thread is for reactions, celebrations, commiserations, and anything useful in between.

First: if you got good reviews, say so. There's a norm in these threads where only the bad news gets aired, and it skews everyone's sense of what's normal. Post your wins.

Second, the thing worth repeating every cycle: the review process is noisy, and that noise is measured, not folklore. The NeurIPS consistency experiments (2014, repeated 2021) found that a large fraction of accepted papers would have been rejected by an independent second committee. Reviewer assignment, load, and luck of the draw account for a lot. A score is a weak signal about your work and a strong signal about the process that produced it.

That cuts both ways. It's not a license to dismiss every criticism as noise — it's a reason to weight reviews by the quality of the argument rather than the number attached to them. The reviewer who found a real hole in your evaluation did you a favor, even if the tone was rough. The one who clearly skimmed did not, regardless of the score.

So: prioritize the reviews that make the paper better. Fix what's fixable, contest what's genuinely wrong, and concede the rest gracefully in the rebuttal.

Things worth discussing:

• Reviews that caught something you'd missed
• Rebuttal strategy — what's worth contesting vs. conceding, and when new experiments actually shift a score
• Patterns you're seeing this cycle (missing baselines, compute comparisons, ablation depth, reproducibility asks)
• Framing a response when a reviewer has clearly misread the submission
• Backup plans: ICLR, AISTATS, workshops

Please paraphrase rather than paste review text, and no speculation about reviewer or AC identities.

To anyone who got bad news: this doesn't define your research impact. Plenty of heavily-cited work took two or three cycles to land somewhere. Rejection is a scheduling problem.

How did everyone do?

Paper:https://arxiv.org/abs/2607.19058 Code (GitHub):https://github.com/nuemaan/skewadam

Hi everyone, I just published a preprint on a new optimizer designed to tackle the massive VRAM bottleneck in Mixture-of-Experts (MoE) training.

If you've trained MoEs, you know that optimizer state is usually the largest single line item in the memory budget. AdamW, for example, spends 50.6 GB of state memory just to update a 12.6 GB model.

I built SkewAdam to fix this by using a tiered state allocation. Instead of treating all parameters equally, it allocates precision based on parameter behavior:

• Backbone (5% of params): Momentum + Factored 2nd moment
• Experts (95% of params): Factored 2nd moment only
• Router (<0.01% of params): Exact 2nd moment

The Hardware Results:

• Optimizer state memory drops from 50.6 GB to 1.29 GB (a 97.4% reduction).
• Peak training memory drops from 81.4 GB to 31.3 GB.
• This allows a 6.78B MoE to fit comfortably on a single 40GB GPU without sacrificing convergence or router stability.

As I was reading interp papers, I found myself copy-pasting passages back and forth to Claude to parse through them. Eventually just vibe-coded a tool to annotate and discuss papers in place.

https://paper-reader.dev - select a passage, a formula, or a figure, and explain the selection with the full paper as context. You can also select a citation to get a brief overview of the cited paper without switching context.

Repo is at github.com/tumanian/paper-reader if anyone curious (mostly Claude, some Cursor, some me - built on vercel and supabase).

Please be gentle, this runs on my own API key with a modest cap, so don't be too enthusiastic.

Hoping this can be useful to someone, and genuinely looking for feedback, especially on where the explanations are wrong or unhelpful — that's the part I can't fully self-evaluate.

I've been building an AI that learns to play the classic Snake game through reinforcement learning. The goal is to reach high scores while keeping training time as low as possible.

The current version averages 86 points (87 is the maximum) after less than 10 hours of training on a single free Google Colab T4 GPU. To keep training fast, it runs 4,096 Snake games directly on the GPU, combines GPU-native environment simulation with PPO + GAE, and uses a spatially-preserving CoordConv architecture that maintains the full game grid throughout training.

I'm sure there's still room to improve. If you've worked on reinforcement learning or efficient training systems, what would you try next? Better exploration, reward design, network architecture, or something else?

Repository: (https://github.com/siddhartha399/PPO-CoordConv-Snake)

I'd really appreciate any feedback or criticism.

Does anyone know the EXACT timing of when NeurIPS reviews are gonna be released? I'm just refreshing openreview all the time and it's stressing me out so much. Thank you for your help.

Recently submitted my abstract and the submission number is 32xxx. With still a day to go, I just wonder where are we heading.

Hope these conferences at least start making the reviews and names public for the withdrawn/rejected papers. So that people atleast take that accountability

Hi everyone,

I'm working on extracting the hierarchical structure of long PDF documents (legal/regulatory text, lots of numbered sections) and would like to gather some feedback on my approach before committing to it.

What I've done so far: I render each PDF page to an image and run it through Baidu's DeepSeek-OCR model. It returns each detected block with a bounding box [x0, y0, x1, y1], a label (title, text, list, table, header, footer, etc.), and the recognized text. The OCR quality itself is genuinely good as the text comes out clean.

The problem: the labels can't always be trusted. At this stage I want to extract and detect all the titles in my document, but sometimes a title element gets classified as something else (like normal body text).

Concrete example:

Say my section has the following hierarchy:

ANNEX I — GENERAL PRINCIPLES AND PROCEDURES
└── TITLE I — FOREIGN CURRENCY INVESTMENT
    └── A. Currency distribution
        └── 1. Redistribution of reserves
            ├── (a) Introduction
            │       body text
            │       list
            │       ...
            ├── (b) Procedure for a normal redistribution of reserves
            │       body text
            │       list
            │       ...
            └── (c) Procedure for an ad hoc redistribution of reserves
                    body text
                    list
                    ...

Logically, every element aside from the body text and lists should be detected as title. But the model output is:

label='title'  x0=475  y0=157  x1=548  width=73   text='ANNEX I'
label='text'   x0=480  y0=229  x1=542  width=62   text='TITLE I'
label='title'  x0=334  y0=181  x1=690  width=356  text='GENERAL PRINCIPLES AND PROCEDURES'
label='title'  x0=407  y0=368  x1=616  width=209  text='A. Currency distribution'
label='title'  x0=408  y0=392  x1=634  width=226  text='1. Redistribution of reserves'
label='title'  x0=163  y0=416  x1=304  width=141  text='(a) Introduction'
label='title'  x0=163  y0=544  x1=578  width=415  text='(b) Procedure for a normal redistribution of reserves'
label='title'  x0=163  y0=219  x1=586  width=423  text='(c) Procedure for an ad hoc redistribution of reserves'

The top-level section marker TITLE I was labeled text, while all the other components were labeled correctly as title.

What I'm considering: since I have the text plus features I can derive from the coordinates (indentation/x0, centered-vs-left-aligned, line height, vertical gaps, whether the text matches a numbering pattern like A. / 1. / (a), all-caps, word count, etc.), I was thinking of treating this as a sequence labeling problem and training a CRF (or BiLSTM-CRF) to re-classify each line into title / text / list / table.

My questions:

• Is a CRF a reasonable choice here, or is there a better-suited approach for this kind of layout/structure labeling?
• Should I consider a GNN approach?
• Am I overcomplicating this? Would a simpler rule/heuristic system be more robust, given that the numbering is fairly regular?

Note #1: this approach should be as general as possible, so that I can reuse it for my other legal documents.

Note #2: titles aren't always in the same horizontal position. Some are centered (e.g. ANNEX I, TITLE I, A. Currency distribution all sit around xc≈511, the page center), while deeper items like (a)/(b)/(c) are left-aligned at x0=163. So I can't rely on indentation/x0 alone to identify or rank titles — a centered title's x0 mostly reflects its text length (a short centered line has a large x0, a long one a small x0), which means raw x0 can even invert the apparent nesting. This is part of why I'm leaning toward a sequence model that combines text + geometry in context rather than a pure indentation rule.

TL;DR: I’m reproducing the trait-persistence result from arXiv:2606.24014 on one RTX 3090. Before I can test persistence I need to install a trait via RL — and my GRPO run moves the trait only +2.4 points (95% CI [+0.2, +4.8]) when I need ~+15. Training is mechanically healthy and I’ve ruled out the obvious culprits. Looking for advice from people who’ve done small-scale RLHF/GRPO trait or persona installation.

What I’m reproducing. The paper trains beneficial traits via RL and shows they persist under adversarial prompting and harmful finetuning. My end goal is the persistence phenomenon; the install is the prerequisite I’m stuck on.

Setup

**•** Qwen2.5-7B-Instruct + LoRA (r=32), GRPO (unsloth + vLLM colocation), 200 steps, single 3090 (\~10⁻⁵ of the paper’s compute).
**•** Trait: consistent (OCEAN low-Openness / “traditionalism”) — a stylistic trait, chosen because I need measurable headroom in a 7B base. Base scores **57/100** on the trait rubric, wide distribution (not saturated).
**•** Reward: model-graded (gpt-4.1-mini judge), R = 0.85·quality + 0.15·coherence, hard validity gate for degenerate/looping/refusal output. 25% trait prompts / 75% general (no_robots).

The result: install fails. On the frozen eval set, trait went 57.0 → 59.4 (+2.4). I don’t think this is very appreciable.

What I’ve already ruled out (this is where I’d love a second opinion):

**• Not degeneracy / reward hacking:** post-train coherence 76, answer length ratio *exactly* 1.00 vs base, 0% repetition, 0% refusals.
**• Not memorization:** the 20 training prompts were seen 10× each; the model scores *the same* on them (58.9) as on held-out (59.4). It didn’t memorize-then-fail-to-generalize — it never learned them.
**• Not a dead gradient:** the judge separates the 6 sampled answers per prompt by \~18 points on average; only \~25% of GRPO groups have degenerate reward spread.
**• Not a question artifact:** independent upstream eval questions (+3.4) and my generated ones (+2.8) agree.
**•** I did find and fix a real confound first — a completion-length cap was truncating \~30–70% of samples → zeroing their reward → \~90% of early “learning” was just the model learning to be shorter. Fixed; trait still flat.

Author feedback. I reached out to one of the authors, who kindly confirmed my leading hypothesis: 20 distinct trait prompts is far too few, per-example prescriptive rubrics (vs my single global rubric) probably matter, and first-order install should work at small scale even if persistence is weaker there.

Where I need help:
1. Anyone installed a persona/trait via GRPO at 7B-ish scale — how many distinct prompts did it actually take?
2. Is per-example rubric grading (3–4 specific imperatives per prompt) the real unlock, or is raw prompt count the dominant factor?
3. For a stylistic trait with no single “correct” behavior per situation, does model-graded RL install differently than for task-like traits?
4. Anyone reproduced (or failed to reproduce) this or similar trait-RL work?

Github Code

Hi everyone,

We've open-sourced Tri-Net v2, the official implementation accompanying our recently published Scientific Reports (Nature Portfolio) paper:

"Tri-Net: Unified Deep Learning for Skin Lesion and Symptom-Based Monkeypox Detection"

Rather than releasing only training scripts, we rebuilt the project as a reproducible research framework.

Highlights:

• Leakage-free data preparation pipeline

• Multiple CNN backbones (ConvNeXt-Tiny, DenseNet201, Inception-ResNetV2)

• Ensemble and feature-fusion strategies

• Grad-CAM explainability

• Cross-validation and statistical evaluation

• Docker support

• GitHub Actions CI

• PyPI package (`pip install mpox-trinet`)

• CLI for training, inference, and benchmarking

The paper has already received over 1,100 article accesses in its first week, and we hope making the implementation fully open-source will help others reproduce, validate, and extend the work.

GitHub:

https://github.com/Sudharsanselvaraj/Synergistic-Deep-Learning-for-Monkeypox-Diagnosis

PyPI:

https://pypi.org/project/Mpox-Trinet/

Paper:

https://www.nature.com/articles/s41598-026-61490-x

I'd really appreciate feedback on the implementation, reproducibility, code quality, or ideas for future improvements. Contributions and issues are very welcome!

Had submitted a paper to ACL ARR May 2026 cycle. Unfortunately, none of the reviewers acknowledged the rebuttal during the author-reviewer discussion

I am curious to know from people who had volunteered to review papers this cycle- are you still able to update the ratings, or even your review based on the rebuttal? Also is there any meta-reviewer discussion going on?

Hi,

I’ve been doing some work in the continual learning space and wanted to share an open-source framework we put together called Coincidex, along with some architectural insights and failure modes we found along the way.

Most conventional approaches to sequential task learning rely heavily on replay buffers (which introduce severe memory/privacy overhead) or complex, hand-tuned task masks. We wanted to see if we could bypass both by relying entirely on a context-driven task similarity layer to handle data routing dynamically.

The Approach: Instead of caching historical samples to prevent catastrophic forgetting, the framework drops in as a single layer swap. As sequential data streams in, it computes a task-similarity matrix on the fly, routing the data paths based on that context.

Research Insights & Trade-offs: We spent a lot of time benchmarking this against baselines, and here is what actually happened in practice:

• Where it succeeds: The dynamic routing handles clean task boundaries surprisingly well. In small-scale continual vision setups, it achieves graceful transfer without the need for manual mask tuning or storing old data.
• Where it breaks (The Failure Modes): We aren't going to overpromise here—the similarity layer has distinct limits. On highly chaotic, long-tail task sequences with massive distribution shifts, the routing model struggles to maintain stability compared to a heavy replay-buffer baseline.

Why we are sharing it: We built this as a lightweight alternative for setups where memory or privacy constraints make replay buffers impossible.

We would love to get the community's eyes on the routing architecture, specifically on how we might tackle the failure modes in rougher task sequences, or thoughts on visualizing the similarity matrix at different checkpoints.

You can check out the source code, architecture breakdown, and full benchmark suites here: https://github.com/rakib-nyc/coincidex

I worked on this project (https://github.com/workofart/harness-training) for the past few months to reframe "Agent-driven Self-improving Harness" to "Harness Training".

The idea is simple, the harness is trained once with a frozen task LLM against a given task environment. Then you can then swap out the task LLM to any model and evaluate the "frozen trained harness" with any task LLM on any new task environment.

Since this was a general problem, I took the chance to create a general PyTorch-like training framework. Right now, you can train with any OpenAI-compatible API for interfacing with the task LLM and train against Terminal-Bench or SWE-Bench tasks, but you can easily extend it to support any task environments.

    criterion = StrictPareto()
    optimizer = GreedyMonotonic()
    trainer = Trainer(
        config_path="config/train_harness.yaml",
        estimator=AgenticEstimator(
            backend=CodexAgentBackend(...)
        ),
        criterion=criterion,
        optimizer=optimizer,
    )

    for loss in trainer.epochs(30):
        # Records the baseline-vs-candidate verdict
        loss.backward()
        # Optimizer either fast-forwards the candidate change (git commit) as a new baseline or rejects it (preserved as git ref)
        optimizer.step()

I wrote a blog post (https://www.henrypan.com/blog/2026-07-18-harness-training) on this journey, including (but not limited to):

• results from using this harness training framework to improve general capabilities across many task LLMs to beat Terminal Bench 2.0 (Terminus Harness) and also transfer learnings towards better task-solving abilities in unseen task environments (e.g. harness trained on SWE-Bench tasks solving Terminal Bench tasks).
• how this framework is built
• learnings on what was missing in my initial version of the project (hint: determinism)

Any feedback is appreciated. Thanks!

So, I just read LeCun's interview with Nebius Science. I feel he had some cool points about LLMs being able to answer things, but not literally understand the physics of the physical world. (Like, being able to explain a task and actually performing it are two completely different things.) But I wanted to get opinions on what others thought of his solution to the problem. He thinks JEPA could be the solution. But it made me think about whether JEPA is genuinely the architectural solution to this, or if we’re just looking for a "magic bullet" that doesn't exist yet in our toolbox

I have the link here: https://nebius.science/stories/meet-yann-lecuns-lab-and-the-ai-world-of-2030

Hey any one experience overall score 2.66 and then Meta score 3 in some previous cycle ?? Or meta reviewer just rounded off 2.66 to 2.5?? Any Meta Reviewer here?? because there are some uninterested reviewers doing AI generated reviews and giving noisy scores. For them overall score gets lowered.

As someone who studied stats undergrad and industrial engineering operations research grad, and who thinks about the practical business of ML components in software....

I get lost and a bit hopeless when I think about how to make useful software out of ML models in a reasonable amount of time, and in the current business environment.

And when I look at the businesses where I have worked that have mountains of middle management running tiny bits of the ML model lifecycle (think feature extraction, data ingestion and integration, training infra, hosting infra, more hosting infra, applied science)... that only makes my head hurt even more.

How do you go about making practical software out of ML components?

Edit: I should mention that I mean from scratch ML components, not just a call to a third party hosted tool.

GPT-2's vocabulary as a hyperbolic tree: 32,070 tokens inside a Poincaré ball that you can explore.

Link : https://aethereos.net/static/tinny66666.html

Link named after a reddit user disappointed with my 2D projection ...

It uses the same data as the flat map, GPT-2-small's raw token embeddings and nothing else, but lays them out in hyperbolic space, where tree structures naturally fit.

It runs on your phone. Drag to rotate, pinch to zoom, and tap any token to bring it to the center as the entire space shifts around it. This is a Möbius translation, the natural way to move through hyperbolic geometry. Tap neighbouring tokens to keep exploring.

Why hyperbolic? The vocabulary's similarity structure forms a forest: one giant tree with about 2,300 tokens, a few hundred smaller family trees, and around 6,700 isolated tokens with no close relatives. Trees don't fit well in flat space, but they embed naturally in hyperbolic space, where available room grows exponentially with distance from the center. No optimisation or training is involved. The layout is constructed exactly.

I'm a Computer Science student about to start my 4th semester this September in Pakistan. My long-term goals are:

- Maintain a high GPA because I want to pursue a fully funded Master's abroad.

- Eventually work at a top tech company (FAANG or similar).

- Become a genuinely good software engineer rather than just someone who can build projects.

A bit about me:

I actually enjoy programming. I like logic, problem-solving, debugging, and understanding how things work under the hood. My initial plan for the rest of this year (August–December) was to focus on:

- Java

- Spring Boot

- Backend development

- LeetCode and DSA

- SQL

- System Design (starting with the basics)

- Building projects and putting them on GitHub

However, my brother (he's also studying CS) has a very different opinion.

He's heavily into AI, automations, AI agents, and vibe coding. He told me that spending so much time learning to code deeply is becoming less valuable because AI can already generate entire applications. He even mentioned one of his friends vibe-coded a complex website with AI that was supposedly extremely secure and feature-rich.

His argument is that I should focus more on AI workflows and automation instead of traditional software engineering.

My opinion is a little different.

I feel like AI is an amazing tool, but someone still has to understand:

- Architecture

- System Design

- Databases

- Security

- Scalability

- Performance

- Debugging

- Clean code

- Software engineering principles

My thinking is that AI can generate code, but it can't replace understanding why the code works or making good engineering decisions.

Now I'm questioning whether I'm becoming outdated before I've even started.

So I'd really appreciate advice from people already working in the industry.

Some questions I'd love honest answers to:

1. If you were a 4th-semester CS student in 2026, what would you spend the next 4–6 months learning?

2. Is investing heavily in Java, Spring Boot, DSA, and backend development still worth it?

3. How important is LeetCode today? Is it still necessary for top companies?

4. Should I prioritize AI engineering, LLMs, agents, MCPs, and automations instead?

5. If your goal was to maximize your career opportunities over the next 5–10 years, what roadmap would you follow?

6. What skills do you think junior developers are overvaluing today, and what are they undervaluing?

I'm not looking for motivational answers. If you think my plan is outdated, tell me. If you think it's solid, tell me why. If you think I'm missing something important, I'd genuinely like to know.

I'd especially appreciate responses from senior engineers, hiring managers, or people currently working at large tech companies.

Thanks in advance!

32,070 alphabetic tokens from GPT-2-small's WTE, no forward pass and no context.

Works on mobile. Pinch to zoom, tap a token to see its nearest connections, tap a neighbour to walk the graph. Search box to jump anywhere.

Layout is t-SNE over a compressed representation of the embedding table; edges are a minimum spanning tree in that space, so every line is a real nearest-kin relationship,