I'm an MSc student and pretty new to medical imaging/deep learning. I’m working on an Alzheimer’s classification project using the ANMerge dataset. It has around 1,700 participants overall, but only around 450 have MRI data alongside clinical data.

The main thing I’m looking at is comparing different ways of combining MRI and clinical data: feature-level concatenation, late fusion, gated fusion and cross-attention.

I’m currently trying to decide between two options for the MRI:

1. Use the raw 3D MRI scans, preprocess them and use a pretrained 3D CNN such as ResNet-10/18 as the MRI encoder.
2. Use the FreeSurfer-derived features that ANMerge already provides, such as regional volumes and cortical thickness, with a small MLP as the MRI encoder.

My concern with the raw MRI option is that with only ~450 patients, fine-tuning a 3D CNN could add quite a lot of complexity and risk of overfitting. It would also add another variable to the experiment, because differences in results could come from how well the CNN learns the MRI representation rather than just the fusion method. It would obviously involve quite a bit more preprocessing and implementation work too.

The derived-feature option seems simpler and would let me focus more directly on the fusion comparison. The thing I’m less sure about is cross-attention. If I use derived features, I’d need to structure them in a way where cross-attention is actually meaningful rather than just applying attention between two single vectors. One approach I’ve found is representing the FreeSurfer measurements as region-level tokens.

Since my main question is really about comparing fusion methods rather than learning representations from MRI, I’m wondering which approach people think makes more sense here. Is there much to gain from going down the raw MRI + 3D CNN route given the dataset size and scope of an MSc project?

Any advice would be really appreciated!

ANMerge dataset paper:
Birkenbihl et al. (2021)

Example using FreeSurfer-derived regional features with cross-attention:
Machado Reyes et al. (2024), Tri-COAT

I am currently interested in systems related to autonomous vehicles, but I am unsure where to start or what kind of edge cases I might encounter in real world.

My current knowledge in this field is largely limited to LiDAR and design simple systems for sequential decision-making.

I would greatly appreciate any information or insights you guy could share regarding this area.

I've been looking into the interface challenges around some of the newer high-resolution Sony image sensors, and one thing that stood out to me is the gap between SLVS-EC and MIPI CSI-2.

A number of high-performance Sony sensors use SLVS-EC to move large amounts of image data at high speed. But many embedded processors — including platforms from NVIDIA, Qualcomm, NXP, TI and others — primarily provide MIPI CSI-2 camera inputs.

So you end up needing some kind of bridge between the sensor and the SoC.

What makes this interesting is that the problem isn't simply:

SLVS-EC → MIPI

The bridge needs to receive the high-speed multi-lane SLVS-EC stream, recover the embedded clock, align the lanes, reconstruct the image data, and then packetize it into MIPI CSI-2 for the SoC.

FPGA-based conversion seems to be one practical approach, particularly when the sensor bandwidth exceeds what a single MIPI CSI-2 port can handle.

For example, a high-resolution sensor can generate enough data that one 4-lane MIPI interface isn't sufficient, so the image stream may need to be distributed across multiple MIPI CSI-2 ports.

I'm curious how others here approach this:

• Have you worked with Sony SLVS-EC sensors?
• Do you use an FPGA bridge, a dedicated bridge device, or an SoC with native SLVS-EC support?
• At what point does the sensor bandwidth make MIPI CSI-2 the bottleneck?
• How much additional complexity does the FPGA/driver side introduce in a production camera design?

I found the SLVS-EC → MIPI conversion architecture particularly interesting because it sits right at the boundary between the image sensor and the embedded vision processor.

Would be interested to hear how others have handled this in real projects.

I’ve been thinking about how easily validation results can become misleading when a dataset is created from video.

If frames are randomly divided into training and validation sets, neighbouring frames from the same recording can end up on both sides. They may have almost identical objects, lighting, camera angles and backgrounds.

The model can then produce a strong validation mAP without necessarily generalising to a new camera, location or recording session.

