Chapter 3: Detection Algorithms and Machine Learning

Fall detection algorithms form the intelligence layer that transforms raw sensor data into actionable fall alerts, distinguishing genuine fall events from the countless normal activities that produce superficially similar sensor patterns. The evolution of these algorithms from simple threshold-based rules to sophisticated machine learning models represents one of the most significant advances in fall detection technology. This chapter explores algorithm design principles, performance metrics, machine learning methodologies, and the WIA-SENIOR-003 algorithm certification framework that ensures consistent, reliable fall detection across diverse implementations and user populations.

Threshold-Based Detection Algorithms

Early fall detection systems employed threshold-based algorithms that triggered alerts when sensor readings exceeded predetermined values. These rule-based approaches offered simplicity, low computational requirements, and explainable decision logic—important attributes for medical devices requiring regulatory approval. A basic threshold algorithm might detect a fall when the magnitude of acceleration exceeded 2.5g, indicating the rapid vertical movement characteristic of falling.

While simple thresholding successfully detected many falls, it suffered from high false positive rates. Activities like quickly sitting down, dropping the device, or vigorous exercise could generate acceleration peaks exceeding fall thresholds. Conversely, some genuine falls, particularly among frail elderly individuals who fall slowly or sideways, produced accelerations below thresholds calibrated for more vigorous falls.

Enhanced Threshold Algorithms

Second-generation threshold algorithms incorporated temporal analysis and multi-phase detection to improve accuracy. Rather than triggering on a single sensor reading, these systems looked for characteristic fall signatures spanning multiple phases: free fall (reduced acceleration), impact (high acceleration spike), and post-fall inactivity (prolonged low movement).

A typical enhanced algorithm might require three conditions: acceleration exceeding 2g during the fall phase, impact acceleration above 3g, followed by less than 0.5g movement for at least 10 seconds indicating the person remained on the ground. This multi-phase approach substantially reduced false positives while maintaining high sensitivity to genuine falls.

// WIA-SENIOR-003 Basic Threshold Algorithm
class ThresholdFallDetector {
  private readonly FALL_THRESHOLD = 2.0;    // g
  private readonly IMPACT_THRESHOLD = 3.0;  // g
  private readonly STILL_THRESHOLD = 0.5;   // g
  private readonly STILL_DURATION = 10000;  // ms

  private state: 'normal' | 'falling' | 'impact' | 'monitoring' = 'normal';
  private impactTime: number = 0;

  detectFall(reading: SensorReading): FallEvent | null {
    const accelMag = reading.accelerometer.magnitude;
    const now = reading.timestamp;

    switch (this.state) {
      case 'normal':
        if (accelMag > this.FALL_THRESHOLD) {
          this.state = 'falling';
        }
        break;

      case 'falling':
        if (accelMag > this.IMPACT_THRESHOLD) {
          this.state = 'impact';
          this.impactTime = now;
        } else if (accelMag < this.FALL_THRESHOLD) {
          this.state = 'normal';  // False alarm
        }
        break;

      case 'impact':
        this.state = 'monitoring';
        break;

      case 'monitoring':
        const stillDuration = now - this.impactTime;
        if (accelMag < this.STILL_THRESHOLD &&
            stillDuration > this.STILL_DURATION) {
          this.state = 'normal';
          return this.createFallEvent(reading);
        } else if (accelMag > this.STILL_THRESHOLD &&
                   stillDuration > 3000) {
          this.state = 'normal';  // Person got up, false alarm
        }
        break;
    }
    return null;
  }

  private createFallEvent(reading: SensorReading): FallEvent {
    return {
      timestamp: reading.timestamp,
      deviceId: reading.deviceId,
      confidence: 0.85,
      impactMagnitude: reading.accelerometer.magnitude,
      detectionMethod: 'threshold-multi-phase'
    };
  }
}

Table 3.1: Algorithm Generation Comparison

Generation	Approach	Sensitivity	Specificity	False Alarm Rate	Computational Cost
1st Gen	Simple threshold	88-92%	85-90%	0.5-1.0/day	Very Low
2nd Gen	Multi-phase threshold	90-94%	92-95%	0.2-0.4/day	Low
3rd Gen	Feature extraction + ML	94-97%	96-98%	0.1-0.2/day	Medium
4th Gen	Deep learning	96-99%	97-99%	<0.1/day	High
5th Gen (Emerging)	Context-aware AI	97-99+%	98-99+%	<0.05/day	Very High

