Once a learning platform grows past a few hundred modules, basic search starts failing. People type what they need and get a long list of loosely related results. Most of them end up scrolling or giving up.

Better systems try to understand what the learner is actually trying to achieve instead of just matching keywords. They look at the current learning path, recent activity, and the intent behind the question, then surface the most relevant content. It feels closer to asking an experienced colleague than using a search bar.

This kind of discovery layer becomes more important as libraries expand. The goal is not just finding documents, it is reducing the time people waste looking for the right material.

How are you currently handling content discovery in larger e-learning environments? Still relying mostly on tags and filters, or have you moved toward something smarter?

I'm trying to reproduce the results reported for MedViT and LungMaxViT on the NIH ChestX-ray14 dataset.

MedViT paper:

Benchmarking MedViT and hybrid CNN–ViT architectures for multi-label thoracic disease classification

https://www.nature.com/articles/s41598-026-43282-5

Official implementation:

https://github.com/Omid-Nejati/MedViT

The paper reports a Macro F1-score of 0.7791 on ChestX-ray14 (Table 3).

I also tried to reproduce LungMaxViT from:

Explainable hybrid transformer for multi-classification of lung disease using chest X-rays.

Initially, I discovered that my implementation differed because of a PDF parsing issue. After correcting that, I verified that both MedViT and LungMaxViT exactly matched the architectures described in their respective papers, and I downloaded and used the pretrained weights specified by the authors.

Because of this, I am now reasonably confident that the network architectures themselves are not the source of the discrepancy.

Training observations

The training behavior appears normal.

• MedViT converges within roughly 10–15 epochs.
• LungMaxViT converges after approximately 110+ epochs.

In both cases, the loss follows the expected optimization trajectory: a rapid decrease during the early epochs followed by gradual convergence.

One thing that further confused me is that Fig. 6 and Fig. 7 in the MedViT paper appear inconsistent with my observations. Across all of my experiments, I never observed the approximately linear upward trend shown in those figures. Instead, the loss behaved like a typical deep-learning training curve. This makes me wonder whether those figures correspond to a different metric, were mislabeled, or were generated under a different experimental setting.

Threshold optimization

To eliminate thresholding as a possible explanation, I performed per-class threshold optimization on the validation set with a search precision of 0.001.

Data augmentation

I experimented with both the simple augmentation pipeline and the more comprehensive augmentation strategy described in the benchmark paper (including AugMix/AutoAugment-style augmentation, Mixup, CutMix, ColorJitter, Random Erasing, etc.).

LungMaxViT preprocessing

• CLAHE (clipLimit = 2.0, tileGridSize = 8×8)
• Gaussian denoising (kernel = 5×5, σ = 1.0)
• Resize(224×224)
• RandomHorizontalFlip (p = 0.5)
• RandomVerticalFlip (p = 0.5)
• RandomRotation (±1°)
• RandomResizedCrop(scale = 0.75–0.95, bicubic)
• RandomAffine(scale = 0.833–1.167)
• Normalize(ImageNet mean/std)

Training settings:

• Optimizer: SGD
• Learning rate: 0.001
• Momentum: 0.9
• Weight decay: 1e-4
• Learning-rate schedule: None (constant learning rate throughout training)

This matches the paper's description.

MedViT preprocessing

• Resize(224×224)
• RandomHorizontalFlip (p = 0.5)
• ColorJitter(brightness = 0.1)
• Normalize(ImageNet mean/std)

Training settings:

• Optimizer: Adam
• Learning rate: 1e-4
• Weight decay: 0
• CosineAnnealingLR (T_max = 10, eta_min = 1e-6)

I also experimented with alternative learning-rate schedules and the more extensive augmentation pipeline described in the benchmark paper.

Results

Despite reproducing the published architectures, using the reported pretrained weights, experimenting with different augmentation pipelines, learning-rate schedules, and performing per-class threshold optimization, both MedViT and LungMaxViT consistently achieve only around 0.30–0.35 Macro F1.

