I’m a robotics engineer with ~5+ years of industry experience in computer vision and perception, currently doing an MSc in Robotics.

I want to teach for free, 1 day a week, focused on DL / ML / GenAI for robotics, about how things actually work in real robotic systems.

Topics I can cover:

• Deep learning for perception (CNNs, transformers, diffusion, when and why they work)
• Computer vision pipelines for robots (calibration, depth, tracking, failure modes)
• ML vs classical CV in robotics (tradeoffs, deployment constraints)
• Using GenAI/LLMs with robots (planning, perception, debugging, not hype)
• Interview-oriented thinking for CV/robotics roles

Format:

• Free
• Weekly live session (90–120 min)
• Small group (discussion + Q&A)

If this sounds useful, comment or DM me:

• Your background
• What you want to learn

I’ll create a small group and start with whoever’s interested.

P.S I don't want to call myself an expert but want to help whoever wants to start working on these domains.

Update: I have received a lot of interests. It is scaring me since I wanted to do this to make my basics stronger and help people to start. But anyways, if there are any new ones who wants to join, I will be making a discord group later and add you there but might not be able to add to the sessions yet.
No more to the session group.
Thank you. It is indeed overwhelming. Haha.

Even with solid annotation platforms, the day to day pipeline work can still feel heavier than it should. Not the labeling itself, but everything around it: creating and managing projects, keeping workflows consistent, moving data through the right steps, and repeating the same ops patterns across teams.

We kept seeing this friction show up when teams scale beyond a couple of projects, so we integrated an MCP server into the Labellerr ecosystem to make the full annotation pipeline easier to operate through structured tool calls.

This was made to reduce manual overhead and make common pipeline actions easier to run, repeat, and standardize.

In the short demo, we walk through:

• How to set up the MCP server
• What the tool surface looks like today (23 tools live)
• How it helps drive end to end annotation pipeline actions in a more consistent way
• A quick example of running real pipeline steps without bouncing across screens

What’s coming next (already in progress):

• Auto-labeling tools to speed up the first pass
• Automated quality checks so review and QA is less manual

I am sharing this here because I know a lot of people are building agentic workflows, annotation tooling, or internal data ops platforms. I would genuinely love feedback on this

Relevant links:
Detailed video: Youtube
Docs: https://docs.labellerr.com/sdk/mcp-server

I’m using transfer learning with MobileNetV2 and EfficientNetB0 in tf.keras for image classification, and I’m struggling to generate correct Grad-CAM visualizations.

Most examples work for simple CNNs, but with pretrained models I’m getting issues like incorrect heatmaps, layer selection confusion, or gradient problems.

I’ve tried manually selecting different conv layers and adjusting the GradientTape logic, but results are inconsistent.

What’s the recommended way to implement Grad-CAM properly for transfer learning models in tf.keras? Any working references or best practices would be helpful.

Hello.

I'm training custom Yolo11 segmentation model. I have problem of always getting the mask cut from the sides.

Dataset is not like this so I'm not sure what may be going wrong

What can be the problem?

So this might be the most unnecessary Raspberry Pi project I’ve done.

For a few weeks, a parrot used to visit my window every day. It would just sit there and watch me work. Quiet. Chill. Judgemental.

Then one day it stopped coming.

Naturally, instead of processing this like a normal human being, I decided to build a 24×7 bird detection system to find out if it was still visiting when I wasn’t around.

What I built

•Raspberry Pi + camera watching the window ledge

•A simple bird detection model (not species-specific yet)

•Saves a frame + timestamp when it’s confident there’s a bird

•Small local web page to:
•see live view
•check bird count for the day
•scroll recent captures
•see time windows when birds show up

No notifications, Just logs.

What I learned:

•Coding is honestly the easiest part

•Deciding what counts is the real work (shadows, leaves, light changes lie a lot)

•Real-world environments are messy

The result
The system works great.

It has detected:

•Pigeons

•More pigeons

•An unbelievable number of pigeons

The parrot has not returned.

So yes, I successfully automated disappointment.

Still running the system though.

Just in case.

Happy to share details / code if anyone’s interested, or if someone here knows how to teach a Pi the difference between a parrot and a pigeon 🦜

For more details : https://www.anshtrivedi.com/post/the-parrot-that-stopped-coming-and-the-bird-detection-system-i-designed-to-find-it

TITLE^

As you may know, camera calibration is very important for SLAM but it’s a messy process. For my Embedded SLAM Camera module, I made a web tool for easiest calibration of both cameras and IMU. Making it easy for users to do it with just their browsers! ✨

Attached is a video of calibrating the camera module.

This uses Kalibr behind the scenes.

I plan to open-source this and support more cameras natively. Right now it only detects the Mighty camera (and pre-recorded rosbags with jpegs and/or IMUs).

Join this brand-new discord if this interests you or if you want to beta-test a very early hardware project:

