test spleeter

app.py

@@ -12,8 +12,6 @@ import warnings
 import soundfile as sf
 import librosa
 import time
-import subprocess
-import shutil
 warnings.filterwarnings("ignore")
 
 # --- Setup the models ---
@@ -28,29 +26,28 @@ htdemucs_model = htdemucs_model.to(device)
 htdemucs_model.eval()
 print("HT-Demucs model loaded successfully.")
 
-# Setup Spleeter with command-line approach
+# Setup Spleeter with Python API approach
 print("Setting up Spleeter...")
+spleeter_separator = None
+spleeter_audio_adapter = None
 spleeter_available = False
 
-def check_spleeter_installation():
-    """Check if Spleeter is installed and available via command line"""
-    try:
-        result = subprocess.run(['spleeter', '--help'], 
-                              capture_output=True, text=True, timeout=10)
-        if result.returncode == 0:
-            print("✅ Spleeter command-line tool is available!")
-            return True
-        else:
-            print(f"❌ Spleeter command failed: {result.stderr}")
-            return False
-    except FileNotFoundError:
-        print("❌ Spleeter command not found. Please install Spleeter.")
-        return False
-    except Exception as e:
-        print(f"❌ Error checking Spleeter: {e}")
-        return False
-
-spleeter_available = check_spleeter_installation()
+try:
+    from spleeter.separator import Separator
+    from spleeter.audio.adapter import AudioAdapter
+    
+    # Initialize Spleeter separator for 5stems model
+    print("Creating Spleeter 5stems separator...")
+    spleeter_separator = Separator('spleeter:5stems')
+    spleeter_audio_adapter = AudioAdapter.default()
+    spleeter_available = True
+    print("✅ Spleeter 5stems model loaded successfully!")
+    
+except Exception as e:
+    print(f"❌ Failed to load Spleeter: {e}")
+    spleeter_separator = None
+    spleeter_audio_adapter = None
+    spleeter_available = False
 
 # --- HT-Demucs separation function ---
 def separate_with_htdemucs(audio_path):
@@ -102,13 +99,13 @@ def separate_with_htdemucs(audio_path):
 def separate_with_spleeter(audio_path):
     """
     Separates an audio file using Spleeter into vocals, drums, bass, other, and piano.
-    Uses command-line execution for reliability.
+    Uses Python API approach from stem_separation_spleeter.py
     Returns FILE PATHS.
     """
     if audio_path is None:
         return None, None, None, None, None, "Please upload an audio file."
 
-    if not spleeter_available:
+    if not spleeter_available or spleeter_separator is None or spleeter_audio_adapter is None:
         return None, None, None, None, None, "❌ Spleeter not available. Please install Spleeter."
 
     try:
@@ -119,62 +116,42 @@ def separate_with_spleeter(audio_path):
         output_dir = f"spleeter_stems_{timestamp}"
         os.makedirs(output_dir, exist_ok=True)
         
-        # Run Spleeter command-line tool
-        cmd = [
-            'spleeter', 'separate',
-            '-i', audio_path,
-            '-o', output_dir,
-            '-p', 'spleeter:5stems-16kHz'
-        ]
-        
-        print(f"Spleeter: Running command: {' '.join(cmd)}")
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
-        
-        if result.returncode != 0:
-            print(f"Spleeter command failed: {result.stderr}")
-            return None, None, None, None, None, f"❌ Spleeter command failed: {result.stderr}"
+        # Load audio using Spleeter's audio adapter (from stem_separation_spleeter.py)
+        print("Spleeter: Loading audio...")
+        waveform, sample_rate = spleeter_audio_adapter.load(audio_path, sample_rate=44100)
+        print(f"Spleeter: Loaded audio - shape: {waveform.shape}, sr: {sample_rate}")
         
+        # Perform the separation (from stem_separation_spleeter.py)
+        print("Spleeter: Separating audio sources...")
+        prediction = spleeter_separator.separate(waveform)
         print("Spleeter: Separation complete.")
+        print(f"Spleeter: Prediction keys: {list(prediction.keys())}")
         
-        # Find the separated files
-        # Spleeter creates a subdirectory with the input filename
-        input_filename = os.path.splitext(os.path.basename(audio_path))[0]
-        spleeter_output_dir = os.path.join(output_dir, input_filename)
-        
-        if not os.path.exists(spleeter_output_dir):
-            print(f"Expected output directory not found: {spleeter_output_dir}")
-            return None, None, None, None, None, "❌ Spleeter output directory not found"
-        
-        # Map Spleeter output files to our expected order
-        stem_mapping = {
-            "vocals": "vocals.wav",
-            "drums": "drums.wav", 
-            "bass": "bass.wav",
-            "other": "other.wav",
-            "piano": "piano.wav"
-        }
-        
+        # Save stems with timestamp
         output_paths = []
