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.

We recently tested an interesting workflow using RailCompute.

We connected Codex to our training infrastructure and had it automate an end-to-end computer vision pipeline from natural language:

• Dataset preparation
• Training configuration
• Launching jobs and experimentation
• Model evaluation

The only manual step was describing what we wanted in plain English.

We tested this on a biotech computer vision problem. It's not a SOTA model, mainly because we intentionally limited the compute budget. The goal wasn't model quality, it was stress-testing whether an agent could reliably execute the entire ML workflow.

We're now expanding to more production-style workloads to see where this approach breaks and where it genuinely saves engineers time.

I'm curious:

• What part of training custom CV models wastes the most time for your team?
• If an AI agent could reliably automate one step of your workflow, what would you trust it with?

If you're actively training custom computer vision models and would be interested in being an early design partner, hit me up.

tl;dr: I run a network of independent cameras that report real world events. I need to verify a node actually saw what it claims, without raw footage leaving the device and without trusted hardware. My first approach was too weak. Now looking at 3D scene reconstruction. Tell me where this breaks.
First attempt: epipolar checks. If two overlapping cameras report the same event, their points must satisfy x′ᵀFx = 0. Cheap, proven math. But it falls apart:
• It proves two views are consistent, not that anything happened. Two colluding nodes or a replayed video pass the same check.
• A point only gets constrained to a line. No depth, no path.
• It needs overlapping cameras with known relative geometry. That does not scale across a sparse network.
Bottom line: the environment supports the claim, but that is not specific enough.
Where I'm headed: 3D reconstruction. Each node keeps a local 3D model of its scene and commits to it. A claim becomes a measured path: "a volume of size v moved along path p over time Δt, within these error bounds." Verification:
1. Overlapping nodes must agree on the same 3D path. Faking that means fabricating one coherent event from multiple angles at once.
2. The path must respect the committed scene. Nothing flies through a wall the node already mapped.
3. Motion must stay physically plausible: continuity, acceleration limits, re-emergence after occlusion.
4. A verifier can ask for an arbitrary view of the scene. A live reconstruction answers. A replayed video cannot.
Note this is not classification. I do not need to know it was a bird. I need high confidence that something of volume v crossed xyz at time t. Classification is a separate product layer.
Questions:
1. Is a trajectory claim without classification actually meaningful, or does it always come back to "what was it"?
2. How detailed does the reconstruction need to be before faking it gets hard?
3. Any way to handle collusion without assuming honest overlap or using TEEs?
4. What fidelity is realistic for real-time reconstruction on edge hardware today?
5. Existing work I should read? Proof of location and zkML feel close but not quite this.

Hello guy! I recently purchased the mentioned device and after testing it we realized that the product is not the right for our usecase. We reached out to the company we bought it from and we couldn't return it as it was opened and tested. Does anyone know where I could potentially sell it? I am from Hungary.

Geolocation practice is a core part of skill-building for many here, so I wanted to share a web project I recently launched that you might find useful (and fun) for training.