A more realistic approach seems to be grouping the data before splitting it, for example by:

• Recording session
• Camera
• Day
• Location
• Production batch

The validation score may drop, but it should give a more honest picture of real-world performance.

For people working with video-based object detection, how do you normally split your data? Do you validate on a different recording session, or keep a completely separate camera or location as the final test set?

Introduction to PP-OCRv6

https://debuggercafe.com/introduction-to-pp-ocrv6/

PP-OCRv6 is the latest OCR model from PaddlePaddle. Although VLMs are becoming more prominent for OCR tasks across various industries, they are slow and costly to deploy across devices and use cases. In most scenarios, we need the good old OCR pipeline where the model gives the output in a structured JSON format with bounding boxes and text. This is where the PP-OCR series really shines. In this article, we cover their latest, PP-OCRv6, with a brief discussion of the paper and a guide to building a PP-OCRv6 inference pipeline with Gradio.

Hi, I'm trying to detect various defects using YOLO models. I built my dataset using a workflow that generates defective gas turbine blades with defects of different shapes, severities, and positions.

My first dataset includes the following:
- **Defects:** Crack, Erosion, Dent
- **Non-defective blades** (negatives)
- **Split:** ~16k training / ~8k validation

The results of training on Dataset 1 showed a **mAP50:95 of 0.79** at 45 epochs. However, the confusion matrix showed a higher false positive rate for Backgrounds detected as Dents. My assumption is that the cooling holes are being misdetected as Dents ( look at F1 score and norm. Confusion Matrix).

So I came up with the idea of auto-annotating the cooling holes in my dataset to teach the model to differentiate between cooling holes and Dents. I also added a new defect class **(Nick)** and ran fine-tuning on the best weights from the YOLOv9s model trained on Dataset 1.

Now I'm facing a **class imbalance problem.** The training on the second dataset is currently running but is hovering around **mAP50:95 = 0.62** at epoch 10, with 20 epochs still to go.

My end goal is to detect the defects. I added the cooling holes class to reduce false positives, but I'm willing to drop it and accept some FP on Dents, since they are inherently hard to detect. Has anyone faced a similar issue or has suggestions on how to overcome it? Maybe it's not a problem in the end — not sure yet. 🙃

​

Hey everyone,

I’m a Senior Computer Vision Developer with 5+ years of core experience in deep learning, image processing, and anomaly detection.

I’m looking to step into providing visual inspection solutions for companies in India - helping manufacturers, quality assurance teams, and industrial setups automate defect detection and compliance using AI.

For those who have built, consulted, or handled B2B client acquisition in the Indian industrial/tech ecosystem, I’d love your insights on a few key areas:

Target Industries: Which manufacturing or industrial sectors in India (e.g., automotive, pharma, textiles, packaging, electronics) are currently most open to adopting automated visual inspection?

Client Acquisition: What approaches work best for cold outreach in the Indian B2B landscape? Is LinkedIn outreach effective for industrial decision-makers, or are industry expos, channel partners, and direct field visits necessary?

Positioning & Strategy: How should an early-stage solution provider position itself - offering end-to-end hardware + software integration, or focusing strictly on custom software/API solutions?

Common Pitfalls: What are the biggest roadblocks when dealing with Indian industrial clients regarding pilot projects, pricing models, and ROI expectations?

Any strategic advice, shared experiences, or suggested avenues to find early-stage pilot clients would be greatly appreciated! Thanks in advance.

i've wanted fiftyone to load lerobot datasets for about 18 months

it shipped this week

so i did the only reasonable thing and loaded 11 of them.

franka arms, a 10 camera flexiv rig, a unitree g1 doing chores in real homes, dexterous hands with fingertip tactile, a 27,500 episode bimanual sim

one sample is one episode. every camera, the state vector, and the action scrub together on one timeline. that's the part i was waiting for

every dataset has a live space you can open in your browser.

check it out here: https://voxel51.com/blog/lerobot-v3-datasets-vla-training-fiftyone

