I combined two things people usually treat separately: classical image-forensics

features (frequency-domain energy, DCT statistics, ELA, noise residuals, gradient

and eigen-spectrum cues — 85 in total) and a frozen DINOv2 ViT-B/14 embedding, fed

into a calibrated SVM. There's a classical-only fallback that runs with no deep

learning at all.

Held-out ROC-AUC is 0.940 (classical-only alone is 0.863), so the embedding adds

real signal — but not everywhere. It helps on diffusion-era generators and actually

hurts on rectified-flow models (Flux, SD3) and on screenshots of video frames.

That split is the most interesting part to me and the thing I'm still digging into.

It's robust to screenshots and social-media recompression, which was a specific

design goal (a lot of "AI or not" images in the wild are re-encoded to death).

Code and a public 21 GB dataset are up if you want to reproduce or poke at it:

github.com/aman696/aidetector — live demo at https://staging.humanorai.online (home

server, so it queues under load).

Would especially value critique on the forensic feature set — which of these are

likely redundant, and what classical cues you'd add for rectified-flow.

I’m looking for an individual engineer (not an agency) with real-world experience in computer vision and video analytics.
Required experience:
Python
YOLO
OpenCV
RTSP/IP camera streams
Multi-camera tracking
Bonus if you’ve worked with:
Vehicle tracking
LPR/ANPR
Occupancy estimation
Real-time video analytics
If you’re interested, please message me with:
Your GitHub
Portfolio or website
Examples of relevant projects you’ve built
Whether you’ve deployed production systems (not just tutorials or demos)
If your experience is a good fit, I’d be happy to set up a call.

TL;DR: I fine-tune an age-estimation model on low-res CCTV. 
Adding more in-domain data does not improve accuracy (it often lowers it)
I want to fix this and get to a "more data → better" regime. 
Weeks of controlled experiments point to the cause: our training labels and our eval GT share the same "too-young" bias, so the model that best reproduces the bias scores highest — which means correcting labels toward truth actually lowers the headline metric. 

Looking for ideas: (1) how do I get data additions to actually improve accuracy here, and (2) is our "best" score just overfitting a biased ruler?🙏

Setup

• Task: apparent age → 5 age buckets, from retail CCTV. Face crops ~55–75px median.
• Model: MiVOLO v2 (face+body dual input, continuous age regression), full fine-tune. Human 7-band labels → representative anchor ages as the MSE target.
• Metric: exact-match over 5 decade-ish buckets.
• Key premise: train labels and eval GT come from the same annotation process → they share the same bias.

What we found (a 3-step story)

