DEV Community

Beck_Moulton
Beck_Moulton

Posted on

Your Voice, Your Health: Tracking Stress and Anxiety with Vocal Biomarkers and XGBoost

#machinelearning #datascience #healthtech #python

We’ve all heard it before: "You sound stressed." But what if we could quantify that? In the world of mental health tech, our voices are goldmines of biological data. By analyzing vocal biomarkers such as frequency fluctuations and amplitude instability, we can build machine learning models that detect anxiety levels with surprising accuracy.

Today, we are diving into the intersection of acoustic analysis and predictive modeling. We will leverage Parselmouth (the Pythonic port of Praat) to extract clinical-grade audio features and use XGBoost to classify stress levels. If you're looking to build health-monitoring apps or simply want to learn how to turn raw audio into actionable insights, you're in the right place!

The Architecture: From Soundwaves to Stress Indices

Before we jump into the code, let’s look at the data pipeline. We aren't just looking at what someone says (NLP), but how they say it (Acoustics).

graph TD
    A[Raw Audio Input .wav] --> B[Preprocessing & Resampling]
    B --> C{Feature Extraction}
    C --> D[Acoustic Features: Jitter & Shimmer]
    C --> E[Spectral Features: MFCCs]
    D & E --> F[Feature Vector]
    F --> G[XGBoost Classifier]
    G --> H[Anxiety/Stress Index Output]
    H --> I[Visualization/Dashboard]
Enter fullscreen mode Exit fullscreen mode

Prerequisites

To follow along, you'll need the following stack:

  • Python 3.8+
  • Parselmouth: For Praat-based acoustic features.
  • Librosa: For general audio processing.
  • XGBoost: For the heavy lifting in classification. 
pip install parselmouth-praat librosa xgboost scikit-learn pandas
Enter fullscreen mode Exit fullscreen mode

Step 1: Extracting the "Micro-Wobbles" (Jitter & Shimmer)

In vocal diagnostics, two metrics are king: Jitter (the variation in frequency) and Shimmer (the variation in amplitude). When we are stressed, our vocal cords lose some fine motor control, causing these values to spike.

import parselmouth
import numpy as np

def extract_vocal_features(audio_path):
    # Load audio into Parselmouth
    sound = parselmouth.Sound(audio_path)

    # Extract Pitch (F0)
    pitch = sound.to_pitch()

    # Extract PointProcess for jitter/shimmer calculation
    point_process = parselmouth.praat.call(sound, "To PointProcess (periodic, cc)", 75, 500)

    # 1. Local Jitter: Frequency instability
    jitter = parselmouth.praat.call(point_process, "Get jitter (local)", 0, 0, 0.0001, 0.02, 1.3)

    # 2. Local Shimmer: Amplitude instability
    shimmer = parselmouth.praat.call([sound, point_process], "Get shimmer (local)", 0, 0, 0.0001, 0.02, 1.3, 1.6)

    # 3. HNR (Harmonics-to-Noise Ratio): Voice quality
    harmonicity = sound.to_harmonicity()
    hnr = parselmouth.praat.call(harmonicity, "Get mean", 0, 0)

    return {
        "jitter": jitter,
        "shimmer": shimmer,
        "hnr": hnr
    }

# Quick test
# features = extract_vocal_features("daily_log.wav")
# print(f"Jitter: {features['jitter']:.4f}, Shimmer: {features['shimmer']:.4f}")
Enter fullscreen mode Exit fullscreen mode

Step 2: Building the XGBoost Stress Classifier

Once we have our features (including MFCCs from Librosa), we feed them into an XGBoost model. XGBoost is perfect here because audio feature sets are often tabular and have non-linear relationships.

import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Assume 'df' contains our extracted features and a 'stress_level' label (0, 1, 2)
def train_stress_model(df):
    X = df.drop('stress_level', axis=1)
    y = df['stress_level']

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # Initialize XGBoost Classifier
    model = xgb.XGBClassifier(
        n_estimators=100,
        learning_rate=0.1,
        max_depth=5,
        objective='multi:softprob'
    )

    model.fit(X_train, y_train)

    preds = model.predict(X_test)
    print(classification_report(y_test, preds))

    return model
Enter fullscreen mode Exit fullscreen mode

The "Production-Ready" Way

Building a local script is easy, but deploying vocal biomarkers into a clinical or production environment requires handling noise cancellation, audio normalization, and secure data handling.

For more production-ready examples, advanced signal processing patterns, and deep dives into AI health diagnostics, I highly recommend checking out the technical guides at WellAlly Blog. They have fantastic resources on bridging the gap between raw data and wellness insights.

Conclusion: Why This Matters

Using voice as a diagnostic tool isn't just "cool science"—it's a step toward passive, non-invasive health monitoring. By tracking these biomarkers over time, users can identify burnout patterns before they lead to physical illness.

What's next?

  1. Data Augmentation: Add background noise to your training set to make the model more robust.
  2. Longitudinal Tracking: Store your daily "Stress Index" in a time-series database like InfluxDB.
  3. Real-time Analysis: Use FastAPI to create an endpoint where your smartphone can upload 10-second clips for instant feedback.

Are you working on audio-based ML? Drop a comment below or share your results! Let’s build a healthier world, one voice clip at a time.

Top comments (0)