implement an lms filter from scratch to perform active noise cancellation from a live audio feed in python

main.py
import numpy as np
import sounddevice as sd
44 chars
3 lines

main.py
class LMSFilter:
    def __init__(self, order, mu):
        self.order = order
        self.mu = mu
        self.weights = np.zeros(order)
        self.buffer = np.zeros(order)
    
    def update(self, input_signal, desired_signal):
        self.buffer[1:] = self.buffer[:-1]  # Shift the buffer
        self.buffer[0] = input_signal  # Add the current input to the buffer
  
        estimated_signal = np.dot(self.weights, self.buffer)  # Estimate the signal
        error_signal = desired_signal - estimated_signal  # Calculate the error signal

        self.weights += self.mu * error_signal * self.buffer  # Update the filter coefficients
        filtered_signal = input_signal - estimated_signal  # Calculate the filtered signal
        
        return filtered_signal
775 chars
19 lines

main.py
order = 128  # Order of the LMS filter (adjust according to your requirements)
mu = 0.01  # Step size or learning rate (adjust according to your requirements)
sampling_rate = 44100  # Sampling rate of the audio (adjust according to your requirements)
block_size = 1024  # Number of samples processed at once
308 chars
5 lines

main.py
lms_filter = LMSFilter(order, mu)
34 chars
2 lines

main.py
def audio_callback(indata, outdata, frames, time, status):
    if len(indata) > 0:
        input_signal = np.mean(indata, axis=1)  # Convert stereo input to mono
        filtered_signal = lms_filter.update(input_signal, input_signal)  # Apply the LMS filter
        outdata[:, 0] = filtered_signal  # Play the filtered signal in the left channel
        outdata[:, 1] = input_signal  # Pass through the original signal in the right channel
440 chars
7 lines

main.py
with sd.Stream(callback=audio_callback, channels=2, blocksize=block_size, samplerate=sampling_rate):
    sd.sleep(60 * 1000)  # Run the stream for 1 minute (adjust as needed)
175 chars
3 lines