Comment supprimer le bruit de fond pour le STT : guide complet de réduction du bruit pour la transcription vocale

Pourquoi supprimer le bruit de fond pour le STT ?

• Un rapport signal/bruit (SNR) réduit rend plus difficile la distinction de la parole par les modèles
• Masquage fréquentiel lorsque le bruit chevauche les fréquences de la parole
• Confusion du modèle lorsque des motifs de bruit ressemblent à de la parole
• Scores de confiance plus faibles entraînant davantage d'erreurs de transcription
• Temps de traitement accru car les modèles peinent avec une entrée bruitée

• ✅ Précision de transcription améliorée (souvent 10 à 30 % de mieux)
• ✅ Meilleure reconnaissance des mots, en particulier des termes techniques
• ✅ Traitement plus rapide avec un audio plus propre
• ✅ Horodatages et segmentation plus fiables
• ✅ Meilleure gestion de la parole à faible volume

Comprendre les types de bruit de fond

1. Bruit constant (stationnaire)

• Exemples : Climatisation, bourdonnement de ventilateur, ronflement électrique, bruit blanc
• Caractéristiques : Fréquence et amplitude cohérentes
• Suppression : Plus facile à enlever avec soustraction spectrale ou filtrage

2. Bruit variable (non stationnaire)

• Exemples : Circulation, brouhaha de foule, frappes au clavier, froissement de papier
• Caractéristiques : Évolue dans le temps, motifs imprévisibles
• Suppression : Nécessite des techniques plus avancées comme des modèles de deep learning

3. Bruit impulsionnel

• Exemples : Clics, claquements, portes qui claquent, sonneries de téléphone
• Caractéristiques : Salves courtes et soudaines
• Suppression : Nécessite détection et remplacement/interpolation

4. Bruit périodique

• Exemples : Bips, alarmes, sons répétitifs
• Caractéristiques : Motifs réguliers à des fréquences spécifiques
• Suppression : Peut être filtré avec des filtres notch

Méthode 1 : Utiliser un logiciel de montage audio

Audacity (gratuit, open source)

1. Ouvrez votre fichier audio dans Audacity
2. Sélectionnez une section contenant uniquement du bruit (pas de parole)
3. Allez dans Effect → Noise Reduction
4. Cliquez sur Get Noise Profile
5. Sélectionnez toute la piste audio
6. Retournez dans Effect → Noise Reduction
7. Ajustez les paramètres :
   • Noise reduction (dB) : 12-24 dB (commencez à 15)
   • Sensitivity : 6.0 (par défaut)
   • Frequency smoothing (bands) : 3 (par défaut)
8. Cliquez sur OK pour appliquer

• Utilisez un échantillon de bruit de 0,5 à 2 secondes
• Choisissez une section avec un bruit représentatif
• Commencez avec des réglages modérés puis augmentez si nécessaire
• Prévisualisez avant d'appliquer à toute la piste

Adobe Audition

1. Ouvrez le fichier audio
2. Sélectionnez la section contenant uniquement du bruit
3. Allez dans Effects → Noise Reduction/Restoration → Capture Noise Print
4. Sélectionnez toute la piste
5. Allez dans Effects → Noise Reduction/Restoration → Noise Reduction (process)
6. Ajustez :
   • Noise Reduction : 40-80% (commencez à 60 %)
   • Reduce by : 6-12 dB
   • High Frequency Transition : 4000-8000 Hz
7. Cliquez sur Apply

Méthode 2 : Bibliothèques Python de traitement audio

Utiliser la bibliothèque noisereduce

import noisereduce as nr
import soundfile as sf

# Load audio file
audio_data, sample_rate = sf.read("noisy_audio.wav")

# Method 1: Stationary noise reduction (for constant noise)
reduced_noise = nr.reduce_noise(
    y=audio_data,
    sr=sample_rate,
    stationary=True,
    prop_decrease=0.8  # Reduce noise by 80%
)

# Method 2: Non-stationary noise reduction (for variable noise)
reduced_noise = nr.reduce_noise(
    y=audio_data,
    sr=sample_rate,
    stationary=False,
    prop_decrease=0.8
)

