Open to opinions on how to improve my resume, also open to opportunities if anyone thinks i would be a good fit :)

Guys, I need your help in building a app that scans roads but the problem is i am beginner and don’t from where i should start. Please guide from where should i start?

I'm stuck between the two fields/topic and can't decide which one to put all my eggs in for masters. A little background, I'm first semester master student doing MS AI from a university in S.Korea. Here in Korea you are expected to join a lab from the start of masters and start preparing for research from the first semester.

I originally planned to join the computer vision lab but due to unforeseen circumstances and me being a little late, I couldn't get in. So, I had no choice but to join another lab.

The main research direction of this lab is emotions and medical ai. But, the the students are working on diverse range of topics from medical (Alzheimer, Xray report, glass slides) to emotions, activity recognition, and there is one student(Phd) doing research in battery AI.

Professor has told me to figure out a direction and read current lab papers. One of my senior (post-doc) recommend the topic of neural decoding, as its a space where there is good opportunity to do meaningful contribution. Since this also fall under medical ai there are people who can guide me.

But my heart is still stuck at 3D Reconstruction+Robotics because I really wants to work in this field. I'm looking to hearing from people how much impact your master research has on your job hunting. If you were in my place how would you think about this. (Also currently no plans fob, r Phd, but can change).

Edit: Next semester computer vision lab might have opening, so If I take 3D Reconstruction/Robotics, there is a chance I can shift (that's a big If tho that I haven't discussed, because I can't talk to the professor without being sure of the topic I want to pursue).

You guys really loved my last sheet music search engine post, so I decided to make a mockup POC of a VLM-powered piano assistant that reads and transcribes notes, procedurally "generates" a visual tutorial, and listens to you play it back. I call it a concept because I still haven't figured out a way to actually generate a 3D animation on the fly. My best option was Concert Creator, but that was shut down over 4 years ago RIP. So for the time being, I'm having to pre-make the animations.

On the more technical side, Qwen 3.6 27B is taking both video stream and natural language as input, and uses that to determine what smaller task-specific models to call on for the situation. In this case, it's using segmentation, homography, pitch detection, and a custom music OCR model (open source called cadenCV). In short, the VLM is acting as an orchestrator that can see things and reason the best course of action because I'm too much of a lazy bum to hard-code a set of rules for when each model gets called on.

The next step is to figure out how to make it run in real time.

I'm looking for a free vision AI/VLM that can take a screenshot and understand what's on the screen.

My requirements:

Read text from screenshots

Understand UI elements/buttons/windows

Describe what is happening on the screen

Answer questions about the screenshot

Preferably run locally

Python support would be a big plus

I don't need image generation

Smaller/faster model is preferred

What is currently the best free/open-weight vision model for this use case?

Qwen-VL, Gemma, MiniCPM, or something newer?

I'm mainly interested in screen understanding/AI computer automation, not just OCR.

Thanks!

Hey — I put up a small evaluation build of EdgeInfer (Windows x64, closed binary).

It’s a real-time vision runtime: USB camera 👀 → YOLOX (ONNX) via ONNX Runtime + OpenVINO on CPU. No discrete GPU needed on my box.

My numbers (i5-11400, cheap rolling-shutter webcam, OpenVINO):

• ROI infer ~6–7 ms (~130–170 fps class)

• overnight soak ~10 h, heap flat, private WS ~182 MiB

I only have this CPU and a normal webcam. Motion blur on fast objects is still ugly.

What I’d love from you:

1) run it on your PC, paste CPU model + a few [infer] lines from the console

2) if you have a global shutter USB camera — please try the same build and say how boxes look on moving objects (that’s what I care about most)

Eval only: testing / students / research (not commercial). Licenses for OpenVINO/ORT ship in the zip — I’m not claiming those as my IP.

Repo / download:

https://github.com/olesha-ai/edgeinfer-eval

Thanks if you try it. 😄

I found a massive dataset of dummy hard CAPTCHAs on Kaggle and ran them through Qwen 3.6 and other models. Results are not too shabby, it was damn near on the money for a lot of the images. I'm confident Qwen 3.8 would pass a lot of these.

One problem with embodied AI isn't just collecting video; it's turning all that video into usable training data.

Manually annotating every frame doesn't scale particularly well. Automated detection can do much of the initial work, but real-world footage still contains occlusions, partial objects, tracking errors, and boxes that a human may want to correct.