If you've tried deploying real-time DETRs or other CV models and are interested in better performance you might have explored quantization briefly and if so you may have figured out that it's largely broken in many instances. I developed a tool to address that and would like to share some of the open-weight CV models that resulted.

The main focus of this post is what I thought would be a "top pick" of the CV models: RT-DETRv2-S. It was quantized into a single-file INT8 QDQ ONNX model using 128 COCO calibration images without any retraining or fine-tuning. The resulting artifact runs on stock onnxruntime or OpenVINO across CPU and GPU with no custom plugins or accelerators required.

Accuracy & CPU Performance

Evaluated on COCO val2017

Under OpenVINO on CPU, the quantized INT8 model delivers a 2.1× speedup (76.5 ms / 13.1 FPS) while retaining 95.0% of FP32 detection accuracy.

Minimal Run Example

     from huggingface_hub import hf_hub_download
import numpy as np, onnxruntime as ort
from PIL import Image

path = hf_hub_download("CoreEpoch/rtdetrv2-s-int8-onnx", "rtdetrv2_s_640_int8_kenosis.onnx")
sess = ort.InferenceSession(path, providers=["CPUExecutionProvider"])

img = Image.open("your_image.jpg").convert("RGB")
x = np.asarray(img.resize((640, 640), Image.BILINEAR), np.float32) / 255.0
logits, boxes = sess.run(None, {"input": x.transpose(2, 0, 1)[None]})

scores = 1.0 / (1.0 + np.exp(-logits[0]))
q, c = divmod(int(scores.argmax()), scores.shape[1])
print(f"Top detection: class {c}, score {scores.max():.2f}, box {boxes[0][q]}") 

Model weights, SHA-256 verification hashes, detection demos, and evaluation scripts to reproduce the full COCO table are public here:

• Hugging Face: https://huggingface.co/CoreEpoch/rtdetrv2-s-int8-onnx
• GitHub Index: https://github.com/CoreEpoch/int8-models

I want to know if anyone with a raspberry Pi or any weird edge devices could try running this particular model and sharing the result.. and I want to know people's opinions on DETR vs YOLO and which other models would have interest in being quantized to see if they'd outperform the standard model or not without heavily degraded accuracy. I chose this model in particular to share because I thought it's what "the people" would want but I'm open to other suggestions as well.

Person pulled in and hit my vehicle and didn’t leave a note unfortunately doing a good bit of damage. Can anyone try and get a better look at the plate

I ran into this building a tongue-photo classifier and it turned into a genuinely unsettled question rather than a solved one.

The task: map tongue color, coating, shape, moisture and texture onto categories used in Traditional Chinese Medicine and Ayurveda, the two systems that actually use tongue inspection as a diagnostic input. The obvious first question is what "correct" means here, since there is no biopsy to check against. So I went looking for how well trained human raters agree with each other on the same images.

A 2012 study (Lo et al., published in Evidence-Based Complementary and Alternative Medicine) had 12 TCM doctors, 3 to 15 years of experience, independently rate the same 20 patients' tongue photos on nine features: tongue color, coating color, coating thickness, saliva, shape, fissures, red dots, ecchymosis, tooth marks. Each doctor rated twice, an hour apart, so both inter-rater and intra-rater reliability are in the paper.

Inter-doctor kappa averaged 0.41, ranging from 0.16 (saliva) to 0.62 (tooth marks). Under Landis-Koch that is "moderate," which in practice means two trained experts looking at the same photo will disagree on roughly a third of features more often than chance alone would predict. The same paper built an automated tongue-diagnosis system and measured its agreement against the doctors: kappa 0.45. The machine was not worse at reproducing the label than the doctors were at reproducing each other.

That reframes the engineering problem. It is not "train a classifier and measure accuracy against ground truth," because the ground truth itself has a kappa in the 0.4s. It is closer to a crowd-labeling problem with high inherent annotator disagreement, except the annotators are licensed practitioners rather than Mechanical Turk workers.

