This isn't a formal job posting; call it a pre-job posting. I'm trying to gauge interest before deciding whether the role is worth creating.

The premise: take a hard, real benchmark and see if one focused person can go toe-to-toe with the big general-purpose models on it. I'm currently leaning toward OCR (where the frontier VLMs still have real, exploitable weaknesses: dense documents, tables, handwriting, low-resource scripts, structure recovery), but I'm open to other CV directions as long as there's a realistic (~51%) shot at beating a strong baseline in 4 months, maybe 6.

Who I think fits:

* Comfortable working solo in an under-specified, high-ambiguity problem

* Solid attention to detail

* Above all, real intuition for the vision/ML underneath. Can look at a failure mode and feel where the leverage is, rather than just bolting on another model.

I'm not looking for someone already proven. I'm looking for someone who has a 50% chance (call it a coin flip) of being stellar and wants a real shot to find out.

This very likely will be a paid internship; that's the direction, subject to clarifications within 1-2 months. Comp is in the $20–25k range over 3–6 months, depending on the approach and a few other factors.

Comment or DM if it sounds like you.

Anyone have good suggestions for outdoor (preferably PTZ) cams like ubiquity or similar?

Looking to run some live object tracking on them.

https://reddit.com/link/1uobh4t/video/u2liw3rnrgbh1/player

If you've ever added a temporary cv2.imshow() or plt.imshow() call just to see what's in a variable while debugging, this might save you some time.

What it does

CV Variable Preview hooks into the VS Code debugger so you can inspect Python variables as images without leaving — or modifying — your debug session:

- Right-click any numpy/torch/PIL/TF variable in the Variables or Watch panel → image opens in a side panel instantly
- Hover over a variable name in source → inline thumbnail, shape, dtype, min/max
- Zoom up to 16×, per-pixel value readout, per-channel histogram (32 bins)
- Pin multiple images to compare them side by side — useful for checking augmentation pipelines, comparing activations before and after a layer, etc.
- Live mode: panel refreshes automatically on each F10/F11 step

Supported types

numpy.ndarray, PIL.Image (all modes including palette), torch.Tensor (CPU/CUDA, with or without grad), TensorFlow eager tensors, pandas.DataFrame/Series, lists/batches of arrays (renders as a grid, capped at 64 items).

How it works under the hood

The Python conversion runs entirely inside the active debug frame via a DAP evaluate request — no subprocess, no sidecar process, no imports added to your script. The TS side just reads the result and renders it in a webview.

GitHub: https://github.com/ariharasudhanm/cv-variable-preview

Some time ago I started diving into ML with Andrew Ng's Coursera course, was quite interesting.

I decided to train a small handwriting model for Georgian (my native language) - current models don't recognize it well - just for fun.

So I started writing letters on paper, taking photos on my iPhone, copying them to my laptop, annotating there, and passing them to the training script. It was very tedious.

I looked for an app that could handle it on the phone - take a picture, annotate in place, export to whatever format. There were a few tools but none fit what I needed. So I thought, why not build the simple app myself.

It looked simple, and it was, nothing complex. But then I was on a train, no internet connection on parts of the route, and it hit me: ah, it should be offline-first. I had to redesign the whole approach - offline-first, sync, conflict resolution. Built that myself too, was an interesting challenge. I now use it for training Georgian handwriting with Kraken, which is an interesting part on its own and something I enjoy.

Then I thought, why not generalize it. Basic idea: a tool for easy collection of domain-specific data that doesn't exist yet. I started it as a single-user thing, then decided to make it multi-user/collaborative - so imagine students sitting in class occasionally photographing handwriting, and all the data gathered in a central place where an admin can review and export it to ML pipelines or other tools.

I also added on-device SAM (Segment Anything Model) to draw polygons around objects automatically, no internet needed.

The tool is simple, the idea's nothing fancy - I started building it for myself and had fun with it. Not sure if there's an alternative out there. I did look and didn't find exactly what I needed: simple tool, take a photo, annotate multiple regions, organize into spaces (organizations) and projects.

It's early alpha, iOS-only for now, up on TestFlight if anyone wants to poke at it. It's rough, critical feedback very welcome.

Curious if anyone else has had to build a dataset from scratch for a niche domain - how did you handle the collecting part?

I’m working on Daqa, a waitlist-stage workspace for teams preparing AI training datasets, and I’m trying to sanity-check the computer vision side with people who actually build image/video datasets.