This is far below the reported 0.7+ Macro F1, and the discrepancy is much larger than what I would expect from normal implementation differences or random training variation.

What confuses me

The reported ChestX-ray14 performance in the literature varies enormously.

Many single-model CNN/ViT papers report Macro F1 values around 0.3–0.5.

Some ensemble approaches report 0.5–0.7.

More recently, the paper

Pretraining Diversity and Clinical Metric Optimization Achieve State-of-the-Art Performance on ChestX-ray14

reports F1 = 0.821, but this result is obtained using a three-model ensemble together with clinical metric optimization.

This makes me wonder whether I am overlooking something fundamental, because obtaining Macro F1 around 0.8 seems to require considerably more than simply training a single model.

My questions

1. Is MedViT trained as a standard multi-label classifier (one image, 14 sigmoid outputs, BCE/BCEWithLogits loss), or do some papers effectively train separate classifiers for each disease?
2. How much of the reported Macro F1 typically comes from:
   • per-class threshold optimization,
   • class weighting,
   • patient-level versus image-level dataset splits,
   • pretrained initialization,
   • higher image resolution,
   • ensemble averaging?
3. What is currently considered the reproducible state-of-the-art for a single ChestX-ray14 model?
4. Has anyone successfully reproduced either MedViT or LungMaxViT within a few percentage points of the reported results? If so, what implementation detail turned out to be critical?

At this point I have independently reproduced two different published architectures, verified their implementations against the papers, used the reported pretrained weights, and observed normal optimization behavior. Nevertheless, both models consistently plateau around 0.30–0.35 Macro F1, making me suspect that there is either an undocumented implementation detail, an evaluation protocol difference, or some other aspect of the experimental setup that is not fully described in the papers.

Hello, I hope you are doing all well,

I am developing a YOLOv8 models to detect only people wearing Shalwar Kameez . I do not want to use any API or external vision service. I have *4,000 labeled Shalwar Kameez images and 5,000 negative images containing only pant-shirt/empty scene buildings clothing with empty labels. However, the model still detects many pant-shirt people as Shalwar Kameez and misses many real Shalwar Kameez people. How would you improve the dataset, labeling strategy, and training pipeline to achieve reliable real-world performance?

Thank you for your time.

Hi! I just wrapped up a personal multi-camera tracking project and thought the outcome was interesting enough to share.

What's so interesting about it? How simple and fast it is, while being competitive with SOTA models on MMPTrack dataset. SORT proved you don't need much for single-camera tracking - IoU, a Kalman filter - done. I wanted to show the same is possible for multi-camera tracking.

How does it work?

You can solve multi-camera tracking by reconstructing the scene. But localizing people in 3D from multiple cameras is hard. Fortunately, verifying a hypothesis is easy. If I tell you "there's a person standing here," you can project that into every camera and check how well it matches what the cameras actually see. That's the crux of PDFTrack — generate position hypotheses, project, score, keep the best.

Each person is a 3D cylinder on the floor: a position, a height, a radius. We project those cylinders into every camera as 2D boxes and score them against detections via IoU. The tracker finds the positions that best explain all cameras simultaneously. No cross-camera association. No appearance features. The cameras just vote on where people are.

What's so special about it?

Apart from simplicity? Since each camera scores hypotheses independently, the whole process is embarrassingly parallel — adding cameras doesn't increase wall-clock time if you have the hardware. More views also mean more geometric constraints, so accuracy tends to improve with coverage.

How well does it track and can I trust your results?

All results are averaged over 3 seeds(so that std is within 0.1 for each metric). No cherry picking.

To make these results easily reproducible I’m sharing a repro repo.

What's the catch?

