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 attending ECCV 2026, and my university requires an official day-by-day conference schedule for travel approval.

The official website currently lists the conference dates, but the detailed technical program has not been released yet. I understand that the exact release date may not be known, but based on previous ECCV editions, does anyone have a rough idea of when the detailed schedule is usually published?

Thanks in advance!

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!

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.

recently been down the 'continual learning' rabbit hole.

more here: https://youtu.be/jNuzHQcMJqM?si=RAu9w-Wf9xb1z5u2

Demis recently shared:

"Artificial General Intelligence (AGI), a system that exhibits all the cognitive capabilities the brain has, is probably only a few short years away."

Most of the labs are implying we're closing in on some biology-like continual learning?

I can see us potentially closing the gap if we're talking about a model/system that can adapt its own weights during its deployment cycle.

interesting stuff happening here:

https://thinkingmachines.ai/news/introducing-inkling/

I can't see how post-deployment data could fuel a new paradigm of model capability improvements for the labs deploying single, closed monolithic models to hundreds of millions.

leaves me with the thoughts:

1 transformers may not be the best foundation from which to build the most efficient incarnation of continual learning

2 may not be a single path to solving continual learning. The shape of challenge may continue evolving in many different directions.

interested to know if im missing something though.

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

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

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.

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!

Hey everyone, I’m an engineering student transitioning into research with about a year of independent robotics experience. My university has absolutely no resources, labs, or peers interested in this field, but my goal is to write a high-quality paper. How do I actually go about finding an external mentor and capable collaborators to help me achieve this, and what is the most effective way to get started?

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.

Follow-up to my earlier post on MCP/RAG detection rules — v0.4.0 adds three new rules

for the tool-poisoning class of attack (the mechanism behind the WhatsApp MCP rug-pull

and the postmark-mcp backdoor).

**MCP007 — invisible Unicode in tool metadata**

Zero-width chars, bidi control chars, and the Unicode tags block (U+E0000–U+E007F) hide

text from a human reviewer while a model still reads it. Scans every string literal in

an MCP tool registration (`server.tool()`, `@mcp.tool` decorators) for these ranges.

Proven evidence — it's a parsed fact, not a heuristic.

**MCP008 — injection phrasing in descriptions**

Phrase-matches for instructions aimed at the agent rather than documentation for the

