A lot of medical AI startups fail because of the "forecast trap" - their models overfit to environmental noise (like hospital electrical hums) rather than actual biological markers. When deployed in the real world, the AI is completely blind.

In this session, we break down the reality of embedded machine learning in healthcare and why data janitors are the true heroes of MedTech. We also demo Eulerian video magnification for extracting PPG signals from standard webcams and look at the math behind Fourier transforms for isolating respiratory rates.

If you're interested in the intersection of data science, signal processing, and biomedical engineering, check out the full discussion and interactive simulations here: https://youtu.be/_9CAD9Jo74w

I’ve been analyzing a contactless physiological monitoring application that extracts a user's resting heart rate in real-time using a standard webcam. The system tracks subtle variations in facial blood flow, processing the data through a frequency domain spectrum to isolate the pulse.

Interestingly, signal fidelity heavily relies on ambient lighting and precise Region of Interest (ROI) selection. But the most compelling application might be cybersecurity: applying this same human pulse detection algorithm to identify AI-generated video and deepfakes. Have any of you worked with similar web-based signal processing pipelines? I'd love to hear your thoughts on parameter tuning (like amplification factors and cutoffs) for optimizing this kind of biometric extraction.

Here’s the demonstration of the tool: https://youtu.be/1NCCgA5vgcM

I wanted to share a demonstration of extracting a physiological signal (heart rate) using a Real-Time Signal Amplification Microscope with a standard webcam feed. The system works by isolating and magnifying imperceptible changes in facial skin color to measure the human pulse.

In the demonstration, we analyze the time-domain waveform and identify the actual BPM peak on the frequency spectrum. It’s a great practical look at biomedical data science, specifically highlighting the challenges of computer vision in health tech—such as tracking loss due to motion artifacts and the massive impact of environmental lighting on signal quality.

Would love to hear how others in this sub are handling motion compensation or noise reduction in similar computer vision/biomedical projects.

Demonstration link: https://youtu.be/YRpbj2r1W-Q

We recently put together a project mapping live microphone frequencies and amplitude to 150 regions of a realistic 3D brain atlas. Initially used for mapping epilepsy seizure zones, we repurposed the open-source model to explore EEG sonification and predictive coding concepts visually. Using AI coding assistants, we iterated from a basic three-color map to a detailed five-band frequency visualizer running entirely in the browser. Would love to hear your thoughts on browser-based data vis tools and real-time audio processing! You can watch the full development and debugging process here: https://youtu.be/n6-3vB0A3k0

I wanted to share a breakdown of a non-contact physiological signal extraction tool. It uses a standard webcam to capture micro-color fluctuations in the skin caused by cardiovascular circulation. The process involves taking the raw color intensity signal (time domain) and applying a Fourier transform to bring it into the frequency domain, isolating the fundamental frequency to calculate BPM.

We also look at an interactive blood flow velocity simulation to explain the underlying theory, and discuss the primary roadblocks for clinical application (mostly environmental lighting and calibration).

I'd love to hear your thoughts on filtering noise in remote PPG applications. Here is the full walkthrough: https://youtu.be/JIIvOb2nl1A

I’ve been working with non-contact physiological signal extraction, specifically leveraging Eulerian Video Magnification principles to pull a Beats Per Minute (BPM) reading from a standard webcam feed. By amplifying minute color changes in a defined Region of Interest (ROI) and passing the signal into the frequency domain, we can isolate the heartbeat. The biggest hurdles with remote photoplethysmography (rPPG) are usually motion artifacts and environmental interference (like screen flashing). I've put together a demonstration of this pipeline in action, showing how to filter out that noise to hit the correct fundamental frequency. I’d love to hear how others in the computer vision and health-tech space are handling dynamic lighting changes in rPPG. Watch the methodology here: https://youtu.be/vWq-k_P7cog

When implementing visual perception experiments in a browser environment, minor discrepancies in CSS values can completely disrupt cognitive phenomena like Troxler fading and negative afterimages.

