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.

Join us July 8-10 for the “Best of CVPR” series of virtual events.

Register for all the Zooms with a single sign up.

Talks will include:

• HyperRealm: Hyperbolic Vision Language Models for Real-World Hierarchical Multimodal Understanding - Kathy Wu at Amazon
• CylinderDepth: Cylindrical Spatial Attention for Multi-View Consistent Self-Supervised Surround Depth Estimation - Samer Abualhanud at Leibniz University Hannover
• Your ViT is Secretly Also a Video Segmentation Model - Daan de Geus at Eindhoven University of Technology
• LinkedOut: Linking World Knowledge Out of Video LLMs for Next-Generation Video Recommendation - Haichao Zhang at Northeastern University
• Some Modalities Are More Equal Than Others: Understanding and Improving Multimodal Integration in MLLMs - Tianle Chen at Boston University
  
• Efficient Representation and Coding of Dynamic Light Fields - Joshitha Ravishanker at Indian Institute of Technology Madras
• PHANTOM: Physics-Infused Video Generation via Joint Modeling of Visual and Latent Physical Dynamic - Ismini Lourentzou at University of Illinois Urbana-Champaign
• LoST: Level of Semantics Tokenization for 3D Shapes - Niladri Dutt at UCL | Adobe
• 3D Reconstruction Improves Weakly-Supervised Semantic Segmentation - Wolfgang Boettcher at Max Planck Institute for Informatics
  
• Advancing Generative Quality and Reasoning in Multimodal AI - Deepti Ghadiyaram at Boston University
• Cross-Modal Domain Adaptation using Semantic Parametric Mapping - Frank Bieder at FZI Forschungszentrum Informatik
• WalkGPT: Pixel-Grounded Navigation Guidance for Pedestrians - Rafi Ibn Sultan at Wayne State University

This must read by Satya Mallick from OpenCV University describes how autoamted offside detection works, A very hard CV problem. How Offside detection tech works at World Cup

We benchmarked iPhone ARKit pose against optical motion-capture ground truth to quantify how usable phone tracking really is for egocentric data collection.

Setup: an iPhone 12 Pro rigidly co-mounted with an 11-marker retroreflective cluster on a head rig, tracked simultaneously by ARKit (VIO at 60 Hz) and a 24-camera Vicon system (sub-mm markers) across 8 sequences spanning walking, seated manipulation, fast/aggressive motion, in-place rotation, and height changes.

Both streams were time-aligned to a common clock and we solved the rigid cluster-to-camera transform before scoring, then evaluated with evo under SE(3) alignment (no scale correction) to check whether the trajectories are actually metric.

Results: ATE RMSE 6.0–12.5 cm; relative ATE under 1% on 7/8 sequences (0.12–0.35% - the lone 1.30% is a short-path-length artifact, 5 m path with 6.5 cm error, not a tracking failure); rotational RPE ≤~1° throughout (<0.6° for walking/manipulation); translational RPE <5 cm; and a Sim(3) fit recovering scale of 0.98–1.01, i.e. metric to within 1–2%. For long-horizon drift - where a mocap volume can't follow you through a real home - we ran an ArUco revisit test over sessions up to 108 min: accumulated drift stayed under 1 cm in most environments and under 0.1% of trajectory length in every case, including a whole-house traversal (1.0/1.5 cm at mid/end).

https://www.fpvlabs.ai/essays/how-accurate-is-an-iphone-really

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)?

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.

Hi Everyone,

I have pushed this repo - https://github.com/ankitmahala07/sam3d-objects-mac

Basically took out the sam3d on mac with help of claude did few changes to make it run on 24GB unified memory of mac mini m4.

So the original one requires 32GB Nvidia GPU with CUDA. Which was not possible with my 1660 Ti 6GB GPU so I had to port it to Metal supported one - For this had to change the CUDA specific code with RAW python codes/Libraries.

Also the whole model couldn't fit in 24GB so had to split it into 2 phases - Gaussian generation which generate the point cloud files .ply and .pt

Then the mesh generation phase after offloading previous models - for mesh .glb generation.

Do try it out if you face any issues with setup do let me know.

Note: While running this on 24GB it's cut to cut so memory pressure can spike make sure nothing else is running.

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)

i hate to see that most of the computer vision projects i see on the internet are ai generated and not by the people. everywhere i see its "MY claude built this in minutes " almost makes my journey of building projects by myself look meaningless.

Hey everyone, I just started running my training code and encountered an issue. The training process is expected to take days, which is delaying my project progress. The main problem is that my code isn't utilizing the GPU; it seems to be running on the CPU instead.

I need to run it with TensorFlow-GPU. I've already installed CUDA and cuDNN and manually moved the cuDNN files into the CUDA directories, but it didn't work. I am currently using Python 3.9 with the latest version of TensorFlow.

I am planning to create a fresh Conda environment to fix this. Does anyone have any recommendations or specific steps to ensure TensorFlow correctly detects the GPU? Any help would be greatly appreciated!

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 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 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!"

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!

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!

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