Rimuovere il rumore da un file audio con Python

in data
Rimuovere il rumore da un file audio con Python

Rimuovere il rumore da un file audio con Python

Versione italiana

Rimuovere il rumore da un file audio con Python

Ecco diversi metodi per ridurre il rumore da file audio usando Python:

1. Usando noisereduce (libreria specializzata)

import noisereduce as nr
import soundfile as sf
import numpy as np

# Carica l'audio
audio, rate = sf.read("input.wav")

# Seleziona una porzione di solo rumore (es. primi 100ms)
noise_sample = audio[:int(rate*0.1)]

# Riduci il rumore
reduced_noise = nr.reduce_noise(y=audio, y_noise=noise_sample, sr=rate)

# Salva il risultato
sf.write("output_clean.wav", reduced_noise, rate)

2. Con librosa (per elaborazione avanzata)

import librosa
import soundfile as sf
import numpy as np

# Carica l'audio
audio, rate = librosa.load("input.wav", sr=None)

# Calcola la STFT (trasformata di Fourier)
stft = librosa.stft(audio)

# Calcola la magnitudine e la fase
magnitude, phase = librosa.magphase(stft)

# Crea un filtro per ridurre il rumore
mask = librosa.util.softmask(magnitude, 0.2 * magnitude, power=2)

# Applica il filtro
clean_stft = stft * mask

# Ricostruisci il segnale audio
clean_audio = librosa.istft(clean_stft)

# Salva il risultato
sf.write("output_clean.wav", clean_audio, rate)

3. Filtro passa-basso con scipy

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

# Carica l'audio
rate, audio = wavfile.read("input.wav")

# Crea un filtro passa-basso
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

# Applica il filtro (es. taglia frequenze sopra 4000Hz)
clean_audio = lowpass_filter(audio, 4000, rate)

# Salva il risultato
wavfile.write("output_clean.wav", rate, clean_audio.astype(np.int16))

4. Installazione delle librerie necessarie

pip install noisereduce librosa soundfile scipy numpy

Consigli per migliori risultati:

  1. Campione di rumore: Per noisereduce, cerca di ottenere almeno 100ms di solo rumore
  2. Parametri sperimentali: Modifica i parametri in base al tuo audio
  3. Formato WAV: Lavora sempre con file WAV non compressi per migliori risultati
  4. Filtri combinati: Puoi combinare più tecniche per risultati migliori

Esempio avanzato (combinazione di tecniche):

import noisereduce as nr
import librosa
import soundfile as sf

# Carica l'audio
audio, rate = librosa.load("input.wav", sr=None)

# Riduzione rumore 1
noise_sample = audio[:int(rate*0.1)]
reduced = nr.reduce_noise(y=audio, y_noise=noise_sample, sr=rate)

# Riduzione rumore 2 con librosa
stft = librosa.stft(reduced)
magnitude, phase = librosa.magphase(stft)
mask = librosa.util.softmask(magnitude, 0.3 * magnitude, power=2)
clean_stft = stft * mask
clean_audio = librosa.istft(clean_stft)

# Salva il risultato finale
sf.write("output_superclean.wav", clean_audio, rate)

English version

Removing noise from an audio file with Python

Here are several methods for reducing noise from audio files using Python:

1. Using noisereduce (specialized library)

import noisereduce as nr
import soundfile as sf
import numpy as np

# Load the audio
audio, rate = sf.read("input.wav")

# Select a portion of noise only (e.g., first 100ms)
noise_sample = audio[:int(rate*0.1)]

# Reduce the noise
reduced_noise = nr.reduce_noise(y=audio, y_noise=noise_sample, sr=rate)

# Save the result
sf.write("output_clean.wav", reduced_noise, rate)

2. With librosa (for advanced processing)

import librosa
import soundfile as sf
import numpy as np

# Load the audio
audio, rate = librosa.load("input.wav", sr=None)

# Calculate the STFT (Fourier transform)
stft = librosa.stft(audio)

# Calculate the magnitude and phase
magnitude, phase = librosa.magphase(stft)

# Create a filter to reduce noise
mask = librosa.util.softmask(magnitude, 0.2 * magnitude, power=2)

# Apply the filter
clean_stft = stft * mask

# Reconstruct the audio signal
clean_audio = librosa.istft(clean_stft)

# Save the result
sf.write("output_clean.wav", clean_audio, rate)

3. Low-pass filter with scipy

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

# Load audio
rate, audio = wavfile.read("input.wav")

# Create a low pass filter
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 the filter (e.g. cut frequencies above 4000Hz)
clean_audio = lowpass_filter(audio, 4000, rate)

# Save the result
wavfile.write("output_clean.wav", rate, clean_audio.astype(np.int16))

4. Installing the necessary libraries

pip install noisereduce librosa soundfile scipy numpy

Tips for best results:

  1. Noise sample: For noisereduce, try to get at least 100ms of pure noise
  2. Experimental parameters: Adjust the parameters based on your audio
  3. WAV format: Always work with uncompressed WAV files for best results
  4. Combined filters: You can combine multiple techniques for better results

Advanced example (combination of techniques):

import noisereduce as nr
import librosa
import soundfile as sf

# Load audio
audio, rate = librosa.load("input.wav", sr=None)

# Noise reduction 1
noise_sample = audio[:int(rate*0.1)]
reduced = nr.reduce_noise(y=audio, y_noise=noise_sample, sr=rate)

# Noise reduction 2 with librosa
stft = librosa.stft(reduced)
magnitude, phase = librosa.magphase(stft)
mask = librosa.util.softmask(magnitude, 0.3 * magnitude, power=2)
clean_stft = stft * mask
clean_audio = librosa.istft(clean_stft)

# Save the final result
sf.write("output_superclean.wav", clean_audio, rate)

Puoi seguire anche il mio canale YouTube https://www.youtube.com/channel/UCoOgys_fRjBrHmx2psNALow/ con tanti video interessanti


I consigli che offriamo sono di natura generale. Non sono consigli legali o professionali. Quello che può funzionare per una persona potrebbe non essere adatto a un’altra, e dipende da molte variabili.
Per supportare e far crescere il canale in modo semplice, rapido e gratuito, potete fare acquisti su amazon usando il mio link di affiliazione.
Questo implica che io prenda una commissione ogni volta che qualcuno faccia un qualsiasi acquisto utilizzando il mio link di affiliazione https://amzn.to/4cgJ3Ls

Commenti

Posta un commento