# Save cleaned audio
sf.write("cleaned_audio.wav", reduced_noise, sample_rate)

pip install noisereduce soundfile

Utiliser librosa pour le filtrage spectral (Spectral Gating)

import librosa
import numpy as np
import soundfile as sf

def spectral_gate(audio_path, threshold_db=-40):
    """Remove noise using spectral gating."""
    # Load audio
    y, sr = librosa.load(audio_path, sr=None)
    
    # Compute short-time Fourier transform (STFT)
    stft = librosa.stft(y)
    magnitude = np.abs(stft)
    phase = np.angle(stft)
    
    # Convert to dB
    magnitude_db = librosa.amplitude_to_db(magnitude)
    
    # Apply threshold (remove frequencies below threshold)
    magnitude_db_cleaned = np.where(
        magnitude_db > threshold_db,
        magnitude_db,
        -80  # Silence very quiet parts
    )
    
    # Convert back to linear scale
    magnitude_cleaned = librosa.db_to_amplitude(magnitude_db_cleaned)
    
    # Reconstruct audio
    stft_cleaned = magnitude_cleaned * np.exp(1j * phase)
    y_cleaned = librosa.istft(stft_cleaned)
    
    return y_cleaned, sr

# Usage
cleaned_audio, sample_rate = spectral_gate("noisy_audio.wav", threshold_db=-35)
sf.write("cleaned_audio.wav", cleaned_audio, sample_rate)

Utiliser scipy pour le filtrage passe-haut

from scipy import signal
import soundfile as sf

def high_pass_filter(audio_path, cutoff_freq=80):
    """Remove low-frequency noise with high-pass filter."""
    # Load audio
    audio_data, sample_rate = sf.read(audio_path)
    
    # Design high-pass filter
    nyquist = sample_rate / 2
    normalized_cutoff = cutoff_freq / nyquist
    b, a = signal.butter(4, normalized_cutoff, btype='high')
    
    # Apply filter
    filtered_audio = signal.filtfilt(b, a, audio_data)
    
    return filtered_audio, sample_rate

# Usage
cleaned_audio, sr = high_pass_filter("noisy_audio.wav", cutoff_freq=100)
sf.write("cleaned_audio.wav", cleaned_audio, sr)

Méthode 3 : Réduction du bruit basée sur le deep learning

Utiliser RNNoise

import rnnoise
import numpy as np
import soundfile as sf

def rnnoise_denoise(audio_path):
    """Remove noise using RNNoise model."""
    # Load audio
    audio_data, sample_rate = sf.read(audio_path)
    
    # RNNoise expects 16kHz mono audio
    if sample_rate != 16000:
        import librosa
        audio_data = librosa.resample(audio_data, orig_sr=sample_rate, target_sr=16000)
        sample_rate = 16000
    
    # Convert to mono if stereo
    if len(audio_data.shape) > 1:
        audio_data = np.mean(audio_data, axis=1)
    
    # Process in chunks (RNNoise processes 480 samples at a time)
    chunk_size = 480
    denoised_audio = []
    
    denoiser = rnnoise.RNNoise()
    
    for i in range(0, len(audio_data), chunk_size):
        chunk = audio_data[i:i+chunk_size]
        if len(chunk) < chunk_size:
            chunk = np.pad(chunk, (0, chunk_size - len(chunk)))
        
        denoised_chunk = denoiser.process(chunk)
        denoised_audio.extend(denoised_chunk)
    
    return np.array(denoised_audio), sample_rate

# Usage
cleaned_audio, sr = rnnoise_denoise("noisy_audio.wav")
sf.write("cleaned_audio.wav", cleaned_audio, sr)

pip install rnnoise

Utiliser Demucs de Facebook

from demucs.pretrained import get_model
from demucs.audio import AudioFile
import torch

