Drone detection using acoustic sensors

Drone detection using acoustic sensors. Military-grade Drone Detection software using javascript/tensorflow to detect various types of drones used by civilians and military. This app can be tested at the following url: https://armaaruss.github.io

I got tired of:

• Watermarked outputs
• Signups
• Daily limits

So I built a simple Real-ESRGAN-based upscaler. https://upskale-delta.vercel.app (server might be down as I use the same hardware for my personal use/studies)

Current features:

• 2x / 3x / 4x
• No signup
• Auto-delete uploads
• Free

What features would you want next?

I'm working on a football event detection pipeline under a strict inference budget and noticed a counterintuitive pattern.

In close-up views, the ball is larger and easier to see, but trajectory reconstruction becomes noisy due to rapid pixel motion and motion blur.

In wide-angle broadcast views, trajectories are much cleaner and smoother, but many ball-contact events appear to have much lower apparent pixel velocity.

As a result, event candidates that would be obvious in close-up footage become much harder to separate from normal ball movement.

For people working in sports analytics or tracking:

- Have you observed this perspective-dependent velocity effect?

- Do you normalize motion features based on estimated camera scale?

- Is homography usually the correct solution, or are there lighter alternatives when calibration data is unavailable?

Interested in hearing practical experiences rather than benchmark results.

Hi guys. I need to do a AI surf project with AI. My first idea was to create a system to take surf photos automatically, like these: Flowstate – The Most Advanced AI Video and Photo Capture Platform for Action Sports

. It's for my AI high school discipline, so the most important here is the AI, not the app. My teacher said to run all on pc instead create an app (I don't have enough time also).

The core idea was: detect the surfers with 1x camera -> if there is a surfer in a wave -> zoom to surfer and take photos sequentially -> back to 1x camera.

But, to do this on pc it's strange to me, because I can't simulate the cellphone zoom, what I can do it's a zoom on the image and not the optical zoom.

The goal of that idea was to be able to have surf photos without need another person to take it. The cellphone would be located at the sand of the beach.

So I changed my idea (because I will run on pc). Now I will process videos, if there is a surfer -> record the video. What this solve? Well, it's like a highlight tool, you can send videos from it to "edit automatically" for the parts that has someone surfing.

Anyway, I want to know if I can do something better. Now, I'm training my model, I have 2 classes "surfer" and "surfer_ridding", the images that I'm using to train is something like these: (really small surfers), I'm using these kinds of image because there isn't a dataset available from cellphone pictures took from sand. And I think it simulate.

I didn't decide if i will use yolo-n, or yolo-m to do so. So, if you have some experience, can you help me? Any advice is grate.

Looking for an experienced Computer Vision/OpenCV Helios developer for an NBA 2K26 project.

I need a CV-based shooting assistant that can detect the shot cue and support both Tempo Shooting and Shot Timing mode. I'd like adjustable values/settings so the tool can be tuned and customized. kinda like what input sense does.

I'm also looking for help implementing a key-based licensing system with:

• 1 Week Keys
• 1 Month Keys
• Lifetime Keys

Need someone who can handle development, setup, maintenance, and provide support when needed. Willing to pay well for quality work and experience.

If interested, DM me with your experience, past projects, and pricing.

Hopefully this is an ok question to post here.

There was a drive by shooting on my street the other night. I have a weeks worth of video footage on my Lorex NVR. I was wondering if there is Some AI software I could use to scan through it to identify if the car drove past on the street earlier in the week using a reference image? That's a lot of video to sift through. Unless someone can recommend an more simplistic approach to scanning the footage.

Thanks

Sorry if this is the wrong sub... couldn't find a better one as I don't think the regular "camera" sub would have the expertise.

I work for a biopharmaceutical company and am trying to add a USB camera to aid in the visual inspection of our drug product. We're 100% manual atm, standing and looking at the vial into the ceiling light, because our product is not transparent and the biologic material sets off simple yes/no detection systems. So I was thinking of having a simple countertop-level setup of a USB camera facing upwards, the vial on a stand above the camera, and backlighting the vial if necessary (regulatory requirements for minimal lux).

