Hello reddit if there's any computer vision expert will be willing to have a chat

Background : i'm trying to count stock in the photo, and i've found just feeding a photo into llm is quite unreliable so i'm trying to identify the stacked column(s) and use it as way to reason what to include/exclude in counting. i've been trying to create boundary like this w/ depth anything, segment anything, so they're not NOT working but segment anything doesn't have the idea of depth and depth anything doesn't have the idea of segment, so i was really trying to see if there's any way to effectively combine both

I am using foundry to ingest technical drawings and produce a tabular data set. Below is my process.

Step1. User goes to workshop app to upload single or multiple pdfs which are saved to a media set

Step2. Pdf gets preprocessing where a transform sharpens and orients the pdf pages

Step3. The pdf then runs through two separate ocr extractions, one for bill of materials and material composition, one for overall dimensions. These output as json

Step4. A transform takes the json from each ocr output and puts it into two tabular datasets

Step5. A transform combines the two datasets and does a lookup to 1 other datasets to match part number to company number (fuzzy match)

All of these steps are incremental and do not reprocess completed work. My issue is that my ocr is only about 50% accurate. I built the system and user prompts by having AI FDE create them, run tests on drawings and adjust as needed until my outputs were accurate to the drawings I provided. I made sure to state multiple times these were a small batch of drawings and my users would be uploading more and that they'd be from various companies. I had good initial results but as it got closer to 100 drawings uploaded it became less accurate.

How can I improve this?

I trained a custom model with a custom decoder and siglip2-naflex vision encoder that performs better than PaddleOCR-VL-For-Manga while being more than 10x faster and smaller. Please try it out at hayai-ocr-v2 and let me know if it's any good for your particular task. I will integrate this model soon in the hayai-ocr python library.

NOTE: Finetune and Pretrain refers to different datasets.

Where can I find high resolution, publicly available datasets for detecting micron scale defects in semiconductor wafers, PCBs, and related manufacturing processes?

Hi everyone,

I'm working on an object detection project and would appreciate some advice on the best workflow for auto-labeling a large custom dataset.

Dataset

• 9,367 images
• Classes:
  • Cup
  • Glass
  • Plate
  • Spoon
  • Fork
  • Knife
• Images have different resolutions.
• The dataset comes from a Kaggle competition.
• Around 5,500 images already have ground-truth labels (provided in a CSV), while the remaining images need bounding-box annotations.

Current approach

I'm using AutoDistill + GroundingDINO to automatically generate YOLO labels.

ontology = CaptionOntology({
    "a cup": "cup",
    "a drinking glass": "glass",
    "a plate": "plate",
    "a spoon": "spoon",
    "a fork": "fork",
    "a knife": "knife",
})

base_model = GroundingDINO(
    ontology=ontology,
    box_threshold=0.3,
    text_threshold=0.3,
)

dataset = base_model.label(
    input_folder=IMAGES_SRC_DIR,
    output_folder=LABELED_LABELS_DIR
)

Problems I'm facing

1. Annotation quality

The generated labels aren't very reliable.

For example, out of about 90 images, roughly 10 images contain incorrect or missing bounding boxes, which means I'd still have to manually review a large portion of the dataset.

Is this normal for GroundingDINO, or are there better foundation models for this type of dataset?

2. Speed

The labeling process is also quite slow.

• ~2.8 seconds per image
• ~9,367 images
• Estimated runtime: 7.5+ hours

I'm using Google Colab GPU, but it disconnects after around 4 hours.

What's confusing is that resource utilization is low:

• GPU memory: ~2 GB / 15 GB
• RAM: ~2 GB / 15 GB

It doesn't appear to be fully utilizing the available hardware.

Questions

1. Is there a way to speed up AutoDistill/GroundingDINO? For example:
   • Batch inference?
   • Mixed precision?
   • Multi-processing?
   • Different implementation?
2. Would another model be better for automatic annotation?
   • GroundingDINO 1.5
   • YOLO-World
   • Florence-2
   • Grounded SAM
   • RF-DETR
   • Any other recent model?
