Skip to content
The Chat Archive
gpt-4-1106-preview· OpenAI WildChat-4.8M (AI2)

Serait-il possible d'ajouter une fonction permettant de supprimer le bruit de fond avant…

  1. User

    Serait-il possible d'ajouter une fonction permettant de supprimer le bruit de fond avant d'identifier les segments les plus bruyants ?

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset): """Find the segments with the highest loudness in the audio data.""" # Calculate the loudness of each segment in the audio file segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, int(video_duration / segment_duration)) ]

    # Combine segment start times with their corresponding loudness
    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(len(segment_loudness))
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # Sort the loudness and segments based on loudness
    loudness_and_segments.sort(key=lambda x: x[0], reverse=True)
    
    # Return the top num_segments segments sorted by loudness
    return loudness_and_segments[:num_segments]
    

    def sort_segments(segments_with_loudness, preference): if preference == 1: return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)

    def extract_segment(video_path, start_time, duration, output_path): """Use ffmpeg to extract a segment from a video with x264 encoding.""" command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c:v", "libx264", # Use x264 video codec "-c:a", "aac", # AAC audio codec "-strict", "experimental", # Allow experimental codecs (if necessary for AAC) output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}")

    def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration

        video_clip.audio.write_audiofile(audio_filename)
        rate, audio_data = wavfile.read(audio_filename)
    
        segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset)
    
        # Trier les segments en fonction de la préférence de l'utilisateur
        sorted_segments = sort_segments(segments_with_loudness, preference)
        
        # Anticiper si les noms de fichiers doivent correspondre à l'ordre initial
        if preference in [1, 2]:
            initial_order_index = {start_time: i for i, (loudness, start_time) in enumerate(segments_with_loudness)}
    
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
    
        for segment in sorted_segments:
            loudness, start_time = segment
            segment_index = initial_order_index[start_time] if preference in [1, 2] else sorted_segments.index(segment)
            output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{segment_index+1}.mp4"
            output_path = os.path.join(output_folder, output_filename)
            extract_segment(video_path, start_time, segment_duration, output_path)
            print(f"Extracted segment to {output_path}")
    
    finally:
        if os.path.exists(audio_filename):
            os.unlink(audio_filename)  # Clean up the temporary file
    

    Main

    if name == "main": starting_offset = float(input("Start offset (sec)? ")) ending_offset = float(input("End offset (sec)? ")) num_segments = int(input("How many segments to extract? ")) segment_duration = float(input("Duration of each segment (sec)? ")) print("Choose your sorting preference for the extracted files:") print("1 - In order of appearance in the video") print("2 - In reverse order of appearance") print("3 - By increasing loudness") print("4 - By decreasing loudness") preference = int(input("Enter the number of your preference: ")) # Validate the user's preference if preference not in [1, 2, 3, 4]: print("Invalid preference. Please enter a valid number.") exit(1)

    for root, dirs, files in os.walk('.'):
        for file in files:
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference)
    
    print("All videos have been processed.")
    
  2. Assistant

    Pour supprimer le bruit de fond dans une piste audio, vous pouvez utiliser différents algorithmes ou outils de suppression de bruit. Un outil commun pour une telle tâche est la bibliothèque noisereduce en Python. Vous pouvez installer cette bibliothèque via pip install noisereduce.

    Vous devez ajouter cette étape avant d'identifier les segments les plus bruyants. Voici comment vous pouvez intégrer noisereduce dans votre flux de travail existant:

    import noisereduce as nr
    
    def remove_background_noise(audio_data, rate):
        """Remove background noise from the audio data."""
        # Assuming audio_data is a 1-D or 2-D numpy array representing audio samples
        # nr.reduce_noise() accepts a 1-D array only, if input is 2-D (stereo), convert to 1-D (mono) using np.mean
        if audio_data.ndim == 2:
            audio_data = np.mean(audio_data, axis=1)
        
        # Reduce noise
        reduced_noise_audio = nr.reduce_noise(y=audio_data, sr=rate)
    
        return reduced_noise_audio
    
    # Later in the process_video_file function, right after reading the audio:
    
    audio_data = remove_background_noise(audio_data, rate)
    

    Assurez-vous de placer l'appel à remove_background_noise juste après avoir lu les données audio avec wavfile.read, de sorte que vous passiez les données de l'audio avec le bruit supprimé à la fonction de calcul de la sonie.

    Notez que le retrait du bruit peut ne pas être parfait et peut dépendre de la qualité du bruit de fond et des données audio d'origine. En outre, l'effet de la réduction du bruit peut parfois altérer légèrement la qualité sonore, il est donc important de l'ajuster en fonction de vos besoins spécifiques.

    Voici un exemple illustrant à quel point vous pourriez intégrer la réduction du bruit dans votre script actuel :

    # ... après avoir installé noisereduce et importé les modules nécessaires ...
    
    # ... (les définitions des autres fonctions restent les mêmes) ...
    
    def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference):
        """Process a single video file to find and extract the loudest segments."""
        unique_id = str(uuid.uuid4())
        audio_filename = f'temp_audio_{unique_id}.wav'
        try:
            video_clip = VideoFileClip(video_path)
            video_duration = video_clip.duration
    
            video_clip.audio.write_audiofile(audio_filename)
            rate, audio_data = wavfile.read(audio_filename)
    
            # Suppression du bruit de fond
            audio_data = remove_background_noise(audio_data, rate)
    
            segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset)
    
            # ... (le reste du code reste inchangé) ...
    
    # ... (le reste de votre script principal reste inchangé) ...
    

    N'oubliez pas d'ajuster remove_background_noise si vous avez besoin d'un contrôle plus fin de la réduction du bruit selon votre scénario spécifique.

  3. User

    ou placer audio_data = remove_background_noise(audio_data, rate) ?

  4. Assistant

    Vous devriez placer la ligne audio_data = remove_background_noise(audio_data, rate) juste après avoir lu les données audio avec wavfile.read, et avant de trouver les segments les plus bruyants. Ceci est nécessaire pour s'assurer que vous utilisez la version avec le bruit de fond réduit lors de la détermination des segments les plus bruyants.

    Voici comment cela serait placé dans la fonction process_video_file:

    def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference):
        """Process a single video file to find and extract the loudest segments."""
        unique_id = str(uuid.uuid4())
        audio_filename = f'temp_audio_{unique_id}.wav'
        try:
            video_clip = VideoFileClip(video_path)
            video_duration = video_clip.duration
    
            video_clip.audio.write_audiofile(audio_filename)  # Extraction de l'audio
            rate, audio_data = wavfile.read(audio_filename)  # Lecture des données audio
    
            # Suppression du bruit de fond
            audio_data = remove_background_noise(audio_data, rate)
    
            # Trouver les segments les plus bruyants avec l'audio nettoyé
            segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset)
    
            # ... (le reste de la fonction process_video_file reste inchangé) ...
    
        finally:
            if os.path.exists(audio_filename):
                os.unlink(audio_filename)  # Nettoyage du fichier temporaire
    

    L'appel à remove_background_noise() utilise les données audio brutes et le taux d'échantillonnage (rate) comme arguments et envoie en retour les données audio traitées avec le bruit réduit, que vous pouvez ensuite utiliser pour le reste du processus.

  5. User

    comment connaitre sa version de python

  6. Assistant

    Pour vérifier la version de Python installée sur votre système, vous pouvez utiliser plusieurs méthodes différentes, mais le moyen le plus simple est d'ouvrir un terminal (sous Linux ou macOS) ou une invite de commandes/commande (sous Windows) et de taper l'une des commandes suivantes :

    python --version
    

    ou

    python -V
    

    Cela affichera la version de Python utilisée par la commande python par défaut.

    Si vous avez également Python 3.x installé, il est souvent accessible via la commande python3. Pour vérifier sa version, utilisez :

    python3 --version
    

    ou

    python3 -V
    

    Pour les utilisateurs avec plusieurs versions de Python installées, le package pyenv peut être utilisé pour gérer différentes versions. Si vous utilisez pyenv, la commande pour voir toutes les versions installées est :

    pyenv versions
    

    Sachez que si vous utilisez un environnement virtuel (virtualenv ou conda), vous devez activer l'environnement virtuel avant de vérifier la version, car l'environnement peut contenir une version différente de Python de celle installée globalement sur votre système.

    Dans les scripts Python eux-mêmes, vous pouvez obtenir la version de Python en cours d'exécution à l'aide du module sys :

    import sys
    print(sys.version)  # Donne des informations complètes sur la version
    print(sys.version_info)  # Donne les détails de la version sous forme de tuple
    

    Le tuple sys.version_info est utile si vous avez besoin de vérifier la version de Python dans le cadre de la logique conditionnelle d'un script.

  7. User

    y a -t-il autre chose que noisereduce pour le faire ?

  8. Assistant

    Oui, il existe plusieurs autres outils et bibliothèques qui peuvent être utilisés pour la réduction du bruit dans les pistes audio. En dehors de noisereduce, voici quelques autres options disponibles :

    1. Audacity - Audacity est un éditeur audio gratuit et open-source qui peut être utilisé pour réduire le bruit de manière interactive. Vous pouvez l'utiliser pour nettoyer manuellement votre piste audio avant de l'utiliser dans votre code Python.

    2. SoX (Sound eXchange) - SoX est un outil de ligne de commande capable de traiter les fichiers audio. Il comprend des fonctions telles que la réduction du bruit. Vous pouvez l'appeler en utilisant subprocess.run() depuis Python après avoir installé SoX sur votre système.

    3. RNNoise - Il s'agit d'une bibliothèque pour la suppression de tout un éventail de bruits. C'est une implémentation de réseau de neurones pour la suppression du bruit qui est plus avancée que certaines approches plus basiques. Des wrappers Python tels que pyrnnoise peuvent être utilisés pour intégrer RNNoise dans un script Python.

    4. Deep learning models/libs - Bibliothèques telles que TensorFlow et PyTorch permettant de construire ou d'utiliser des modèles de réseaux de neurones déjà entraînés pour la suppression du bruit. Par exemple, des modèles tels que Wave-U-Net ou Deep Noise Suppression (DNS) de Microsoft peuvent être employés.

    5. FFmpeg - FFmpeg est un outil de ligne de commande et une bibliothèque pour manipuler les fichiers multimédia. Il offre des filtres d'audio pour réduire le bruit. Vous pouvez l'invoquer par subprocess.run() depuis votre script Python.

    6. speexdsp - C'est une bibliothèque d'encodage et de traitement audio destinée à la voix. Elle comprend des fonctionnalités pour la suppression de bruit et l'annulation d'écho.

    7. WebRTC's Noise Suppression module - Il s'agit d'un module de traitement de signal disponible dans le cadre du projet WebRTC, et il a été porté pour être utilisé dans Python sous le nom pebrtc.

    Chaque outil ou bibliothèque a ses propres avantages et inconvénients et peut nécessiter des niveaux variables de paramétrage ou de connaissances techniques. Le choix dépendra de vos besoins spécifiques, de la nature du bruit de fond et de la qualité audio désirée. Certains outils peuvent être mieux adaptés à des types spécifiques de bruit ou de signal audio. Pour les applications critiques, vous pourriez avoir besoin de tester plusieurs approches pour voir laquelle fonctionne le mieux pour votre cas d'usage.

  9. User

    Fais le avec speexdsp

  10. Assistant

    La bibliothèque speexdsp en Python est une interface pour le Speex DSP (Digital Signal Processing), qui inclut des fonctionnalités de traitement de la voix telles que la suppression du bruit. C'est un port du code C du projet Speex vers Python grâce à ctypes ou cffi.

    Voici comment vous pourriez intégrer speexdsp dans votre script Python existant pour réduire le bruit de fond. Tout d'abord, vous devez l'installer en utilisant pip:

    pip install speexdsp
    

    Après avoir installé speexdsp, vous pouvez utiliser son module de suppression du bruit de la manière suivante :

    from speexdsp import EchoCanceller, preprocess_state_init, preprocess_run
    from scipy.io import wavfile
    
    def remove_noise_with_speexdsp(audio_data, rate):
        frame_size = 160  # La taille du frame doit être 160 pour une fréquence de 8000 Hz. Pour d'autres fréquences d'échantillonnage, cela peut changer.
        
        if rate != 8000:
            raise ValueError("SpeexDSP supports only 8000 Hz audio.")
    
        audio_data = audio_data.astype('int16')  # SpeexDSP nécessite des entiers 16 bits.
        
        preprocessor_state = preprocess_state_init(frame_size, rate)
        preprocessor_state.set('noise_suppress', -30)  # Niveau de suppression du bruit en dB.
        
        processed_audio_data = np.empty_like(audio_data)
        for i in range(0, len(audio_data), frame_size):
            frame = audio_data[i:i+frame_size]
            preprocess_run(preprocessor_state, frame)
            processed_audio_data[i:i+frame_size] = frame
        
        return processed_audio_data
    
    # … Le reste de votre code
    
    rate, audio_data = wavfile.read(audio_filename)
    audio_data = remove_noise_with_speexdsp(audio_data, rate)
    
    # … Continuez avec les données audio où le bruit a été réduit
    

    Notez que SpeexDSP est conçu pour fonctionner avec des fréquences d'échantillonnage spécifiques (par exemple, 8000 Hz pour la voix). Si vous devez travailler avec des taux qui ne sont pas directement supportés par la bibliothèque, vous pourriez avoir besoin de rééchantillonner votre piste audio avant de l'envoyer à SpeexDSP.

    La suppression du bruit avec SpeexDSP peut ne pas être aussi efficace sur de la musique ou des effets sonores complexes par rapport à la voix, car elle est conçue principalement pour le traitement de signaux vocaux. La performance de la suppression du bruit peut varier selon les caractéristiques du bruit de fond de votre piste audio.

  11. User

    comment passer à une version inférieure de python

  12. Assistant

    Pour passer à une version inférieure de Python, vous pouvez suivre ces étapes générales :

    Pour les utilisateurs de Windows :

    1. Désinstallation de la version actuelle :

      • Allez dans le Panneau de configuration → Programmes → Programmes et fonctionnalités.
      • Trouvez Python dans la liste des programmes installés et désinstallez-le.
    2. Installation de la version désirée :

      • Téléchargez l'installateur pour la version spécifique de Python que vous souhaitez depuis le site web officiel de Python (python.org).
      • Exécutez l'installateur et suivez les instructions pour installer la version plus ancienne de Python. Veillez à choisir correctement l'emplacement d'installation et les options souhaitées (par exemple, ajouter Python au PATH).

    Pour les utilisateurs de macOS et Linux :

    Sous macOS et Linux, Python est souvent utilisé via un gestionnaire de versions comme pyenv pour installer et gérer plusieurs versions de Python. Pour installer une version spécifique de Python avec pyenv :

    1. Installer pyenv (si ce n’est pas déjà fait) :

      # Homebrew sous macOS
      brew update
      brew install pyenv
      
      # pyenv-installer sur Linux
      curl https://pyenv.run | bash
      
    2. Installer une nouvelle version de Python à l'aide de pyenv :

      pyenv install 3.7.9  # Remplacez par la version que vous voulez.
      
    3. Définir la version de Python pour un répertoire spécifique :

      pyenv local 3.7.9
      
    4. Définir la version de Python globalement (optionnel):

      pyenv global 3.7.9
      

    En utilisant des environnements virtuels :

    Pour les projets qui nécessitent différentes versions de Python, l'utilisation d'environnements virtuels est une pratique recommandée. Cela évite de changer la version système de Python. Pour ce faire :

    1. Installez virtualenv (si vous ne l'avez pas) :

      pip install virtualenv
      
    2. Créez un environnement virtuel en spécifiant la version Python :

      virtualenv -p /usr/bin/python3.7 myenv  # Remplacez le chemin avec celui de la bonne version de Python
      
    3. Activez l'environnement virtuel :

      • Sous Linux/macOS :
        source myenv/bin/activate
        
      • Sous Windows :
        myenv\Scripts\activate
        
    4. Vérifiez que la version de Python est la bonne :

      python --version
      

    Souvenez-vous de toujours sauvegarder vos données et projets avant de modifier les installations Python, car changer de version peut potentiellement affecter les environnements de développement et les dépendances de vos projets.

  13. User

    Collecting speexdsp Downloading speexdsp-0.1.1.tar.gz (4.4 kB) Preparing metadata (setup.py) ... done Building wheels for collected packages: speexdsp Building wheel for speexdsp (setup.py) ... error error: subprocess-exited-with-error

    × python setup.py bdist_wheel did not run successfully. │ exit code: 1 ╰─> [13 lines of output] running bdist_wheel running build running build_py creating build creating build\lib.win-amd64-3.10 creating build\lib.win-amd64-3.10\speexdsp copying src\speexdsp.py -> build\lib.win-amd64-3.10\speexdsp copying src_init_.py -> build\lib.win-amd64-3.10\speexdsp running build_ext building 'speexdsp._speexdsp' extension swigging src/speexdsp.i to src/speexdsp_wrap.cpp swig.exe -python -c++ -Isrc -o src/speexdsp_wrap.cpp src/speexdsp.i error: command 'swig.exe' failed: None [end of output]

    note: This error originates from a subprocess, and is likely not a problem with pip. ERROR: Failed building wheel for speexdsp Running setup.py clean for speexdsp Failed to build speexdsp ERROR: Could not build wheels for speexdsp, which is required to install pyproject.toml-based projects

  14. Assistant

    L'erreur que vous voyez est très probablement due à l'absence de l'exécutable swig sur votre système, ou à un problème rencontré pendant son exécution. SWIG est un outil utilisé pour générer des liaisons entre le code C/C++ et des langages de programmation de haut niveau comme Python. Vous aurez besoin de SWIG installé pour construire la bibliothèque speexdsp en raison de ses dépendances C/C++.

    Voici comment vous pouvez essayer de résoudre le problème :

    Installer SWIG

    Sous Windows :

    1. Téléchargez l'exécutable SWIG depuis le site officiel.
    2. Ajoutez le répertoire contenant swig.exe à votre variable d'environnement PATH.

    Sous Linux :

    Sur les systèmes basés sur Debian (comme Ubuntu), utilisez :

    sudo apt-get install swig
    

    Sur les distributions basées sur Red Hat (comme Fedora), utilisez :

    sudo dnf install swig
    

    Sous macOS :

    Vous pouvez installer SWIG à l'aide de Homebrew :

    brew install swig
    

    Autres possibilités

    Si SWIG est déjà installé et que vous voyez toujours une erreur, voici d'autres étapes à suivre :

    • Assurez-vous que la version de Python que vous utilisez est compatible avec speexdsp. Certaines extensions C/C++ peuvent ne pas être compatibles avec les dernières versions de Python.
    • Vérifiez si vous avez un compilateur C/C++ installé. Sous Windows, vous aurez besoin de Visual Studio ou de Build Tools pour Visual Studio pour compiler les extensions Python C.

    Après avoir installé SWIG (et potentiellement d'autres outils de build nécessaires), réessayez d'installer speexdsp :

    pip install speexdsp
    

    Si l'installation échoue encore après avoir suivi ces instructions, vous pourriez envisager de rechercher des versions binaires pré-compilées (wheels) de speexdsp qui sont spécifiques à votre plateforme et version de Python, ou de changer de méthode pour la réduction du bruit, en utilisant par exemple une autre bibliothèque ou en passant par une application tierce capable de traiter les fichiers audio avant leur utilisation dans votre script Python.