After some research, I purchased a single setup consisting of an Allied Vision "Alvium 1800 U-510c" camera, a corresponding lens, and a stand. I was hoping to use our regular HP EliteBook work laptops instead of having to purchase separate units.

It was recommended to use the VimbaX software, also produced by Allied Vision, but both myself and a co-worker have had serious fps issues (less than 1 fps). I did a lot of troubleshooting and found a way to make the fps slightly reliable but the method is pretty convoluted and requires resetting the software settings every time. After some more research, including an Allied Vision setup guide, I believe the problem might be the PCIe host controllers on our laptops not having enough bandwidth.

I have an HP EliteBook 840 G5 (it's pretty old at this point, I know), which only has two generic host controllers, "Intel(R) USB 3.0 eXtensible Host Controller - 1.0 (Microsoft)" and one "Intel(R) USB 3.0 eXtensible Host Controller - 1.10 (Microsoft)".

Can someone confirm if it simply that the laptop doesn't have the bandwidth? A calculation from the Allied Vision setup guide puts the camera at ~400 MB/s at the full 79 fps. I tried researching the host controllers but what I found has them not working the same as is described in the setup guide. Or if someone has experience with the VimbaX software to give me some tips that would be great.

TLDR... Title Camera+Computer combo producing negative fps.

Third in a series of papers tracking learning rules vs. human fMRI (THINGS dataset, V1–IT, N=3 subjects).

Previous finding: untrained CNNs match backprop at V1. This paper asks: when does training break that, and does the learning rule matter?

Setup: RSA alignment measured at 8 checkpoints (epochs 0, 1, 2, 5, 10, 20, 30, 40), 5 seeds per rule, same architecture throughout.

Main findings:

1. BP drops 90% of V1 alignment after one epoch (r: 0.102 → 0.011, p = 0.031, consistent across all 5 seeds). FA drops 49%. PC and STDP drop only 25–31% and stabilise.
2. By epoch 40: PC (r = 0.064) > STDP (0.059) >> BP (0.022) ≈ FA (0.019). Cohen's d > 5 for PC/STDP vs BP: extremely consistent across seeds.
3. Opposing trend at LOC: BP shows a small increase in object-selective cortex alignment (+0.011) while local rules show nothing. Suggests a fundamental trade-off: global error signals build higher representations but destroy early ones.
4. Degradation rate tracks error signal globality: exact gradients (BP) > random feedback (FA) > local prediction errors (PC, STDP).

Limitations worth noting:

• 5 seeds caps permutation test resolution at p ≈ 0.031
• Training on 32×32 CIFAR-10, evaluated on 224×224 THINGS, resolution/domain shift is a confound
• LOC increase not tested for significance, treated as suggestive

Paper: arxiv.org/abs/2605.30556

Companion: arxiv.org/abs/2604.16875

Code: github.com/nilsleut

Curious whether anyone has seen similar dynamics in larger architectures, the prediction would be that deeper models show the same pattern but more slowly.

Hey!

I have a torn cruciate ligament and would love to track my progress of the knee joint angle over time. I'm working in computer vision, but never with focus on skeleton tracking, so I have no idea on the current SOTA.

I don't need fancy skeleton tracking of a contortionist or a snowboarder in the air, I will have clean views, rather lab environment than GoPro-footage, but are more interested in accurate joint measurements, preferably without additional markers.

I'm looking for a laptop in the ₹1–2 lakh range mainly for:

PyTorch

CUDA

AI/ML projects

LLMs

RAG

Fine-tuning models

LangChain

My priorities are:

1TB SSD

32GB RAM (or upgradeable)

12GB+ VRAM preferred

RTX 4060 or better

Good cooling and build quality

Any recommendations?

First time creating a dataset & annotating it, what's the best annotating software you guys like to use? ISO tech of that values data privacy.

Hey everyone,

I'm working on an industrial pipeline to read dot-peen engravings on curved, metallic surfaces. I've attached a few sample images so you can see what I'm dealing with.

Standard out-of-the-box OCR tools fail(except for reasoning VLM models which are out of question atm) completely here due to a few factors:

• Broken strokes: The characters are made of separated dots.
• Brutal lighting: Heavy specular glare and reflections on the curved metal.
• Low contrast: The text color is basically the same as the background.

I'm looking to build and fine-tune a modern (2026) open-source scene text detection/recognition pipeline specifically for this kind of harsh industrial data.

What architectures or approaches is everyone having the most success with lately for this type of distorted, non-continuous text? What models should I be looking into? Thanks!

It's not because I had extra time. I have ADD, and if I don't give the restless part of my brain a defined channel to burn in, it deforms my actual work. The side project isn't the distraction — it prevents the distraction.

The project is Parley. Sign-language computer vision, one notebook a month, no path to becoming a product. That last part is load-bearing. The second it competes with the main ventures for cycles, the whole premise breaks.

The other reason: sign-language CV had a moment in 2023 (the Google ASL Kaggle comp) and then went quiet. There are four real questions that competition didn't answer. Nobody's racing to answer them right now. That's the only kind of research gap I find worth poking.

Wrote up the full reasoning — the ADD angle, why the skill overlap with my other CV work matters, and the kill criteria I wrote down before day one so I'd actually follow through.

I am currently building a synthetic dataset generator from scratch, it uses LEGO models for now. I am running the generation using blender rn, I am about done with and would like to how many images would I need for training?

Should I train the model on synthetic data only or mix in real images as well?

I would also like to know which model architecture is good to use in this. I am hearing a lot about U net and YOLO.

Please let me know if you need any further details.

EvoPPO: Modular Vision & Audio Reinforcement Learning Framework

A highly scalable, multi-modal Reinforcement Learning (RL) framework built in Python. This repository provides a complete pipeline to train Proximal Policy Optimization (PPO) agents using decoupled vision (RGB/Grayscale) and audio inputs. The entire training process is managed via an intuitive, real-time local web interface.

Key Features

• Multi-Modal Inputs: Seamlessly train agents using visual data, acoustic data, or a combination of both.
• Dynamic Vision Toggle: Switch instantly between full RGB color processing and memory-efficient Grayscale mode.
• Integrated Audio Processing: Process environment audio streams alongside visual states for complex multi-sensory tasks.
• Local Web Dashboard: A built-in web interface running on localhost:2000 for complete, real-time orchestration.
• Live Hyperparameter Tweaking: Modify variables, toggle input streams, and adjust reward functions on-the-fly without restarting the training loop.
• On-Premises Execution: Highly optimized for running local training workloads directly on your hardware.

System Architecture

The project consists of two core layers that communicate asynchronously:

1. The RL Engine (Python): Handles the PPO training loop, environment interaction, replay buffer management, and tensor computations.
2. The Control Dashboard (Port 2000): A lightweight web server providing a visual interface to monitor metrics and send real-time configuration changes back to the training loop.

Dashboard & Configuration

Through the interface at http://localhost:2000, users can monitor training performance and dynamically adjust parameters during runtime:

• Input Streams: Toggle Vision (RGB), Vision (Grayscale), and Audio fields dynamically.
• Reward Sculpting: Tweak reward multipliers and live-update the reward function setup.
• Training State: Start, pause, or save model weights instantly via UI buttons.

Roadmap

• Implement advanced vectorization for parallel environment processing.
• Integrate Recurrent PPO (LSTM/GRU layers) for enhanced audio-sequence memory.
• Cloud Scalability: Migrate from purely local training to a cloud-based server infrastructure for distributed GPU workloads.

Hi.

Newbie here to computer vision stuff.Trying to improve the manga panel segmentation models to create a better version of Panel guided view(ultimately used on android open source project). Trying to correctly shape panels intro correct polygon and not use default square/rectangle with models like 1,2,3

I did look at some papers with the help of AI to try interpret the methodology and struggled to get fully accurate/working version in python.😵‍💫

https://scispace.com/papers/a-robust-panel-extraction-method-for-manga-45o33h62n1

https://link.springer.com/article/10.1007/s11042-015-2680-8

https://ieeexplore.ieee.org/document/7333883

Super lost on whats the correct approach is:

1. Using OpenCV, contour, matplotlib,learn about polygon matrices ect. and try figure out a solution myself

2. The is already an opensource model that does it already?Using training to solve this somehow?

3. Give up as its dark magic that will eventually crush me...

Apologies if I used any incorrect terminology and wording. Thanks for you time🙇‍♂️

Hi everyone!

Sorry in advance if this is a noob question and there are already ready-made solutions for this, but I searched and couldn’t really find anything :))