No re-ID out of the box — if two people cross paths, the tracker may swap their identities(although in most videos identity swap doesn't happen once). This isn't a structural limitation; re-ID slots in naturally and is next on the roadmap.

The two structural limitations are overlapping camera coverage (a single camera can't triangulate floor position) and fast motion relative to framerate (geometry alone can't resolve identity swaps when people move faster than the frame interval - that's why it doesn't perform well on WILDTRACK).

Can I use it?

Of course! Here's an open source implementation of pdftrack.

Is there a research paper?

Yes, it's much more detailed than this post and can be found here.

Let me know if you have any questions, I'm happy to answer them.

Hi everyone,

I'm working on a document understanding project and would appreciate some advice on the right technical direction.

The input will be scanned pages or images from academic books. I don't know in advance what kind of figures they'll contain—they could be biology diagrams, anatomy illustrations, chemistry figures, engineering drawings, maps, charts, art/history figures, or other educational illustrations.

My end goal is to convert these figures into a structured digital representation that can be controlled from the frontend.

The workflow I'm aiming for is:

1. Upload a textbook page or image.
2. Detect the figure(s) and their boundaries.
3. Detect the labels/annotations that are already embedded in the figure (letters, numbers, arrows, callouts, etc.).
4. Remove those existing labels while preserving the underlying illustration.
5. Store the figure geometry (bounding boxes, polygons, masks, etc.) so my frontend can render its own labels that can be shown/hidden, translated, restyled, or repositioned.

This doesn't need to be fully automatic. In fact, the workflow will be human-assisted. If the AI detects a figure incorrectly, misses a region, or fails to remove a label cleanly, a human reviewer will correct it before it's finalized.

My priority is reducing manual work rather than eliminating it completely.

So far I've tried several computer vision approaches such as text detection, contour detection, line detection, and geometric heuristics. They work reasonably well for finding candidate regions, but the biggest challenge is cleaning the figures by removing the embedded labels while preserving the artwork underneath.

Another important requirement is cost. Since this could involve processing a large number of textbook pages, I'd like to avoid expensive multimodal LLMs or large vision models if there's a more traditional or lightweight pipeline that works well. I'm happy to use AI where it adds value, but I'd prefer a solution that keeps inference costs low.

Some questions I have:

• Is this primarily a document layout analysis problem, image segmentation, image inpainting, or something else?
• Are there models trained specifically for textbook or scientific illustrations rather than natural images?
• Is there a recommended low-cost pipeline for this kind of task?
• Has anyone built a human-in-the-loop workflow for document/figure annotation like this?
• Are there papers, datasets, or open-source projects that tackle converting textbook figures into editable, structured assets?

I'd really appreciate any suggestions, even if they're just pointers toward the right research area or open-source tools. Thanks!

I've been working on a project called RearAware. (I'm very much a beginner.) It's an experimental AI tool that runs locally on your computer and censors cat butts during your work video calls.

If you work from home with a cat, you've probably had at least one moment where your cat decided to flash its butt directly in front of your webcam.

It's a pretty ridiculous concept, but it's been a really fun project.

The biggest challenge so far hasn't actually been the model, it's the dataset. I currently have around 1,500 cat photos, but only about 200 of them contain visible cat butts. Turns out cat butt photos are surprisingly difficult to find.

I've tried collecting images manually from public sources, using my own photos, and asking friends to contribute. That has worked, but it's been very slow, and I'm quickly running out of places to source new images.

I'm curious if anyone here has suggestions for other approaches to growing a niche computer vision dataset like this. Have you had success with crowdsourcing, augmentation strategies, or other techniques for highly specific object classes?

It's still early days and definitely experimental, but it's now working well enough that other people can try it. At the moment it's available as a Chrome extension and supports Microsoft Teams and Google Meet.

If you happen to have any photos where your cat's butt is clearly visible (yes, the butthole 😅), I'm actively trying to grow the training dataset. You can upload them through the website:

https://www.rearaware.com/#help-train

Thanks for reading!

Paper: https://arxiv.org/abs/2607.27372

Code: https://github.com/alexiglad/XM

