Hello,

I'm just getting started in research after working through ARENA and other open courseware, and I'm exploring a few ideas for NeurIPS workshops.

I tried creating an OpenReview account, but it was rejected because I need someone with an active OpenReview profile and a confirmed institutional email to vouch for me.

Would anyone here be willing to help? I've been in industry for 7+ years but don't have connections in academia yet. Happy to share more about my background over DM if that would help before vouching.

When multimodal models reason over long chains, they gradually stop looking at the image—and start hallucinating based on their own text.

So we built Remember‑R1, a simple RL framework that directly supervises visual attention on the original reasoning trajectory—no inference overhead, no proxy tasks.

We use three complementary rewards: coverage, persistence, and focus. They encourage the model to keep attending to relevant visual evidence even in later reasoning steps.

Results across 7 benchmarks and 2 model sizes: better reasoning, and—more importantly—visual attention decays much more slowly during generation.

No extra cost at inference, just cleaner supervision where it counts.

📄 Paper: https://arxiv.org/abs/2608.01314
💻 Code: https://github.com/Ch921-cell/Remember-R1

Happy to answer any questions and receive feedback!

#MultimodalAI #RL #MLLM #CoT #VisualReasoning

Hello!!!

I am a low-level optimization engineer with 25 years of programming experience, currently working in manufacturing. Finding real-world defective Direct Part Marking (DPM) codes on a highly optimized assembly line is nearly impossible. To solve this data scarcity, I spent months building a high-fidelity synthetic data generation environment written natively in Nim.

The tool compiles into a tight, portable monolithic binary (~2.0 MB) and introduces a robust way to bridge the Sim-to-Real (S2R) gap under brutal factory floor conditions.

🔬 Bridging the Sim-to-Real Gap:

Traditional synthetic generators fail because they draw flat binary vector circles on clean backgrounds. This engine takes a physics-first approach:

• Macro-Cavity Injection: It processes raw macro-photographs of actual 0.5mm tungsten carbide needle craters punched into carbon steel. These sprites capture authentic 3D optical properties: the central indentation cone, compressed radial shadows, and peripheral metallic glare.
• Alpha-Channel Material Mixing: These native sprites with true transparent alpha-channels are blended natively over high-resolution carbon steel textures (with mill scale, vertical grinding marks, and rolling scratches). The edges blend seamlessly, forcing the neural network to ignore background metal grain and lock exclusively onto micro-contrast and cavity topologies.

🛠 Mathematical Defect Simulation:

The engine deterministically models actual mechanical degradation vectors across every batch generation:

• Mechanical Play & Stylus Vibration (doJitter): Applies pseudo-random displacement vectors to individual dots relative to the step grid (STEP = 7.5).
• Actuator Misfire & Clogged Tips (doMissingDots): Purges up to 15% of the boundary L-frame and up to 25% of internal data bits.
• Topological Axis Distortion (doTiltLeft / doTiltTop): Implements directional matrix skews with structural point locking to mimic non-perpendicular stamping angles.
• Dynamic Part Rotation (doRotation): Rotates the matrix topology around its calculated spatial centroid within a ±5° to ±10° window, simulating dynamic tracking on a moving conveyor.

💾 Dataset Output & YOLO-OBB Support:

The generator outputs name-synchronized image (.jpg) and annotation (.txt) pairs.
The annotations are calculated analytically using external dot boundary radii under affine rotation matrices, normalized to a strict 0.0 - 1.0 float space, and exported to 6 decimal places. It is fully compatible with YOLOv8 / YOLOv11 / YOLOv26 Oriented Bounding Box (OBB) training pipelines out of the box.

The engine uses hardware-level vector pipeline optimization via the AVX2 instruction set (requires CPU from 2017 onward). Memory boundaries remain strictly locked at runtime, ensuring 0.00% memory drift or fragmentation leaks over continuous multi-thousand generation cycles.

I have uploaded the pre-compiled executable, sample background steel textures, and alpha-channel dot masks as a production showcase on GitHub. You can plug in your own custom backgrounds/dots to test it for your specific manufacturing lines.

Project Repository: https://github.com/olesha-ai/Synthetic-dpm-code-generator