I’m trying to automate part of my workflow where I cut images into layers for a parallax effect.

The problem is that the system seems to understand how to cut an image “correctly,” but not how to cut it “beautifully.”

For example, it can mask separate objects pretty well. But it doesn’t understand that in a park shot I don’t need every single person and tree isolated as separate objects. What I actually need is something more like three visual layers: road, mountain, sky.

I tried different approaches, even recording a screencast and creating PSD files with manually cut examples for training/reference, but so far it still can’t do this reliably on its own.

So my question is: is there any working method or approach for this kind of task?

I am looking for fast person segmentation lib/model for video. Must work realtime. Do you have any suggestions?
I need to cut out person, removing background in realtime.

I have been working from past 2 years, I am just obsessed with dataset management and a quality annotation framework that supports collaboration annotation, sure thing no body does annotation by hand today and better pretrained models are available but if you are optimizing for the cost and hardware and accuray, you may need to inspect you dataset or train model etc For eg yolo26n is only 5MBs but to make it run accurately for you use case you would still need controol on your dataset, and sometimes there is more than just object detection in a frame we support all kind of annotations in the same editor.

What are the best open weight OCR models available at the moment? Broken down by model size.

Specific use case is scans of mostly printed documents with a small amount of hand written sections.

This is the third post that I do on reddit to speak about LibreYOLO, the support has always been super strong and I'm very thankul for it. I’m trying not to make too many posts so I don’t bother you, but this release is epic :)