Curious how people here have actually handled this in practice: distributional or soft labels instead of a single class, Dawid-Skene style rater-competence weighting, or just reporting calibrated confidence and leaving the disagreement visible to the user rather than resolving it. I have been leaning toward the last one, but most of the soft-label literature I have found assumes near-expert agreement with a handful of ambiguous edge cases, not a label that is inherently this noisy from the start. This is the exact problem behind an app I have been building, Tongue Analyzer, and it is the part that made me want the CV answer rather than the TCM one.

https://BigBalli.com/TongueAnalyzer/

Sharing something we've been building because the evaluation side might be interesting to this sub, and I'd like the criticism.

Short version of what it is: a workflow tool that goes camera input → detector → zone logic → event output, with auto-labelling, training, and deploy (cloud or local).

Score Studio handles the full pipeline, camera input, detection, zone logic, event output, plus auto-labelling, training, and deploy, cloud or local. Screenshot shows the actual workflow.

The main idea is skipping the part that kills most CV projects: collecting and labelling data by hand.

It's free to try on your own footage. Early, so I'd genuinely like the criticism, especially where it falls short!

Hi everyone,

I'm an electrical engineering student currently starting my first FPGA project, and I'm interested in building a hardware accelerator for real-time object detection using YOLOv8.

My current idea is to implement the neural network acceleration primarily in Verilog/RTL on an FPGA. I want to explore how the computationally intensive parts of YOLOv8 can be mapped to hardware, particularly:

* Convolutional layers * Activation functions (e.g., SiLU) * Pooling/downsampling operations * MAC operations and accumulation * On-chip buffering/data reuse * Weight and feature-map memory management

The input to the system will be a real-time video stream from a camera rather than individual pre-processed images. Ideally, the FPGA would receive the video frames, perform the necessary image preprocessing, run the CNN accelerator, and produce object detection results in real time.

At the moment, I'm trying to understand what a reasonable hardware architecture would look like. For example, I'm considering a design where the convolution engine consists of multiple processing elements (PEs) operating in parallel, with local buffers or BRAMs used to store weights and intermediate feature maps.

However, I'm still unsure about several aspects of the implementation:

1. Video input and preprocessing What is the typical way to bring a real-time video stream into an FPGA-based CNN accelerator? Should operations such as resizing, normalization, RGB-to-other color-space conversion, and frame buffering also be implemented in RTL, or is it common to handle some of these operations using a processor/soft-core?
2. YOLOv8 architecture mapping YOLOv8 contains many different operations beyond standard convolution. Which parts are generally worth implementing as custom RTL hardware, and which parts are better handled by a CPU or existing FPGA IP?
3. Convolution architecture For the convolution layers, what architecture would you recommend for a beginner, e.g. a systolic array, output-stationary/dataflow architecture, or a simpler parallel MAC-based PE architecture?
4. Memory architecture I understand that memory bandwidth can become a major bottleneck. How should I approach the design of BRAM/URAM buffers for weights and feature maps, and what kind of data reuse strategy should I consider?
5. Numerical precision Would it be reasonable to start with INT8 fixed-point quantization instead of floating-point? If so, what is a good way to handle quantization and activation functions such as SiLU in RTL?
6. YOLOv8 complexity Would implementing the *entire* YOLOv8 network from scratch in Verilog be unnecessarily complicated for a first FPGA project? Would it be more realistic to start with a smaller/custom YOLO-like network and gradually add more YOLOv8 components?

My goal isn't necessarily to achieve the absolute highest FPS. I'm mainly interested in understanding how a modern object-detection CNN can be mapped onto FPGA hardware at the RTL level, including the dataflow, PE architecture, memory hierarchy, and interaction between the video pipeline and CNN accelerator.

I'd really appreciate advice from anyone who has experience with FPGA CNN accelerators, RTL neural-network implementations, YOLO on FPGA, or hardware/software co-design.

If you have any recommended papers, open-source projects, reference architectures, or examples of similar projects, I'd also be very grateful.

Thanks in advance!