-        for stem_name, filename in stem_mapping.items():
-            source_path = os.path.join(spleeter_output_dir, filename)
-            if os.path.exists(source_path):
-                # Copy to our timestamped directory for consistency
-                dest_path = os.path.join(output_dir, f"{stem_name}_{timestamp}.wav")
-                shutil.copy2(source_path, dest_path)
-                output_paths.append(dest_path)
-                print(f"✅ Spleeter saved {stem_name} to {dest_path}")
+        stem_names = ["vocals", "drums", "bass", "other", "piano"]
+        
+        for stem_name in stem_names:
+            if stem_name in prediction:
+                out_path = os.path.join(output_dir, f"{stem_name}_{timestamp}.wav")
+                stem_audio = prediction[stem_name]
+                
+                print(f"Spleeter: {stem_name} audio shape: {stem_audio.shape}, dtype: {stem_audio.dtype}")
+                
+                # Save using soundfile for better compatibility
+                sf.write(out_path, stem_audio, sample_rate)
+                output_paths.append(out_path)
+                print(f"✅ Spleeter saved {stem_name} to {out_path}")
             else:
-                print(f"⚠️ Warning: {stem_name} file not found: {source_path}")
+                print(f"⚠️ Warning: {stem_name} not found in prediction")
                 output_paths.append(None)
         
-        # Clean up the intermediate directory
-        if os.path.exists(spleeter_output_dir):
-            shutil.rmtree(spleeter_output_dir)
-        
+        # Ensure we have 5 outputs
+        while len(output_paths) < 5:
+            output_paths.append(None)
+
         return output_paths[0], output_paths[1], output_paths[2], output_paths[3], output_paths[4], "✅ Spleeter separation successful!"
 
-    except subprocess.TimeoutExpired:
-        return None, None, None, None, None, "❌ Spleeter separation timed out (5 minutes)"
     except Exception as e:
         print(f"Spleeter Error: {e}")
         import traceback

requirements.txt

@@ -8,5 +8,5 @@ numpy>=1.21.0,<1.25.0
 soundfile
 librosa==0.8.1
 httpx>=0.19.0,<0.20.0
-numba==0.56.4
-llvmlite==0.39.1
+numba==0.55.2
+llvmlite==0.38.1