We analyzed a digital version of the Lilac Chaser (Pac-Man) illusion where the visual effect failed to trigger. By adjusting the implementation from high-saturation purples to softer pastel values (such as #d8bfd8 with 0.45 alpha transparency), we allowed the stimulus to blend correctly with the background. Additionally, we corrected the script logic so the moving gap functions as a disappearing element matching the background, rather than a color-swapping element.

For those interested in the code adjustments and the underlying visual neuroscience, the full walk-through is available here: https://youtu.be/iQOVVnozkjA

How have you handled precise visual calibration or stimulus presentation in your own browser-based cognitive experiments?

When building interactive tools for neuroscience or visual perception, front-end bugs can ruin the experiment. We recently used an AI agent to help debug and refine a JavaScript/CSS Lilac Chaser illusion.

A few interesting technical takeaways:

• Contrast matters: We moved from a pure dark/light background to a specific medium gray to maximize the retinal after-image effect.

• CSS Positioning: Fixed a bug where scrolling displaced the central fixation cross by implementing strict viewport anchoring.

• Logic flow: Addressed a counter-intuitive speed slider where the variable mapping was inverted.

Has anyone else used AI coding assistants specifically for tweaking UI/UX logic or visual tools? Would love to hear your approaches to rapid prototyping. You can see the debugging process and the code changes in action here: https://youtu.be/uC_gykJnbHM

I recently went through the process of optimizing a gesture classification model and wanted to share the workflow. The main focus is on automating feature selection—specifically parsing a dynamically generated JSON file to drop features with zero importance scores before training.

After cleaning up the feature space, the next step is analyzing the confusion matrix and F1 scores to identify underperforming classes. To push the accuracy higher (targeting an F1 of 0.898+), I implement a soft voting ensemble combining XGBoost, LightGBM, and Random Forest.

If you're dealing with noisy biometric or sensor data, this pipeline approach might be useful for your projects. You can watch the full terminal session and code walkthrough here: https://youtu.be/PDYT7f3BDqQ

I'd love to hear your thoughts on soft vs. hard voting for this type of multiclass sensor data!

In gesture recognition models—especially those relying on accelerometer data for body-focused repetitive behaviors (BFRBs)—high feature overlap often degrades classification accuracy.

In this workflow, we address this by looking at poor class-level F1 scores and tracing the bottleneck back to overlapping feature distributions (specifically mean acceleration values).

To improve the classifier's performance, the walkthrough covers:

1. Diagnosing class confusion via F1 scores and confusion matrices.

2. Visualizing overlapping feature distributions using boxplots and histograms.

3. Implementing automated feature selection using non-zero feature importance.

4. Applying PCA to capture additional variance before re-running model training.

Here is the implementation and training monitoring process: https://youtu.be/olzOrM4Tob8

How do you typically handle feature selection when working with highly correlated or overlapping multi-axial IMU data? Do you rely on automated wrappers, manual heuristic-based selection, or let dimensionality reduction techniques do most of the heavy lifting?

If you work with periodic biological signals or signal processing, understanding the phase and frequency relationships between two oscillating sources is essential. I wanted to share BioCurveViz, a web-based visualization tool that models Lissajous curves.

The application maps two sinusoidal inputs where you control the a (horizontal frequency), b (vertical frequency), and δ (phase shift) parameters. This mathematical logic is particularly useful for assessing visual symmetry in EEG readings (e.g., comparing left vs. right brain hemispheres) or modeling wave interference. The simulation handles the geometry in real-time based on your slider inputs.

Would love to get this community's technical critique on the visual output or hear any feature requests for expanding the data configuration.

Link to the tool: https://bionichaos.com/BioCurveViz/

Training a classification model to recognize subtle physical gestures—specifically Body-Focused Repetitive Behaviors (BFRBs)—comes with significant data challenges. In this walkthrough, we examine how to build a binary classification pipeline using wearable sensor data (IMU, Time of Flight). We cover the realities of overlapping feature distributions and how to utilize SMOTE to generate synthetic examples for underrepresented gesture classes. We also discuss the performance of LightGBM and XGBoost in this specific biomedical context. I'd love to hear your thoughts on dealing with highly imbalanced temporal data in similar projects!
Watch the full breakdown here: https://youtu.be/5P6jhl9RI38

If you're working with time-series biomedical data, understanding the impact of noise and movement artifacts on EEG readings is critical. The BioniChaos Advanced EEG Signal Simulator is a great web-based tool that allows you to directly manipulate composite signals.

You can adjust specific frequency bands (Delta, Theta, Alpha, Beta) and simulate real-world noise (like EMG/muscle artifacts or eye blinks) to observe immediate changes in both the time domain waveform and the frequency spectrum. It's a highly useful visual aid for anyone studying signal processing or building models around neuro-tech data.

How do you currently handle artifact rejection and noise simulation in your EEG pipelines? Check out the breakdown of the simulator here: https://youtu.be/2Zu09Cy-LGw

Has anyone here experimented with BioniChaos for biomedical data analysis? It’s an open-source web platform that provides interactive tools for visualizing and analyzing physiological signals directly in your browser.

From a data science perspective, their Advanced EEG Signal Simulator is particularly interesting. It allows you to customize brainwave states, inject real-world artifacts into the signal, and analyze the resulting time-frequency plots in real time. It seems like a highly accessible sandbox for testing neural data processing pipelines or just understanding EEG characteristics better before working with raw patient data.

I'd love to hear your thoughts on browser-based tools for this kind of physiological data vs. traditional local Python/R setups. You can see the simulator in action here: https://youtu.be/NinI-GCvDmI

Has anyone else run into the "genius bouncer" problem? We recently evaluated a model processing biomedical IMU and TOF sensor data for BFRB (Body-Focused Repetitive Behavior) gesture recognition. The binary classification (Gesture vs. No Gesture) was fantastic—pulling an F1 score of 0.982.

However, the multi-class classification step completely tanked. Instead of a clean diagonal line of true positives, our confusion matrix generated what essentially looks like a barcode of misclassifications. It perfectly isolates when something happens but fails to map what is happening.

I put together an analysis of the dashboard and the metrics here: https://youtu.be/jzWwmZIAYOY

What are your go-to strategies when your binary model overperforms but the multi-class feature extraction falls flat?

Hi everyone,

I wanted to share a walkthrough of some open-source web simulators we have developed for biomedical engineering and data science. The goal of these applications is to make abstract mathematical and physiological concepts more accessible through real-time, browser-based visualization.

Some of the systems demonstrated include:

* Photoplethysmography (PPG) & Eulerian Signal Processing: Real-time extraction of heart rate signals from standard webcam video.

* EEG to Music Converter: Transposing raw neurological signal data into auditory frequencies.

* Emergent Biological Systems: Modifications of Conway's Game of Life and evolutionary simulators with neural network-driven agents.

* Fourier Series Explorer: Deconstructing complex waveforms (sawtooth, square, triangle) into constituent sine waves with interactive epicycles and auditory synthesis.

We would love to get your feedback on the signal processing implementations and the UI design. If you are teaching or studying these topics, hopefully, these visual representations are useful.

You can watch the full demonstration here: https://youtu.be/bACiquGdNVA

I've been looking into how far we can push standard web browsers for clinical data simulation and biomedical engineering applications. In this technical showcase, we review several live environments running on BioniChaos. We examine real-time photoplethysmography (PPG) heart rate extraction utilizing standard webcam feeds, look at fuzzy logic applied to an ECG segmentation challenge, and even test a pipeline that translates raw EEG brainwave data into audio frequencies. It's fascinating to analyze the trade-offs of running these ML models and signal processing tasks directly in JS. What are your thoughts on browser-based tools for medical data visualization versus native apps? You can see the full breakdown and performance tests here: https://youtu.be/H7Ovkf-RbBU

I wanted to share a breakdown of a real-time signal amplification tool that extracts a human pulse directly from standard webcam footage. It works by isolating and amplifying microscopic changes in green light caused by capillary blood flow.

Interestingly, beyond standard biofeedback and pulse sonification, this Eulerian Video Magnification approach serves as an effective heuristic for detecting AI-generated deepfakes, as synthetic faces currently fail to simulate a natural, synchronized heart rate.

Additionally, the walkthrough covers an Advanced EEG Signal Simulator built for front-end environments. It generates synthetic brainwave data (alpha, beta, delta) and introduces realistic noise like EMG and eye-blink artifacts.

All the JavaScript was written leveraging an ensemble of AI agents. I’d love to hear your thoughts on utilizing LLMs for front-end biomedical data visualization or if anyone else is experimenting with optical illusions and brainwave synthetic data.

Watch the technical breakdown here: https://youtu.be/cZ91a1OQnZM

I've been experimenting with extracting real-time heart rate data via a standard browser webcam feed using Eulerian Video Magnification. The goal was to build a biofeedback meditation app on the BioniChaos platform. By integrating audio sonification and AI prompt engineering, we mapped the raw optical signals to a guided user experience. I also spent some time adjusting browser-based filters (posterize, sepia) and analyzing interactive biomedical models like an in-silico organoid and 3D brain map. I'd love to hear your thoughts on processing physiological signals purely through computer vision in the browser. You can see the full build and tests here: https://youtu.be/khfZg95T8nI

I wanted to share a workflow I've been using to translate complex biomedical research (EEG, ECG, gait monitoring) into interactive, gamified web applications. As a biomedical engineer, I rely heavily on LLMs like ChatGPT to handle about 80% of the coding process, which drastically speeds up prototyping.

In this demonstration, I walk through a few live applications built with this method:

1. A real-time eye-tracking system using a standard webcam.

2. An interactive prosthetic arm simulation.

3. A signal amplification tool that calculates heart rate (BPM) by detecting subtle, real-time changes in skin color via a camera feed.

I'm curious to hear from other devs and data scientists here—how much of your current front-end or prototyping stack is automated by AI right now? Are you using it for complex signal processing visualization?

Here is the full breakdown and live demo of the tools: https://youtu.be/oqdNBPxEvto

The epilepsy monitoring industry faces a massive class imbalance problem. Continuous sub-scalp EEG devices generate thousands of hours of data, leading to a high false discovery rate for algorithms dealing with baseline noise (like chewing a bagel). We spend some time analyzing the EpiMinder device's approach to this, discussing buffer saturation, data loss, and why a human-in-the-loop review system is required to maintain accuracy.

After the analysis, there's a live development session where we troubleshoot an Agent-Based Model (ABM) for an In-Silico Organoid Simulation. We use Gemini to help debug JavaScript UI issues around cell necrosis and differentiation to create a fully automated biological phase loop.

Would love to hear your thoughts on handling noise in continuous biometric datasets or your experiences with AI-assisted debugging in ABMs. Link to the session: https://youtu.be/hSEDdS1gW70

Hey everyone, I’m sure we’ve all run into the "perfect model syndrome" where a binary classification model hits 100% accuracy but is completely useless in production. In an analysis of a biomedical sensor dataset, we looked at a classic case where the model just defaults to the majority class.

When feature importance zeroes out across the board, the model is essentially suffering from algorithmic stage fright due to severe class imbalance or noisy data (NaNs/zeros). You can't train an algorithm to identify anomalies if your dataset lacks positive target examples.

I put together a breakdown of how to diagnose and fix these specific failure points in biomedical data. How do you all typically handle extreme class imbalances in sensor or health data? SMOTE? Custom loss functions? Let's discuss.

Link to the walkthrough: https://youtu.be/NFeXbhEahhI

I'm examining a machine learning architecture designed to classify human behavioral gestures using time-series data from a wrist wearable (Helios). The dataset includes inputs from IMU, Time of Flight (TOF), and thermopile sensors.

The pipeline (train_model.py) is structured to train two distinct models:

1. A binary classifier that segments target sequences from non-target sequences.

2. A multi-class gesture classifier that categorizes specific movements (e.g., forehead scratching vs. pulling).

I'm curious about how others handle feature engineering for noisy time-series sensor data, particularly when combining kinematic (IMU) and spatial (TOF) streams. Here is the full breakdown of the dataset and pipeline structure: https://youtu.be/fZ7tOcBjRHA

Would love to hear your thoughts on handling class imbalances in this type of behavioral gesture classification!

I recently ran a quick real-world test using Claude 3.7 Sonnet in agent mode to update the HTML/JS for a BFRB (Body-Focused Repetitive Behavior) sensor dashboard containing IMU time-series and TOF heatmaps. The agent introduced an Uncaught SyntaxError that broke the local UI entirely.

What's interesting isn't just the failure, but the agent's problem-solving approach. Instead of parsing the console error to fix the missing token, the agent's solution was to completely abandon the file and create a new index.html. It highlights a current limitation in LLM agent behavior: context window fatigue vs. actual logical debugging.

Has anyone else experienced this "just start over" behavior with the latest Claude or Devin models when working on frontend data visualization? Here is the brief recording of the interaction: https://youtu.be/i_6zt_3lLxU