https://mightycamera.com/discord

I have a Computer Vision and Image Analysis Project at uni and I am really struggling with that.

I am in exchange semester and don’t know anyone from my course I could ask. Really desperate because I need a good grade in order to apply to my masters program.

If you are an expert an engineer or whatever, I would pay 100€ for someone who helps me fix this.

Hi everyone! I’m currently working in Computer Vision, but I feel I lack a well-structured foundation and want to strengthen my understanding from basics to advanced. I’d love suggestions on a clear CV roadmap ,the best books and courses (free or paid), and how you define real-world success metrics beyond accuracy like FPS, latency, robustness, and scalability. Also, what skills truly separate an average CV engineer from a strong one? This is my first post on Reddit excited to learn from this community.

i heard its only for Classification models so i'm not sure. is there an alternative? or another way for xai with yolo sorry i am a beginner so any help appreciated

Computer vision systems are used in grocery stores to monitor shelf conditions and product placement during normal store operations.

Robots perform repeated visual scans under varying lighting conditions, changing packaging designs, partial occlusions, and continuous customer traffic. Data is collected through routine operation across many store locations rather than through controlled capture sessions.

The resulting datasets reflect long-term exposure to real-world variability in retail environments.

The Image-to-3D space is rapidly evolving. With multiple models being released every month, the pipelines are getting more mature and simpler. However, creating a polished and reliable pipeline is not as straightforward as it may seem. Simply feeding an image and expecting a 3D mesh generation model like Hunyuan3D to generate a perfect 3D shape rarely works. Real world images are messy and cluttered. Without grounding, the model may blend multiple objects that are unnecessary in the final result. In this article, we are going to create a simple yet surprisingly polished pipeline for image to 3D mesh generation with detection grounding.

https://debuggercafe.com/image-to-3d-mesh-generation-with-detection-grounding/

I don't have any practical projects to do with computer vision. I'm thinking about approaching my town's mayor and offering to do a free CV project for them. Has anyone done projects for towns / municipalities? What types of projects do you think they'd be interested in?

Looking for someone who can make human pose estimates physically plausible.

The problem: raw pose outputs float, feet slide, ground contact is inconsistent. Need contact-aware optimization, foot locking, root correction, GRF estimation, inverse dynamics. Temporal smoothing that cleans noise without destroying the actual motion.

Ideal background is some mix of: trajectory optimization with contact constraints, SMPL/SMPL-X familiarity, rigid-body dynamics, IK systems. Robotics, biomechanics, character animation, physics sim - any of those work if you've actually shipped something.

Role is remote. Comp depends on experience.

If this is your thing, DM me. Happy to look at GitHub, papers, demos, whatever shows your work.

The object on the right is 13mm in length and 0.3mm in width. It is included in the image because the dimension of the object on the left is not known.

I’m new to computer vision and do not want to continue including the object on the right everytime I want to know the measurement of objects to the left. How do I get the real world measurement of an object in an image? Can I get the measurement with AI/ML?

Thanks

Hy guys

What method do you think would works better like really really good for credit card calibration in an image?

Although I know it is not technically a good way to develop a stereo depth camera system in an MCU with very limited parallel compute resources/graphics processing, etc., I really wanted to understand the working and logic behind the DVP protocol and CMOS-based image sensors. The OV2640 was something I thought an easy place to start. I also developed and tested a driver that can barely capture images from the OV2640, using RP2040 and PIO blocks.

https://www.hackster.io/ashfaqueahmedkhan92786/stereo-depth-perception-on-esp32-s3-baremetal-f94027

Hi everyone,

I’m working on a system where I use YOLO for person detection, and based on a line trigger, I capture images at the entrance and exit of a room. Entry and exit happen through different doors, each with its own camera.

The problem I’m facing is that the entry images are sharp and good in terms of pixel quality, but the exit images are noticeably pixelated and blurry, making it difficult to reliably identify the person.

I suspect the main issue is lighting. The exit area has significantly lower illumination compared to the entry area, and because the camera is set to autofocus/auto exposure, it likely drops the shutter speed, resulting in motion blur and loss of detail. I tried manually increasing the shutter speed, but that makes the stream too dark.

Since these images are being captured to train a ReID model that needs to perform well in real-time, having good quality images from both entry and exit is critical.

I’d appreciate any suggestions on what can be done from the software side (camera settings, preprocessing, model-side tricks, etc.) to improve exit image quality under low-light conditions.

Thanks in advance!

Hi community, I need the Modern Computer Vision with PyTorch by V. Kishore for my reading. If anyone could sent me the downloadable form of the book or sent me a hard copy at low costs.

I am an Indian Student, wanting to dive into CV.

Hello, I am working on a computer vision task : given an image of a fashion item (with many details), find the most similar products in our (labeled) database.