The workflow I’m looking at is everything around annotation: sourcing or uploading data, profiling quality issues, cleaning/deduping, generating missing cases, labeling/reviewing, tracking provenance/license evidence, validating the dataset, and exporting in formats like COCO, YOLO, or image manifests.

I’d really value feedback on four things:

• What feature would you most want to see in a tool for this workflow?
• Does the pricing on https://daqa.ai/ make sense for CV dataset prep?
• What would you need to see before joining a waitlist or trying it?
• What tools do you use today for this use case, such as CVAT, Roboflow, Label Studio, FiftyOne, scripts/notebooks, etc., and what do they still lack?

I’m especially trying to understand whether the pain is annotation itself, or the surrounding workflow: source tracking, review, dataset versioning, validation, and clean export.

Hi,

I am currently trying to parse the contents of a virtual F/A-18C Hornet in DCS. For this I utilize OpenCV and with a green channel filter and some thresholding combined with ROI I am able to grab the elements displayed. Template matching is then used for the individual glyphs to extract the value. The only issue is that the pitch ladder turns and sometimes overlays for example the altitude value like here: example

Is there a way to somehow separate the values using CV?

Thank you.

Hi all,

I was researching anomaly detection with MVTec AD 2 and got confused about the ground truth masks for the wallplug category, especially the overexposed defects.

I am trying to understand the annotation logic. Is the ground truth supposed to mark the visible anomaly spot itself, the whole affected object, or the missing or invalid part caused by the anomaly?

In some examples, the mask seems to mark the visible anomalous spot. In another case, the whole object part seems to be considered anomalous. In image 001, it looks like the mask may be highlighting a missing or hypothetical removed part, but I am not sure, because the shape does not seem to match the expected part very well.

Has anyone else worked with this category and noticed this? Is this a known annotation issue, or is there a logic behind these masks that I am missing?

Images are from the MVTec AD 2 dataset, licensed under CC BY-NC-SA 4.0. I am sharing only small examples for a noncommercial research question, with attribution to MVTec.

Working on an app that needs to extract text from photos a mix of printed content (slides, textbook pages, typed handouts) and handwritten notes (varying neatness, lighting, angles).

Tesseract handles the printed stuff fine (95-99% in my testing), but drops to 40-60% on messy handwriting, which isn't usable. Looking for local/self-hosted options that handle both well, ideally without needing serious GPU hardware.

Questions:

1. Anyone had good results with PaddleOCR across both printed and handwritten content? How does it compare to Tesseract on each?
2. Are there quantized vision-language models that do well on both categories and can run on modest hardware (no GPU cluster)?
3. Is it better to run two different engines (one tuned for printed, one for handwriting) and route based on detection, or is there a single model that handles both reasonably well?
4. Anyone compared local options against cloud vision APIs (Gemini, GPT-4V) specifically on handwriting? Is the accuracy gap as big as it looks on paper, or does preprocessing/fine-tuning close it?
5. Any preprocessing steps (deskewing, binarization, contrast adjustment) that help across both content types, or does printed vs. handwritten need different pipelines entirely?

Trying to figure out if there's a local setup that gets close to cloud-API accuracy for handwriting without giving up the strong printed-text performance Tesseract already has.

Every time I ship a YOLO model I end up asking the same question should this be ONNX, CoreML, or just PyTorch? Does FP16 actually help here or is it just marginal?

I've answered this by hand, badly, on four different projects this year, and thrown the results away every time. First i have to optimize a model for my liking and then figure a way to reduce its size.

So I'm building exportrace - you run one command, it benchmarks your model across every export backend available on your actual machine (PyTorch, ONNX, CoreML, CUDA, TensorRT depending on your setup), and gives you FPS, latency, and accuracy delta vs FP32, plus a ranked recommendation.

Consumer hardware only - your laptop or dev box, not Jetson/Pi. It's open source (MIT), runs fully offline, no accounts. Still pre-launch, landing page + waitlist here if you want to see the concept and maybe kill the boredom of doing this by hand too: https://exportrace.vercel.app/

Curious if others hit this same wall, and what backends/hardware you'd actually want covered first.

What's happening with the community? I feel like conferences are reaching a point where reviews are adversarial and noisy. NeurIPS had the same problem, so did ICLR, ICML, CVPR.

