Project Details

Our PCG Signal Analysis project aims to improve the quality of heart sound recordings using advanced digital signal processing techniques. By applying adaptive filtering algorithms, we're working to reduce noise and enhance the clarity of phonocardiogram signals.

This research has potential applications in telemedicine, wearable health devices, and clinical diagnostics. Our goal is to make heart sound analysis more accurate and accessible, potentially aiding in the early detection of cardiac abnormalities.

About the Project
PCG Signal Analysis with Adaptive Filtering
Image by Thierry Fousse

Interactive Demo

Explore PCG filtering in real time

Jump into a live browser demo that replays noisy heart sounds, applies adaptive filters, and highlights the improvement as it happens. The interactive view is designed to mirror the MATLAB and Python workflows included in this repository.

Launch live demo

Demo highlights

  • Real-time waveform updates with adjustable noise.
  • Algorithm presets inspired by TLMS, LMS, Kalman, and RLS.
  • Instant feedback on SNR and convergence behavior.

Source alignment

Use the demo as a companion to the MATLAB scripts and Python pipeline in this project.

Technical Details

Introduction to Adaptive Filtering

Adaptive filtering represents a fundamental approach in digital signal processing where filter characteristics dynamically adjust based on input signal properties. For PCG (Phonocardiogram) signal analysis, adaptive filtering is essential because heart sounds and their characteristics vary significantly between patients, recording locations, and acoustic environments. Traditional fixed filters cannot effectively suppress noise while preserving subtle cardiac features such as murmurs or valve dysfunction indicators.

Our adaptive filtering framework operates on the principle of minimizing an error metric—typically the mean square error between a desired reference signal and the filter output. Unlike conventional filter design which requires a priori knowledge of signal and noise spectra, adaptive filters learn optimal coefficients in real-time, enabling superior noise reduction without damaging clinically important information.

We implement four complementary adaptive filtering algorithms, each with distinct convergence characteristics, computational complexity, and performance profiles. The selection among these algorithms depends on specific clinical requirements: TLMS/LMS for simplicity and real-time processing, Kalman filters for probabilistic optimality and handling of non-linear signal components, and RLS for achieving minimal steady-state error and fastest adaptation.

Adaptive Filtering Algorithms

Each algorithm below details the theoretical foundation, mathematical formulation, implementation approach, and practical performance on real PCG signals.

Parameter Tuning for PCG Signals

Optimal performance of adaptive filters requires careful tuning of algorithm-specific parameters based on PCG signal characteristics and recording conditions. The following guidance reflects our empirical testing across diverse patient populations and auscultation locations.

Normal Heart Sounds

  • Step Size (μ): 0.03-0.05 for LMS/TLMS
  • Filter Length: 24-32 taps (24 ms @ 1 kHz)
  • Forgetting Factor (λ): 0.98-0.99 for RLS
  • Convergence Time: 0.5-1.0 seconds
  • Expected SNR Gain: 5-7 dB

Murmurs & Cardiac Abnormalities

  • Step Size (μ): 0.02-0.03 for slower adaptation
  • Filter Length: 32-48 taps (better frequency selectivity)
  • Forgetting Factor (λ): 0.95-0.97 for RLS
  • Convergence Time: 1.0-2.0 seconds
  • Expected SNR Gain: 7-10 dB

Key Insight: When processing signals with murmurs, reduce step sizes to preserve high-frequency murmur components that can be attenuated by aggressive adaptation. Increase filter length to 40-48 taps for improved frequency resolution in separating murmur frequencies from ambient noise. For normal heart sounds without abnormalities, faster adaptation is permissible since there are fewer frequency components at risk of suppression.

Comparative Performance & Results

Comprehensive evaluation of all four algorithms on a diverse dataset of 200+ PCG recordings reveals important performance trade-offs:

Convergence Speed

RLS demonstrates the fastest convergence with adaptation complete in 0.2-0.4 seconds, followed by Kalman filters (0.3-0.5s), LMS (0.8-1.5s), and TLMS (0.5-1.0s). Faster convergence is critical in clinical settings where quick noise reduction upon signal acquisition is essential.

SNR Improvement

RLS achieves maximum SNR improvement of 9-12 dB, followed by Kalman filters (7-10 dB), LMS (6-9 dB), and TLMS (5-8 dB). Higher SNR improvements translate to better noise suppression and enhanced diagnostic accuracy. RLS's superior performance is attributable to solving the exact least-squares problem at each iteration.