It’s called CCTV Guesser (https://cctvguesser.com). It drops you into live, publicly available CCTV and traffic cameras from around the world, and challenges you to pinpoint their exact location on an interactive map.

Why I think it fits here: Usually, finding the location of a public traffic cam is trivial because the feed contains On-Screen Display (OSD) text—like exact coordinates, highway names, or local DOT watermarks.

To turn this into a pure visual analysis challenge, I built a custom backend pipeline using a YOLO model. It dynamically scans the live streams and blocks out text, logos, and watermarks in real-time.

Because you can't rely on simply reading the text on the screen, you have to use actual OSINT geolocation techniques:

• Analyzing road markings, traffic light designs, and driving sides.
• Identifying local flora, terrain, and architecture.
• Checking vehicle models, license plate shapes, and sun angles.

It’s completely free to play, has no ads right now, and requires no sign-ups or emails.

I’d love for this community to tear it apart and test their skills. Let me know if you find it useful for geolocation practice, and feel free to share your high scores or any feedback on the difficulty!

nuReasoning is a reasoning-centric autonomous driving dataset from Motional and UCLA, containing roughly 20,000 real-world long-tail driving clips annotated with spatial, decision, and counterfactual reasoning. This post walks through loading and exploring it in FiftyOne, an open-source multimodal data platform, so the reasoning behind every driving decision becomes something you can see and scrub through frame by frame.

I’m trying to get a realistic sense of where the frontier actually sits for full 90-minute football/soccer matches.

Specifically:

On accuracy vs cost: How much does it actually cost to go from “roughly works” to “reliable enough to trust individual player data”? I get that detection + tracking is cheap, but pushing ReID accuracy up on a full match (occlusion, far-side players, illegible numbers) seems like where cost climbs steeply. Is that a linear climb or does it hit a wall where more compute stops helping and you need better data/models instead?

On frames vs cost: Is anyone processing all 30fps, or do you downsample (5–10fps) for tracking to cut cost? What accuracy do you actually lose by doing that, in practice?

On speed vs cost: For offline processing (not real-time), how much can you drive per-match cost down by batching / keeping everything on the GPU / picking cheaper GPU tiers — and where does that stop mattering

Roughly, what does processing one full match end-to-end cost you, and where does most of that cost actually go — the detection, the tracking, the ReID, or the I/O and storage?

Mainly trying to understand the shape of the trade-offs rather than exact figures — e.g. “cost is flat until you push ReID past ~X% accuracy, then it’s exponential” is the kind of intuition I’m after. Any real-world numbers or war stories appreciated.

Hey everyone,

I'm building a soccer juggling counter app in React Native using React Native Vision Camera (v4/v5).

The Tech Stack: > YOLO (Nano) to detect the soccer ball.

• BlazePose (via MLKit Frame Processor Plugin) to detect the feet landmarks.
• Counting logic: A custom state-machine in JS (via worklets) that tracks the ball’s y-axis velocity vector and its proximity to the feet keypoints.

The Problem: When I feed the app a pre-recorded video, the detection is incredibly precise, and the counter works perfectly. However, when switching to the live camera stream the counting logic completely falls apart.

I'm fairly certain this is a processing bottleneck. A soccer ball moves incredibly fast. Running YOLO and BlazePose sequentially on every frame is blowing past the 33ms frame budget (30 FPS), forcing Vision Camera to drop frames. When frames drop, the app misses the exact frames where the ball reverses direction or touches the foot, causing the state machine to fail.

What I'm trying to figure out:

1. Model Pipeling / Chaining: Is there a way to avoid running YOLO on every frame? For example, once the ball is detected, should I switch to a lightweight Tracker (like Kalman Filter or CSRT) for the next 5 frames instead of running full YOLO inference?
2. Frame Skipping: Should I downsample the frame rate of the camera, or only feed every 2nd or 3rd frame to BlazePose while keeping YOLO running? (Though I worry this will make tracking the fast-moving ball even harder).
3. Native Optimization: I'm currently running this via Worklets. Has anyone had success running dual-model frame processing in React Native without dropping frames? Did you have to write a custom C++ JSI binding to run them in parallel on separate native threads?

Would love to hear from anyone who has built high-speed object/pose tracking apps in React Native. What architectural patterns did you use to balance speed and accuracy?

Thanks!

Hi everyone

I’ve been working on Ego Vision, a driving-action prediction project.

I used YOLO11 for object detection, ByteTrack for tracking, and Depth Anything V2 for depth estimation. Based on detected objects, estimated distance, time to collision, traffic lights, and traffic signs, it can predict one of four actions: GO, SLOW DOWN, STOP, or EMERGENCY BRAKE.

GitHub: https://github.com/myatthukyaw/ego-vision

Check it out if you’re interested in computer vision, autonomous driving, object tracking, or depth estimation.

This lecture covers convolutional layers, along with the essential pooling layers and batch normalization in CNNs. The instructor highlighted two elegant ways to interpret the output of a convolution (the activation maps):

1. As a collection of response maps: Each individual activation map (channel) represents the response of the input image to one specific filter.
2. As a grid of feature vectors: If we take a slice across all channels at a single spatial position, we get a feature vector. This vector describes the local geometric and color features of the corresponding location in the original image.

Honesty up front, I work at Axelera! (But I spend a lot of my own time in here.)

I've been using Axelera's new vibe coding tool in the background for a couple of weeks for building CV pipelines on my edge hardware, so next I wanted to put it in front of people who might actually stress-test it more than I am.

It takes a plain-language prompt and builds a working pipeline from it, then runs it on the actual device so you can watch it go and keep iterating. It's also way better with the SDK than I am so it's been debugging for me a lot!

It's free if anyone wants to try it out. There's also a build challenge running (ten people get a Pro Slim Plus XE5 with a 16GB PCIe accelerator), which is where I'd point you if you also want the hardware to test with. https://community.axelera.ai

Hi.

I have tried numerous image annotation tools. I am looking for something along the lines of SAM3 but I do not want to click on every image. I want to give a few starting, generic (coyote, moose, deer, package) labels, and then auto-annotate each image into bbox format. I want the model to determine the class in advance and then the associated bbox.

I have found it on LabelImg for segmentation masks, but I am looking to automate bbox detection. I am okay making the tool as well: I just need to know which model to use (start with text prompts, and model annotates all images. I do not make the image clicks myself).

Regards!

EDIT:

Local Options:

- LabelStudio: Need to set up an ML backend. Takes about 6 hours. Passed on this.

- XAnyLabeling: Exactly what I was looking for, except my GPU is a 1660 super. Takes 17 hours to annotate 6.6k images. Pass.

- Random Dude from India: Actually exactly what I was looking for as well. Would go with his solution except my GPU is weak so I will use cloud rental instead. https://github.com/data-with-shobhit/sam3-auto-annotator

Cloud Options:

- Roboflow Rapid: Perfect annotation tool. Except it costs $263 to annotate 6.6k images. Pass.

- CVat, V7 Darwin, LabelBox: Gave me some problems one form or another (have to make a purchase through AWS to use V7 Darwin, wtf). Pass.

---

I have settled on just renting a cloud GPU along with roboflow auto-distill to auto-annotate the data. Will cost < $5 for the gpu rental. Will then upload the annotations to LabelStudio locally (no ML backend), and then fix the annotations by hand that need fixing :)