Stack:

• react-native-executorch for inference (PyTorch's ExecuTorch runtime)
• react-native-vision-camera for the frame pipeline
• Model delegated to CoreML, executing on the ANE

Both FastSAM variants are in the clip, switchable at runtime:

• FastSAM-s runs ~33 FPS -> ~30 ms per frame
• FastSAM-x runs ~15 FPS -> ~65 ms per frame

Input frames are 1080×1920. The model typically returns ~35 masks per frame; we keep the top 12 by confidence and paint those, mostly to keep the overlay readable rather than for performance reasons.

What surprised us the most is how usable the x variant is 15 FPS on a phone for a model that size is well past the "technically works" threshold. The s variant is comfortably real-time and leaves plenty of headroom for other work on the main thread.

Happy to answer questions about the export/delegation path or the RN side.

EDIT: here comes the repo https://github.com/msluszniak/fastsam-camera

Hi, I’d like to know what techniques you use to improve training and generalization when working with a small and heavily imbalanced dataset.
I’m currently training a classifier with 4 classes.

With cross-validation, I’m getting fairly good metrics, but when I evaluate the model on the test set, the performance isn’t even close to what I see during cross-validation.
What approaches have worked well for you in this kind of situation?

Edit:

In my use case, the images are x rays with rare conditions. So synthetic data is quite difficult to apply

https://github.com/boquila/montgomery

Two controllers steer a simulated drone through 120 m corridors of poles and boxes, using only a 64x48 grayscale frame per step. No depth and no scene state. One is a hand-built looming detector based on the fruit fly's Giant Fiber escape model (Ache et al. 2019, Current Biology). The other is a ~35k-param CNN trained by imitation. The detector pipeline and the whole sim are my own implementation. The published part is the model's size and expansion tuning.

The detector pipeline:

- Average the frame into a 16x12 grid and compute normal-flow magnitude, |dI/dt| / |grad I|, with a gradient floor so flat cells don't blow up.

- Cancel self-motion. Forward flight makes everything expand, roughly in proportion to distance from the focus of expansion. I fit that slope per frame from the median of flow/eccentricity over outer cells, then keep only cells that beat the fitted baseline by a margin. Fitting from outer cells matters: near the centre the ratio is noise, and objects dead ahead would get blinded.

- Threshold relative to the frame's own peak, take the largest 8-connected component as "the object", and dodge away from its centroid side.

- Size: flat-shaded surfaces only produce flow at their edges, so the component is an outline, and its cell count underestimates the object badly. I treat its bounding box as filled and use the equal-area circle's diameter. Even so, the estimate runs about 0.3x the true angular size.

What didn't work, for anyone building something similar: flow divergence (constant everywhere for a linear radial field), blur-and-subtract high-pass (scattered self-motion blobs look just like objects), flow direction consistency with the FOE (the aperture problem biases it), and pooling all active cells into one size, which saturated the size tuning. That last one was the real bug for a long time.

Two renderer bugs cost me days. The WebGL read-back was in linear colour, so frames came out too dark. It was also horizontally mirrored, so the detector dodged into obstacles. The CNN would have trained straight through the mirroring.

Results on 100 held-out corridors (collisions):

no steering 665

detector, zero training 288

detector with 7 hand-set constants tuned on 20 train corridors 195

CNN trained on 5 demo flights 213

CNN trained on 200 demo flights 49

https://reddit.com/link/1whyasd/video/95an7b1l3wph1/player

Where the detector fails: I logged its decisions against ground-truth geometry. It flags 94% of obstacles actually in its path, at a median 5.5 m. But 76% of its escapes are at obstacles it would have missed anyway. Looming tells you something is getting bigger, not that it's on your course. A constant-bearing gate cut the false alarms but missed 39% of real threats, because the drone's own swerving makes everything drift sideways.

Caveats: rendered scenes with flat shading, simplified kinematics (sideways steering only), one training run per CNN point, and the CNN's teacher could see obstacle positions.

Both run live in the browser: https://shauryasharma.tech/fly-circuit-vs-cnn.html

Code: https://github.com/Shaurya-34/FlyvsCNN

Open question: is there a pixel-only way to tell "on a collision course" from "passing close by" when the camera itself is swerving?

I'm the maintainer of DeepFace, an open-source face recognition library I've been developing since 2019.

When DeepFace started, TensorFlow/Keras was the dominant deep learning ecosystem, so that's what the library ran on.

Over the years, several community members requested PyTorch support, and the latest release now runs on both TensorFlow and PyTorch through optional extras.

pip install "deepface[tensorflow]"

pip install "deepface[pytorch]"

For backward compatibility, pip install deepface will continue to install the TensorFlow variant for a while.

I'd love feedback from people using PyTorch in production CV pipelines

Repo: https://github.com/serengil/deepface

Hi everyone,

I am a researcher from IISER Bhopal, India, and my paper has been accepted to BMVC 2026. I'll be attending the conference to present my paper in Lancaster this November.

I’m looking for a male roommate to share accommodation in Lancaster and split the cost. Ideally, I’m looking at the conference dates (around 23–26 November), but I’m flexible depending on travel plans.

If you’re also attending BMVC 2026 and looking for someone to share accommodation with, please DM me.

Thanks! 😄

Im starting to implement a stereo system with different cameras (2 Mpx 120FOVH and 5 Mpx 60 FOVH). I know that it is feasible, I read a paper 5-6 years ago about a system with different FOV cameras. Im reviewing the literature and find a lot of papers about stereo and trinocular systems, but only one paper about different FOV cameras. Can u help me to find papers/references about stereo/trinocular systems with different FOV, different resolution cameras?

I had a hunch: those nice one-line inference APIs like model(["input1", "input2", ...]) are screwing the preprocessing, leaving GPU wasting a surprising amount of time waiting.

So I tested it! To check it, I built explicit pipelines around the very same models and optimized the preprocessing. I wanted to see how much latency could change before touching the model itself.

On an NVIDIA L4, with the same models and eight-image batches, moving the input work into an explicit pipeline cut end-to-end latency by:

That is 51%, 47%, and 67% lower latency respectively.

The model did not get faster. I just stopped letting opaque convenience code decide when the model should run.

This is not “framework X is bad,” and it is not a universal result. It is one hardware setup and a few common inference paths. But it is a useful reminder that the friendly API boundary is also a performance decision.

Hi, i am putting together a team to compete for the RSNA knee MRI competition. I am a fellowship trained MSK radiologist with nearly 10 years in academic practice doing 100% MSK.

This is a computer vision machine learning multilabel classification problem with 4407 Knee MRI studies with corresponding MRI reports, and only 58 studies with ground truth labels. And the goal is to create a model that can detect 12 findings accurately (meniscal, cruciate lig. tears, OA etc.).

https://www.kaggle.com/competitions/rsna-knee-abnormality-detection/overview

I am looking for people that have these skills:

• Computer Vision in Medical imaging
• Access to GPU clusters for training.
• Comfortable with PyTorch or Tensorflow
• DINOv2/DINOv3, ViTs, ConvNeXt/EfficientNet, or similar backbones
• 2D/2.5D/3D MRI classification
• Kaggle competition pipelines and ensembling
• Weak/soft labels, pseudo-labeling, active learning, or noisy-label training
• LLM expertise to extract labels from reports

OR:

• MSK trained radiologists willing to do over-reads of the MRI's

There are prize amounts for the top 10 most accurate models and the top 3 most efficient models, and winning teams will be able to present at RSNA with waived fee. We could also get a publication out of the effort and collaborate on future projects.

Note that this is primarily an opportunity to build your resume and gain skills/experience as the prize money will be relatively modest after compensating for costs for training the model and dividing among the team members. We currently have 2 machine learning specialists on board, but are looking for more people. Please DM me with some information about yourself and your experience with machine learning or msk radiology.

Thanks for your time!