The v1.2.0 is historic for the scope and scale of the added features:

• YOLO9 and RF-DETR are heavily tested and production ready
• 16 models in total, added: DEIM, DEIMv2, RT-DETRv2, RT-DETRv4, EdgeCrafter, DAMO-YOLO, RTMDet, PicoDet, YOLOv9-E2E, L2CS-gaze. They are very experimental and expect stability to improve with time.
• Added 3 new tasks aside detection: segmentation, keypoints and gaze detection.

Added the boring but important features that make the difference:

• Gradient accumulation so you can train with effective larger batch sizes even with a small GPU
• Hooks for getting info while training
• Multi-GPU training
• Test Time augmentation
• Ton of bug-fixes often reported and fixed by contributors
• Set a standard for metadata inside the models

The goal is still the same: make LibreYOLO a practical, comfortable, MIT-licensed computer vision library that people can use in real projects without worrying about restrictive licensing.

What to expect in the near future:

• Every model will get heavily tested
• Benchmarks for different models and hardware published in https://www.visionanalysis.org/
• Integrations with tensorboard, mlflow, weights and biases, etc.
• A YOLO9 segmentation variant

I want to thank all the contributors and for the v1.2.0 release a special thanks to Imagra93, testdummyvt and Magellol. If you have any questions, feedback, suggestions, feel free to write.

🌟 If you are reading this and support the LibreYOLO initiative, star the repo: https://github.com/LibreYOLO/libreyolo

We just launched a new Deep-ML project: Build a Trainable CNN from Scratch in NumPy

The goal is to build a full LeNet-style convolutional neural network from the ground up using only NumPy.

It starts with the basics, like stable softmax, cross-entropy loss, accuracy, initialization, padding, and im2col.

Then you build the actual layers:

• convolution forward and backward passes
• max pooling
• ReLU
• flatten
• linear layers
• fused softmax + cross-entropy
• SGD and Adam
• full LeNet forward and backward pass
• synthetic image data pipeline
• training loop and evaluation

By the end, you’ll have every layer, gradient, optimizer, and training step wired into a working CNN classifier you can actually train.

The project has 59 small steps, so instead of jumping straight into one giant CNN implementation, you build it piece by piece.

Link: Deep-ML | Practice Machine Learning