Feature Extraction and Machine Learning

Third-generation fall detection algorithms moved beyond hand-crafted rules to machine learning approaches that automatically discover discriminative patterns in sensor data. Rather than directly analyzing raw acceleration values, these systems extract engineered features—statistical and frequency-domain characteristics that capture fall signatures more robustly than raw sensor readings.

Time-Domain Features

Time-domain features describe statistical properties of sensor signals over short windows (typically 1-5 seconds). Common features include mean, standard deviation, maximum, minimum, and range of acceleration values. For fall detection, particularly useful features include signal magnitude area (total acceleration over time), peak-to-peak amplitude, and velocity changes estimated by integrating acceleration.

The signal magnitude area (SMA) proves especially discriminative for fall detection. Falls produce characteristic SMA patterns: low during free fall, extremely high during impact, then low again during post-fall immobility. This pattern differs from most daily activities, making SMA a powerful feature for machine learning classifiers.

Frequency-Domain Features

Frequency-domain analysis reveals periodic patterns and spectral characteristics invisible in time-domain signals. Fast Fourier Transform (FFT) converts acceleration time series into frequency spectra, enabling extraction of features like dominant frequency, spectral energy, and frequency band power distribution.

Falls tend to produce high-frequency components during the impact phase, while normal ambulation generates lower-frequency patterns corresponding to gait rhythm. Walking typically shows dominant frequencies around 1-2 Hz, while fall impacts contain substantial energy above 5-10 Hz. Machine learning algorithms leverage these spectral differences to distinguish falls from activities.

// WIA-SENIOR-003 Feature Extraction
class FeatureExtractor {
  extractFeatures(window: SensorReading[]): FeatureVector {
    const accelX = window.map(r => r.accelerometer.x);
    const accelY = window.map(r => r.accelerometer.y);
    const accelZ = window.map(r => r.accelerometer.z);
    const magnitude = window.map(r => r.accelerometer.magnitude);

    return {
      // Time-domain features
      meanMagnitude: this.mean(magnitude),
      stdMagnitude: this.std(magnitude),
      maxMagnitude: Math.max(...magnitude),
      minMagnitude: Math.min(...magnitude),
      sma: this.signalMagnitudeArea(accelX, accelY, accelZ),

      // Statistical features
      variance: this.variance(magnitude),
      skewness: this.skewness(magnitude),
      kurtosis: this.kurtosis(magnitude),

      // Peak features
      peakCount: this.countPeaks(magnitude, 2.0),
      peakToPeak: Math.max(...magnitude) - Math.min(...magnitude),

      // Cross-axis features
      correlation_XY: this.correlation(accelX, accelY),
      correlation_XZ: this.correlation(accelX, accelZ),
      correlation_YZ: this.correlation(accelY, accelZ),

      // Frequency features (if FFT available)
      dominantFreq: this.getDominantFrequency(magnitude),
      spectralEnergy: this.getSpectralEnergy(magnitude),

      // Gyroscope features (if available)
      angularMagnitude: this.getAngularMagnitude(window),
      rotationRate: this.getRotationRate(window)
    };
  }

  private signalMagnitudeArea(x: number[], y: number[], z: number[]): number {
    return x.reduce((sum, val, i) =>
      sum + Math.abs(val) + Math.abs(y[i]) + Math.abs(z[i]), 0) / x.length;
  }

  private mean(values: number[]): number {
    return values.reduce((a, b) => a + b, 0) / values.length;
  }

  private std(values: number[]): number {
    const avg = this.mean(values);
    const squareDiffs = values.map(v => Math.pow(v - avg, 2));
    return Math.sqrt(this.mean(squareDiffs));
  }

  private variance(values: number[]): number {
    const avg = this.mean(values);
    return values.reduce((sum, v) => sum + Math.pow(v - avg, 2), 0) / values.length;
  }

  private skewness(values: number[]): number {
    const avg = this.mean(values);
    const std = this.std(values);
    const n = values.length;
    return values.reduce((sum, v) => sum + Math.pow((v - avg) / std, 3), 0) / n;
  }