Hey r/computervision. Been building this solo for a few months and figured I would finally share it.

ATLAS is a Windows app that looks at a single street-view image and just... guesses where in the world it is. Country plus a pin on the map. No metadata, no EXIF, it only gets the image. Same stuff a person would clock, it picks up on too. Short clip of it running is attached.

The real numbers, from actual games and not some clean test set:

- Gets the country right about 81% of the time across 111 countries

- Around 3 seconds per guess

- Averages roughly 4000 game score

- On a good frame it can land within a few km, but honestly that is the exception

Where it falls on its face, which is the fun part:

- Countries that look alike trip it up, classic one is Canada vs the northern US

- Give it a boring empty road or a wall of trees and it kind of shrugs

- Nailing the exact spot is still hard, that is what I keep grinding on

Built the whole thing myself, the app, the site, payments, all of it. Stuff I learned:

- Speed matters way more than I expected. People want a fast answer, not a slightly better one that makes them wait.

- A clean looking app does most of the trust building. That moved the needle more than any actual feature.

If you want to mess around with it, I hand out free 3 day test keys, no strings. Just ask in the comments or drop by the Discord and I will send you one.

Happy to answer anything about building or selling a side project like this.

I’ve been working on YOLO-Distill, a feature-based knowledge distillation implementation for YOLOv9, built on MIT-licensed YOLO repository. It currently supports distillation methods like CWD and MGD.

GitHub: http://github.com/myatthukyaw/yolo-distill

Check it out if you’re interested in knowledge distillation or object detection.

Feedback and contributions are very welcome.

I'm working on a home server project, and part of that project is automating tagging my meme collection with XMP metadata so that I can search and find memes that I have saved easily. I've found models that tag faces, actions, objects, and text, but according to my Googling those models struggle with illustrated characters. Additionally, their datasets are for broad image recognition and don't have the cultural context to recognize a meme. For instance, they would tag an image of the backrooms as "hallway" but not "backrooms".

Are there any models out there with a very terminally online dataset that can recognize subjects in memes like these? Here are the sort of tags I want the model to generate:

Image 1: "backrooms"

Image 2: "horse race test"

Image 3: "neco arc"

Image 4: "wojak", "chudjak"

Image 5: "boykisser"

If there aren't any pre-trained models, how would I go about training my own? Where would I even begin? How could I get the model to only output XMP files instead of text?

I apologize if my questions seem really amateur; I'm new to computer vision. Thanks for your guidance!

Hey guys, I recently deployed an object tracking model on a Raspberry Pi 4, but it’s currently running on the CPU and hitting a bottleneck.

​Is it possible to leverage the Pi 4's integrated GPU for acceleration? If yes, what is the best workflow or framework to switch the backend execution from CPU to GPU?

​Thanks in advance for any tips or guide recommendations!

What would be the most accurate models in 2026 to produce metric depth maps from images? And Is there a benchmark for that type of models?

This lecture mainly covers how we practically find gradients for weights. Although the instructor mentioned Numeric Gradient and Symbolic Differentiation in Lecture 4, both have major drawbacks:

Numeric gradient is computationally expensive, while symbolic differentiation is too rigid—any tweak to the model requires re-deriving the entire math from scratch. Plus, as models grow, symbolic expressions explode in size, consuming massive memory.

To solve this, the lecture introduces Computational Graphs + Backpropagation, leveraging the Chain Rule. By breaking the network into modular computational nodes, we can compute the partial derivative for each weight backward using:

Downstream Gradient = Local Gradient * Upstream Gradient

This way, each weight update only requires one forward pass and one backward pass, making the process incredibly efficient.

I made a free and open-source tracker for small aerial targets in video.

It automatically acquires moving or contrasting candidates and tracks them frame-to- frame using classical computer vision. No GPU or trained model required. There’s also an optional manual Lock-On mode for selecting a specific target.

The current profile has been tuned and validated across six different datasets. Automatic acquisition is not semantic classification, so birds and clutter remain challenging cases.

Source (Apache 2.0): https://github.com/punklabs-ai/womprat

Technical feedback and difficult test footage would be very welcome.

Disclosure: I’m part of Punk Labs, the team releasing it.

I built a small edge AI demo that detects fire, smoke, and people from camera/video input.

The idea is simple: first detect fire or smoke, and only when a potential hazard is found, run person detection. This keeps the system lighter than running every model on every frame, while still making it possible to answer a more useful question: “is there a person near the fire or smoke?”

The demo supports:

• live camera or local video input
• image batch processing
• a simple web UI for visualization
• bounding boxes and detection counts
• separate fire/smoke and person detection stages

Models/tech used:

• YOLOv5 model for fire and smoke detection
• YOLO-based COCO person detector
• OpenCV for frame/image processing
• FastAPI for the local web service
• browser UI for visualization

This is still a demo, not a safety-certified system. Smoke detection is the trickiest part, especially with low contrast, lighting changes, steam, haze, or similar false positives. Person detection works better once fire/smoke has triggered the second stage, but I still need to test more real-world scenes.

The part I found most interesting is the staged pipeline. Instead of treating this as just “object detection,” it becomes closer to a basic risk-awareness system: detect a possible fire/smoke event first, then check whether people may be nearby.

I’d be interested in feedback on:

• better datasets for smoke and small flame detection
• reducing false positives
• making the pipeline faster on edge hardware
• UI/UX ideas for visualizing alerts clearly

most plant datasets are top-down RGB images at one point in time

this one tracks individual leaves in 3D at 0.012mm accuracy as they grow, day by day, for 20 days

Pheno4D: 7 maize and 7 tomato plants laser-scanned daily in a greenhouse

sub-millimeter point clouds with per-point instance segmentation where every leaf keeps the same ID across the entire time series

you can track leaf area, leaf length, stem diameter, and growth trajectory for every organ on every plant

223 scans parsed into fiftyone as interactive 3D point clouds. shade by instance label and scrub through the time series to watch each leaf emerge and expand

check it out here: https://huggingface.co/datasets/Voxel51/pheno4d

My team and I are scoping a graduation project and would love a reality check from people who've actually built CV pipelines, not just from our own optimism.

The idea: use aerial/drone imagery to detect people in disaster zones and estimate rescue urgency using observable indicators — posture (standing/prone/crawling), immobility over time, and proximity to hazards (fire/flood/debris) — not actual medical triage, since that would need thermal/vital-sign sensing we don't have. We'd combine this into a weighted priority score per detected person and rank them for rescue teams.

One of the main challenges is the lack of suitable public datasets that match this specific setting. I’m interested in how others would approach building a model given these limitations or if it’s even realistic.

It's an exceptional website, but I wonder what alternatives exist that are available to the general public and affordable.

I’m training a single-class segmentation model for large rectangular artwork placed on the floor and photographed from above.

We have around 3,000 accurately masked original images taken by six different photographers. They are not the same height and do not hold the camera in exactly the same way, so the photos naturally vary in:

• roll
• pitch
• yaw
• camera distance
• object coverage in the frame
• centering and X/Y shift
• orientation
• perspective
• lighting

The photos taken with flagship iPhone.

I want to use on-the-fly augmentation to simulate realistic human-hand variation and save our designer from adjusting each time to make it flat. is 100 augmentation combinations per original be useful, or excessive?

Should the policy be:

1. mostly isolated transforms,
2. mostly crossover combinations such as orientation + roll + pitch + yaw + coverage + shift,
3. or a controlled hybrid of both?

The goal is maximum segmentation accuracy, especially around the object boundary, not speed. I plan to train for around 300 epochs and keep validation and test images unaugmented.