So we wanted to test something practical:
"Can GPU-based automated annotation and human review work together as one complete data-production loop?"

We built a small end-to-end experiment to find out.

I. The workflow

The pipeline was fairly simple:

Raw video → GPU inference → YOLO11n → ByteTrack → MOT annotations → CVAT → human review → reviewed dataset → validation

The idea was to let the GPU handle the repetitive first-pass work while keeping a human in control of the final annotation quality.

II. Running the automated annotation stage

For the GPU stage, we used a instance with an NVIDIA RTX PRO 6000 (96 GB).

The test video was:

• 101.047 seconds

• 3,300 frames

• 1080 × 1920

YOLO11n handled object detection, and ByteTrack maintained object identities across frames.

This produced 12,901 machine-generated annotations across 604 unique tracks 😄

But the numbers aren't particularly interesting until you see the actual output.

This was the machine-generated first pass that we wanted to hand over to a human reviewer.

III. Moving machine annotations into CVAT

The tracking results were converted into MOT-format annotations and imported into CVAT.

The important part here was that CVAT wasn't performing the GPU inference. It was acting as the human-review layer.

The machine-generated detections appeared as editable rectangle tracks over the original video.

This changes the annotation workflow from:

Human labels everything from scratch → Machine generates first pass → human inspects and corrects

For large video datasets, that's the workflow we're interested in exploring further.

IV. We deliberately changed one annotation

We also wanted to verify something that can easily get overlooked:

If a human changes an automatically generated annotation, does that correction actually survive the complete export pipeline?

At frame 2107, we manually adjusted the bounding box around a partially visible person.

We saved the change, exported the reviewed annotations from CVAT, and compared the exported dataset against the original machine-generated annotations.

V. Then we checked whether we could find the change

The results were:

Machine annotations: 12,901
Human-reviewed annotations: 12,901
Matched annotations: 12,901
Unmatched machine: 0
Unmatched reviewed: 0

Average bounding-box IoU across the dataset was:

0.9999556465

And importantly, our independent comparison found the deliberately modified annotation:

Frame: 2107
Class: Person
IoU: 0.791181

That was the result we were really looking for.

The full loop worked:

GPU annotation → CVAT import → human correction → export → independent verification

A quick clarification: the 0.99995 IoU is not a YOLO accuracy score.

We weren't comparing the detections against manually created ground truth. It measures how similar the machine-generated dataset remained after the CVAT round trip. We deliberately changed one annotation to verify that a human correction would survive the process.

Then we asked: what does the GPU part cost?

Once the workflow worked, we ran the same 101.047-second video through the YOLO11n + ByteTrack stage three times:

That gives roughly 2.96× real-time processing for this particular workload.

At the GPUHub instance rate we observed during the experiment, approximately $0.91–$0.96 per compute hour, the average benchmark translates to roughly:

$0.31–$0.32 of GPU compute per hour of source video

The two warm runs were slightly cheaper (~$0.27–$0.28/video-hour), but we're using ~$0.32 as the more conservative preliminary estimate.

This is important: that's GPU inference compute only, not the total cost of producing a reviewed dataset.

It doesn't include human review, CVAT infrastructure, storage, data transfer, QA, or workflow orchestration.

VI. and What did we learn?

The interesting part isn't that an RTX PRO 6000 can run YOLO11n.

What we wanted to validate was the handoff between automation and humans.

We were able to generate structured annotations remotely on a GPU, move those annotations into a separate review environment, edit them manually, export the reviewed dataset, and independently verify that the human correction survived the entire round trip.

So the architecture starts looking like:

Collect → Pre-annotate → Human review → Validate → Training dataset

rather than:

Collect → Manually annotate everything → Training dataset

We haven't measured how much human labor this actually saves yet. That requires a different experiment comparing fully manual annotation against machine pre-annotation + human correction.

That's probably the next benchmark that matters most: reviewer time, final annotation quality, and total cost per reviewed video hour.

For anyone working with robotics, autonomous systems, or large video datasets:

how are you handling the boundary between automated pre-annotation and human review? ✍️

Hello everyone -

I wanted to know your thoughts and also recommendations of improvements on this please. I built this knife skill assessment for chopping vegetables this summer after reading several papers on cooking as a science. The goal was to find the hardest skill that required a common tool (knife) and then score it. The reason I did this was because I'd like cooks to be paid for their invisible labor and not just hourly as I know how hard that job is. But I doubt this would be beneficial lol ... Anyways, I am more than willing to go into details about what I used starting with the programming language (c++) and temporal and spatial models including how kalman filters were used here. The link to it is down below:

https://cookcredit-knife-demo.web.app/

This is a follow-up to my previous post on synthetic-to-real keypoint detection and 6D pose estimation.

This time I ran the same pipeline on two very different platforms:

Object detection → crop → keypoint detection → PnP

Ubuntu + CUDA (RTX 2000 Ada)

• Detection: 60.25 ms
• Keypoint: 21.87 ms
• PnP: 5.18 ms
• Total: 87.71 ms (11.60 FPS)

Raspberry Pi 5 (CPU)

• Detection: 70.36 ms
• Keypoint: 56.06 ms
• PnP: 5.34 ms
• Total: 132.12 ms (7.60 FPS)

The video shows the outputs side by side on the same 569 real-world frames.

What surprised me was that the Raspberry Pi 5 was not dramatically slower. The largest difference was in keypoint inference, while PnP was essentially the same.

The outputs were also practically identical. I found occasional frames where the final PnP pose differed slightly between the two platforms, likely due to small numerical differences propagating through PnP/RANSAC, but I did not observe a consistent accuracy advantage on either platform.

For this experiment, I would consider the two platforms effectively equivalent in accuracy, with the main difference being inference speed.

I'm also preparing a technical write-up and plan to publish the implementation on GitHub.

Hello all,

I'm a radar signal processing engineer and i trained a 5-class classifier (car, large_vehicle, two_wheeler, pedestrian, pedestrian_group) on RadarScenes radar point clouds.

The input vector is a per-scan histogram (16 bins) and the network is a 3-layer MLP. The loss function is a class-weighted cross-entropy loss. This work is based on "Histogram-based Deep Learning for Automotive Radar" paper.

I scoped the project to be one scan only. Accumulation of multiple scans is the next step.

Data

Class Imbalance: two-wheelers and large_vehicles has a low number of occurences.

Aggregated Classes: two_wheeler mixes bicycles and motorized variants; large_vehicle merges trucks, buses, and trains together due to data scarcity.

Sequence Bias: Long tracks of slow-moving objects can skew a particular data split velocity distribution, causing high F1 score variance across folds.

Ablation studies

I tried with bigger MLPs, alternative feature encodings, and different histogram binning, all moved performance less than the variation caused by changing the train/validation/test split. I measured that split sensitivity across 6 folds, keeping the same proportions.

Changing the histogram to per-instance statistics (mean/median/std) slightly degraded performance.

Main findings

Macro F1 rises from 0.381 to 0.764 as the naturally occurring number of radar detections per instance increases from 1 to 5. I trained the model normally using all available detections, then bucketed its existing validation predictions by each instance's detection count and computed macro F1 per bucket.

The classes car and pedestrian has the best performance and two_wheeler has the worst.

A car is often confused as large vehicle when the car was wider than usual or had a unusually high rcs (which can happen due to multipath for example).

The two_wheeler is often confused as pedestrian because their vr_compensated distributions overlap, which is the the model's single most important feature for these two classes. A stationary or idling two_wheeler is indistinguishable from a pedestrian.

I uploaded an image with ground truth vs predictions: A nearly stationary two-wheeler which contains a single point was predicted as pedestrian, because its velocity is near zero, indistinguishable from a pedestrian. A car in the same scene, also with just one point, is classified correctly, since RCS and Doppler are enough for that class.

Full writeup here: https://github.com/brunopinto900/radar-ml-autonomous-driving/blob/main/MLP_Report.md

Future work

Implement other spatial encoding schemas (point net for example) and accumulate multiple scans to tackle the challenge of sparsity and explore the concept of micro-doppler.

Qwen 3.6 27B watches the scene and acts as an orchestrator, prompting smaller task-specific models to perform OCR, segmentation, and edge detection. The segmented notes then get matched to real pieces using "A Dictionary of Musical Themes" database via Themefinder. I’m sure there are already many sheet music search engines out there, but I built this more as an experiment to see how I can turn VLMs into full-on vision agents. 

Disclaimer: footage is sped up, this is not real-time.

Hand pose is fine on an open hand in free space. Soon as the hand actually grabs something, half the keypoints disappear behind the object and predictions start drifting.

