[AI from Scratch] Episode 308: Preprocessing Audio Data — Normalization and Filtering Techniques

Recap and Today’s Theme

Hello! In the previous episode, we discussed noise reduction, learning various techniques to remove noise from audio data to improve its quality. Noise reduction is an essential step in enhancing the overall clarity and accuracy of audio analysis.

In today’s episode, we will focus on preprocessing audio data, specifically normalization and filtering techniques. These processes are key to preparing audio data for further tasks such as speech recognition or acoustic analysis. We will cover the importance of these methods and how to implement them using Python.

What is Audio Data Preprocessing?

Audio data preprocessing involves cleaning and organizing the audio signal before further analysis or processing. This ensures the data is in a consistent and clean format, which improves the performance of tasks such as speech recognition and audio feature extraction. Some common preprocessing techniques include:

1. Normalization: Adjusting the amplitude of the audio data to a consistent range.
2. Filtering: Removing unwanted frequency components to focus on the relevant signals.
3. Changing the sampling rate: Converting audio data to a suitable sampling rate for analysis.
4. Energy and Zero Crossing Rate extraction: Calculating features that describe the characteristics of the audio signal.

1. Normalization

Normalization adjusts the amplitude of the audio data so that the maximum amplitude value is consistent across all audio files. This helps maintain consistency in audio volume, which is important for applications like speech recognition, where volume variations can impact accuracy.

Normalization in Python

We can normalize audio data using the LibROSA library in Python.

import librosa
import numpy as np

# Load the audio file
audio_path = 'example.wav'
y, sr = librosa.load(audio_path, sr=None)

# Normalize the audio data
normalized_y = y / np.max(np.abs(y))

# Check the maximum amplitude after normalization
print(f'Max amplitude after normalization: {np.max(np.abs(normalized_y))}')

• y / np.max(np.abs(y)): This operation adjusts the amplitude of the audio so that it falls within the range of -1 to 1, ensuring uniformity across different audio files.

Things to Keep in Mind for Normalization

• Avoid Over-Normalization: While normalization is important, over-normalizing can affect the natural dynamics of the audio, leading to a loss in sound quality.
• Clipping: If the original amplitude is too high, normalization may lead to distortion. It’s important to check for clipping and adjust accordingly.

2. Filtering

Filtering is used to remove unwanted frequency components from the audio signal, such as background noise, while retaining the important parts. Common types of filters include:

• Low-pass filter: Allows only low-frequency components to pass and removes high-frequency noise.
• High-pass filter: Removes low-frequency noise and allows high-frequency components to pass.
• Band-pass filter: Focuses on a specific frequency range, removing both low and high frequencies outside this range.

Implementing Filtering in Python

We can implement a low-pass filter using the SciPy library. Below is an example of how to apply a low-pass filter to audio data.

from scipy.signal import butter, lfilter

# Design a Butterworth low-pass filter
def butter_lowpass(cutoff, sr, order=5):
    nyquist = 0.5 * sr
    normal_cutoff = cutoff / nyquist
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    return b, a

# Apply the low-pass filter
def apply_lowpass_filter(data, cutoff, sr, order=5):
    b, a = butter_lowpass(cutoff, sr, order=order)
    y = lfilter(b, a, data)
    return y

# Apply the filter to the audio data
cutoff_frequency = 5000  # Allow frequencies below 5kHz
filtered_y = apply_lowpass_filter(y, cutoff_frequency, sr)

# Display filtered data length
print(f'Filtered data length: {len(filtered_y)} samples')

• butter_lowpass(): This function designs a low-pass filter using the Butterworth filter design. The cutoff parameter sets the frequency at which the filter starts removing components.
• apply_lowpass_filter(): This function applies the low-pass filter to the audio data to remove unwanted high-frequency noise.

Use Cases of Filtering

• Removing Low-Frequency Noise: High-pass filters are used to remove low-frequency noise, such as electrical hum or background vibrations.
• Speech Enhancement: Band-pass filters focus on the frequency range of human speech (approximately 300 Hz to 3,400 Hz), improving speech recognition accuracy by filtering out irrelevant frequencies.

3. Changing the Sampling Rate

When dealing with audio data, sometimes you need to adjust the sampling rate to match the requirements of the model or analysis tool you are using. For example, many speech recognition systems operate at a sampling rate of 16 kHz.

Changing the Sampling Rate in Python

Here’s how you can change the sampling rate of audio data using LibROSA:

# Change the sampling rate to 16 kHz
new_sr = 16000
resampled_y = librosa.resample(y, sr, new_sr)

# Display the new sampling rate
print(f'New sampling rate: {new_sr} Hz')

• librosa.resample(): This function changes the sampling rate of the audio data to the specified new_sr.

Considerations for Changing Sampling Rate

• Loss of High-Frequency Information: Lowering the sampling rate can cause a loss of high-frequency details. Choose an appropriate sampling rate based on the task.
• Upsampling: Increasing the sampling rate does not improve sound quality, as the original data lacks the extra information being added.

4. Energy and Zero Crossing Rate Extraction

Energy Calculation

Energy measures the strength of the audio signal and is used to detect loud and quiet segments.

# Calculate the energy of the audio
energy = np.sum(y ** 2) / len(y)
print(f'Energy: {energy}')

Zero Crossing Rate (ZCR) Calculation

The Zero Crossing Rate (ZCR) measures how often the signal changes sign, which can be used to detect the noisiness or texture of the audio.

# Calculate the zero crossing rate
zcr = librosa.feature.zero_crossing_rate(y)
print(f'Zero Crossing Rate: {zcr.mean()}')

By calculating energy and ZCR, you can gain insights into the nature of the audio signal, which is useful for distinguishing between different types of sounds.

Summary

In this episode, we covered essential audio preprocessing techniques, including normalization, filtering, changing sampling rates, and calculating energy and zero crossing rate. These steps are crucial for improving the quality of audio data and ensuring better performance in subsequent tasks such as speech recognition and acoustic analysis.

Next Episode Preview

Next time, we will dive into the basics of speech recognition, learning how to convert audio into text and exploring the underlying techniques of speech-to-text systems.

---

Notes

• Normalization: Adjusting the amplitude of audio data to a consistent range.
• Filtering: Removing unwanted frequency components to emphasize the important signal.