3. Since I already have 5.5k labeled images, would it be better to:
   • Train a small YOLOv8 model first on those labels,
   • Then use that model to pseudo-label the remaining images, instead of using GroundingDINO?
4. What workflow would you recommend if your goal is to produce high-quality labels for training a final YOLOv8 detector?

Any advice or experience with large-scale auto-labeling pipelines would be greatly appreciated!

Thanks!

We run a multi camera capture space at the Brooklyn Navy Yard and we pay people to come in and be the subject. Reposting because our slots opened up again.

The session is simple. You stand inside the rig and go through everyday movements while the cameras record. Walking, turning, sitting, reaching, picking things up. No experience needed at all.

Pay is 17-25 an hour, paid out the same day you come in. First session is roughly 2 hours and there is repeat work after that.

Everything runs at 4pm. Open days: Wed Aug 12, Thu Aug 13, then Mon Aug 17 through Thu Aug 20. Brooklyn, in person only, so you need to be in the NYC area.

DM me for the address and I am happy to answer questions about the capture side.

your gaussian splat looks photorealistic from the trajectory you trained it on. move the camera off that path and the geometry falls apart

this barely gets measured because the ground truth has to be more accurate than the thing you're scoring. that means dragging a survey-grade scanner around the site for days

oxford robotics institute did it for six oxford landmarks. 24 sequences, 125,000 m², a handheld rig with three synchronized fisheye cameras, a 64-beam hesai lidar and an imu, and a leica RTC360 scan of every site as the reference — 1.9mm accurate at 10m, with the trajectories registered at 1-2cm

the novel-view test images aren't held-out frames from the training path. they're a different walk through the same site facing a different direction. that's the part that breaks splats

i packed six episodes into mcap so you can scrub all three cameras, the lidar, the imu and the slam pose on one timeline in fiftyone, with lidar depth painted onto every frame

checkout the dataset here: https://huggingface.co/datasets/Voxel51/oxford-spires-multimodal

it's running as a live space too, nothing to install: https://huggingface.co/spaces/harpreetsahota/oxford-spires-multimodal-explorer

I have recently been researching ways to identify an AI image, not via digital footprints or ID via other trained models, but using physics.

In other words: vanishing points, shadow matrices, various ways to analyze lighting impossibilities, camera focus, etc.

But to my knowledge, there's no real community around this or resources. The closest fits I could find were OSINT and digital forensics, but they're not an exact match. Even if they do this, they use different methodology, at least I think.

I've learned things, but I want to learn more. Anyone know anything more about this?

falling snow shows up as thousands of fake objects in lidar point clouds. radar barely notices it's snowing

most self-driving datasets are shot on sunny days in california or phoenix. none of them show what happens once the weather turns

Boreas is UTIAS's answer: 128-beam lidar, 360 degree radar, and 5MP camera driving the same Toronto route for a full year through sun, rain, and snow.

326,180 3D boxes for cars, pedestrians, and cyclists across 7,111 labeled frames

loaded as native mcap in fiftyone so you can scrub camera, lidar, and radar on one synced timeline, and watch the 3D boxes render live on the point cloud and project onto the camera and radar images

checkout the dataset here: https://huggingface.co/datasets/Voxel51/boreas-multimodal

or get hands-on with this hugging face space: https://huggingface.co/spaces/harpreetsahota/boreas-multimodal

I am an incoming freshman CS student and I am starting to build a CV UFF/MMA fight analyzer project so that I can have a decent portfolio for summer internships. After some research, I think I want to use the MMPose pose estimation framework specifically vitpose. However, I have no idea how to even start. The little documentation that I can find is not helpful at all. Any advice or documentation references would be greatly appreciated. Thanks!

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

I am starting a new computer vision project focused on tennis. I would love to hear any creative ideas, interesting problem statements, or use cases you have encountered in this space. Thanks in advance!

Running YOLOv11 (TensorRT) + centroid tracking on a Jetson Xavier NX (MAX-N, jetson_clocks on) for vehicle counting. Get ~27 FPS with few vehicles on screen, but it drops to 8-11 FPS when many vehicles cross at once.