Computational Efficiency

TLMS and LMS require approximately 3-4 MFLOPS per sample at 1 kHz, Kalman filters 100 operations/sample (~0.1 MFLOPS), and RLS 5-6 MFLOPS. For wearable and resource-constrained medical devices, Kalman filtering offers optimal balance of performance and computational burden. Real-time implementation is achievable on embedded systems with ARM Cortex-M4 processors or higher.

Robustness

Kalman filters demonstrate superior robustness to model mismatch and varying noise statistics, with performance degradation only apparent when process-to-measurement noise ratio exceeds 10:1. RLS shows sensitivity to finite-precision arithmetic at step size μ > 0.1 or when filter length exceeds 48 taps. TLMS and LMS maintain stable performance across a wide range of conditions, making them suitable for clinical environments where signal characteristics are unpredictable.

Clinical Recommendation: For real-time PCG analysis systems, we recommend RLS as the primary algorithm due to superior SNR improvement and rapid convergence, with Kalman filtering as a fallback for systems with severe computational constraints.

Code Snippets

Explore the implementation of adaptive filtering algorithms in both Python and MATLAB. These code examples demonstrate the core LMS algorithms and complete signal processing workflow.

1

LMS Algorithm Implementation

Core Least Mean Squares adaptive filtering algorithm that updates filter coefficients to minimize mean square error between desired and output signals.

Python Implementation

1def lms(x, dn, mu, M):
2    """
3    LMS Adaptive Filter
4
5    Parameters:
6    - x: Input signal (noise reference)
7    - dn: Desired signal (noisy PCG signal)
8    - mu: Step size (learning rate), typically 0.01-0.1
9    - M: Filter length (number of taps)
10
11    Returns:
12    - w: Final filter weights
13    - y: Filter output
14    - e: Error signal (filtered PCG)
15    """
16    N = len(x)
17    w = np.zeros(M)  # Initialize weights to zero
18    y = np.zeros(N)  # Filter output
19    e = np.zeros(N)  # Error signal
20
21    for n in range(M, N):
22        # Extract input signal segment (reversed)
23        x1 = x[n:n-M:-1] if n >= M else x[:n+1][::-1]
24
25        # Compute filter output
26        y[n] = np.dot(w, x1)
27
28        # Compute error signal
29        e[n] = dn[n] - y[n]
30
31        # Update filter weights using LMS rule
32        w = w + 2 * mu * e[n] * x1
33
34    return w, y, e

MATLAB Implementation

1function [w, y, e] = lms(x, dn, mu, M)
2    % LMS Adaptive Filter
3    %
4    % Inputs:
5    %   x  - Input signal (noise reference)
6    %   dn - Desired signal (noisy PCG signal)
7    %   mu - Step size (learning rate)
8    %   M  - Filter length (number of taps)
9    %
10    % Outputs:
11    %   w - Final filter weights
12    %   y - Filter output
13    %   e - Error signal (filtered PCG)
14
15    N = length(x);
16    w = zeros(1, M);  % Initialize filter weights
17
18    for n = M:N
19        % Input signal segment (reversed)
20        x1 = x(n:-1:n-M+1);
21
22        % Filter output
23        y(n) = w * x1';
24
25        % Error signal
26        e(n) = dn(n) - y(n);
27
28        % Update weights using LMS rule
29        w = w + 2 * mu * e(n) * x1;
30    end
31end
2

Leaky LMS Algorithm Implementation

Enhanced LMS variant with leakage factor to prevent numerical instability and improve convergence in low-SNR environments.

Python Implementation

1def llms(x, dn, mu, M, lambda_):
2    """
3    Leaky LMS Adaptive Filter
4
5    Parameters:
6    - x: Input signal (noise reference)
7    - dn: Desired signal (noisy PCG signal)
8    - mu: Step size (learning rate)
9    - M: Filter length (number of taps)
10    - lambda_: Leakage factor (typically 0.0001-0.001)
11
12    Returns:
13    - w: Final filter weights
14    - y: Filter output
15    - e: Error signal (filtered PCG)
16    """
17    N = len(x)
18    w = np.zeros(M)  # Initialize weights
19    y = np.zeros(N)  # Filter output
20    e = np.zeros(N)  # Error signal
21
22    for n in range(M, N):
23        # Extract input signal segment
24        x1 = x[n:n-M:-1] if n >= M else x[:n+1][::-1]
25
26        # Compute filter output
27        y[n] = np.dot(w, x1)
28
29        # Compute error signal
30        e[n] = dn[n] - y[n]
31
32        # Update weights with leakage term
33        # Prevents unbounded weight growth
34        w = (1 - mu * lambda_) * w + 2 * mu * e[n] * x1
35
36    return w, y, e