  private kurtosis(values: number[]): number {
    const avg = this.mean(values);
    const std = this.std(values);
    const n = values.length;
    return values.reduce((sum, v) => sum + Math.pow((v - avg) / std, 4), 0) / n - 3;
  }

  private correlation(x: number[], y: number[]): number {
    const n = x.length;
    const meanX = this.mean(x);
    const meanY = this.mean(y);
    const stdX = this.std(x);
    const stdY = this.std(y);

    let sum = 0;
    for (let i = 0; i < n; i++) {
      sum += (x[i] - meanX) * (y[i] - meanY);
    }
    return sum / (n * stdX * stdY);
  }
}

Supervised Machine Learning Classifiers

Once features are extracted from sensor windows, machine learning classifiers learn to distinguish fall patterns from normal activity patterns. Third-generation systems typically employ classical machine learning algorithms like Support Vector Machines (SVM), Random Forests, or k-Nearest Neighbors (k-NN).

Support Vector Machines

SVMs construct optimal decision boundaries (hyperplanes) that separate fall events from non-fall events in high-dimensional feature space. The algorithm finds the hyperplane that maximizes the margin between the two classes, improving generalization to unseen data. SVMs handle non-linearly separable data through kernel functions that implicitly map features into higher-dimensional spaces where linear separation becomes possible.

For fall detection, SVMs typically achieve 94-97% sensitivity and 96-98% specificity when trained on diverse datasets including multiple fall types and activity types. The main limitations include sensitivity to parameter tuning and difficulty handling highly imbalanced datasets (far more normal activity samples than fall samples).

Random Forest Classifiers

Random Forests construct ensembles of decision trees, each trained on random subsets of features and training samples. Predictions aggregate across all trees, typically through majority voting. This ensemble approach reduces overfitting compared to single decision trees while providing feature importance rankings that offer insights into which sensor characteristics most strongly indicate falls.

Random Forests excel with imbalanced datasets common in fall detection (millions of normal activity samples, thousands of fall samples). They handle missing features gracefully, important when dealing with heterogeneous sensor configurations. Performance typically matches or slightly exceeds SVMs (95-97% sensitivity, 96-98% specificity) with less parameter tuning required.

Table 3.2: Machine Learning Algorithm Comparison

Algorithm	Sensitivity	Specificity	Training Time	Inference Time	Memory	Interpretability
SVM (RBF kernel)	94-97%	96-98%	Medium-High	Low	Medium	Low
Random Forest	95-97%	96-98%	Medium	Low-Medium	Medium-High	Medium
k-Nearest Neighbors	92-95%	94-96%	Low	High	Very High	High
Gradient Boosting	96-98%	97-99%	High	Low-Medium	Medium	Low-Medium
Neural Network	95-97%	96-98%	High	Low	Medium-High	Very Low

Deep Learning Approaches

Fourth-generation fall detection systems employ deep learning—neural networks with multiple layers that automatically learn hierarchical feature representations from raw sensor data. Rather than hand-crafting features, deep learning systems discover optimal features through end-to-end training on large datasets. This approach has achieved state-of-the-art performance across many pattern recognition tasks, including fall detection.

Convolutional Neural Networks

Convolutional Neural Networks (CNNs) excel at discovering local patterns in sequential data. For fall detection, 1D CNNs process acceleration and gyroscope time series, automatically learning to recognize characteristic fall signatures. Convolutional layers detect local patterns (like the rapid acceleration spike during impact), while pooling layers provide translation invariance and reduce dimensionality. Fully connected layers at the network's end integrate learned features for final fall/non-fall classification.

CNNs trained on diverse fall datasets achieve 96-99% sensitivity with 97-99% specificity—performance approaching or exceeding expert human observers reviewing sensor data. However, they require substantial training data (tens of thousands of labeled examples), significant computational resources for training, and careful architecture design to prevent overfitting.

Recurrent Neural Networks

Recurrent Neural Networks (RNNs), particularly Long Short-Term Memory (LSTM) networks, explicitly model temporal dependencies in sensor sequences. Unlike CNNs that process fixed-size windows, RNNs maintain internal state across time steps, enabling them to learn long-range temporal patterns characteristic of different fall types.