def demucs_separation(audio_path):
    """Separate speech from noise using Demucs."""
    # Load pre-trained model
    model = get_model('htdemucs')
    model.eval()
    
    # Load audio
    wav = AudioFile(audio_path).read(streams=0, samplerate=model.sample_rate, channels=model.audio_channels)
    ref = wav.mean(0)
    wav = (wav - ref.mean()) / ref.std()
    wav = torch.from_numpy(wav).float()
    
    # Separate sources
    with torch.no_grad():
        sources = model(wav[None])
        sources = sources * ref.std() + ref.mean()
    
    # Extract vocals (speech) - usually index 0 or 3
    speech = sources[0, 0].cpu().numpy()
    
    return speech, model.sample_rate

# Usage
speech_audio, sr = demucs_separation("noisy_audio.wav")
sf.write("speech_only.wav", speech_audio, sr)

Méthode 4 : Outils de réduction du bruit en ligne

1. Audacity Online (version cloud)

• Gratuit, basé sur le navigateur
• Bon pour un traitement rapide
• Taille de fichier limitée

2. Adobe Podcast Enhance

• Réduction du bruit alimentée par l'IA
• Gratuit pour un usage limité
• Excellents résultats pour la parole

3. Krisp.ai

• Suppression du bruit en temps réel
• API disponible pour l'intégration
• Bon pour l'audio en direct

4. Cleanvoice.ai

• Suppression automatique du bruit
• Gère plusieurs types de bruit
• Traitement par lots disponible

Workflow complet : prétraitement audio pour le STT

import librosa
import noisereduce as nr
import soundfile as sf
from scipy import signal
import numpy as np

def preprocess_audio_for_stt(audio_path, output_path):
    """Complete audio preprocessing pipeline for STT."""
    
    # Step 1: Load audio
    print("Loading audio...")
    y, sr = librosa.load(audio_path, sr=16000, mono=True)
    
    # Step 2: Remove DC offset
    print("Removing DC offset...")
    y = y - np.mean(y)
    
    # Step 3: High-pass filter (remove low-frequency noise)
    print("Applying high-pass filter...")
    nyquist = sr / 2
    normalized_cutoff = 80 / nyquist
    b, a = signal.butter(4, normalized_cutoff, btype='high')
    y = signal.filtfilt(b, a, y)
    
    # Step 4: Normalize volume
    print("Normalizing volume...")
    max_val = np.max(np.abs(y))
    if max_val > 0:
        y = y / max_val * 0.95  # Normalize to 95% to avoid clipping
    
    # Step 5: Noise reduction
    print("Reducing noise...")
    y = nr.reduce_noise(
        y=y,
        sr=sr,
        stationary=False,  # Use non-stationary for variable noise
        prop_decrease=0.8  # Reduce noise by 80%
    )
    
    # Step 6: Final normalization
    print("Final normalization...")
    max_val = np.max(np.abs(y))
    if max_val > 0:
        y = y / max_val * 0.95
    
    # Step 7: Save processed audio
    print(f"Saving to {output_path}...")
    sf.write(output_path, y, sr)
    
    print("Preprocessing complete!")
    return y, sr

# Usage
preprocess_audio_for_stt("noisy_recording.wav", "cleaned_for_stt.wav")

Bonnes pratiques pour la suppression du bruit

1. Choisir la bonne méthode

• Bruit constant : Utiliser la soustraction spectrale ou la réduction du bruit stationnaire
• Bruit variable : Utiliser la réduction non stationnaire ou des modèles de deep learning
• Bruit impulsionnel : Utiliser la suppression des clics ou l'interpolation
• Types de bruit multiples : Combiner plusieurs techniques

2. Préserver la qualité de la parole

• N'abusez pas du traitement (cela peut introduire des artefacts)
• Utilisez des paramètres de réduction du bruit modérés (60-80 %)
• Préservez la plage de fréquences de la parole humaine (80-8000 Hz)
• Maintenez des caractéristiques vocales naturelles

3. Tester et itérer

• Prévisualisez toujours avant d'appliquer à toute la piste
• Comparez l'audio original et l'audio traité
• Testez la précision de transcription avec les deux versions
• Ajustez les paramètres selon les résultats

4. Tenir compte de votre modèle STT

