Noise Cancellation Using Adaptive Filter: How It Works and Example

Noise cancellation using an adaptive filter is a method where the filter automatically adjusts its parameters to reduce unwanted noise from a signal. It works by continuously learning the noise pattern and subtracting it from the original signal to produce a cleaner output.

How It Works

Imagine you are trying to listen to a friend in a noisy room. The noise cancellation system acts like a smart helper who learns the noise pattern around you and tries to remove it from what you hear. An adaptive filter changes its settings step-by-step based on the noise it detects, improving its ability to cancel noise over time.

The filter uses a reference signal that contains noise similar to what is in the main signal. By comparing the two, it adjusts its parameters to create an estimate of the noise. This estimate is then subtracted from the noisy signal, leaving a cleaner version of the original sound.

This process is continuous, so the filter adapts to changes in noise, like a friend who keeps tuning their hearing to block out new background sounds.

Example

This example shows a simple adaptive noise cancellation using the Least Mean Squares (LMS) algorithm. It simulates a noisy signal and uses an adaptive filter to reduce the noise.

python

import numpy as np
import matplotlib.pyplot as plt

# Parameters
np.random.seed(0)
num_samples = 500
mu = 0.01  # Learning rate
filter_order = 4

# Generate original signal (clean)
signal = np.sin(2 * np.pi * 0.05 * np.arange(num_samples))

# Generate noise
noise = np.random.normal(0, 0.5, num_samples)

# Noisy signal
noisy_signal = signal + noise

# Reference noise (correlated with noise in noisy_signal)
reference_noise = noise + np.random.normal(0, 0.1, num_samples)

# Adaptive filter initialization
weights = np.zeros(filter_order)
output = np.zeros(num_samples)
error = np.zeros(num_samples)

# Adaptive filtering using LMS
for n in range(filter_order, num_samples):
    x = reference_noise[n-filter_order:n][::-1]  # Input vector
    y = np.dot(weights, x)  # Filter output (noise estimate)
    output[n] = noisy_signal[n] - y  # Noise cancelled output
    error[n] = signal[n] - output[n]  # Error signal
    weights += 2 * mu * error[n] * x  # Update weights

# Plot results
plt.figure(figsize=(10,6))
plt.plot(signal, label='Original Signal')
plt.plot(noisy_signal, label='Noisy Signal', alpha=0.5)
plt.plot(output, label='Noise Cancelled Output')
plt.legend()
plt.title('Adaptive Noise Cancellation Using LMS Filter')
plt.xlabel('Sample Number')
plt.ylabel('Amplitude')
plt.show()

Output

A plot showing three lines: Original Signal (smooth sine wave), Noisy Signal (sine wave with noise), and Noise Cancelled Output (sine wave with reduced noise).

When to Use

Adaptive noise cancellation is useful when noise changes over time or is unknown beforehand. It works well in environments where noise patterns are not fixed, like in headphones that reduce background sounds or in communication systems to improve voice clarity.

Real-world uses include:

• Noise-cancelling headphones that adapt to different surroundings.
• Removing engine noise from car microphones.
• Improving speech signals in hearing aids.
• Cleaning sensor data in industrial machines where noise varies.

Key Points

• An adaptive filter learns noise patterns and updates itself continuously.
• It uses a reference noise signal to estimate and remove noise from the main signal.
• Common algorithms include LMS (Least Mean Squares) for easy implementation.
• Ideal for environments with changing or unknown noise.
• Widely used in audio devices, communication, and sensor data cleaning.

Key Takeaways

Adaptive filters automatically adjust to reduce noise in signals.

They use a reference noise input to estimate and subtract noise.

The LMS algorithm is a simple and popular method for adaptive noise cancellation.

This technique is best when noise changes over time or is unpredictable.

Applications include headphones, hearing aids, and communication systems.