Hello everyone,

I have a few edge devices (including Nvidia Orin Nano) and am interested in SLAM (visual-SLAM). I want to do some experiments, but I don't have any experience with SLAM. What are the best resources for beginners? Maybe some courses, textbooks, articles, or research papers?

Join us on Nov 5 for the Visual AI in Agriculture virtual Meetup! Register for the Zoom.

Talks will include:

• U-Net Framework for Micro-Scale Surface Damage Segmentation in High-Resolution Soybean Seed Imagery - Saurav Upadhyaya at Louisiana State University
• From camera to drone: wildfire detection and integration at the edge - Maxime Carriere at kernwerk
• 5,000 Flights to Answer One Question: Can a Drone Sample as Well as a Human? - Rohan Talwadia at LabGPT

Guys, I came across an open research challenge that is primarily an image analysis problem and I think it could be of interest to many of you.

Astronomers re-examining scanned glass photographic plates from the 1950s Palomar Sky Survey have reported thousands of short-lived point sources that look like stars but don't appear on images of the same field taken before or after (Solano et al. 2022). The debate is whether they are real flashes of light or emulsion defects, dust and scanning artifacts, which makes it a classification problem on noisy, decades-old images.

The challenge asks teams or individuals to run this kind of search on plates from observatories other than Palomar, taken before October 1957. You pre-register how you define a detection, your sample and your controls before touching the data, and you register a checksum of your detection list before analysis. A null result counts the same as a positive one, and code and detection lists have to be released openly.

The challenge provides a reference detection pipeline on GitHub and a public sample of the Palomar detections to train or validate against and is open to independent researchers as well as university teams.

Prizes for the top three teams/individuals are $75k, $50k and $25k, respectively.

I think I'll take a stab at it.

Repo, weights and a playable demo at the bottom. Everything trained on free Kaggle T4s.

MK-SH-V is a visual decision model. It takes an image, a question with options, and returns calibrated probabilities, a choice, and a refusal when confidence sits below a gate frozen in advance.

Held-out real numbers

It wins overall and on screenshots, loses receipts badly. The gate answers 98.6% of the held-out synthetic set with a CP95 selective-risk bound of 4.1%. Out of distribution it says so, real receipts risk runs around 25%.

The demo is a Papers Please style border booth set in 1974. Travelers claim firms, the model reads their papers, and every check in the game is one the checkpoint actually measured. Below tau 0.55 it refuses to advise and routes the file to you, which happens on documents like a 5,250.00 invoice sitting at p 0.536. You can also take a bribe, it goes about as well as you would expect.

Honesty section, the part I care most about

• Two experiments after the released checkpoint both missed their gates. The weights are unchanged.
• On general VQA boards the model measures at chance. It is a decision model for a narrow contract, not a chat VLM.
• Synthetic training data hurt real transfer until I mixed real screenshots in. Details in the run logs.

Links

• Play in browser: https://gjusev-mk-sh-v-demo.hf.space
• Code with criteria frozen before each experiment: https://github.com/Gjusev/mk-sh-v
• Weights Apache 2.0: https://huggingface.co/Gjusev/MK-SH-V

Happy to answer training questions. It is two T4s and a lot of frozen criteria.

Disclosure: I’m Philip, with SingNova. These measurements and implementation details come from a colleague on our engineering team. This text was drafted with AI assistance. I’m sharing their profiling notes and will relay technical questions to them, then share their confirmed answers here.

In a browser-to-device object-detection demo, preprocessing takes 51.0–59.5 ms, while the worker’s inference stage takes 59.5–62.7 ms. Preprocessing, inference and postprocessing currently run serially. The useful question for us is how to break down the preprocessing measurement before deciding whether to reduce that work or overlap it with inference.

The demo also illustrates a measurement distinction: the output stream is configured at 25 FPS, but one run completed only about 7.5 new inferences per second. Those are different quantities, and neither establishes capture-to-display latency.

Setup and video path

• Host CPU architecture: riscv64; model execution: a dedicated DFU accelerator, not the host CPU.
• OS: openEuler 24.03 LTS-SP2, Linux 6.6.118+.
• Runtime: 1.0.3, with a model-specific plugin and explicit cache synchronization.
• Source video: 640×360 at 25 FPS.
• Decode: FFmpeg software decoding. Hardware video decode is being developed separately and is not part of these measurements.
• Model: YOLOv12s; input: 1×3×640×640, with BGR input for this setup.
• Preprocessing: colorspace conversion, scaling and black letterbox padding.
• Postprocessing: tensor decoding, confidence filtering, NMS and box rendering.

​

Browser → WebRTC/WHIP → ZLMediaKit → FFmpeg software decode
        → preprocessing → DFU inference → postprocessing/overlay
        → FFmpeg H.264 encode → RTSP → WebRTC/WHEP → browser

