Audio filtering (noise removal) in Signal Processing

Introduction

Audio filtering helps remove unwanted sounds like noise from recordings. This makes the audio clearer and easier to understand.

Cleaning up a voice recording made in a noisy room.

Improving sound quality in a podcast or interview.

Removing background hum or static from music tracks.

Enhancing speech clarity for hearing aids or voice assistants.

Syntax

Signal Processing

filtered_audio = apply_filter(raw_audio, filter_type, filter_params)

raw_audio is the original sound data.

filter_type defines the kind of filter, like 'lowpass' or 'bandstop'.

Examples

This removes high-frequency noise above 3000 Hz.

Signal Processing

filtered_audio = apply_filter(raw_audio, 'lowpass', cutoff=3000)

This removes noise between 50 and 60 Hz, often electrical hum.

Signal Processing

filtered_audio = apply_filter(raw_audio, 'bandstop', low=50, high=60)

Sample Program

This program loads a noisy audio file, applies a lowpass filter to remove high-frequency noise above 3000 Hz, saves the cleaned audio, and plots the original and filtered signals for comparison.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from scipy.signal import butter, lfilter

# Load audio file (mono)
sample_rate, data = wavfile.read('noisy_audio.wav')

# Normalize data
if data.dtype == np.int16:
    data = data / 32768.0

# Define a lowpass filter to remove high-frequency noise
def butter_lowpass(cutoff, fs, order=5):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    return b, a

def lowpass_filter(data, cutoff, fs, order=5):
    b, a = butter_lowpass(cutoff, fs, order=order)
    y = lfilter(b, a, data)
    return y

# Apply lowpass filter with cutoff at 3000 Hz
cutoff_freq = 3000
filtered_data = lowpass_filter(data, cutoff_freq, sample_rate)

# Save filtered audio
wavfile.write('filtered_audio.wav', sample_rate, np.int16(filtered_data * 32767))

# Plot original and filtered signals (first 1000 samples)
plt.figure(figsize=(10, 6))
plt.plot(data[:1000], label='Original')
plt.plot(filtered_data[:1000], label='Filtered', alpha=0.75)
plt.title('Audio Signal Before and After Noise Removal')
plt.xlabel('Sample Number')
plt.ylabel('Amplitude')
plt.legend()
plt.show()

Important Notes

Always listen to filtered audio to check quality; filtering can sometimes remove important sounds.

Choosing the right cutoff frequency is key to balancing noise removal and sound clarity.

Summary

Audio filtering removes unwanted noise to improve sound quality.

Lowpass filters block high frequencies; bandstop filters remove specific frequency ranges.

Filtering helps in many real-life audio tasks like podcasts, music, and voice recordings.

Practice

1. What is the main purpose of applying an audio filter in signal processing?

easy

A. To remove unwanted noise from the audio signal

B. To increase the volume of the audio

C. To change the audio format

D. To add echo effects to the audio

Solution

1. Step 1: Understand the role of audio filters

   Audio filters are designed to modify signals by removing or reducing unwanted parts, such as noise.

2. Step 2: Identify the main goal in noise removal

   The main goal is to clean the audio by removing noise, not to change volume or format.

3. Final Answer:

   To remove unwanted noise from the audio signal -> Option A

4. Quick Check:

   Audio filtering = noise removal [OK]

Hint: Filters clean audio by removing noise, not changing volume [OK]

Common Mistakes:

• Confusing filtering with volume control
• Thinking filters change audio format
• Assuming filters add effects like echo

2. Which of the following is the correct way to import the Butterworth filter function from the SciPy library in Python?

easy

A. from scipy import butter

B. from scipy.signal import butter

C. import butter from scipy.signal

D. import scipy.signal.butter

Solution

1. Step 1: Recall Python import syntax for functions

   To import a specific function, use 'from module import function'.

2. Step 2: Match the correct module and function

   The Butterworth filter function is 'butter' inside 'scipy.signal'. So, 'from scipy.signal import butter' is correct.

3. Final Answer:

   from scipy.signal import butter -> Option B