stem_separation_spleeter.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""Stem_Separation_Spleeter.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1ZanGdGmndmOSa0q2arjO1hT5p72n56rm
+
+# Audio Stem Separation with Spleeter
+Audio stem separation is the task of isolating individual components (stems) from a mixed audio signal, such as vocals, bass, drums, and other instrumental parts. This technology has various applications, including music production, remixing, karaoke, and forensic audio analysis. Spleeter, developed by Deezer Research, is a powerful open-source tool that leverages deep learning to perform this separation efficiently and effectively.
+
+This Jupyter notebook demonstrates how to use Spleeter, an open-source library developed by Deezer Research for audio stem separation. The notebook provides a step-by-step guide to:
+
+1. Install the Spleeter library
+2. Separate an audio file into different stems (vocal, bass, drums, and other)
+3. Visualize the separated audio sources using waveforms and spectrograms
+
+Additionally it is demonstrated how to use Spleeter from the command-line.
+The code is designed to be adaptable for both Google Colab and local Python environments, with clear instructions for running the script in different settings.
+
+View Spleeter on GitHub: https://github.com/deezer/spleeter
+
+## Instructions to run the code
+Let's begin by installing spleeter.
+
+I had problems running this in my local python 3.11 environment because my numpy and librosa versions were incompatible. If this problem happens to you as well, I would recommend using COLAB instead or using an older python version (for example 3.8).
+"""
+
+!pip install spleeter
+!pip install librosa
+!pip install matplotlib>=3.5
+
+"""Next, we import all the required packages."""
+
+from spleeter.separator import Separator
+from spleeter.audio.adapter import AudioAdapter
+from IPython.display import Audio
+import librosa.display
+import matplotlib.pyplot as plt
+import numpy as np
+
+"""Before running the next cell, please insert a .mp3 / .wav file into this directory and paste the name of it in the variable *INPUT_FILE* in the code.
+If you are using COLAB, you can find this option by selecting files at the verical bar on the left.
+
+With the current settings, the model separates vocals, bass, drums and accomplishment from the input-file.
+However, you can change this by setting *SPLEETER_MODEL* to one of the following:
+- spleeter:2stems
+  - separates only Vocals and accomplishment
+- spleeter:4stems
+  - separates vocals, bass, drums and accomplishment
+- spleeter:5stems
+  - separates vocals, bass, drums, piano and accomplishment
+
+Lets start by separating our first stems.
+Running this cell might take some time, depending on your setup, the audio file and the selected model
+"""
+
+# insert your file name here
+INPUT_FILE = 'example_for_demo.mp3'
+INPUT_FILENAME = INPUT_FILE.split('.')[0]
+OUTPUT_DIR = 'outputs'
+SUPPORTED_EXTENSIONS = ('.wav', '.mp3')
+SAMPLE_RATE = 44100
+SPLEETER_MODEL = 'spleeter:5stems'       # You might want to change this to 'spleeter:2stems' or 'spleeter:4stems' for different models
+
+# Initialize separator
+separator = Separator(SPLEETER_MODEL)
+
+# Load audio
+audio_loader = AudioAdapter.default()
+waveform, _ = audio_loader.load(INPUT_FILE, sample_rate=SAMPLE_RATE)
+
+# Perform the separation and save the output
+print("Separating audio sources...")
+# prediction = separator.separate(waveform)         # separating the audio, without saving it
+separator.separate_to_file(INPUT_FILE, OUTPUT_DIR)
+
+"""## Displaying Audio, Spectrogram and Waveform
+
+Lets create two helper-functions that plot the waveform and the spectrogram of an audio file.
+By using different librosa methods, we can easily create such plots.
+
+Finally we create a method that calls these two methods and additionally displays the audio, so that it can be played directly in this notebook.
+"""
+
+# Visualization of Waveforms and Spectrograms
+
+# Plot waveform
+def plot_waveform(waveform, sr, title='Waveform'):
+    plt.figure(figsize=(15, 2))
+    librosa.display.waveshow(waveform, sr=sr)
+    plt.title(title)
+    plt.tight_layout()
+    plt.show()
+
+# Plot spectrogram
+def plot_spectrogram(signal, sr, title='Spectrogram'):
+    D = librosa.amplitude_to_db(np.abs(librosa.stft(signal)), ref=np.max)
+    plt.figure(figsize=(15, 2))
+    librosa.display.specshow(D, sr=sr, x_axis='time', y_axis='log')
+    plt.title(title)
+    plt.colorbar(format='%+2.0f dB')
+    plt.tight_layout()
+    plt.show()
+
+def display_audio_and_plots(fileName):
+    display(Audio(fileName))
+    print(fileName)
+    y, sr = librosa.load(fileName)
+    plot_waveform(y, sr, f'Waveform of {fileName}')
+    plot_spectrogram(y, sr, f'Spectrogram of {fileName}')
+    print('---' * 50)
+
+"""Now we can use this method and display all the relevant formats for the original song and each separated stem.
+Here you should be able to notice some characteristics (depending on the song that you picked):
+- The bass should be located at the lower frequencies of the spectrogram.
+- The spectogram of drums often consists of vertical lines, which means, that they occur in multiple frequencies at the same time and that their hits are of very short time (which is typcal for drums).
+- Vocals often display as horizontal lines in the Spectrogram (depending on the Genre). This is because their tones are often held longer, compared to other instruments.
+
+In the following cell, you can insert the path of any wav/mp3 file and display the different plots.
+You might have to comment some calls of display_audio_and_plots() depending on the model that you've chosen.
+"""
+
+display_audio_and_plots(INPUT_FILE)
+
+# if you are running this in a local environment, you can use the following code to display the audio
+display_audio_and_plots(f'{OUTPUT_DIR}/{INPUT_FILENAME}/other.wav')
+display_audio_and_plots(f'{OUTPUT_DIR}/{INPUT_FILENAME}/vocals.wav')
+display_audio_and_plots(f'{OUTPUT_DIR}/{INPUT_FILENAME}/bass.wav')
+display_audio_and_plots(f'{OUTPUT_DIR}/{INPUT_FILENAME}/drums.wav')
+display_audio_and_plots(f'{OUTPUT_DIR}/{INPUT_FILENAME}/piano.wav')
+
+
+# if you are running this in COLAB, you can use the following code to display the audio
+# display_audio_and_plots(f'/content/{OUTPUT_DIR}/{INPUT_FILENAME}/other.wav')
+# display_audio_and_plots(f'/content/{OUTPUT_DIR}/{INPUT_FILENAME}/vocals.wav')
+# display_audio_and_plots(f'/content/{OUTPUT_DIR}/{INPUT_FILENAME}/bass.wav')
+# display_audio_and_plots(f'/content/{OUTPUT_DIR}/{INPUT_FILENAME}/drums.wav')
+# display_audio_and_plots(f'/content/{OUTPUT_DIR}/{INPUT_FILENAME}/piano.wav')
+
+"""## Running Spleeter on Command Line
+
+The following Cell demonstrates how to use Spleeter on the command-line. You can execute the cell here in this Notebook, or you copy the command into your command line. Note that if you run this directly on the command-line, you have to remove the "!" before the command.
+
+Again, you can choose between different Models here. Either 2, 4 or 5 stems can be separated.
+
+To run Spleeter on comman-line, you have to provide a name of the output directory (here: audio_output), a model and an audio file (here: example_for_demo.mp3).
+"""
+
+# 2 stems
+!spleeter separate -o audio_output example_for_demo.mp3
+# 4 stems
+# !spleeter separate -o audio_output -p spleeter:4stems example_for_demo.mp3
+
+# 5 stems
+# !spleeter separate -o audio_output -p spleeter:5stems example_for_demo.mp3