• Certains modèles (comme Whisper) gèrent bien le bruit
• Le prétraitement n'est pas toujours nécessaire
• Testez avec et sans prétraitement
• Les modèles plus grands sont plus robustes au bruit

Erreurs courantes à éviter

• Peut supprimer des fréquences vocales
• Crée des artefacts et de la distorsion
• Rend la parole robotique

• Peut supprimer des composantes importantes de la parole
• Rend la parole mince ou métallique
• Affecte le naturel

• Le prétraitement peut ne pas améliorer la précision
• Certains modèles fonctionnent mieux avec l'audio original
• Faites toujours des tests A/B

• Assurez un taux d'échantillonnage correct (16 kHz recommandé)
• Utilisez des formats sans perte lorsque possible
• Évitez la double compression

Intégration avec le speech-to-text

Utilisation avec OpenAI Whisper

import whisper
import noisereduce as nr
import soundfile as sf

def transcribe_with_noise_reduction(audio_path):
    """Transcribe audio with noise reduction preprocessing."""
    
    # Step 1: Reduce noise
    audio_data, sr = sf.read(audio_path)
    cleaned_audio = nr.reduce_noise(
        y=audio_data,
        sr=sr,
        stationary=False,
        prop_decrease=0.75
    )
    
    # Save temporary cleaned file
    temp_path = "temp_cleaned.wav"
    sf.write(temp_path, cleaned_audio, sr)
    
    # Step 2: Transcribe with Whisper
    model = whisper.load_model("base")
    result = model.transcribe(temp_path)
    
    # Clean up
    import os
    os.remove(temp_path)
    
    return result["text"]

# Usage
transcription = transcribe_with_noise_reduction("noisy_audio.wav")
print(transcription)

Utilisation avec l'API SayToWords

import requests
import noisereduce as nr
import soundfile as sf

def transcribe_with_saytowords(audio_path):
    """Preprocess and transcribe with SayToWords."""
    
    # Preprocess audio
    audio_data, sr = sf.read(audio_path)
    cleaned_audio = nr.reduce_noise(
        y=audio_data,
        sr=sr,
        stationary=False,
        prop_decrease=0.8
    )
    
    # Save cleaned audio
    cleaned_path = "cleaned_for_api.wav"
    sf.write(cleaned_path, cleaned_audio, sr)
    
    # Upload and transcribe
    with open(cleaned_path, 'rb') as f:
        files = {'file': f}
        response = requests.post(
            'https://api.saytowords.com/transcribe',
            files=files,
            headers={'Authorization': 'Bearer YOUR_API_KEY'}
        )
    
    return response.json()

Mesurer l'efficacité de la réduction du bruit

Comparaison avant/après

import librosa
import numpy as np

def measure_snr(audio_path):
    """Estimate signal-to-noise ratio."""
    y, sr = librosa.load(audio_path, sr=None)
    
    # Simple SNR estimation
    signal_power = np.mean(y ** 2)
    noise_floor = np.percentile(np.abs(y), 10) ** 2
    snr_db = 10 * np.log10(signal_power / noise_floor) if noise_floor > 0 else 0
    
    return snr_db

# Compare before and after
original_snr = measure_snr("noisy_audio.wav")
cleaned_snr = measure_snr("cleaned_audio.wav")

print(f"Original SNR: {original_snr:.2f} dB")
print(f"Cleaned SNR: {cleaned_snr:.2f} dB")
print(f"Improvement: {cleaned_snr - original_snr:.2f} dB")

Conclusion

• Type de bruit (constant vs variable)
• Qualité audio (taux d'échantillonnage, profondeur de bits)
• Outils disponibles (logiciel vs programmation)
• Modèle STT (certains gèrent mieux le bruit que d'autres)

• Pour un traitement rapide : utilisez Audacity ou des outils en ligne
• Pour l'automatisation : utilisez des bibliothèques Python comme noisereduce
• Pour les meilleurs résultats : combinez plusieurs techniques
• Pour la production : testez avec votre modèle STT spécifique

Ressources supplémentaires

• Whisper for Noisy Background Guide
• How to Fix Unclear Recordings
• Audio Enhancement Best Practices