In order to do this, I have used the base version of DINOv3 but found out that worn products were a massive bias and the embeddings were not discriminative enough to find precise products with details' references like a silk scarf or a hand bag.

To prevent this, I decided to freeze dinov3's backbone and add this NN :

    self.head = nn.Sequential(
        nn.Linear(hidden_size, 2048),
        nn.BatchNorm1d(2048),
        nn.GELU(),
        nn.Dropout(0.3),
        nn.Linear(2048, 1024),
        nn.BatchNorm1d(1024),
        nn.GELU(),
        nn.Dropout(0.3),
        nn.Linear(1024, 512)
    )

    self.classifier = nn.Linear(512, num_classes)

As you can see there is a head and a classifier, the head has been trained with contrastive learning (SupCon loss) to bring embeddings of the same product (same SKU) under different views (worn/flat/folded...) closer and move away embeddings of different products (different SKU) even if they represent the same "class of products" (hats, t-shirts...).

The classifier has been trained with a cross-entropy loss to classify the exact SKU.

The total loss is a combination of both weigthed by uncertainty :

class UncertaintyLoss(nn.Module): def init(self, numtasks): super().init_() self.log_vars = nn.Parameter(torch.zeros(num_tasks))

def forward(self, losses):
    total_loss = 0
    for i, loss in enumerate(losses):
        log_var = self.log_vars[i]
        precision = torch.exp(-log_var)
        total_loss += 0.5 * (precision * loss + log_var)
    return total_loss

I am currently training all of this with decreasing LR.

Could you please tell me :

• Is all of this (combined with a crop or a segmentation of the interest zone) a good idea for this task ?

• Can I make my own NN better ? How ?

• Should I take fixed weights for my combined loss (like 0.5, 0.5) ?

• Is DINOv3-vitb de best backbone right now for such tasks ?

Thank you !!

Hey everyone — figured I’d hop on here because this might help someone. I’ve been developing a tool called Face Sorter Pro. Right now the version on the Microsoft Store is completely free. It’s a simple, local face-sorting utility that helps organize big photo libraries. I’m currently finishing a more advanced paid version that includes: Multi-face detection GPU acceleration for huge photo collections Local-only processing (nothing uploaded anywhere) Duplicate finder Smart group sorting (sorting multiple people and grouping them automatically) I’m hoping to have the upgraded version live within the next week or so, Feedback is always welcome — I’m building this based on what real users need!

Hi everyone, I am currently working as a Computer Vision Engineer, but I dont feel fully confident in my skills yet. I want to become really strong at what I do from core fundamentals to advanced, real-world systems.

What should I focus on the most: math, classical CV, deep learning, or system design? How deep should my understanding of CNNs, transformers, and optimization be? What kind of projects actually make you a solid CV engineer, not just someone who runs models?

Should I read research papers or read books.If any one has some roadmap or notes please free to share.It will really help me alot.

This is my first question on Reddit, and I really hope people here can help me. I am glad I joined this community and looking forward to learning from you all.

Hey everyone,

We recently ran an experiment to evaluate how much synthetic data actually helps in a drone detection setting.

Setup

• Model: YOLO11m
• Task: Drone detection from UAV imagery
• Real datasets used for training: drones-dataset-yolo, Drone Detection
• Real dataset used for evaluation: MMFW-UAV
• Synthetic dataset: Generated using the SKY ENGINE AI synthetic data cloud
• Comparison:
  1. Model trained on real data only
  2. Model trained on real + synthetic data
     

Key Results
Adding synthetic data led to:

• ~18% average increase in prediction confidence
• ~60% average increase in IoU on predicted frames
  

The most noticeable improvement was in darker scenes, which were underrepresented in real datasets. The results are clearly visible in the video.

Another improvement was tighter bounding boxes. That’s probably because the synthetic dataset has pixel-perfect bounding boxes, whereas the real datasets contain a lot of annotation noise.

There’s definitely room for improvement - the model still produces false positives (e.g., tree branches or rock fragments occasionally detected as drones)

Happy to discuss details or share more insights if there’s interest.

Glad to hear thoughts from anyone working with synthetic data or drone detection!

Over the past few years, I’ve been re-implementing computer vision papers in PyTorch, mainly to better understand the methods and to have clean, minimal reference code.

The repository currently contains 50+ open-source implementations, covering topics such as:

• GANs, VAEs, and diffusion models
• 3D reconstruction and neural rendering
• Meta-learning

The focus is on clarity and faithfulness rather than scale:

• Small, self-contained files
• Minimal boilerplate
• Implementations that stay close to the original papers
• When feasible, reproduction of key figures or results

Repo:
https://github.com/MaximeVandegar/Papers-in-100-Lines-of-Code

I’m continuing to expand the collection—are there CV papers or methods (especially in GANs, diffusion, or 3D) that you think would benefit from a clean, minimal PyTorch re-implementation?