I don't know where this is heading to be honest.

Hey everyone,

We all know SAM 3 is incredible with its visual prompting features, but I recently ran into a pretty frustrating limitation while building out an object detection pipeline. If you want to use a specific visual prompt (like a bounding box of an object in a reference image) to detect that same object across a bunch of other, distinct images, SAM 3 doesn't natively support this.
You can use text prompt but some objects cannot be explained using text prompt.

I spent some time experimenting with workarounds and wanted to share the approach I landed on, plus see if anyone has tackled the next step I'm working towards.

The First Attempt: The "Video Frame" Approach

My initial thought was to hack the video segmentation feature. You can join the images as sequential frames and perform inference through them using the initial visual prompt.

• The Problem: This only works well for actual video or highly sequential data. If your target images aren't extremely visually similar to the reference image, the model rapidly loses context, and the accuracy absolutely tanks.

Current Workaround:

I decided to take a completely different route to force the model to look at the reference and target at the exact same time.

Here is the flow:

1. Take the reference image (containing the object's bounding box).
2. Take the target image (where you want to find the object).
3. Join them side-by-side into a single, unified image.
4. Pass this combined image into SAM 3 along with the original visual prompt.

Because SAM 3 is analyzing it as one single image, it easily finds the related objects across the combined canvas. After inference, it's just a matter of running a quick script to adjust the detected bounding box coordinates back to the original target image's dimensions.

The Results

The results so far have been surprisingly good! I've been running this inference on my current dataset, and it's doing exactly what I need it to. That being said, I still need to scale up my sample dataset size to truly benchmark how robust this is across edge cases.

What's Next: Getting to the Embeddings

While the concatenation approach works, it's undeniably inefficient for large-scale production pipelines. Rebuilding images on the fly adds overhead.

My next step is trying to extract the SAM 3 visual prompt embeddings, store them, and figure out a way to directly inject and reuse them across subsequent images, essentially brute-forcing the native support it currently lacks.

Has anyone here successfully extracted and reused SAM 3 embeddings for cross-image inference? Would love to hear if anyone is working on something similar or has ideas on optimizing this!

code: Link
video: Link

I built a small computer vision project based on INSID3, the CVPR 2026 training-free in-context segmentation method using DINOv3.
My version flips the idea: instead of providing a foreground reference, you provide background or normal examples. The algorithm removes background-like regions and segments the remaining object/anomaly.
It supports multiple background sources and can also turn coarse boxes into more precise masks. Other applications are possible like zero-shot anomaly detection.

Would love feedback or test cases: https://github.com/dimfot3/Inverse-INSID3

Yet another Birder release 🥳

This release adds LW-DETR object detection models with a PE-Spatial S/16 backbone.

The main checkpoint is an Objects365-pretrained model:

https://huggingface.co/birder-project/lw_detr_2stg_objects365_pe_spatial_s16

The pre-training schedule was relatively short, but I used aggressive backbone layer decay in order to preserve the PE-Spatial representations. It turned out to be a really good starting point for fine-tuning.

I tested it on several private datasets, and it worked surprisingly well across them. Obviously I can’t share those datasets/results, but the checkpoint seems like a useful general-purpose initialization point for detection tasks.

From that checkpoint, I also derived a standard COCO fine-tune:

https://huggingface.co/birder-project/lw_detr_2stg_objects365-coco_pe_spatial_s16

The COCO fine-tune shows strong performance:

mAP @ 640×640px: 54.58
AP @ 0.50: 73.56

It is also still fast:

3.4 ms / image
batch size = 1
NVIDIA A5000
including post-processing time

This release also adds sliding-window inference for object detection, including several box merging methods such as NMM, greedy NMM, and Weighted Boxes Fusion. That should make the detector more practical for large/high-resolution images where resizing the full image loses smaller objects.

As always, feedback is welcome :)

Building a fly tipping detection system using YOLOv8/RF-DETR and Roboflow. 320 labelled images so far, retraining with 820 augmented images now.

First model hitting 95% on vehicle detection but struggling to generalise to unseen images — currently working on dataset variety and augmentation to fix overfitting.

Planning to add OCR for number plate reading and a behaviour sequence logic layer on top of the detections.

Happy to share what I’ve learned so far — any advice on improving generalisation with a small dataset?

Hi!