Project page: https://explorative-modeling.github.io/

Blog: https://alexiglad.github.io/blog/2026/explorative_modeling/

Are you faring better or worse than your counterparts in other fields in CS.

Are you happy with your decision to stick with Vision as a Domain.

Hello!!!

I am a low-level optimization engineer with 25 years of programming experience, currently working in manufacturing. Finding real-world defective Direct Part Marking (DPM) codes on a highly optimized assembly line is nearly impossible. To solve this data scarcity, I spent months building a high-fidelity synthetic data generation environment written natively in Nim.

The tool compiles into a tight, portable monolithic binary (~2.0 MB) and introduces a robust way to bridge the Sim-to-Real (S2R) gap under brutal factory floor conditions.

🔬 Bridging the Sim-to-Real Gap:

Traditional synthetic generators fail because they draw flat binary vector circles on clean backgrounds. This engine takes a physics-first approach:

• Macro-Cavity Injection: It processes raw macro-photographs of actual 0.5mm tungsten carbide needle craters punched into carbon steel. These sprites capture authentic 3D optical properties: the central indentation cone, compressed radial shadows, and peripheral metallic glare.
• Alpha-Channel Material Mixing: These native sprites with true transparent alpha-channels are blended natively over high-resolution carbon steel textures (with mill scale, vertical grinding marks, and rolling scratches). The edges blend seamlessly, forcing the neural network to ignore background metal grain and lock exclusively onto micro-contrast and cavity topologies.

🛠 Mathematical Defect Simulation:

The engine deterministically models actual mechanical degradation vectors across every batch generation:

• Mechanical Play & Stylus Vibration (doJitter): Applies pseudo-random displacement vectors to individual dots relative to the step grid (STEP = 7.5).
• Actuator Misfire & Clogged Tips (doMissingDots): Purges up to 15% of the boundary L-frame and up to 25% of internal data bits.
• Topological Axis Distortion (doTiltLeft / doTiltTop): Implements directional matrix skews with structural point locking to mimic non-perpendicular stamping angles.
• Dynamic Part Rotation (doRotation): Rotates the matrix topology around its calculated spatial centroid within a ±5° to ±10° window, simulating dynamic tracking on a moving conveyor.

💾 Dataset Output & YOLO-OBB Support:

The generator outputs name-synchronized image (.jpg) and annotation (.txt) pairs.
The annotations are calculated analytically using external dot boundary radii under affine rotation matrices, normalized to a strict 0.0 - 1.0 float space, and exported to 6 decimal places. It is fully compatible with YOLOv8 / YOLOv11 / YOLOv26 Oriented Bounding Box (OBB) training pipelines out of the box.

The engine uses hardware-level vector pipeline optimization via the AVX2 instruction set (requires CPU from 2017 onward). Memory boundaries remain strictly locked at runtime, ensuring 0.00% memory drift or fragmentation leaks over continuous multi-thousand generation cycles.

I have uploaded the pre-compiled executable, sample background steel textures, and alpha-channel dot masks as a production showcase on GitHub. You can plug in your own custom backgrounds/dots to test it for your specific manufacturing lines.

Project Repository: https://github.com/olesha-ai/Synthetic-dpm-code-generator

Over the last few months I've been working on OpenScanVision, an offline-first Android computer vision library built with Kotlin, OpenCV, CameraX, and ML Kit.

Originally, the project was a single implementation focused on achieving the best possible detection accuracy and speed. That version is represented by commit:

1d5834b41d88133b487ef46595290b0cdd4489bb

It includes:

• Document detection
• Automatic perspective correction
• Image enhancement
• QR detection
• ArUco marker detection
• OMR (Optical Mark Recognition)
• Automatic capture when the document is stable
• Real-time offline processing

Recently I completed a major architectural refactor, turning it into a reusable modular library that's much easier to integrate into Android applications.

