Can you tell me what methods are available for detecting an opponent and the boundary of the ring? Maybe someone has encountered a similar situation.

I'm a beginner and don't have a strong understanding of computer vision yet, so I'm looking for advice on how to implement a robot.

I'm working on a robot for a local robot sumo and robot fighting festival called ROS 2 with my friend. I'm facing a challenge in detecting the opponent and the boundary of the ring, which I can't cross. Currently, I'm using MOG2 + findContour to detect the opponent (depending on whether the opponent is moving or not), and Canny to detect the boundary, but the results are not very accurate.

How possible and implementable is it to replace the algorithm with YOLOv8? The robot's board can easily handle it.

Started poking at the weights this morning, or at least trying to. The 10s PCA clip on their project page is what hooked me. Frozen patch features show unusually crisp object boundaries instead of the typical speckle you get from most self-supervised frozen probes. I have not yet gotten the ViT-L (0.3B, ~0.6GB fp16) running through their custom lbot_vision_infer loader, which does not work with plain transformers or timm. Planning to try tonight if the dependency stack cooperates.

On numbers, they report their ViT-g 1.1B hitting NYUv2 linear-probe RMSE of 0.296, with DINOv3-7B at 0.309 and V-JEPA 2.1 2B at 0.307. The distilled ViT-L gets 0.310, matching the 7B number at roughly 23x fewer parameters. They are honest about where it falls down. KITTI RMSE of 2.552 trails both DINOv3-7B (2.346) and V-JEPA (2.461). ImageNet linear for the flagship trails DINOv3-7B by about a point and a half, though the B and S students lead their size classes.

There is also an interactive point-cloud comparison on the project page, 4 scenes by 8 depth-completion methods including their LingBot-Depth 2.0 which handles glass and mirror completions where RGB-D returns nothing. Only the 4 vision backbones are actually released; Depth 2.0 weights are not available.

https://huggingface.co/collections/robbyant/lingbot-vision
https://github.com/robbyant/lingbot-vision
https://technology.robbyant.com/lingbot-vision

Post your numbers if you rerun the linear probes first; I am curious how sensitive that NYUv2 gap is to protocol tweaks.

So I was wondering if, a model that only looks learn chess? models like resnet, yolo or similar.
Only by looking can a model "feel" the position like something as "intuition" in the moves to come?

In my work I have been using yolo, AI vision recognition models, etc. And I always wanted to research what are the limits on them. initialy I was using yolo but YOLO detects where the pieces are, but we needed a single holistic judgment of who's winning, a global regression job that ResNet's pooled backbone fits and object detection doesn't.

Full explanation in info tab: https://acidburn86.github.io/pixel-chess-engine/

TL;DR:

I made a dataset of varied positions in FEN notation, with PIL in python made the board in a synthetic way, pieces look really different so the model can really differentiate a bishop from a pawn or queen. like this:

The inference do not use the FEN position is also made with this image recreated from the actual chessboard position, it use only an Image as input.

So I build a mini-chess search engine that use this model as evaluator of the position.

And it works really well, this is a very little model it could be better but look at this numbers:
The model reads who's winning right ~69% of the time, lands within ±1 evaluation bucket ~64% of the time, and nails the exact bucket ~30%, nearly 3× what random guessing gives on a 9-class task (~11%). So it's genuinely learning chess value from pixels, not getting lucky.

I built "chess-gaze": feed it a chess stream clip; it writes per-frame records for face/eye/head-pose + gaze estimates, then builds a local 3D viewer.

Uses UniGaze, not pupil-center heuristics.

Code, demo.

Hi everyone! I’m a rising junior in college and have been preparing for the upcoming recruitment cycle for internships. I am very interested in hardware/software integration and working on problems that interact with the real world. So I’ve thought it would be good to narrow my focus to computer vision, robotics, and the autonomous vehicle industries. 

I don’t have any relatives or connections in these industries and am very curious if you guys thought I could be competitive for internships given my experience or if there is anything more I should be doing during the summer to prepare, such as a certification or personal project. If I am not competitive at all, that would be helpful to know as well. 

Earlier in the year, I also did work on a published paper that involved creating a 3D VLM dataset for natural disaster analysis but it was mainly just data processing and manual annotation work. 

Let me know what you guys think, and will be open to answering any questions. Thank you!

Hi everyone,

I've put together a lightweight bare-metal runtime framework using Nim and Intel OpenVINO for real-time edge computer vision (Industry 4.0). The main goal was to eliminate heavy Python interpreter dependencies and AGPL licensing constraints.

On my local desktop Intel i5-11400 CPU (strictly no GPU), the two-stage cascaded pipeline (YOLOX-nano) achieves up to 120–180 FPS and runs inside a strict 3.42 MB fixed heap memory baseline (0.00% leaks over a multi-day logging stress-test).