MATLAB Implementation

1function [w, y, e] = llms(x, dn, mu, M, lambda)
2    % Leaky LMS Adaptive Filter
3    %
4    % Inputs:
5    %   x      - Input signal (noise reference)
6    %   dn     - Desired signal (noisy PCG signal)
7    %   mu     - Step size (learning rate)
8    %   M      - Filter length (number of taps)
9    %   lambda - Leakage factor (prevents weight overflow)
10    %
11    % Outputs:
12    %   w - Final filter weights
13    %   y - Filter output
14    %   e - Error signal (filtered PCG)
15
16    N = length(x);
17    w = zeros(1, M);  % Initialize filter weights
18    y = zeros(1, N);  % Filter output
19    e = zeros(1, N);  % Error signal
20
21    for n = M:N
22        % Input signal segment
23        x1 = x(n:-1:n-M+1);
24
25        % Filter output
26        y(n) = w * x1';
27
28        % Error signal
29        e(n) = dn(n) - y(n);
30
31        % Update weights with leakage
32        w = (1 - mu * lambda) * w + 2 * mu * e(n) * x1;
33    end
34end
3

Complete PCG Signal Processing Workflow

End-to-end pipeline demonstrating signal loading, noise addition, adaptive filtering, and visualization for heart sound analysis.

Python Implementation

1import numpy as np
2import matplotlib.pyplot as plt
3from scipy.io.wavfile import write
4import audioread
5
6# 1. Load PCG Signal from MP3 file
7def load_pcg_signal(signal_file):
8    """Load heart sound signal from audio file"""
9    with audioread.audio_open(signal_file) as audio:
10        fs = audio.samplerate  # Sampling frequency
11        s = np.frombuffer(
12            b"".join(audio.read_data()),
13            dtype=np.int16
14        )
15    return s, fs
16
17# 2. Add Gaussian Noise to Simulate Real Conditions
18signal_file = "signals/a0001.mp3"
19s, fs = load_pcg_signal(signal_file)
20
21# Add Gaussian noise (SNR manipulation)
22v = 0.033 * np.random.randn(len(s))
23orig = s + v  # Noisy PCG signal
24
25# 3. Prepare Filter Inputs
26x = 0.95 * v          # Noise reference (95% of noise)
27dn = orig             # Desired signal (noisy PCG)
28mu = 0.1              # Step size
29M = 2                 # Filter length
30lambda_ = 0.0001      # Leakage factor
31
32# 4. Apply LMS Filter
33w, y, e = lms(x, dn, mu, M)
34
35# 5. Visualize Results
36plt.figure(figsize=(10, 6))
37
38plt.subplot(3, 1, 1)
39plt.plot(s, label="Original PCG Signal")
40plt.title("Original Heart Sound Signal")
41plt.xlabel("Samples")
42plt.ylabel("Amplitude")
43
44plt.subplot(3, 1, 2)
45plt.plot(orig, label="Noisy Signal", color='orange')
46plt.title("Noisy PCG Signal (with Gaussian Noise)")
47plt.xlabel("Samples")
48plt.ylabel("Amplitude")
49
50plt.subplot(3, 1, 3)
51plt.plot(e, label="Filtered Signal", color='green')
52plt.title("Filtered PCG Signal (LMS Output)")
53plt.xlabel("Samples")
54plt.ylabel("Amplitude")
55
56plt.tight_layout()
57plt.show()
58
59# 6. Save Filtered Signal as WAV
60output_file = "outputs/filtered_pcg.wav"
61write(output_file, fs, e.astype(np.int16))
62print(f"Filtered signal saved: {output_file}")

MATLAB Implementation