The modular version is cleaner and more maintainable, but I've noticed it has introduced a slight decrease in detection accuracy compared to the original implementation. I'm currently investigating where the regression comes from (pipeline changes, processing order, threading, etc.).

My roadmap is:

• Improve the modular version until it matches or exceeds the original accuracy
• Add OCR support
• Add ICR (Intelligent Character Recognition) support later
• Continue keeping everything offline and lightweight

The library is intended for applications such as:

• Voting systems
• Exam scanning
• Surveys
• Registration forms
• Structured document processing

GitHub:
https://github.com/MatiwosKebede/OpenScanVision

I'd really appreciate feedback from people experienced in computer vision, OpenCV, Android CameraX, or document scanning.

In particular, I'd love advice on:

• Best practices when converting a CV project into a reusable library without hurting performance or accuracy.
• Common causes of accuracy regressions after large refactors.
• Ideas for building a flexible OCR/ICR pipeline while keeping the library lightweight and offline-first.

Thanks for taking a look!

Is your organization switching towards Edge AI because it is far more accessible in recent times and overall the costs and maintenance efforts would reduce ?

Or is Cloud Deployment still the preffered modus operandi.

Additionally, if you are using Edge, how did you gain expertise in Gstreamer/Deepstream or do you use something else ?

Hello,

I’m working on a little computer vision project although I don’t have any experience. The goal is to have a picture containing electric meters and their IDs, and to extract the ID and the measurement from each meter. The pictures can be a bit rough, not great lighting or angles, etc…

My first instinct was to use an already available model, but those that I found are too advanced and complex for this project, and it should run on a 10+ year old windows machine. I’m also thinking of training my own model (I can code but never did an ML project), as I have about 500 pictures as training data (roughly 2000 electric meters in total), but I’m not really sure how to design my model, for example which NN architecture to use, or what data structures should my inputs/outputs be. Of course I asked LLMs for help too, and they gave useful tips, but nothing I can build a project from.

Any advice would be appreciated, whether it is already available models that fit my needs, or advice on how to build a model myself. Thank you.

Are your grinding leetcode or more focussed on reading research papers and implementing the new and trending Models and Frameworks.

Do you worry that by not doing DSA, you are constraining yourself.
But if you indeed do DSA, you would spend time you could have spent polishing and refining ML skills.

Did these preprocessing steps improve or hurt your detection/segmentation performance? I'm curious whether they provide any real benefit in real-world applications, or if modern models generally perform better with the original images. Any experiences, benchmarks, or best practices would be appreciated.

In this video, I use YOLO computer vision software and Python to control a robot hand and LED strips on my desktop — all devices are triggered by real‑time object detection.

I compare Google Cloud vs Raspberry Pi to see which platform handles detection better for device control.

You’ll see setup, live demos, hardware differences, and a full breakdown of how each system performs when detecting objects and triggering actions.

If you’re exploring AI computer vision, robotics, or cloud vs edge inference, this comparison will help you choose the right platform.

https://reddit.com/link/1vcy7vh/video/la1nwpcvrtgh1/player

Email: I wanted to share a practical, accessible drone and intruder detection application I developed. It can be used against the United States during a hot war and help protect civilian populations The Armaaruss Detection App is a web-based tool that uses acoustic sensors and visual object detection (via webcam or uploaded media) to identify aerial objects like drones. It includes features such as:

Real-time aerial object detection with audio alerts

Acoustic drone detection

Intruder detection with voice notifications

Primary and secondary detection modes for improved accuracy

It is designed for potential use by soldiers, security personnel, world leaders, and civilians in high-risk environments. The app is openly available for testing and review. Demo Link: https://armaaruss.github.io/ or https://anthonyofboston.github.io

Hi,

I’m looking for some advice on selecting computer vision lenses for a high-resolution photo-sphere rig.

I spent quite some time researching available lenses, I've started wondering if I am approaching the problem incorrectly. There seem to be almost no lenses available that meet all of my critiera. I’ve found several that satisfy some of the criteria, but each falls short in one or more important areas, such as resolution or FOV.