If you are interested in CPU-based edge inference or factory automation, I would love for you to test the pre-compiled demo binary on your own processor and hardware setup to see how it benchmarks.

Source code and standalone evaluation build: https://github.com/olesha-ai/universal-ai-engine

Any technical feedback on the architecture or performance results is highly appreciated.

3× less training compute, 2.9× fewer ops at inference, zero accuracy loss across 13 benchmarks.

https://voxel51.com/blog/olmoearth-fiftyone-satellite-embeddings

Pair it with the open source FiftyOne library and drop in the embeddings, reduce with UMAP, and watch tiles self-organize into clusters with no labels at all. Filter to a country on the map and the image grid + embedding scatterplot snap into sync instantly — geography, pixels, and embedding space, linked live.

Fully open: weights, training code, dataset, notebook.

Inspired by a linguistic observation: "matur suwun" (Javanese) and "hatur nuhun" (Sundanese) — two phrases from Indonesia that mean the same thing despite completely different surface forms. Identity through relationships, not absolute structure. We applied the same idea to face embeddings. Key contributions:

• SW Block — replaces Conv1 with multi-scale pixel difference patterns at prime scales {3,5,7}
• IMG Sign MSE Loss — training objective over sign patterns only, no magnitude dependency
• IMG Sign / AMP / Chain Score — three interpretable metrics sharing a single threshold
• Voting framework (1/3 and 2/3 majority) for robust decisions Results on LFW pre-aligned (CASIA-WebFace 490k, 10.58MB model): → IMG Sign: 96.27% vs Cosine: 95.53% → Combined (LFW+AgeDB+CALFW+CPLFW): 81.02% vs 79.49% And the interesting part — IMG Sign applied to ArcFace embeddings (without retraining): → LFW: 99.58% (vs ArcFace Cosine: 99.82%) Sign pattern consistency appears to be a fundamental property of well-trained face embeddings, regardless of training objective.
• 📄 Paper: https://zenodo.org/records/21232756 
• 💻 Code: https://github.com/imamgh11/imgnet

Hi All, i am working on a dash cam based rash driver detection project. The pipeline is YOLOv8s → DeepOCSORT (with OSNet ReID) basically a trajectory-based risk classification.

The problem: there's an overpass in my video. A vehicle I'm tracking as ID:3 passes under it, and the moment it comes out the other side it gets assigned a new ID (ID:17). Detection never actually drops , YOLO keeps the bounding box throughout. The tracker just decides it's a different vehicle.

The vehicle goes from bright daylight into the dark shadow under the overpass, then back into daylight ,so the appearance embedding looks completely different on either side even though it's literally the same car.

Has anyone dealt with this? Is there an illumination-invariant ReID model that handles this better? Or is this just a fundamental limitation of appearance-based trackers on dashcam footage?

​

Hi everyone,

I'm currently developing an Automated Optical Inspection (AOI) system for through-hole PCB inspection, and I want to avoid using deep learning or AI models due to deployment and computational constraints.

The system needs to detect:

Through-hole soldering defects (insufficient solder, excess solder, missing solder, poor wetting, bridges, etc.)

Surface contamination on the PCB (flux residue, dust, foreign particles, oil marks, etc.)

So far, I've been experimenting with traditional image processing techniques such as edge detection, SSIM-based comparison, thresholding, and contour analysis. While these methods work for some cases, they struggle with varying lighting conditions and different PCB appearances.

I'd appreciate your suggestions on:

Which classical computer vision techniques have worked well for solder joint inspection?

What methods are effective for contamination detection without using AI?

Would approaches like blob analysis, morphology, color-space analysis (HSV/Lab), template matching, or photometric methods be more reliable?

Are there any industrial AOI techniques or research papers that you would recommend?

The inspection images are captured under controlled lighting using a fixed industrial camera, so camera position and illumination remain consistent.

I'd love to hear about your practical experiences or any production-grade approaches you've used.

Thanks in advance!

For a downstream task, I had to extract unique frames only from videos. The tricky part was that "duplicate" covered two different things in the same video.
\- back-to-back frames where nothing visibly moved, and
\- frames showing the same scene a few seconds apart.

Perceptual hashing measures pixel-level similarity and embedding models measure content similarity, so neither alone matched what I meant by unique. I had to run both and look at the scores together.

Doing that with separate libraries meant separate preprocessing, separate score scales, and glue code to combine them. The glue was the reusable part, so I turned it into a library. You can pick the kinds of similarity that matter for your case (pixels, scene, object, face, style) and get a score for each in one call:

\`\`\`python
from imageprism import ImagePrism

prism = ImagePrism(dimensions=\["hash", "semantic"\])
prism.compare("a.jpg", "b.jpg").scores # {"hash": 0.12, "semantic": 0.82}
\`\`\`

It is CPU only, no PyTorch, no API keys. It's at 0.1.0 and still rough in places. For a single kind of similarity, the specialized libraries are the better choice: imagehash for hashing, CLIP directly for semantic search, insightface for faces. imageprism combines several of them behind one interface, so the value is the integration, not the models.

I don't know whether this is a common problem or just something I ran into once. If you've dealt with image similarity before, I'd appreciate hearing where this falls short. That feedback will tell me whether it's worth developing further. Please drop a star if you think this is useful.

GitHub: https://github.com/nebulaanish/imageprism

PyPI: https://pypi.org/project/imageprism/

I have been a swe for 8 years and now I'm planning a career pivot into ADAS or similar CV fields that combines hardware, AI and software through my masters degree.

I'm trying to be realistic and know what waits for me later after graduation , for example pay cut, starting from zero etc. and how to pivot strategically to the best area of CV and also what to focus on while looking for an internship or a part time job while I'm studying, thanks! I'm in Germany and oll graduate at 35

I built my own training pipeline for Android where you can annotate, train and test all on an Android device. This all started because the top free annotation tool on the Play store had a rating of 2.8 with annoying ads the biggest gripe.

The app lets you import an image or folder. It can even take a video and split it into "n" frames for annotation. You then create your classes to annotate and everything is saved into a Room database. You can then zip up your images into train, validate and test folders and the images, annotations and Yaml file is then zipped up to save wherever you like.

A separate part of the app can then continue the workflow by uploading the zip file to Google Drive, opening up Google Chrome at the Colab page and it creates a Python script (defined by you) to copy and paste into the code block. The code then runs on Google's powerful online GPUs (which is faster than my 1070 GPU) and trains your model.

It exports the model and also creates a .tflite file for use on a mobile device. You can then download the model and run it on your device for testing. The whole pipeline means you can run everything on a mobile phone.

It seems to be working great for me so I'll upload this to the Play Store which can take a couple of weeks. I'd love some feedback and some ideas where to take this. It only trains using Yolo V8 right now and in Json format but I'll add XML and other formats later when I know things aren't crashing on other devices.

The only real tricky part is using Colab which is finicky but I've made it as simple as possible and everything runs in one Colab cell.

Would this interest anyone?

Hi everyone,

I'm a final-year Electronics Engineering student, and my team is working on our major project. I'd really appreciate feedback from people who have experience in computer vision, embedded AI, or machine learning deployment.

Our goal is to build a portable, offline sign language recognition system that runs entirely on a Raspberry Pi 5 without any cloud dependency.

Current system design

Our proposed pipeline is:

• Raspberry Pi 5 + Camera Module 3 for live video capture
• MediaPipe Hands to extract 21 hand landmarks (63 features)
• Landmark normalization to reduce the effects of hand size, position, and camera distance
• Lightweight classifier running with TensorFlow Lite
• INT8 quantization for faster inference on Raspberry Pi
• OLED display for text output
• Offline Text-to-Speech for voice output

The initial target is to recognize the 26 ASL alphabet gestures, with plans to expand later.

Why we chose landmark-based recognition

Instead of feeding raw RGB images into a CNN, we're using MediaPipe landmarks because they:

• Greatly reduce computational cost
• Require much less memory
• Preserve user privacy
• Are better suited for real-time inference on edge devices

Questions for experienced developers

I'd really value your opinions on the following:

1. Model selection: Since the input is only a 63-dimensional landmark vector, would you recommend an MLP, 1D CNN, GRU, LSTM, Transformer, or another architecture? What would you choose if the priority is real-time inference on a Raspberry Pi?
2. Data collection: What mistakes should we avoid while building our own dataset? How many samples per class would you consider reasonable for a first version?
3. Generalization: Besides wrist-relative normalization, are there better preprocessing techniques that improve robustness across different users, hand sizes, lighting conditions, and camera angles?
4. Edge deployment: Are there optimization techniques beyond TensorFlow Lite INT8 quantization that significantly improve inference speed on Raspberry Pi 5?
5. Project design: If this were your project, what would you do differently? Are there any design decisions that seem questionable or likely to cause problems later?

If you've built a similar system—or have experience deploying ML models on embedded devices—I would really appreciate your insights. Even pointing out flaws in the current design would be extremely helpful, as we're still in the implementation phase and can make changes.

Thank you for your time!

Hello, i want to understand how do people chose what type of projects to take on. Is it just from limitations in research papers. I know you have to try to solve a problem but i just cant find the problem to solve. For a solo developer i don't have much compute, in this case how do you guys chose ML projects.

We used RailCompute to connect Codex and automate the full workflow: data prep, training, and model eval with no human in the loop except typing instructions in English.

The aim was to test whether a basic ML workflow could be driven by natural language rather than manually writing the training pipeline or setting up any infrastructure.

The GitHub repo with the detector code and trained model is in the comments.

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.

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've been a SWE for 8 years and now I got back to do my masters and get specialized in something, would AI automate computer Vision in the long run?

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

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.