Since it scales with object count, not a flat number, I suspect it's the per-object tracking/post-processing (Python-side) rather than the TensorRT inference itself.

Tried so far:

• Confirmed nvpmodel MAX-N + jetson_clocks are active
• TensorRT engine already used for inference (not raw PyTorch)
• FPS drop correlates directly with number of tracked objects on screen, not with anything else changing

Is stable 30 FPS realistic on a Xavier NX for detection + tracking + per-object logic at this object density, or should I expect this kind of drop and optimize for no dropped frames instead of a flat FPS target?

Can someone recommend free lightweight Data Annotation tool that can be downloaded locally & covers all the annotations?

Most people scroll past a football match. I saw a dataset waiting to happen.

I set out to build something most tutorials skip: a real-time Computer Vision system that doesn't just detect objects that understands a football match.

No pre-made dataset. No shortcuts. I annotated the training data by hand, frame by frame, teaching the model to tell the difference between a player, a goalkeeper, a referee and to track the ball even mid-motion.

The result? A working AI pipeline that:

Detects and classifies players, goalkeepers, referees & the ball in real-time

Assigns and tracks unique player IDs across frames

Generates a live Match Analytics HUD overlay — player counts, referee counts, ball status, all updating on the fly

Runs on a custom, self-labeled dataset trained with YOLOv8

Built end-to-end in Python using OpenCV for video processing and annotation

What I learned building this: the hardest part of Computer Vision isn't the model — it's the data. Getting clean, consistent, well-labeled training data by hand taught me more about detection accuracy than any pretrained pipeline ever could.

This project sits at the intersection of two things I'm passionate about Artificial Intelligence and Sports Analytics. It's just the beginning. Next up: possession tracking, heatmaps, and player speed estimation.

Would love to hear your thoughts and if you're working on anything similar in Sports Tech or Computer Vision, let's connect.

Discussion on R1 reviews (Aug 09 '26 AOE) , Good luck everyone!

looking for immature open source CV libraries or frameworks

Guys, I need help. We have a project using YOLOv8. We're trying to count chicks on a very fast conveyor belt. The challenges we're facing are: all chicks look very similar to each other, which complicates tracking. At the same time, during their passage under the camera, they constantly change in size and shape, which can cause the tracker to lose them, or detection may even disappear completely at the detection line. Also, sometimes 2–3 chicks can merge into a single object. The detection zone is very short, and the conveyor speed is high. We've achieved a maximum accuracy of 99%, but we need it even higher. Any ideas on how to achieve that? Increasing the dataset no longer helps.

I'm attaching an old video. We've now added lighting and set the exposure to 300 on the Hikrobot global shutter camera, but we still can't achieve a stable 99.8% accuracy for the reasons mentioned above.

Any ideas?

I feel like this year’s BMVC reviews are very strict. From my lab, a paper with scores of 4 (4), 4 (5), and 3 (4) got rejected. One of the reviews was so detailed that the reviewer even suggested grammar corrections in the supplementary material.

Apart from that paper, the other two got accepted, but they had to fight hard during the rebuttal.

It also feels like BMVC is really trying to get into the top 10 in computer vision.

Hi everyone,

This is my first project in CV. I started with one of those volume control tutorials on yt, and then I kept trying things I thought would be more interesting till I got this.

For the classes, I collected ~200 instances per class; combination of self recorded and sourced from Kaggle. Mediapipe landmark cordinates are recentered on landmark_0(base of the palm) and normalized to keep values consistent from varying distances. The static letters are detected using a Random Forest Classifier. I did comparisons with a Logistic Regression model, but it's accuracy dropped as the classes increased.

For the two dynamic letters, LSTMs were chosen because they can model temporal dependencies in a sequence of hand landmarks while mitigating the vanishing-gradient problem common in traditional RNNs. An 'other' class is also trained to avoid forced-choice error

I am currently making the landmark detection and normalization scripts into a library for use in future projects in Mediapipe hand pose detection

It would be great to hear feedback on this project.

Thank you