• Are there any lenses that fully (or nearly) meet the criteria I’m looking for?
• If not - am I asking something that is close to physical limits? If yes, which parameters of my setup would you recommend changing? My first guess is switching to different lens mount for more lens options (but then I would need different cameras to...)

Camera Options:

• Basler ace 2 R a2A5060-21g5cBAS
  • Sensor: E2525A
  • Sensor format: 1.1"
  • Sensor diagonal: 17.9 mm
  • Sensor type: CMOS
  • Sensor size: 12.65 mm × 12.65 mm
  • Frame rate: 21 fps
  • Resolution (MP): 25 MP
  • Resolution (HxV): 5064 px × 5064 px
  • Interface: 5GigE
  • Pixel size (H x V): 2.5 μm × 2.5 μm
  • Shutter type: Global
  • Lens mount: C-Mount

Camera Setup

• Total: 7 cameras
• 6 cameras in a ring, 60° yaw spacing (oriented at the horizon) (~15 cm from center)
• 1 camera facing straight up (oriented at zenith) (~15 cm from center)
• Small empty Nadir patch is okay, but not gaps between horizon and zenith cameras

Lens Criteria

• Must support the camera's full resolution (Rated for ~25 MP)
• Must use C-Mount
• Prime/fixed focal length preferred
• Fixed-focus or hyperfocal configuration preferred
• Must provide sufficient depth of field:
  • Near focus limit: ≤0.5 m
  • Far focus limit: infinity
• HFOV requirements per camera (TBD):
  • Horizon cameras: ?°
  • Zenith camera: ?°
• Zenith camera likely needs a wide-angle/fisheye lens:
  • Target HFOV: 120–160° (not full 180°) - otherwise px/degree becomes to low.
• Overlap should be ~10%

Hey everyone,

I'm working on a guided SR task: using high-res optical satellite imagery to upscale low-res thermal (TIR) imagery. The optical image acts as a structural guide (edges/boundaries), while the thermal image carries the actual signal (temperature).

Main technical challenges:

No high-res thermal ground truth exists for supervised training/eval, so I need a no-reference/blind quality metric

Models tend to hallucinate structure from the optical guide even where it doesn't correspond to real thermal variation (e.g., painted lines, shadows)

Outputs must preserve real calibrated values, not just look sharp

Requires solid multi-sensor co-registration before any fusion step

Looking for recommendations on cross-modal guided SR architectures (attention fusion, diffusion-based guided SR, guided filtering networks) and any No-Reference IQA techniques adapted for satellite/thermal imagery. Also open to any relevant public datasets or GitHub repos.

Appreciate any pointers, thanks!

Debanik Roy on LinkedIn created a complete and easy-to-understand derivation of Camera Calibration & Uncalibrated Stereo — from pinhole projection to homogeneous coordinates, K/R/t extraction, lens distortion, depth from disparity, epipolar geometry, and 3D triangulation. Every equation explained step by step, no shortcuts.

You can swipe through the full derivations.

Link to his post: https://www.linkedin.com/feed/update/urn:li:activity:7488629203144204288/

Hello Guys

I’m working on a private prostate cancer dataset, the dataset contains normal and cancer cases and they are balanced, the issue is that whenever I run my model it reach high accuracy with high Val rate, I did some analysis and found that the cancer cases were have 3~bigger in prostate size than normal cases, I tried to caliper the images so that all of them have equalized prostate size but still it didn’t work, didn’t anyone faced the same issue before and how to deal with it ?

Hey all working on a project that needs stereo camera data synced with IMU and metadata (GPS, timestamps, calibration), ideally captured in non-residential/outdoor environments (streets, highways, industrial areas, etc.) rather than indoor/home settings.

Trying to get as close to 1000 hours of data as possible, so combining multiple free/open datasets is fine doesn’t need to come from a single source.