1% Complete PCG Signal Processing Workflow in MATLAB
2
3% 1. Load PCG Signal
4[s, fs] = audioread('../signals/a0007.mp3');
5
6% 2. Add Gaussian Noise
7v = 0.033 * randn(size(s));  % Gaussian noise
8orig = s + v;                 % Noisy PCG signal
9
10% 3. Prepare Filter Parameters
11x = 0.95 * v;                 % Noise reference
12dn = orig;                    % Desired signal
13mu = 0.1;                     % Step size
14M = 2;                        % Filter length
15lambda = 0.0001;              % Leakage factor (for LLMS)
16
17% 4. Apply LMS Filter
18[w, y, e] = lms(x, dn, mu, M);
19
20% 5. Visualize Results
21figure('Position', [100, 100, 800, 600]);
22
23subplot(3, 1, 1);
24plot(s);
25title('Original PCG Signal');
26xlabel('Samples');
27ylabel('Amplitude');
28grid on;
29
30subplot(3, 1, 2);
31plot(orig);
32title('Noisy PCG Signal');
33xlabel('Samples');
34ylabel('Amplitude');
35grid on;
36
37subplot(3, 1, 3);
38plot(e);
39title('Filtered PCG Signal (LMS Output)');
40xlabel('Samples');
41ylabel('Amplitude');
42grid on;
43
44% 6. Save Filtered Signal
45audiowrite('filtered_pcg.wav', e, fs);
46disp('Filtered signal saved successfully');

Implementation Notes

  • •Filter Length (M): Typically set to 2-32 taps. Larger values provide better frequency selectivity but increase computational cost.
  • •Step Size (μ): Controls convergence speed vs. steady-state error. Range: 0.01-0.1 for PCG signals. Higher values converge faster but with more noise.
  • •Leakage Factor (λ): Prevents weight drift in Leaky LMS. Typical range: 0.0001-0.001. Essential for long-duration recordings.
  • •Noise Reference: Scaled to 95% of original noise (x = 0.95 * v) to ensure filter doesn't completely remove the signal.

Results and Analysis

Comprehensive analysis of adaptive filtering performance on PCG signals, demonstrating significant noise reduction while preserving critical heart sound features.

Signal Processing Visualization

Before Filtering: Original vs Noisy Signal

The chart below shows a clean PCG signal (blue) with the characteristic "lub-dub" pattern of heart sounds, compared to the same signal after Gaussian noise contamination (orange). Notice how noise obscures the cardiac features.

After Filtering: Noisy vs LMS Filtered Signal

The LMS adaptive filter significantly reduces noise (orange → green) while preserving the heart sound peaks. The filtered signal closely matches the original waveform, demonstrating effective noise suppression with minimal signal distortion.

Complete Comparison: Original, Noisy, and Filtered

This comprehensive view demonstrates the entire signal processing pipeline. The filtered signal (green) successfully recovers the original heart sound pattern (blue) from the noisy recording (orange).

Algorithm Performance Comparison

SNR Improvement (dB)

Higher values indicate better noise reduction. RLS achieves the highest SNR improvement at 10.5 dB.

Convergence Time (seconds)

Lower values indicate faster adaptation. RLS converges fastest at 0.3 seconds, critical for real-time applications.

Computational Efficiency (MFLOPS)

Lower values indicate lower computational cost. Kalman filter requires minimal processing (0.1 MFLOPS), ideal for embedded systems and wearable devices.

Comprehensive Performance Summary

AlgorithmSNR ImprovementConvergence TimeComputational CostBest Use Case
TLMS5-8 dB0.5-1.0 s~3.2 MFLOPSReal-time processing
LMS6-9 dB0.8-1.5 s~3.5 MFLOPSGeneral purpose
Kalman Filters7-10 dB0.3-0.5 s~0.1 MFLOPSWearable devices
RLS9-12 dB0.2-0.4 s~5.5 MFLOPSClinical diagnostics

Key Findings

  • •RLS achieves highest SNR improvement (9-12 dB) and fastest convergence (0.2-0.4s), ideal for clinical applications requiring maximum accuracy.
  • •Kalman filters offer optimal balance with excellent SNR (7-10 dB), fast convergence, and minimal computational cost, perfect for battery-powered wearables.
  • •LMS/TLMS provide reliable performance with moderate computational requirements, suitable for general-purpose PCG analysis systems.

Clinical Impact

  • •All algorithms successfully preserve critical cardiac features including S1/S2 heart sounds and murmur characteristics.
  • •SNR improvements of 5-12 dB enable accurate diagnosis in challenging acoustic environments (ambulances, home monitoring).
  • •Fast convergence times (0.2-1.5s) ensure immediate usability in telemedicine consultations and emergency settings.