What the timers measure

We have two levels of instrumentation.

Inside the runtime, kernel_ms measures device execution. total_ms covers the inference call, including input/output copies and cache synchronization. The reported YOLOv12s averages are:

One individual invocation is shown below. It is a sample, not the averages above:

[DFU_PROFILE] infer_id=977 status=ok
input_copy_ms=1.677 input_cache_clean_ms=0.263
kernel_ms=50.570 result_pre_read_ci_ms=0.095
output_copy_ms=1.043 result_post_read_ci_ms=0.114
total_ms=53.834
input_bytes=2457600 result_bytes=1411200

Separately, the worker reports pipeline-stage timings:

infer_ms is the worker-level measurement, not an alias for kernel_ms. The runtime averages and pipeline ranges should be read separately. The worker-level inference timings are higher than the reported runtime-call mean, but these are different measurement scopes and summaries. We have not yet quantified or attributed the difference using paired per-invocation traces.

The preprocessing timer is aggregated. It does not yet separate colorspace conversion, scaling/padding, tensor preparation, copies or any waiting included in that scope. We cannot yet identify which operation dominates it.

Throughput, dropped frames and unmeasured latency

One run completed 977 inferences in 130 seconds, approximately 7.5 new inferences per second.

The source is capped at 25 FPS. When processing cannot keep up, the current implementation drops older input frames; the engineering notes report approximately 69% input frames dropped in the YOLOv12s test.

Output video remains configured at 25 FPS and can repeat the last detection result between inferences. A smooth output stream therefore does not imply a new detection result for every frame.

Model-switch initialization is recorded separately: the first YOLOv12s pipeline invocation was 1459.9 ms, versus approximately 60–61 ms in steady state. Those invocation figures are not whole-pipeline or capture-to-display latency.

Capture-to-display latency has not been measured. We do not currently have frame IDs connecting browser capture with the returned result. The figures above describe processing time and throughput, not end-to-end latency or frame age at display.

Questions for people profiling similar vision pipelines

1. Where would you place additional trace points? How would you separate FFmpeg/filter work, scaling/padding, tensor preparation and copies, especially when a stage timer might include waiting for a frame or buffer?
2. What evidence would make you prioritize reducing preprocessing work versus overlapping preprocessing and inference? The current three-stage worker is serial, and input buffers are explicitly synchronized before device execution. How would you measure the opportunity while checking buffer ownership and safe reuse?
3. How do you preserve frame identity through a latest-frame/drop-old pipeline? I’m interested in approaches that let you measure frame age at display without assuming synchronized browser and device clocks.

Specific profiling methods or examples from comparable pipelines would be useful. These are measurements from one implementation on one engineering unit, not a comparison across devices or a general claim about RISC-V performance.

I'm a degree student and my project is basically about detecting factory workers who aren't wearing hard hat and safety vest. Then sends notification to a dedicated dashboard and Telegram to notify safety manager while simultaneously firing an on-site alarm to warn the worker. My supervisor agreed to accept this as my project, which is good, but personally I feel like this project is too cliche as a fyp. When I first thought of this idea, I've never heard of a factory using AI integrated CCTV cameras to monitor workers, so I was excited to develop it. I'm writing this post to ask for opinions from my fellow redditors so I can improve it and impress my supervisor as I can't think of any new features that would seperate my project from any existing products out there. Thank you in advance ;)

I'm a degree student and my project is basically about detecting factory workers who aren't wearing hard hat and safety vest. Then sends notification to a dedicated dashboard and Telegram to notify safety manager while simultaneously firing an on-site alarm to warn the worker. My supervisor agreed to accept this as my project, which is good, but personally I feel like this project is too cliche as a fyp. When I first thought of this idea, I've never heard of a factory using AI integrated CCTV cameras to monitor workers, so I was excited to develop it. I'm writing this post to ask for opinions from my fellow redditors so I can improve it and impress my supervisor as I can't think of any new features that would seperate my project from any existing products out there. Oh and how about cctv camera, is Tapo C210 a good model for my project? Thank you in advance ;)

Left is the photo, right is Depth Anything's depth map. Same performer in a faceted mirror suit, shot outdoors in uncontrolled light — LA River concrete channel, under a bridge, desert hillside, hilltop at sunset.

The model finds the person in all four. Everything behind him is where it falls apart: the river and concrete wall flatten into a gradient, the bridge scene gets a black void where sky should be, the hillside turns flat and the suit collapses into a blob, the mountains become a flat black wall.

So the question for people who actually run these models: is this a specular problem, a background problem, or both? What breaks first in your stack — highlight blowout, or the geometry behind the reflection?

I shot the full set for exactly this failure mode. Details in the first comment.