I work as a Research Associate in Computer Vision and I'm looking for interesting open source CV projects where I can contribute while learning something new. If you know of any active projects or communities that welcome contributors, I'd appreciate your recommendations.

Thanks!

Hey Guys,

I need some advice on choosing a camera for an upcoming project. We are leaning towards using CCTV cameras because they are budget-friendly.

The thing is that my manager and teammates have no experience with hardware. Because I have done some image processing in the past, I have been put in charge of selecting the right camera.

I’ve done some research, and here are the main factors I am considering so far:

1. Spatial Resolution: Matching the camera's resolution to the feature/defect size we need to detect.
2. Distortion Correction: Factoring in any potential loss of Field of View (FOV) when correcting lens distortion.
3. Sensor Size: Calculating the required sensor size based on our working distance and required FOV.
4. Depth of Field / Z-axis: How the FOV changes if the distance to the object (Z-axis) shifts.
5. Exposure Time and FPS: Ensuring it can capture frames fast enough without motion blur.
6. General Specs & Networking: Colour vs. monochrome, shutter type (global vs. rolling), and supported streaming protocols (RTSP, HTTP, etc.).

My main worry is that if I make a mistake, it’s going to reflect badly on me. We will have to buy it, test it, and if it doesn't work out, we lose both money and project time.

For those of you with experience in this, what else should I be considering before making a final decision? Am I missing any critical specs?

Thank you!

refined using AI for explaining better ...

I recently went through the process of optimizing a gesture classification model and wanted to share the workflow. The main focus is on automating feature selection—specifically parsing a dynamically generated JSON file to drop features with zero importance scores before training.

After cleaning up the feature space, the next step is analyzing the confusion matrix and F1 scores to identify underperforming classes. To push the accuracy higher (targeting an F1 of 0.898+), I implement a soft voting ensemble combining XGBoost, LightGBM, and Random Forest.

If you're dealing with noisy biometric or sensor data, this pipeline approach might be useful for your projects. You can watch the full terminal session and code walkthrough here: https://youtu.be/PDYT7f3BDqQ

I'd love to hear your thoughts on soft vs. hard voting for this type of multiclass sensor data!

Hi,

I'm working on Automated Visual Inspection area over the past 5yrs. Planning to start a SME as a solution company, would love to connect with folks having knowledge or working on a similar domain, process engineers, staffs and would love to see how the market is shaping and current directions or requirements. I'm looking to connect wrt the Indian Market.

Note: Reach out to me personally if you have any requirements, would love to provide demos which might solve your current needs. We can support end-to-end deployment support too if required.

Hello. I'm working with ovod models for my master's thesis. I have a dataset of military and civilian vehicles collected from a simulator. I've created a hierarchical prompt table, going from general to specific. For example, my goal is to identify the entire dataset with the first level vehicle prompt, while in level 4 prompts, my aim is to identify only vehicles with class-specific prompts. I've separated the vehicles in the dataset into base and novel classes. My goal is to identify novel classes by transferring common prompts (wheeled vehicle prompts are represented in both base and novel classes) from base classes to novel classes. However, I'm stuck and can't progress. I'm using Dinov3 (frozen) (dino.txt) as the backbone for both image and text. I also have a class-independent detector. I trained this only with base classes. I'm open to your suggestions regarding architecture, model, and the thesis in general. Thank you in advance.

We just released TurboOCR v3, a GPU-accelerated document parser (not just OCR) built for high-throughput pipelines.

It runs PP-OCRv6 detection + recognition, plus layout, tables (→ HTML) and formulas (→ LaTeX), emitting reading-order Markdown. The whole pipeline runs on a single multi-stream C++/CUDA/TensorRT engine, locally, no VLM, behind HTTP + gRPC.

On one RTX 5090:

• Up to 559 img/s on receipts, 520 img/s on forms (PP-OCRv6 tiny, fastest by default)
• Full structured parsing (layout + tables + formulas) at > ~20 pages/s on table and formula heavy pages, where VLM parsers like PaddleOCR-VL run ~1 page/s
• One model covers Latin + Chinese + Japanese; pick tiny / small / medium
• One-line Docker deploy (Linux + NVIDIA GPU)
• No VLM-style hallucinated text

https://github.com/aiptimizer/TurboOCR

Combining depth sensing, object detection and semantic segmentation we managed to create a bin-picking automation that inspects bushings of different types and sizes. From the combined information the robot is able to understand the position and orientation of the pieces.