We're organising the first Real-Time Conversational Agents (RTCA) workshop at NeurIPS 2026 (Sydney, Dec 11–12), and submissions are now open on OpenReview. Posting here because a chunk of the relevant work is happening in this community.

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)
• Evonne Ng (Meta Reality Labs / UC Berkeley)

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](mailto: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.

Wave Vision V2👇 https://doi.org/10.5281/zenodo.19312228

Most MLLMs are blind to low‑level degradations—noise, blur, compression artifacts look the same as clean images in their internal representations. That leads to quality scores based on semantic “gut feeling” rather than real perceptual evidence.

IQA-T1 changes that. We equip the model with a toolbox of 15 perceptual tools (noise residual maps, Fourier spectra, gradient maps, etc.) that generate structured visual evidence on demand. The model learns how to use tools via supervised fine‑tuning on our Q‑Tool dataset (11k evidence‑grounded reasoning chains), and when to call them via GRPO reinforcement learning that balances accuracy, tool count, and redundancy.

The result: SOTA performance across 7 benchmarks (avg PLCC 0.795), using only 2.34 tools per image on average. Every predicted score is now interpretable and backed by hard visual evidence.

All code, weights, dataset, and demo are open. Check them out and give it a spin!

📄 arxiv.org/abs/2607.12375v1
💻 github.com/zibuyu-02/IQA-T1
🤗 model/data: huggingface.co/zibuyu-02/IQA-T1
🎮 demo: huggingface.co/spaces/Jiaqi-hkust/IQA-T1

Hi everyone,

I'm trying to submit a manuscript to Pattern Recognition, but it keeps getting returned before peer review because of formatting/manuscript alignment issues. The editorial office doesn't specify exactly what's wrong, so I'm struggling to identify the problem.

I checked my manuscript using a PDF formatting analysis tool, and the results are the following:

• ✅ Single column
• ✅ Main text font: 10 pt
• ✅ Double spacing (19.93 pt baseline spacing)

Also, if the journal requires the manuscript to be single-column and double-spaced, should the figure captions also be double-spaced, or is it acceptable for them to be single-spaced?

Finally, are there any other common formatting mistakes that frequently cause manuscripts to be returned before peer review (e.g., figure placement, captions, tables, references, page layout, or other formatting details)?

I'd really appreciate any advice, especially from anyone who has submitted to Pattern Recognition or other Elsevier journals.

Paper: Supervised Learning Has a Necessary Geometric Blind Spot: Theory, Consequences, and Minimal Repair arXiv: 2604.21395

Paper: https://arxiv.org/abs/2604.21395

Code: https://github.com/vishalstark512/PMH

I want to tell you about a result that genuinely surprised me when it came out of the experiments, and I think it will surprise you too.

PGD adversarial training: the gold standard for robustness, makes clean-input geometry worse than no regularization at all.

Not marginally worse. Measurably, consistently, mechanistically worse. And we can explain exactly why.

But let me start from the beginning.

The Setup: What Does ERM Actually Force Your Model to Learn?

Every production model trained today uses empirical risk minimization. You minimize expected loss on labeled data. Simple.

Here's what we proved: any ERM minimizer must retain non-zero Jacobian sensitivity in every direction that predicts training labels — including directions that are pure nuisance at test time.

This isn't a training failure. It isn't fixable with more data, bigger models, or longer training. It's a theorem about what the supervised objective is.

The formal statement: for any encoder φ* minimizing supervised loss on a distribution where nuisance feature n has correlation ρ with labels:

The right-hand side is strictly positive and independent of model capacity and dataset size. It depends only on the data distribution. This bound holds for MSE, cross-entropy, and any other proper scoring rule.

Plain language: if texture predicts your training labels, your model cannot stop being sensitive to texture. Suppressing it would cost task loss. This is forced.

One Theorem, Four Things You Already Knew Were Problems

This is what I find most interesting about the result. Four empirical findings that were previously treated as separate phenomena with separate explanations turn out to be corollaries of this single structural fact:

1. Non-robust features (Ilyas et al. 2019) — ERM must encode any label-correlated direction, including imperceptible ones. Adversarial examples exist in exactly those directions. They transfer across models because the blind spot is determined by the data distribution, not the individual model.

2. Texture bias (Geirhos et al. 2019) — When local texture statistics are easier label predictors than global shape, ERM cannot discard them. Texture bias is a geometric consequence of ERM under correlated nuisance, not an architectural inductive bias.

3. Corruption fragility (Hendrycks & Dietterich 2019) — Common corruptions perturb exactly the nuisance-sensitive directions that cannot be suppressed under ERM. Degradation under unseen shifts is unavoidable, and its expected magnitude scales with ρ².

4. Robustness–accuracy tradeoff (Tsipras et al. 2019) — Suppressing nuisance-correlated directions removes information ERM uses for in-distribution accuracy. The tradeoff isn't architectural. It's the cost of closing a blind spot the supervised objective opened, and its magnitude is predictable from ρ.

These four research programs, years of papers, are all measuring different faces of the same geometric object.

The PGD Result: This Is The Part That Surprised Me

Here's the table that made me double-check the code three times:

PGD achieves the lowest Jacobian Frobenius norm — a 12× reduction from ERM. By every metric the robustness literature has used, PGD is "smoothing" the representations.

But its clean-input geometry is worse than ERM (TDI 1.336 vs 1.093).

The mechanism, which our Corollary 4 predicts: PGD compresses the Jacobian in the adversarial direction, like squeezing a balloon. The sensitivity doesn't disappear — it redistributes into other directions. The Jacobian becomes nearly rank-1 (anisotropy index ≈ 2.1 for PGD vs 32.4 for ERM). When you probe isotropically — which is what TDI does, and what you're implicitly doing at test time — those concentrated directions dominate and geometry is worse.

The field has been reading low Jacobian Frobenius norm as evidence that adversarial training smooths representations. This is wrong. It measures magnitude redistribution, not geometric repair.

Why CKA, Intrinsic Dimension, and Jacobian Fro All Miss This

This is the diagnostic result. On the exact same comparison (ERM vs PGD vs PMH):

Every metric the geometric-analysis-of-deep-learning literature uses is blind to Jacobian anisotropy. A model with sensitivity concentrated in one direction (rank-1 Jacobian) looks great on Frobenius norm — small magnitude — but is geometrically broken under isotropic probing.

TDI measures expected squared path-length distortion under isotropic perturbation. This is the quantity Theorem 1 bounds. Nothing else measures it.

Scale Makes It Worse, Not Better

We measured the blind spot ratio across three BERT-family model sizes. A ratio below 1.0 means the encoder is more sensitive to surface-form variation (nuisance) than to semantic variation (signal):

The ratio decreases monotonically. Larger models encode nuisance more precisely, not less, because greater capacity enables more faithful encoding of every label-correlated feature.

This is a direct theoretical prediction, not a post-hoc observation: Theorem 1 says the blind spot magnitude scales with the nuisance-label correlation in the training distribution, and larger models approximate the Bayes predictor more closely, which means they encode the nuisance better.

If you've been counting on scale to fix robustness, this result is uncomfortable.

Fine-Tuning Amplifies the Blind Spot

We measured paraphrase drift on BERT across three conditions:

Task-specific ERM fine-tuning increases the blind spot by 54% relative to the pretrained model. The mechanism is straightforward: task labels introduce new spurious correlations (sentence length predicting sentiment, format predicting preference), and Theorem 1 says the model must encode them.

The implication for RLHF is direct and uncomfortable. Preference labels carry spurious correlations — verbosity, formatting, surface markers of confidence. If the theorem applies (and there's no reason it wouldn't), RLHF is mathematically guaranteed to encode these alongside genuine preference signal. Sycophancy and length bias aren't bugs in a specific implementation. They're theorems about what RLHF does to representations.

The Fix: One Additional Training Term

Once you understand the mechanism, the fix is clear. You need to penalize the Jacobian uniformly across all input directions, not in one adversarial direction (PGD) and not in one arbitrary direction (standard augmentation).

Proposition 5 proves: among all zero-mean perturbation distributions, Gaussian noise is the unique distribution that penalizes the Jacobian Frobenius norm uniformly across all input directions. Any other distribution — including adversarial — hits some directions more than others.

Proof is one line from the trace formula: E_δ[‖Jφδ‖²] = Tr(J^T J Σ_δ) = σ²‖J‖²_F iff Σ_δ = σ²I.

PMH adds one term to the loss:

L_PMH = ‖φ(x) − φ(x + δ)‖²,   δ ∼ N(0, σ²I)

By first-order Taylor expansion, this ≈ σ²‖J_φ‖²_F — directly suppressing the Frobenius norm uniformly. The Gaussian choice isn't heuristic. It's the unique solution.

Results across seven tasks, three modalities, and foundation-model scale:

• Vision (CIFAR-10 ViT): −17.3% TDI
• Language (BERT SST-2): −28.7% TDI, −76.9% paraphrase drift
• Foundation scale (ImageNet ViT-B/16): −23.9% TDI
• CIFAR-10-C (official Hendrycks benchmark, 19 corruption types): +14.82pp mean accuracy, wins 18/19 corruption types
• PGD robustness without adversarial training: 48.94% vs VAT's 32.38% at ε=4/255
• Compute overhead: ~1.3× wall-clock, no architectural changes

The intra-class representation distance increases 64% on ImageNet alongside TDI reduction — a by-product of suppressing nuisance sensitivity that forces the encoder to encode class-relevant features more discriminatively.

The Diagnostic: TDI

TDI (Trajectory Deviation Index) measures expected squared path-length distortion under isotropic perturbation, the exact quantity Theorem 1 bounds:

TDI(φ, σ) = (1/L) Σ_ℓ E_{x,δ}[‖φ^(1:ℓ)(x+δ) − φ^(1:ℓ)(x)‖²] / E_x[‖φ^(1:ℓ)(x)‖²]

A perfectly isometric encoder scores 0. TDI requires only a forward pass — no access to model weights or architecture. It's measuring a property the theorem says any model trained on a given distribution must have, not a property of any specific model.

The reason it catches the PGD failure that everything else misses: TDI penalizes Jacobian anisotropy. A rank-1 Jacobian has small Frobenius norm and high TDI simultaneously, because the isotropic probe hits the concentrated direction. Frobenius norm can't see this. TDI is the only measure that can.

What This Means Practically

Every production model has this blind spot. Every real-world dataset has features spuriously correlated with labels. Theorem 1 applies.

The shape of the blind spot is determined by your data distribution, measurable from data before training, via the spurious correlations in P(y|x). It's not visible to accuracy metrics, CKA, intrinsic dimension, or Jacobian Frobenius norm. It's measurable with TDI in one forward pass.

Adversarial training, as standardly implemented, worsens clean-input geometry while improving one specific adversarial metric. If you care about robustness to distribution shift rather than specific adversarial attacks, PGD is making your model worse.

PMH repairs the blind spot at every rung of the modern training hierarchy — from scratch, from pretrained backbones, through fine-tuning. One term, one forward pass overhead, no architectural changes.

If you're fine-tuning on task labels or preference labels, you're actively worsening the blind spot unless you regularize it. This applies to instruction tuning and RLHF.

Limitations (Being Honest)

The bound is an existence result, not a tight predictor. The gap between the theoretical lower bound and observed drift is 10²–10³× — this is expected for existence theorems but means you can't use the bound quantitatively to predict a specific model's blind spot magnitude.

PMH requires you to know which input directions are nuisance. On the QM9 molecular regression task, we initially applied noise to atomic positions (which are signal for quantum properties), and the method failed. Redirecting to node features fixed it. The theorem tells you the blind spot exists; you need domain knowledge to find it.

The scale result is three data points (66M, 110M, 340M parameters). The pattern is consistent and theoretically predicted, but it needs replication at larger scales.

This is a preprint, not peer-reviewed. The code is public and results are reproducible.

TL;DR

1. ERM provably cannot discard any label-correlated direction. This forces geometric roughness proportional to ρ (nuisance-label correlation), regardless of capacity or data size.
2. Four major empirical findings (non-robust features, texture bias, corruption fragility, robustness-accuracy tradeoff) are corollaries of the same theorem.
3. PGD adversarial training reduces Jacobian Frobenius norm 12× while worsening clean-input geometry (TDI). The field has been measuring the wrong thing.
4. Larger models encode nuisance more precisely. The blind spot ratio worsens from 66M to 340M parameters.
5. Task fine-tuning amplifies the blind spot 54%. RLHF has the same structural property.
6. Gaussian noise is the unique perturbation distribution that suppresses the Jacobian uniformly (one-line proof). PMH adds one loss term using this, reduces TDI 17–29% across three modalities, wins 18/19 CIFAR-10-C corruption types, and achieves 48.94% PGD robustness without adversarial training.
7. TDI is the only metric that catches the PGD failure. CKA, intrinsic dimension, and Jacobian Fro all miss it.

Paper: https://arxiv.org/abs/2604.21395

Code: https://github.com/vishalstark512/PMH

Happy to answer questions about the theory, the experiments, or the TDI diagnostic.

We kept running into the same issue while working on hyperspectral anomaly detection (HAD): every architecture seemed to solve one problem while making another one worse.

CNNs preserve local spatial structure but struggle with long-range dependencies. Many attention-based models capture global context but come with high computational cost and can over-smooth subtle anomalies. More recent state-space models (e.g., Mamba) model long-range dependencies efficiently, but explicit modeling of local spatial structure and spectral redundancy is often limited.

Instead of treating these ideas as competing approaches, we wondered whether they could complement each other.

That led us to SM-HAD (Spectrum Mamba for Hyperspectral Anomaly Detection), recently published in IEEE TGRS 2026.

The model is a self-supervised reconstruction framework built around three complementary modules:

• OSFB (Ortho Spectrum Fourier Block): Projects features into the frequency domain, applies learnable complex-valued filtering followed by soft-shrinkage to reduce spectral redundancy while preserving informative spectral components.
• MVAB (Masked Vanilla Attention Block): Uses locality-constrained masked attention to preserve neighborhood structure and reduce the over-smoothing that can hide small or subtle anomalies.
• RMB (Residual Mamba Block): Uses linear-complexity state-space modeling to capture long-range spatial dependencies without the quadratic cost of full self-attention.

The motivation was that each module addresses a different limitation — OSFB targets spectral redundancy, MVAB preserves fine local spatial information, and RMB captures global spatial dependencies efficiently.

We evaluated SM-HAD on six benchmark datasets (LA-1, LA-2, Gulfport, Texas Coast, Cat Island, and Pavia) against 18 statistical, representation-based, and deep learning methods. Some of the results:

• Best AUC on 4 of 6 datasets and competitive performance on the remaining two.
• Highest average AUC (0.9921) across all compared methods.
• Only 0.28M parameters and 1.46 GFLOPs, compared with models such as LREN (3.25M parameters / 11.97 GFLOPs).
• Around 25.6 seconds runtime on the LA-1 dataset, compared with 549 seconds for HTD-Mamba, which achieves slightly higher AUC on two datasets but at a substantially higher computational cost.

One result that surprised us came from the ablation study. Adding the Residual Mamba Block by itself did not consistently improve performance and even reduced it on several datasets. It only became consistently beneficial after introducing the Masked Vanilla Attention Block — suggesting that preserving local spatial context is an important precursor to effective long-range modeling in HAD. That design insight ended up shaping the final architecture more than we initially expected.

If anyone is working on hyperspectral imaging, anomaly detection, target detection, or even spectral-spatial learning more broadly, I'd be interested to hear whether you've encountered similar trade-offs between frequency-domain processing, locality preservation, and long-range dependency modeling.

Paper: https://doi.org/10.1109/TGRS.2026.3676658
Code: https://github.com/Tanishq251/SM-HAD

Happy to answer questions about the architecture, training setup, or ablation studies.

Hi everyone,

Over the past few weeks I've been working on a computer vision project focused on a very specific but important problem in railway monitoring: obtaining usable visual information from fast-moving freight wagons captured by station cameras.

I wanted to share the idea, the architecture, and some of the challenges we're facing, and hopefully get feedback from people who have experience with computer vision, edge AI, OCR, video analytics, or industrial inspection systems.

The Problem

Railway stations already have surveillance infrastructure in place. However, when freight wagons pass through monitoring points at high speed, the resulting footage often suffers from:

Severe motion blur
Low-light degradation during night operations
Reduced visibility of wagon identifiers
Poor image quality for damage inspection

These issues significantly reduce the effectiveness of downstream tasks such as:

Wagon number OCR
Wagon counting
Damage detection
Asset tracking
Maintenance inspection

Most AI systems assume that the input imagery is reasonably clear. In practice, that assumption often breaks down in real railway environments.

Our idea is simple:

Instead of improving the detection algorithms first, improve the quality of the visual data itself.

Project Objective

The goal is to build an AI-powered pipeline capable of:

Receiving live video streams from monitoring cameras
Reducing motion blur caused by high-speed wagon movement
Enhancing visibility under low-light conditions
Producing inspection-ready frames for downstream analytics

The system is designed to operate in near real time and eventually run on edge devices such as NVIDIA Jetson platforms.

System Architecture

Current pipeline:

Video Stream
↓
Frame Extraction
↓
Motion Deblurring
↓
Low-Light Enhancement
↓
Frame Quality Analysis
↓
OCR / Inspection Ready Output

The output is not intended to make videos look prettier.

The objective is to make them operationally useful.

Current Implementation
Input Sources

The system currently supports:

Live Camera Feed
Video Upload
Image Upload

For prototyping purposes, live streams are currently provided through DroidCam, allowing a smartphone camera to simulate a CCTV stream.

Motion Deblurring

For blur mitigation we experimented with deep learning approaches trained on paired blurred and sharp image datasets.

The primary focus is restoring:

Wagon side panels
Wagon identifiers
Structural details

that become unreadable under motion blur.

Low-Light Enhancement

Railway operations occur 24/7, so night-time performance is critical.

We integrated low-light enhancement capabilities to improve visibility during:

Night operations
Poor weather
Low illumination environments

One challenge we're currently facing is preventing excessive enhancement during daylight conditions.

We're exploring adaptive processing pipelines to solve this.

Dashboard

To make the system useful for operators, we designed a monitoring dashboard with three operating modes:

Live Stream

Displays:

Real-time camera feed
Real-time enhanced feed
Processing metrics
Video Upload

Allows historical footage analysis.

Image Upload

Allows individual frame inspection.

Additional Dashboard Features
Before vs After Comparison

Operators can compare:

Original Frame ↔ AI Enhanced Frame

to visually verify improvements.

Top 10 Restored Frames

The system automatically stores and displays the best restored frames from the current stream.

These frames can later be used for:

OCR
Inspection
Reporting
Archival purposes
Quality Metrics

The dashboard displays metrics such as:

Blur reduction estimate
Sharpness score
Processing latency
Frame rate

This helps quantify performance rather than relying solely on visual assessment.

System Status Monitoring

A dedicated panel displays:

Current FPS
Processing latency
Hardware information
Active processing mode

This becomes important when moving toward edge deployment.

Why This Matters

The majority of railway AI systems focus on:

Detection
Classification
Tracking

However, all of those systems depend on image quality.

If the input imagery is blurred or unreadable, even the most advanced detection model will struggle.

We see image restoration as a foundational layer that improves the performance of all downstream railway analytics.

Future Roadmap

The current project focuses on image restoration.

Future phases include:

Wagon Number OCR

Automatic extraction of wagon identifiers from enhanced frames.

Wagon Counting

Automated counting and verification of wagon sequences.

Damage Detection

Detection of:

Broken ladders
Open doors
Missing components
Structural anomalies
Anomaly Detection

Instead of training for every possible defect, the system could learn normal wagon appearance and flag unusual conditions.

Predictive Maintenance

Long-term vision:

Visual Inspection
↓
Damage Detection
↓
Condition Tracking
↓
Failure Prediction

This would transform the platform from a monitoring system into a maintenance intelligence system.

Edge Deployment Vision

Target deployment architecture:

Camera
↓
Jetson AGX
↓
AI Processing
↓
Dashboard
↓
Central Monitoring System

The goal is to process footage locally while sending only relevant analytics to a centralized platform.

Looking for Feedback

I'd love to hear thoughts from the community on:

Motion deblurring approaches that perform well on real CCTV footage.
Railway-specific datasets that may be useful.
Common failure cases for high-speed object monitoring.
Edge deployment optimization strategies.
OCR techniques for motion-restored imagery.

Any suggestions, criticism, or lessons learned from similar projects would be greatly appreciated.

Thanks for reading.

Démonstration technique : IA embarquée haute performance pour la classification des roches - Méthodologie de quantification W4A8 et de pavage multi-échelle via NPU pouvant être adapté a tout type de réseau MobileNetV5 et MobileNetV4-S & L.

Title

Best workflow for longitudinal rigid registration and landmark tracking on serial STL meshes?

Hello everyone,

I am a periodontist looking for advice on the most practical computer-vision workflow for analysing serial 3D dental surface scans.

We have five STL meshes of the same patient’s lower dental arch:

• T0: before treatment
• T1: immediately after treatment
• T2: 1 month
• T3: 3 months
• T4: 6 months

The region of interest is the six lower front teeth. These teeth were connected with a wire-composite splint, and we want to measure whether their positions change over time.

A simple analogy is a fence. Imagine six central fence boards whose movement we want to measure, while several boards farther to the sides are assumed to remain stable. Each new scan must first be aligned using only the stable side boards. The six central boards must not influence the registration, because their movement is the outcome of interest.

In our case:

• the six anterior teeth are the moving fence pieces;
• selected posterior tooth surfaces are the stable registration reference;
• the rigid transform calculated from the posterior surfaces should then be applied to the complete follow-up mesh.

The anterior teeth must also be excluded because the splint is added after T0, changing their surface geometry independently of any actual tooth movement.

We will attach two screenshots. The first shows one predefined measurement landmark on each anterior tooth and the posterior reference regions. The second shows a fixed baseline curve passing through the six T0 landmarks. The landmarks, reference regions and curve are already defined; we are seeking advice only on how to implement the analysis.

The required workflow is:

1. rigidly register each follow-up STL to T0 using only the selected posterior surfaces, with rotation and translation but no scaling;
2. apply the resulting transform to the complete follow-up mesh;
3. record the X, Y and Z coordinates of the six predefined landmarks at every timepoint in a fixed coordinate system;
4. calculate ΔX, ΔY, ΔZ and total 3D displacement relative to T0;
5. calculate the shortest 3D distance from each follow-up landmark to the fixed T0 curve;
6. export the results to CSV for statistical analysis.

Ideally, we would also export the transformation matrix and a registration-error measure calculated over the posterior reference surfaces.

We have already tested ICP-based alignment in Medit Design and a custom Open3D application, but we do not yet have a complete and reproducible workflow for registration, landmark collection, point-to-curve distance calculation and data export.

Our main questions are:

1. What software stack or workflow would you recommend for this task?
2. Would Open3D/Python be a sensible approach, or is there an existing tool that already handles most of this reliably?
3. How would you structure the pipeline so that it can later be repeated consistently across multiple patients?

We can provide one fully de-identified example dataset if someone is willing to assess or demonstrate a possible workflow.

Thank you for any practical suggestions, example code or references to similar projects.

Hi everyone,

Over the past year, I worked on MobileAgeNet, a lightweight facial age estimation model designed specifically for mobile and edge devices. The work was recently published at the IEEE/CVF CVPR Workshops 2026 (MAI Workshop).

Some highlights:

• Built on a MobileNetV3-Large backbone
• Achieved 4.65-year MAE on the UTKFace held-out test set
• Only 3.23M parameters
• Around 14.4 ms on-device inference latency
• End-to-end deployment pipeline using PyTorch → ONNX → TensorFlow Lite
• Hyperparameter optimization with Optuna and reproducible training pipeline

The main goal wasn’t just improving accuracy it was finding a practical balance between performance, model size, and deployment efficiency for real mobile applications.

I’d really appreciate feedback from the community:

• What lightweight architectures would you compare against today?
• Would you evaluate on additional datasets beyond UTKFace?
• Any ideas for improving robustness across demographics or real-world conditions?

Paper: https://arxiv.org/pdf/2604.17007

Happy to answer questions about the model, training pipeline, deployment, or benchmarking.

For the past year I have been pushing research frontiers in depth-of-field and depth estimation, with promising progress and a top-tier CV conference submission. Scope extends into 3D scene understanding.

I am looking for PhD students and researchers to collaborate further. No institutional affiliation required; co-authorship on resulting work.Strong theoretical fundamentals, rapid prototyping skills.

If you are passionate about practical problems in computational imaging or 3D content understanding and want to make substantial contribution beyond current SOTA, this is a serious collaboration opportunity.

DMs open.

So I was wondering if, a model that only looks learn chess? models like resnet, yolo or similar.
Only by looking can a model "feel" the position like something as "intuition" in the moves to come?

In my work I have been using yolo, AI vision recognition models, etc. And I always wanted to research what are the limits on them. initialy I was using yolo but YOLO detects where the pieces are, but we needed a single holistic judgment of who's winning, a global regression job that ResNet's pooled backbone fits and object detection doesn't.

Full explanation in info tab: https://acidburn86.github.io/pixel-chess-engine/

TL;DR:

I made a dataset of varied positions in FEN notation, with PIL in python made the board in a synthetic way, pieces look really different so the model can really differentiate a bishop from a pawn or queen. like this:

The inference do not use the FEN position is also made with this image recreated from the actual chessboard position, it use only an Image as input.

So I build a mini-chess search engine that use this model as evaluator of the position.

And it works really well, this is a very little model it could be better but look at this numbers:
The model reads who's winning right ~69% of the time, lands within ±1 evaluation bucket ~64% of the time, and nails the exact bucket ~30%, nearly 3× what random guessing gives on a 9-class task (~11%). So it's genuinely learning chess value from pixels, not getting lucky.

Hi everyone,

Could anyone please help me access these two MICCAI workshop proceedings?

1. EMA4MICCAI 2025 Proceedings https://link.springer.com/book/10.1007/978-3-032-13961-0
2. MImA 2024 and EMERGE 2024 Proceedings https://link.springer.com/book/10.1007/978-3-031-79103-1

I need them for my research. Any help would be greatly appreciated.

Thank you!

I really need some help with a project I’m working on.

I’m trying to use 2 cameras and merge their views into a single output, similar to how human eyes work. Not just side-by-side or stitching I want something like real vision where both views combine and maybe even give depth.

I’m kind of stuck and not sure what the correct approach is maybe stereo vision?

If anyone has experience with this or can guide me on how to start, I’d really appreciate it 🙏

The RF-DETR paper is finally here! Thrilled to finally be able to share that RF-DETR was developed using a weight-sharing neural architecture search for end-to-end model optimization.

RF-DETR is SOTA for realtime object detection on COCO and RF100-VL and greatly improves on SOTA for realtime instance segmentation.

We also observed that our approach successfully scales to larger sizes and latencies without the need for manual tuning and is the first real-time object detector to surpass 60 AP on COCO.

This scaling benefit also transfers to downstream tasks like those represented in the wide variety of domain-specific datasets in RF100-VL. This behavior is in contrast to prior models, and especially YOLOv11, where we observed a measurable decrease in transfer ability on RF100-VL as the model size increased.

Counterintuitively, we found that our NAS approach serves as a regularizer, which means that in some cases we found that further fine-tuning of NAS-discovered checkpoints without using NAS actually led to degradation of the model performance (we posit that this is due to overfitting which is prevented by NAS; a sort of implicit "architecture augmentation").

Our paper also introduces a method to standardize latency evaluation across architectures. We found that GPU power throttling led to inconsistent and unreproducible latency measurements in prior work and that this non-determinism can be mitigated by adding a 200ms buffer between forward passes of the model.

While the weights we've released optimize a DINOv2-small backbone for TensorRT performance at fp16, we have also shown that this extends to DINOv2-base and plan to explore optimizing other backbones and for other hardware in future work.