4. Quick Check:

   Correct import syntax = from scipy.signal import butter [OK]

Hint: Use 'from module import function' to import specific functions [OK]

Common Mistakes:

• Using 'import function from module' which is invalid syntax
• Trying to import directly from 'scipy' instead of 'scipy.signal'
• Using 'import module.function' which is incorrect

3. Consider the following Python code using SciPy to create a lowpass Butterworth filter:

from scipy.signal import butter, lfilter

fs = 1000  # Sampling frequency
cutoff = 100  # Cutoff frequency
order = 3

b, a = butter(order, cutoff / (0.5 * fs), btype='low')
filtered_signal = lfilter(b, a, [1, 2, 3, 4, 5])
print(filtered_signal)

What will be the output type of filtered_signal?

medium

A. A NumPy array of filtered values

B. A list of filtered values

C. A single float value

D. A tuple containing filter coefficients

Solution

1. Step 1: Understand the output of lfilter function

   The lfilter function applies the filter and returns a NumPy array of filtered signal values.

2. Step 2: Check the input and output types

   The input is a list, but lfilter converts it internally and returns a NumPy array, not a list or single value.

3. Final Answer:

   A NumPy array of filtered values -> Option A

4. Quick Check:

   lfilter output = NumPy array [OK]

Hint: lfilter returns NumPy arrays, not lists [OK]

Common Mistakes:

• Assuming output is a list like input
• Expecting a single value instead of array
• Confusing filter coefficients with output

4. The following code attempts to apply a highpass Butterworth filter but raises an error:

from scipy.signal import butter, lfilter

fs = 40
cutoff = 50
order = 2

b, a = butter(order, cutoff / fs, btype='high')
filtered = lfilter(b, a, [10, 20, 30, 40, 50])
print(filtered)

What is the likely cause of the error?

medium

A. Input signal must be a NumPy array, not a list

B. Order of the filter must be 1 or less

C. Cutoff frequency is not normalized by Nyquist frequency

D. Highpass filter requires cutoff frequency greater than sampling frequency

Solution

1. Step 1: Check cutoff frequency normalization

   The cutoff frequency must be divided by Nyquist frequency (half the sampling rate), but here it is divided by fs directly.

2. Step 2: Understand Nyquist frequency role

   Nyquist frequency = fs / 2, so cutoff should be cutoff / (fs/2) to normalize between 0 and 1.

3. Final Answer:

   Cutoff frequency is not normalized by Nyquist frequency -> Option C

4. Quick Check:

   Normalize cutoff by Nyquist frequency [OK]

Hint: Always normalize cutoff by Nyquist frequency (fs/2) [OK]

Common Mistakes:

• Dividing cutoff by fs instead of fs/2
• Using invalid filter order
• Assuming input must be NumPy array

5. You have an audio signal sampled at 8000 Hz containing noise mostly above 3000 Hz. Which filter setup best removes this noise while keeping the main audio intact?

hard

A. Apply a notch filter at 3000 Hz

B. Apply a highpass Butterworth filter with cutoff frequency at 3000 Hz

C. Apply a bandpass Butterworth filter between 3000 Hz and 8000 Hz

D. Apply a lowpass Butterworth filter with cutoff frequency at 3000 Hz

Solution

1. Step 1: Identify noise frequency range

   Noise is mostly above 3000 Hz, so we want to remove frequencies higher than 3000 Hz.

2. Step 2: Choose filter type to keep frequencies below cutoff

   A lowpass filter allows frequencies below cutoff (3000 Hz) and removes higher frequencies (noise).

3. Step 3: Evaluate other options

   Highpass would keep noise, bandpass keeps noise range, notch removes only a narrow band.

4. Final Answer:

   Apply a lowpass Butterworth filter with cutoff frequency at 3000 Hz -> Option D

5. Quick Check:

   Lowpass filter removes high-frequency noise [OK]

Hint: Use lowpass filter to keep low frequencies, remove high noise [OK]

Common Mistakes:

• Choosing highpass which keeps noise
• Using bandpass that includes noise frequencies
• Confusing notch filter with broad noise removal