Bidirectional LSTMs, which process sensor sequences both forward and backward in time, achieve particularly strong performance for fall detection. They can recognize pre-fall instability patterns and post-fall immobility within a single model, achieving 97-99% sensitivity with false alarm rates below 0.1 per person-day in research studies.

Performance Metrics and Evaluation

Rigorously evaluating fall detection algorithms requires carefully designed test protocols and appropriate performance metrics. The WIA-SENIOR-003 standard specifies comprehensive evaluation requirements ensuring algorithms perform reliably across diverse real-world conditions.

Classification Metrics

Sensitivity (recall, true positive rate) measures the proportion of actual falls correctly detected. A sensitivity of 95% means the algorithm detects 95 out of 100 genuine falls. High sensitivity is critical—missing falls can have life-threatening consequences. The WIA standard requires minimum 90% sensitivity across all test scenarios.

Specificity (true negative rate) measures the proportion of non-fall activities correctly classified. A specificity of 97% means the algorithm correctly identifies 97 out of 100 non-fall activities, triggering false alarms for only 3. While high specificity is important for user acceptance, it typically receives less emphasis than sensitivity given the life-safety application.

Precision (positive predictive value) indicates what proportion of fall alerts represent genuine falls. Low precision (high false alarm rate) leads to alert fatigue where users and responders ignore alarms. Achieving high precision proves challenging due to the severe class imbalance: people experience thousands of non-fall activities for each fall, so even excellent specificity (99%) can yield poor precision if sensitivity isn't near-perfect.

Practical Performance Metrics

False alarm rate, measured in alarms per person-day, provides a more intuitive metric than precision for evaluating real-world impact. Research indicates seniors will tolerate approximately 0.1-0.3 false alarms per day before compliance degrades. The WIA standard specifies maximum false alarm rates of 0.3 per person-day for certification.

Detection latency measures the time from fall occurrence to alert generation. Faster detection enables quicker emergency response, critical for time-sensitive injuries. The WIA standard requires maximum 30-second detection latency for 90% of falls, with 60 seconds maximum for all falls under normal operating conditions.

Table 3.3: WIA-SENIOR-003 Algorithm Certification Requirements

Metric	Minimum Required	Recommended Target	Test Conditions
Sensitivity	≥90%	≥95%	All fall types, all test subjects
Specificity	≥92%	≥97%	20+ daily activities
False Alarm Rate	≤0.3 per day	≤0.1 per day	24-hour continuous monitoring
Detection Latency (90th %)	≤30 seconds	≤10 seconds	From fall initiation to alert
Detection Latency (Max)	≤60 seconds	≤30 seconds	Worst-case scenarios
Age Diversity	60-90+ years	50-95+ years	Balanced across age groups
Fall Type Coverage	6+ types	10+ types	Forward, backward, lateral, syncope, etc.

Training Data and Model Development

High-quality training data proves essential for developing accurate fall detection algorithms. The challenge lies in collecting sufficient examples of genuine falls—rare events that cannot be easily simulated without risk to participants. Different approaches to training data collection each offer distinct advantages and limitations.

Simulated Falls

Most fall detection research relies on simulated falls performed by young, healthy volunteers trained to fall safely onto padded surfaces. While this approach enables large-scale data collection under controlled conditions, simulated falls differ substantially from genuine falls experienced by elderly individuals. Young volunteers typically generate more vigorous movements, fall more predictably, and exhibit better protective responses than real fall victims.

Despite limitations, simulated fall data provides valuable training examples when collected systematically across multiple fall types (forward, backward, lateral, syncope), speeds, and landing positions. Advanced data augmentation techniques can partially compensate for differences between simulated and genuine falls.

Genuine Fall Data

The gold standard for training data consists of sensor recordings from genuine falls experienced by elderly individuals during normal daily activities. Several long-term monitoring studies have collected such data by equipping elderly participants with fall detection devices during multi-year observation periods, capturing thousands of genuine falls alongside millions of hours of normal activity.

Genuine fall data reveals important patterns absent from simulations: slower fall velocities, different impact characteristics, varied recovery patterns (or inability to recover), and real-world environmental contexts. Algorithms trained on genuine falls typically generalize better to real deployment scenarios than those trained exclusively on simulations.