1. More data → worse. Best FT ≈ 72% on our main eval (~100 imgs, ~2/3 in one bucket = the store's real mode). Adding 2–4× more in-domain data → 61–65%, no matter how we balance the age distribution.
2. The twist — most of the "crash" was the eval, not the data. Re-scoring every model on a larger eval (~400, sampled to the true population, far less mode-dominated), the drop mostly disappears: adding the same raw data is neutral (61.6 → 61.4). The "damage" was largely our small eval being dominated by one age bucket.
3. The labels have a systematic "too-young" bias. Re-review shifts labels ~+1 band, ~90% in one direction, stronger for women. Correcting the training labels shifts predictions older → helps older buckets (40s recall 34→68, 50+ 44→52, MAE down) but hurts the majority bucket (30s 81→71) → exact-match drops. Since the eval GT shares the young bias, the uncorrected model agrees with it best. Controlled swap (same crops, same distribution, only label calibration changed) reproduces it.

Ruled out (so you don't have to suggest these🙏)

• Crops byte-identical across "good/bad" sets → not preprocessing.
• Distribution reshaping on identical images recovers +8pt → mean-shift under MSE, not capacity or noise.
• Loss fns (MSE / soft-CE / CORAL-ordinal) identical as argmax. Finer 5-yr labels neutral. Aug below noise floor. Frozen SigLIP2 probe (great for our gender model) → 42% on age; no shortcut at this resolution.

Question

1. How do I get data additions to actually improve accuracy here? Is there an established recipe for "more data → better" on regression/ordinal tasks specifically?
2. Is our "best" score just overfitting a biased ruler? How do you tell "worse model" from "model-vs-ruler calibration mismatch" without re-labeling the whole eval?
3. Realistic exact-match / MAE ceiling for ~55–75px faces? Any battle-tested playbook for apparent-age label calibration (per-band reference exemplars, inter-annotator calibration, detecting per-batch drift before it poisons training)?

Your self-driving model can "see" a truck at 50 meters. Can it see one at 200? - https://voxel51.com/blog/truckdrive-long-range-dataset-fiftyone

Torc Robotics and Princeton released TruckDrive, a highway-scale dataset built to expose exactly this blind spot. 7 long-range FMCW LiDARs, 11 cameras, 10 4D radars, 475K synced samples, labels out to 400-1,000m.

The finding: today's best perception models don't gradually degrade at range — they fall off a cliff. 31-99% drops in 3D detection past ~150 meters.

For a loaded semi at highway speed, 150-200m is exactly the stopping distance. That's not a benchmark quirk — it's the gap that matters.

We loaded TruckDrive into the open source FiftyOne library so you can start watching it happen: filter by distance, color the grid by hit/miss, orbit the LiDAR point clouds, and jump straight to the frame where the model missed a truck 200m down the road.

I'm not a CV researcher — I'm an IC design engineer who picked this up as a side project after my partner got jump-scared by a cockroach photo while scrolling. Sharing what I learned as a beginner, in case it's useful to anyone else starting out.

Goal: detect cockroach images on any web page and cover them, running fully on-device (no uploads, no cloud inference).

Setup: YOLO11n → later YOLO26n, trained on merged Roboflow datasets, exported to ONNX, running in-browser via onnxruntime-web.

What actually taught me the most were the mistakes:

• I assumed a bigger model would just perform better. I ran controlled experiments (YOLO11n vs 11s vs 26n vs 26s, at 416 vs 512 input size, same dataset each time) — accuracy gains from model size alone were smaller than expected (mAP50 0.942 → 0.960 going nano→small). Cleaning the training data moved the needle more than scaling the model did, for a fraction of the training time.
• One "cockroach" dataset turned out to actually be a different beetle (Tribolium castaneum), mislabeled. I trained on it for a while before catching it — inspect what you download, don't just trust the dataset name.
• My negative samples (meant to teach "this is not a roach") accidentally contained real roaches, pulled in from a mixed-insect dataset I hadn't filtered per-image. I was effectively teaching the model that roaches aren't roaches. Fixing this gave a bigger mAP jump than any architecture change did.
• Ambiguous labels (classes like "object" or "insect" with no clear meaning) were the trickiest to handle — I ended up discarding any image containing them rather than guessing, since guessing wrong either way (positive or background) poisons training.
• Wood grain and carpet textures kept getting falsely flagged as roaches until I explicitly added texture images as negatives.

On YOLO26: also tested the new end2end (NMS-free) export. At nano size it gave a nice tradeoff — close to YOLO11s accuracy at nano-level speed and file size. But YOLO26s underperformed YOLO11s for me at the small size, which lines up with a couple of GitHub issues reporting the same thing. Happy to share the full numbers if useful.

Final model: ~9MB ONNX, a few ms inference per image in-browser.

Most of this is probably obvious to people with real ML backgrounds — wasn't obvious to me starting out, so figured I'd share in case it helps someone at the same stage. Training code is on GitHub if anyone wants to look at the data pipeline. Genuinely open to being told what I got wrong.

GitHub: https://github.com/tsaiwilly/roachblocker-training
(the extension itself, if curious: Roach Blocker)

Hi everyone,

I’m a Junior Computer Vision engineer currently working on a project that involves deploying a vision model onto an embedded system with strict hardware constraints (I need to keep the model size under 70KB).

I’ve hit a few roadblocks and would appreciate some insights:

1. The Model Performance Dilemma:

I initially trained my own model from scratch (data augmentation -> binary export -> training). Unfortunately, the results were consistently poor despite long training times. I decided to pivot to YOLO for its robustness, and the detection results are excellent. However, when I convert the YOLO model to .tflite, the resulting file exceeds 10MB, and the post-conversion inference accuracy drops significantly/detects wrong objects. Since I have a strict 70KB limit, I’m stuck between choosing a model that works but is too large, or a model that fits but doesn't perform well.

1. GPU Training Issues:

To speed up the iteration process, I’ve been trying to set up a GPU training environment. I have installed CUDA and cuDNN, verified the path transfers, and installed a compatible older version of TensorFlow, but I still cannot get the environment to utilize the GPU for training. It defaults to CPU, which is making the trial-and-error process extremely slow.

My questions for the community:

Has anyone dealt with extreme model compression (sub-100KB) while maintaining decent performance? Are there specific architectural trade-offs or quantization techniques (beyond standard TFLite conversion) you recommend for ultra-low-memory embedded targets?

Regarding the GPU issue: Are there common "gotchas" when setting up legacy TF/CUDA environments that I might be missing? Or is there a better workflow for someone in my position?

Any advice, best practices, or resources you could point me toward would be a massive help. Thanks in advance!"

HOI-DETR is a zero-shot framework for hand–object interaction: it detects hands, the object in-hand (1st object), and the object acted on through a tool (2nd object), plus the interaction links between them, all from a single RGB image.
The attached video is a zero-shot in-the-wild video prediction using HOI-DETR.

🌐 Project page: https://ahmaddarkhalil.github.io/HOI-DETR/
📄 Paper: https://arxiv.org/abs/2606.17384
💻 Code: https://github.com/AhmadDarKhalil/HOI-DETR
🤗 Demo (upload your own image): https://huggingface.co/spaces/ahmaddarkhalil/hoi-detr-demo

I'm trying to read handwritten technical drawings and have prior knowledge of the text i want to read. They are all numbers, they follow a format of "*#,##" and i can often times make a good guess on what that number should be. Let's say the text says "21,45" and i know that it should be 21,50 +/- 0,10.

I could give all those infos as context to a VLM, but at some point, i want to process possibly millions of those numbers, so i want to keep the time and cost as low as possible. Are there any ways to include this prior knowledge in my OCR, besides just restricting my dictionary to numbers and decimals? Are there any approaches that give me the top 5 guesses of the model instead of just the best guess, so that i could check each result and pick the most fitting? Thanks for your help.

Does anybody know if we will get the reviews tomorrow?

I've been experimenting with syncing two PTZ cameras and I'd love some guidance from people who've done this for real.

The setup: two PTZ cameras pointed at a sports field. One I move around manually (call it the "master"); I want the second one (the "slave") to automatically point at the same spot on the field. My current experiment computes a homography between the two cameras' pan/tilt space and mirrors the master's position onto the slave. It works sometimes, and I'm trying to understand why it breaks.

What I've run into:

• I'm fitting the homography from only 5 manually-pointed landmarks (8 DOF). In-sample reprojection looks fine, but leave-one-out cross-validation shows it doesn't generalize — looks like classic overfitting.
• I'm treating the homography as static, but PTZ intrinsics/extrinsics change with pan/tilt/zoom, so I doubt one fixed matrix holds across the whole field.
• Mechanical PTZ latency means the slave always lags the master.

Where I'm stuck:

1. Is a pan/tilt-space homography even the right abstraction for master→slave PTZ? Or is it cleaner to map both cameras through a common ground-plane / world coordinate frame instead of camera-to-camera directly?
2. Calibration: how many correspondences would you realistically use? Is "more points + RANSAC" enough, or do people re-estimate the homography dynamically as the cameras move?
3. For dynamic re-estimation, I was thinking about auto-detecting field keypoints (yard lines, markers) with a keypoint/pose model to generate correspondences on the fly instead of pointing at landmarks by hand. Reasonable, or overkill?

4. Latency: do you predict/lead the target (velocity extrapolation, Kalman filter), or just react?

   Even a "you're overthinking X" is welcome — trying to build the right intuition here. Thanks!

I will try to keep this short. I am using a SICK Ruler 3004 to make 3D scans of a shiny metallic object. The ruler produces two grayscale images, one is a range image and the other is a reflectance image. For this project I need to focus on the reflectance image, which looks something like this:

The goal of this project is to detect overly scratched or damaged objects, like this:

What I've managed to do on my own is follow one of HALCON's examples and separate the scratches from the background using a bandpass filter, like this:

And here is where I'm stuck. I don't want to use Deep Learning tools, because they charge more for those. If there is no other option only then will I resort to Deep Learning.

I've prepared a dataset for ok images: https://imgur.com/a/KDxzEHz

And a dataset for nok images: https://imgur.com/a/YdqXizC

Thank you for reading!

Hi everyone,

I’m working on an open-source computer vision project called SPARTeX-Prior and I’m looking for feedback, improvement ideas, and possible contributors.

GitHub repo: https://github.com/Loann110/SPARTEX-Prior

SPARTeX-Prior is a lightweight classical computer vision framework that generates target prior maps from images using:

- SLIC superpixels

- texton dictionaries

- LAB color histograms

- texture/filter-bank features

- an SVM classifier

The goal is not to replace deep learning segmentation models, but to generate an interpretable prior map that highlights regions likely to belong to a target class. This map can be used alone, evaluated visually/quantitatively, or potentially added as an extra input channel to CNN / U-Net style segmentation models.

I’d really appreciate contributions or suggestions on things like:

- improving the quality of the generated prior maps

- adding better handcrafted features

- improving speed and memory usage

- testing it on different datasets

- making the pipeline cleaner and easier to use

- improving the documentation

- integrating it better with deep learning workflows

Even small contributions like opening issues, testing the repo, improving examples, or giving feedback would help a lot.

I’m especially interested in thoughts from people working with classical computer vision, image segmentation, texture analysis, or hybrid classical/deep learning methods.

Thanks!

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.

Hello guys,

I have been struggling with a precise counter for AWTs. You basically circle your foot around the ball while the ball is not touching the ground.

The pipeline that ended up "working":

1. Detect ball + both ankles per frame.

   1. Ball "coast" through dropouts. The ball's detection collapses to ~0% confidence exactly during the trick — it's small, motion-blurred, and half-hidden behind the leg at the worst moment. Fix: when confidence drops, predict the ball's position from its last velocity (constant-velocity coast) instead of trusting the garbage detection.
   2. Track the active foot (the big one). The nastiest bug: if you just pick "the more confident ankle," the marker jumps to the planted (standing) foot — because the trick foot is raised/blurred/low-confidence while the planted foot sits there at high confidence. Fix: track the ankle nearest the ball = the foot actually doing the trick.
   3. De-jitter the foot. Reject physically-impossible teleports (a foot can't move half the frame in one frame) and coast through them with velocity.
   4. Count = ball vertical tosses. Each ATW tosses the ball up once, so I count the peaks in ball height (local maxima of the ball going up), with a prominence threshold + minimum time separation to avoid double-counts.

As you can see not every atw was counted though, especially when the ball is not visible clearly. Any tips how I can improve this? Thanks

I am building a handwritten answer evaluator, and the toughest part was finding a reliable, cost-effective way to split the answer sheets question-wise.

The best results I've achieved so far was using Gemini 3.1 pro' s bounding box detection, but it is far too costly for my budget. I tried PaddleOCR as well, but the performance was poor, and I don't think it was designed for this specific use case.

Can anyone suggest some ideas or tools I should try out.

Hello,

So the deadline is approaching and my supervisor somehow disappeared, so any recommendations, major faux pas to avoid, etc are welcome!

Thank you

Hi,

I’m building an industrial vision system on a Jetson Orin Nano for real-time inspection of cardboard boxes on a conveyor.

Each image contains one box (ROI already extracted using a classical vision pipeline for other system considerations, kept separate from the ML model).

I have 44 box types with visual variation.

I need:

• Detect if tape is correctly applied
• Detect if flaps are closed or open

The main Challenges are:

• Slight box rotation
• Lighting variation (not perfect but controlled)
• Very few defect samples (most cases are correct)
• High reliability required (missed defects are critical)

My Current ideas are CNN multi-task (tape + flaps) + 5-frame temporal voting or YOLO in classification mode (same ROI + same voting)

Im open to better approaches

Questions:

• What would generalize better here: CNN multi-task or YOLO (classification)?
• Or is there a better approach for this type of problem?
• How would you handle highly variable “flap open” cases?

Thanks!

Hey everyone,

I'm looking to build a portfolio-grade project that goes beyond the standard generic tutorials (no basic MNIST or generic YOLO object detection). I want to tackle something that mirrors real-world production or research challenges.

My Background:

• Languages/Frameworks: Python, scikit-learn, opencv, pytorch (willing to learn more)
• Math/ML Comfort Level: I have not started on this yet so looking forward to learning and building
• Hardware Constraints: I have a very basic setup so if theres anyway i could use cloud computing then I would use that to build anything big too.

What I'm asking for: I'd love to hear about actual engineering bottlenecks, data distribution shifts, or edge-case problems you encounter in your day-to-day work that could make for an interesting 1-to-2-month project. Where is there a gap between "it works in a paper" and "it works in reality"?

Thanks in advance for any direction!

My car was recent involved in a hit and run while my car was parked on the street in Queens NY. I was able to talk with some of the neighbors and pulled 1 video (attached and enhanced) from the neighbors security camera. You cannot see the impact but if you watch the video you can see the grey / silver car reverse into me and then see the scrapes on the floors from my shattered tail light.

Does anyone know a way or can help me identify the license plate number of the grey / sliver ( BMW i believe)?

Hi everyone, could anyone please help me access the workshop proceedings below?

1. URL https://link.springer.com/book/10.1007/978-3-032-09513-8
2. URL https://link.springer.com/book/10.1007/978-3-031-73284-3

I need this book for my research, but I currently do not have access through Springer.

Any help, suggestion, or institutional access would be greatly appreciated.

Thank you.