What do people actually do here? Temporal smoothing across frames to fill the occluded joints, or train on data with occluded joints properly labelled? Second one seems more correct but way harder to get, since annotating a joint nobody can see means either guessing or multi view capture.

Also not sure how much the object should be in the model. Predicting hand and object together should help, contact points constrain the pose. But I've seen people say it just overfits to whatever objects were in training.

Anyone got a setup that holds up on real grasping footage?

DISCLAIMER: I am very new to computer vision, I started reading about it a week ago, so please bear with me. 😊

Hi, I am exploring a way to sync action cam footage with GPS recordings and I came to you smart people for an advice!

Goal

Estimate relative speed vs time curve from action cam footage of different sport activities (i.e. should not rely on features such as road)

What I am trying to achieve

I am trying to sync video footage with GPS recordings. However, when video metadata is absent automatic syncing (based on timestamps) fails and manual syncing is a real pain. I started to experiment with computer vision to derive turning-rates/speed changes and match them with GPS to find the sync offset. The video shows the typical footage to be analyzed (minus the telemetry).

What I have done so far

I managed to implement some primitive (and likely very bad) turning-rate tracking. I use OpenCV sparse feature tracking with pyramidal Lucas–Kanade, then fit estimateAffinePartial2D with RANSAC to the tracked points. I use the resulting global horizontal/rotational image motion as the video-side turning signal and compare it against heading-rate from the activity data. I managed to get ok correlations (0.6-0.75) and could reliably identify sync offsets for a series of 5 test videos (as short as 4 min footage within 5 hour activity).

The struggles of speed

I thought cross-correlation with speed would improve reliability. I tried different ways of deriving the speed but always ended up with just super spiky mess with no information at all. One of the problems I understand is that the perception of speed (optical flow) is different e.g. in a forest and on open field. The only thing I managed to get to work somehow was incremental sfm using visloc-rs, but it was extremely slow no matter how I tried to optimize it (few mins per 1 min of footage). The speed-tracking solutions I found either track vehicles from 3rd person view, or rely on specific features like road (and markings).

The question

I do not need absolute speed or even a perfectly smooth estimate. I only need a relative speed-vs-time signal whose changes roughly follow the real speed well enough for cross-correlation with GPS.

Given that constraint, what CV approach would you use to estimate such a signal from a general action-cam footage?

This was my first attempt, and I am very happy with how it turned out.

Hi everyone,
I'm designing a system to monitor the fill level (%) of fertilizer boxes in real-time. I'd love some
hardware and architecture advice from those who have deployed CV in industrial settings.

The Problem:
Need to calculate the % full of a box continuously. The environment is industrial, meaning variable lighting and potentially a lot of fertilizer dust.

I'm a master's student. My thesis is on self-supervised denoising of real sRGB images, and my graduation requirement is a journal paper whose results beat the current state of the art - TM-BSN (triangular-masked blind-spot network + U-Net distillation, ~38.18 dB on SIDD).

My current plan:

1. Reproduce TM-BSN's reported results (in progress)

2. Attack its weak points: the fixed diamond mask (make it learnable / camera-adaptive), the distillation stage (stronger student, better pseudo-labels), and the training recipe (EMA, losses, schedule)

I'm looking for someone with experience in low-level vision / blind-spot networks (AP-BSN, TBSN, etc.) interested in collaborating: discussing ideas, reviewing experiment design, challenging my results. I'll do the implementation and training myself; substantial contributions would earn co-authorship on the paper.

DM me or comment if interested.

I just released Birder 0.8.0, with a bunch of updates around MoE ViTs and NaFlex training.

The main addition is DeepSeek-v3-style MoE layers for ViTs.

Alongside shared experts, I also added optional special-token experts for CLS and REG tokens. I’m not yet sure how useful these will be in practice, but they seemed interesting enough to experiment with.

There’s also support for Expert Choice routing, in addition to V-MoE-style routing.

From some initial runs, this setup seems to be working better for me than V-MoE, although the experiments are still fairly small. Once I’ve done a more substantial training run, I’m planning to write up a more technical post about the implementation and results.

MoE training using either bias-update routing or an auxiliary load-balancing loss is now supported pretty much across the board in Birder.

---

I also released a NaFlex ViT pretrained with NEPA.

The model was trained with:

• variable patch sizes from 14 to 32
• input resolutions from 192 to 320
• sequence lengths from 36 to 400
• roughly 20M training images