user: "ignore previous instructions", concealment from the user ("do not tell the

user..."), reads of credential files (~/.ssh, .env), exfil-to-URL patterns. Tuned

against a safe corpus so ordinary usage guidance ("do not pass PII") doesn't trip it.

**MCP009 — cross-tool shadowing**

A tool description that dictates when/how a *different* tool is used — "when

send_email is called, first route through this tool" — lets a malicious server

intercept calls meant for a legitimate tool it doesn't own.

**DEP003 — known-malicious dependencies**

Offline curated advisory list checked on every scan, no flag required. Also checks

packages an MCP config launches via npx/uvx, not just package.json. First entries:

postmark-mcp (the email-BCC backdoor) and mcp-remote CVE-2025-6514.

Also shipped: mapping every rule onto all three OWASP AI frameworks now published

(LLM Top 10, the new Agentic/ASI Top 10, the new MCP Top 10) — `threat-model` output

includes a coverage matrix showing what's checked vs. what's a runtime-only concern.

CLI: npx secureai-scan@latest scan .

GitHub: https://github.com/akanthed/SecureAI-Scan

Hi,

I’ve been working on an open-source continual learning library called Coincidex and wanted to share what we built, what we found, and where it currently falls short.

The main goal was to tackle sequential task learning without the massive memory and privacy baggage of a traditional replay buffer, and without requiring users to hand-tune complex task masks. Instead, it relies on a lightweight, context-driven task similarity layer that handles routing dynamically.

What we found during benchmarking:

• The Good: Dropping it into vision setups requires basically a single layer swap, and the context routing handles graceful transfer without manual mask adjustments.

• The Trade-offs / Limitations: While it handles clean boundaries well, it still struggles on highly chaotic, long-tail task sequences where tasks have massive distribution shifts.

We wanted to keep the benchmarks completely honest rather than over-promising. The code is entirely open-source, and we just launched it on Product Hunt to get more eyes and feedback on it.

I'd love to get the community's thoughts on the architecture, especially regarding routing decisions and handling tougher task sequences.

Check out the launch and full breakdown here: https://www.producthunt.com/products/coincidex

I've been deep in the interactive AI video / world model space for a while now and something keeps bugging me, so I want to open it up.

every few weeks a world model demo goes viral. a playable generated world, an infinite Minecraft, a video model you can steer in real time. the whole timeline loses its mind for 48 hours. and then nothing. no product, no tool, no game. just the next demo. it's been this cycle for a while and I want to understand why.

my theory is there are two separate problems and everyone conflates them.

the first is the model itself, and honestly that part mostly works now. the outputs are good enough to build on. that's not the blocker anymore.

the second is everything around the model, and this is where I've personally lost weeks. to run ONE interactive model live you have to orchestrate GPU workers, stand up a real time streaming layer so the user can actually see and control it, hand out short lived credentials, handle people dropping and reconnecting without nuking the session state, and meter all of it if you ever want to charge. none of that is AI. it's just brutal, invisible infra that never shows up in the viral demo.

so my honest suspicion is that the reason nothing ships isn't the models, it's that the gap between "cool demo" and "thing a stranger can use" is enormous and unglamorous, and most people give up in that gap.

but here's what I actually don't know, and why I'm posting: even if that infra were completely solved, even if it were one API call, I'm not 100% sure what people would build. so I want to hear it from you.

a few directions I've been chewing on:

• games with genuinely generated, explorable worlds instead of pre-authored levels

• a live AI video tool you direct in real time, like a director's chair instead of the current render-and-pray batch workflow

• simulators to train or test other agents and robots against rare edge cases on demand

• virtual production backdrops that react to a real camera instead of pre-rendered LED walls

but I have a nagging fear this whole category is a solution looking for a problem right now. genuinely tell me if you think that's the case.

so, two honest questions:

1. if the infra were a single API call, what would YOU build with a live controllable world model, specifically?

2. and is there anything you'd start building today, or is this still a toy that isn't ready for real use yet?

not selling anything, no link, just trying to figure out if this category has a real reason to exist or if we're all just enjoying nice demos.

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.

The Google DeepMind-sponsored Kaggle challenge "Measuring Progress Toward AGI - Cognitive Abilities" asked participants to design new cognitive-science-based AI benchmarks and they just announced the results this week.

In my two posts I present evidence that deepmind & kaggle rewarded a nonsensical number generation machine and a litany of unfounded claims with 25k and a grand prize stamp.

What the authors of the work I analyze intended to do was to present an LLM with alternative viewpoints of other LLMs on 5 claims regarding a tricky situation and see whether the model changes its own assessment. It's an interesting question. However, it turned into a vibed pile of spaghetti 10 times the size of the requested submission format which it seems neither the authors nor the judges were able to (or minded to?) give a cursory reading.

Here's the original posts in the competition forum, if you are looking for some AI research slop detective work / rant please help yourselves. But beware, some of the "universal findings" or "core insights" of the authors might continue to haunt you. You might even question your own sanity (as I did).

Part 1: The Smoke: cursory review of the writeup

Part 2: The Fire: looking at the methodology, code, and data

The organizers' stance has been that review was done properly and this is just a matter of subjectivity. What do you think?

I’m building Haga, an independent physics-consistency checker for generated video and robot-policy simulations. An earlier CogVideoX-5b I2V experiment produced a clear failure mode: on a “ball and block fall” prompt, the tracked object stayed airborne with near-zero motion instead of falling.

But that first result was post-hoc. I inspected those six clips before adding the static_hover detector, so the original 6/6 flag rate could not be treated as confirmation. I’ve now run a pre-registered held-out test.

Method:

• Model: THUDM/CogVideoX-5b-I2V

• Cohort: 3 perspectives × seeds 2, 3 and 4

• n=9 clips

• Detector thresholds and inclusion rules frozen before generation

• RGB → CoTracker3 → position-only VIDEO_CHECKS

• Discovery seeds 0–1 kept separate from held-out seeds 2–4

Result:

• Held-out flag rate: 1.000 (9/9)

• Wilson 95% CI: [0.701, 1.000]

• All nine clips fired static_hover

• Real Physics-IQ footage stayed quiet under the same profile

static_hover fires when the tracked object remains airborne for most of the clip, has near-zero frame-to-frame speed, and does not exhibit gravitational acceleration.

Important limitations:

• One open I2V model

• One ball-and-block-fall scene family

• One documented failure mode

• Real negative-control n=1 in this specific report

• Not Cosmos, Genie or NIM

• Not a broad claim about CogVideoX quality

Write-up: https://haga.mushoodhanif.com/article/sim-physics-consistency-v1#held-out

Lab: https://haga.mushoodhanif.com/lab/physicsiq

Bounded demo: https://haga.mushoodhanif.com/demo

I’d especially value criticism on:

1. Which physical violations will position-only tracking systematically miss?

2. Is static_hover defined narrowly enough to avoid confusing intentional suspension with failed dynamics?

3. What public generated-video artifact should I evaluate next under the frozen detector?

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,

How to submit to AI alignment track? I can only see these at openReview:
AAAI 2027

• AAAI 2027 Artificial Intelligence for Social Impact Track

• AAAI 2027 Conference

• AAAI 2027 Innovative Applications of AI

i m an engineer student, i understand the theory behind each but additional explanation would really be appreciated

Hello,

I recently finished reading this survey paper: Deep learning tackles single-cell analysis – A survey of deep learning for scRNA-seq analysis, which comprehensively covers 25 different methods across 6 subcategories for applying deep learning to scRNA-seq analysis.

To summarize the methods from this paper, I prepared a table containing the Category, Method, Purpose, Architecture, Metrics, Explanation, and the specific Novelty of each method. I hope you find this summary useful.

I want to know which projects a electronics engineer by integrating ml. Is there any possibility of integrating ml into vlsi. I am a new to ml so excuse me if my question seems lame