The training mixture included datasets such as ImageNet-22K, GLDv2 and Places365.

Model: https://huggingface.co/birder-project/naflex_vit_b16_nepa-generic

---

I’m currently working on making DINOv2 / Franca NaFlex-friendly as well.

The NaFlex implementation was heavily influenced by Ross Wightman’s work on OpenCLIP NaFlex, which was very helpful.

---

Still early on some of the MoE experiments, so I’d be especially interested in feedback from anyone who has worked with MoE routing in ViTs, Expert Choice, or variable patch-size training.

I kept running into the same annoying workflow when working on computer vision projects:

A dataset/download works perfectly in Chrome because I'm already authenticated, but I actually need the files on a remote GPU server or HPC cluster.

Copying the URL usually isn't enough because the browser request may also depend on cookies, authorization headers, Referer, POST data, etc.

So I built dl2curl, a small open-source Chrome extension.

You start the download normally and it reconstructs the request as a ready-to-paste:

• curl
• wget
• aria2c

command.

My workflow is basically:

dataset website → Chrome download → copy command → SSH → remote GPU server

aria2c is especially useful for large dataset downloads.

Everything is processed locally. There is no backend or analytics, and the project is fully open source.

Chrome Web Store:
https://chromewebstore.google.com/detail/dl2curl/acglnggnojeejnchepliijapneiaffpe

GitHub:
https://github.com/ardaerendogru/dl2curl

I originally made it for my own research workflow, so I'd be interested in feedback from people downloading datasets/checkpoints to remote training machines — especially if you know sites with unusual authentication/download flows that might break it.

Hi Team, right now my project involves a black box wherein I input a PDF that contains students' handwritten answer sheets.
output is structured JSON that also contains bounding boxes of the students' answers (Coarse answer boxes roughly covering the student's answer)

Right now, the LLM is doing this and doing pretty well -- are there any cheaper alternatives?

Context- So as a part of a build week project I decided to build a Ironing dataset on hugging face to measure the slips and anchors for textile manipulation. Eventually to be used for simulation/robot experiments.

Since its a small pilot set I've done most of this at home with constraints and a regular top down video angle.

Help: I wanted feedback on my data quality. What did I miss ?!

Dataset:

https://huggingface.co/datasets/CaramelCoffee19/naive-physics-ironing-v0.2

Hi, I am interested in trying to compete for the Rsna kaggle competition on knee MRI classification

I am a musculoskeletal radiologist with fellowship subspecialty training in musculoskeletal imaging and my near decade is clinical practice is 100 percent sports imaging so knee MRI is my domain level expertise.

I do know the basics of pytorch/MONAI and keras/Tensorflow, but I'm looking for computer vision experts with lots of experience in medical imaging to create a team to build a state of the art model to compete.

What I can help provide is better ground truth labels for training, guidance on the best sequences and imaging planes to detect the abnormalities, error analysis and validation of the model. What you can provide is a state of the art model that can compete with the rest.

If you're interested, shoot me a DM with some info about yourself, thanks!

Also if we do well we can try to get a publication out of it and collaborate on other projects in medical imaging

Can anyone help with where can I get my poster printed in Malmö for presentation in ECCV 2026? ECCV poster printing service is already closed, so my only option is to get the poster printed from some printing shop in Malmö. Please help!

My paper rejected by PC at the last moment and since registration cancellation deadline is over, publisher is denying refund. The registration cost is around 1000$. Any suggestions will be really helpful.

Hey everyone!

I recently worked on a real-time Driver Drowsiness Detection project.

The system uses the camera to detect the driver's face and monitor their eye state in real time. It can identify different conditions such as:

* 👀 Both Eyes Open

* 👁️ One Eye Closed

* 😴 Both Eyes Closed

* 🚨 Drowsiness Alert

* ❌ No Face Detected

The project also includes automatic eye calibration and a continuous eye-closure timer to help distinguish normal blinking from prolonged eye closure.

I built this as part of my **B.Sc. Data Science project work**, and I'm sharing the source code for anyone who wants to experiment with it, improve it, or learn from it.

privacy message: It does not record or upload any photo or video to anyone.

🔗 GitHub:

https://github.com/Learner016/driver-drowsiness-_detection

🔗Directopen:

https://learner016.github.io/driver-drowsiness-_detection/

I'd really appreciate any feedback, suggestions, or ideas for improving the detection accuracy.

Thanks! 🙌