### Setup Conda Environment and Install Dependencies

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/speech_super_resolution/README.md

Creates and activates a Conda environment for ClearerVoice-Studio and installs necessary Python packages from the requirements.txt file. Supports Python 3.8 and potentially higher versions.

```sh
cd ClearerVoice-Studio
conda create -n ClearerVoice-Studio python=3.8
conda activate ClearerVoice-Studio
pip install -r requirements.txt
```

--------------------------------

### Start Model Training

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/speech_enhancement/README.md

Initiates the model training process using the 'train.sh' script. Allows configuration of the network model, whether to continue training from a checkpoint, and the path to an initial model for fine-tuning.

```sh
bash train.sh
```

```sh
network=MossFormer2_SE_48K            #Train MossFormer2_SE_48K model
train_from_last_checkpoint=1          #Set 1 to start training from the last checkpoint if exists, 
init_checkpoint_path=./               #Path to your initial model if starting fine-tuning; otherwise, set it to 'None'
```

--------------------------------

### Install ClearVoice via PyPI

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

Installs the ClearVoice library using pip, a package installer for Python. This is the recommended method for users who want to quickly integrate ClearVoice into their projects.

```sh
pip install clearvoice
```

--------------------------------

### Start Training

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/target_speaker_extraction_online/README.md

Executes the main training script using bash. This command initiates the model training process based on configurations in the 'train.sh' file.

```sh
bash train.sh
```

--------------------------------

### Setup Conda Environment and Install Dependencies

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/target_speaker_extraction_online/README.md

Creates a Conda environment named 'clear_voice_tse' with Python 3.9, installs PyTorch, torchvision, torchaudio, and other requirements from 'requirements.txt'. This ensures the correct software versions for training.

```sh
cd ClearerVoice-Studio/train/target_speaker_extraction_online/
conda create -n clear_voice_tse python=3.9
conda activate clear_voice_tse
conda install pytorch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1  pytorch-cuda=11.8 -c pytorch -c nvidia
pip install -r requirements.txt
```

--------------------------------

### Install ClearVoice from GitHub

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

Clones the ClearVoice GitHub repository and installs the library in editable mode. This method is useful for developers who want to contribute to the project or use the latest development versions.

```sh
git clone https://github.com/modelscope/ClearerVoice-Studio.git
cd ClearerVoice-Studio/clearvoice
pip install --editable .
```

--------------------------------

### Install FFmpeg on macOS

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

Installs FFmpeg on macOS using the Homebrew package manager. Homebrew simplifies the installation of command-line tools and libraries on macOS.

```sh
brew install ffmpeg
```

--------------------------------

### Install FFmpeg on Ubuntu/Debian

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

Installs FFmpeg, a crucial dependency for ClearVoice, on Ubuntu or Debian-based Linux distributions using the apt package manager. FFmpeg is needed for handling various audio formats.

```sh
sudo apt update
sudo apt install ffmpeg
```

--------------------------------

### Start Training Speech Super-Resolution Models

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/speech_super_resolution/README.md

Initiates the training process for speech super-resolution models using a bash script. Allows configuration for training a specific network (e.g., MossFormer2_SR_48K) and choosing between fresh training or fine-tuning from a checkpoint.

```sh
bash train.sh
# Example configuration within train.sh:
# network=MossFormer2_SR_48K            #Train MossFormer2_SR_48K model
# train_from_last_checkpoint=1          #Set 1 to start training from the last checkpoint if exists, otherwise, set it to 0
```

--------------------------------

### Import ClearVoice in Python

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

Imports the main ClearVoice class from the installed library. This is the first step required in a Python script to start using ClearVoice functionalities.

```python
from clearvoice import ClearVoice
```

--------------------------------

### Evaluate Speech Metrics for Audio Directories using Python

Source: https://github.com/modelscope/clearervoice-studio/blob/main/speechscore/README.md

This snippet demonstrates how to evaluate speech quality metrics for multiple audio files located in specified directories. The SpeechScore object is configured similarly to the single file example, but the input paths point to directories. The `return_mean=True` argument is used to obtain the average scores across all files in the directories. The output includes both the mean scores and individual file scores.

```python
from clearvoicestudio.evaluation import SpeechScore
import pprint

# Initialize a SpeechScore object with a list of score metrics to be evaluated
# Supports any subsets of the list
# Non-intrusive tests ['NISQA', 'DNSMOS', 'DISTILL_MOS', SRMR'] : No reference audio is required

mySpeechScore = SpeechScore([
    'SRMR', 'PESQ', 'NB_PESQ', 'STOI', 'SISDR', 
    'FWSEGSNR', 'LSD', 'BSSEval', 'DNSMOS', 
    'SNR', 'SSNR', 'LLR', 'CSIG', 'CBAK', 
    'COVL', 'MCD', 'NISQA', 'DISTILL_MOS'
])

# Call the SpeechScore object to evaluate the speech metrics between 'noisy' and 'clean' audio
# Arguments:
# - {test_path, reference_path} supports audio directories or audio paths (.wav or .flac)
# - window (float): seconds, set None to specify no windowing (process the full audio)
# - score_rate (int): specifies the sampling rate at which the metrics should be computed
# - return_mean (bool): set True to specify that the mean score for each metric should be returned


print('score for wav directories')
scores = mySpeechScore(test_path='audios/noisy/', reference_path='audios/clean/', window=None, score_rate=16000, return_mean=True)

# Pretty-print the resulting scores in a readable format
pprint.pprint(scores)

# Print only the resulting mean scores in a readable format
#pprint.pprint(scores['Mean_Score'])
```

--------------------------------

### Configure ClearerVoice-Studio Training Parameters

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/speech_separation/README.md

These variables within the 'train.sh' script allow users to specify the network architecture (e.g., MossFormer2_SS_16K), choose to train from the last checkpoint, and set the path for initial model weights if fine-tuning.

```sh
network=MossFormer2_SS_16K              #Train MossFormer2_SS_16K model
train_from_last_checkpoint=1            #Set 1 to start training from the last checkpoint if exists, 
init_checkpoint_path=./                 #Path to your initial model if starting fine-tuning; otherwise, set it to 'None'
```

--------------------------------

### Run ClearerVoice-Studio Demo Script

Source: https://github.com/modelscope/clearervoice-studio/blob/main/speechscore/README.md

This command navigates to the 'speechscore' directory and executes the demo script 'demo.py' using Python. Alternatively, the provided Python script demonstrates how to import and utilize the SpeechScore class for evaluating speech quality metrics.

```sh
cd speechscore
python demo.py
```

```python
# Import pprint for pretty-printing the results in a more readable format
import pprint
# Import the SpeechScore class to evaluate speech quality metrics
from speechscore import SpeechScore 

```

--------------------------------

### Visualize Training Progress

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/target_speaker_extraction_online/README.md

Launches Tensorboard to visualize the training progress. It monitors logs and checkpoints stored in the './checkpoints/' directory.

```sh
tensorboard --logdir ./checkpoints/
```

--------------------------------

### Run ClearVoice Demo Scripts

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

Executes the provided demo scripts for ClearVoice. These scripts demonstrate various functionalities and can be activated by setting specific boolean flags within the script files.

```sh
cd ClearerVoice-Studio/clearvoice
python demo.py
```

```sh
cd ClearerVoice-Studio/clearvoice
python demo_with_more_comments.py
```

```sh
cd ClearerVoice-Studio/clearvoice
python demo_Numpy2Numpy.py
```

--------------------------------

### Initialize ClearVoice Object for Speech Tasks

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Demonstrates how to initialize the ClearVoice object for different speech processing tasks like enhancement, separation, super-resolution, and target speaker extraction. Specifies the task and model names for each initialization.

```python
from clearvoice import ClearVoice

# Initialize for speech enhancement at 48kHz
myClearVoice = ClearVoice(
    task='speech_enhancement',
    model_names=['MossFormer2_SE_48K']
)

# Initialize for speech separation with multiple speakers
myClearVoice_sep = ClearVoice(
    task='speech_separation',
    model_names=['MossFormer2_SS_16K']
)

# Initialize for speech super-resolution (bandwidth extension)
myClearVoice_sr = ClearVoice(
    task='speech_super_resolution',
    model_names=['MossFormer2_SR_48K']
)

# Initialize for audio-visual target speaker extraction
myClearVoice_tse = ClearVoice(
    task='target_speaker_extraction',
    model_names=['AV_MossFormer2_TSE_16K']
)
```

--------------------------------

### Initialize SpeechScore Object

Source: https://github.com/modelscope/clearervoice-studio/blob/main/speechscore/README.md

This code snippet demonstrates how to initialize the SpeechScore object, which is used to calculate various speech quality metrics. It accepts a list of file paths to analyze.

```python
mySpeechScore = SpeechScore(['.'])
```

--------------------------------

### Generate LibriMix Dataset using Shell Script

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/speech_separation/README.md

This section describes how to generate the LibriMix dataset by cloning the necessary repository and executing a provided shell script. It requires a LibriSpeech dataset and the WHAM! noise dataset.

```sh
git clone https://github.com/JorisCos/LibriMix
cd LibriMix 
./generate_librimix.sh storage_dir
```

--------------------------------

### SpeechScore Initialization - Python

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Initializes the SpeechScore toolkit with a comprehensive set of intrusive and non-intrusive speech quality assessment metrics. Users can select all available metrics or a specific subset.

```python
from speechscore import SpeechScore
import pprint

# Initialize with full set of metrics
mySpeechScore = SpeechScore([
    'SRMR',          # Non-intrusive: Speech-to-Reverberation Modulation Energy Ratio
    'PESQ',          # Intrusive: Perceptual Evaluation of Speech Quality
    'NB_PESQ',       # Intrusive: NarrowBand PESQ
    'STOI',          # Intrusive: Short-Time Objective Intelligibility
    'SISDR',         # Intrusive: Scale-Invariant Signal-to-Distortion Ratio
    'FWSEGSNR',      # Intrusive: Frequency-Weighted Segmental SNR
    'LSD',           # Intrusive: Log-Spectral Distance
    'BSSEval',       # Intrusive: ISR, SAR, SDR metrics
    'DNSMOS',        # Non-intrusive: Deep Noise Suppression MOS (BAK, OVRL, SIG, P808_MOS)
    'SNR',           # Intrusive: Signal-to-Noise Ratio
    'SSNR',          # Intrusive: Segmental SNR
    'LLR',           # Intrusive: Log Likelihood Ratio
    'CSIG',          # Intrusive: Signal distortion MOS
    'CBAK',          # Intrusive: Background intrusiveness MOS
    'COVL',          # Intrusive: Overall quality MOS
    'MCD',           # Intrusive: Mel-Cepstral Distortion
    'NISQA',         # Non-intrusive: Quality, Noisiness, Coloration, Discontinuity, Loudness
    'DISTILL_MOS'    # Non-intrusive: Distilled MOS from wav2vec2.0
])

# Initialize with subset of metrics
mySpeechScore_basic = SpeechScore(['PESQ', 'STOI', 'SNR'])
```

--------------------------------

### Evaluate Speech Metrics for Single Audio File using Python

Source: https://github.com/modelscope/clearervoice-studio/blob/main/speechscore/README.md

This snippet demonstrates how to initialize and use the SpeechScore object to evaluate speech quality metrics for a single WAV file. It takes a noisy audio file and a clean reference file as input. The output is a dictionary containing scores for each requested metric. Non-intrusive tests can be performed by setting the reference_path to None.

```python
from clearvoicestudio.evaluation import SpeechScore
import pprint

# Initialize a SpeechScore object with a list of score metrics to be evaluated
# Supports any subsets of the list
# Non-intrusive tests ['NISQA', 'DNSMOS', 'DISTILL_MOS', SRMR'] : No reference audio is required

mySpeechScore = SpeechScore([
    'SRMR', 'PESQ', 'NB_PESQ', 'STOI', 'SISDR', 
    'FWSEGSNR', 'LSD', 'BSSEval', 'DNSMOS', 
    'SNR', 'SSNR', 'LLR', 'CSIG', 'CBAK', 
    'COVL', 'MCD', 'NISQA', 'DISTILL_MOS'
])

# Call the SpeechScore object to evaluate the speech metrics between 'noisy' and 'clean' audio
# Arguments:
# - {test_path, reference_path} supports audio directories or audio paths (.wav or .flac)
# - window (float): seconds, set None to specify no windowing (process the full audio)
# - score_rate (int): specifies the sampling rate at which the metrics should be computed
# - return_mean (bool): set True to specify that the mean score for each metric should be returned


print('score for a signle wav file')
scores = mySpeechScore(test_path='audios/noisy.wav', reference_path='audios/clean.wav', window=None, score_rate=16000, return_mean=False)
#scores = mySpeechScore(test_path='audios/noisy.wav', reference_path=None) # for Non-instrusive tests
# Pretty-print the resulting scores in a readable format
pprint.pprint(scores)
```

--------------------------------

### Clone Repository

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/target_speaker_extraction_online/README.md

Clones the ClearerVoice-Studio repository from GitHub. This is the initial step to obtain the project's codebase.

```sh
git clone https://github.com/modelscope/ClearerVoice-Studio.git
```

--------------------------------

### Speech Enhancement using File I/O

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Processes noisy audio files for speech enhancement using file-based input and output. Supports single files, directories, and .scp files, as well as multiple audio formats.

```python
from clearvoice import ClearVoice

# Initialize speech enhancement model
myClearVoice = ClearVoice(
    task='speech_enhancement',
    model_names=['MossFormer2_SE_48K']
)

# Process single audio file and return waveform
output_wav = myClearVoice(
    input_path='samples/input.wav',
    online_write=False
)
myClearVoice.write(output_wav, output_path='samples/output_enhanced.wav')

# Process entire directory of audio files
myClearVoice(
    input_path='samples/path_to_input_wavs',
    online_write=True,
    output_path='samples/path_to_output_wavs'
)

# Process files listed in .scp file
myClearVoice(
    input_path='samples/scp/audio_samples.scp',
    online_write=True,
    output_path='samples/path_to_output_wavs_scp'
)

# Support for multiple audio formats
output_wav = myClearVoice(input_path='samples/speech1.mp3', online_write=False)
myClearVoice.write(output_wav, output_path='samples/output_enhanced.mp3')
```

--------------------------------

### Evaluate Checkpoints

Source: https://github.com/modelscope/clearervoice-studio/blob/main/train/target_speaker_extraction_online/README.md

Runs the evaluation script to assess the performance of trained checkpoints. This is an optional step after training.

```sh
bash evaluate_only.sh
```

--------------------------------

### Speech Enhancement with MossFormer2_SE_48K in Python

Source: https://github.com/modelscope/clearervoice-studio/blob/main/clearvoice/README.md

This script utilizes the ClearVoice library for the speech enhancement task using the MossFormer2_SE_48K model. It shows how to process single WAV files, entire directories of WAV files, and WAV files listed in an .scp file. The `online_write` parameter controls direct saving during processing, and `output_path` specifies the save location.

```python
from clearvoice import ClearVoice

myClearVoice = ClearVoice(task='speech_enhancement', model_names=['MossFormer2_SE_48K'])

#process single wave file
output_wav = myClearVoice(input_path='samples/input.wav', online_write=False)
myClearVoice.write(output_wav, output_path='samples/output_MossFormer2_SE_48K.wav')

#process wave directory
myClearVoice(input_path='samples/path_to_input_wavs', online_write=True, output_path='samples/path_to_output_wavs')

#process wave list file
myClearVoice(input_path='samples/scp/audio_samples.scp', online_write=True, output_path='samples/path_to_output_wavs_scp')
```

--------------------------------

### Speech Enhancement using Numpy Arrays

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Performs speech enhancement directly on Numpy arrays, bypassing file I/O for integration into pipelines. Requires audio resampling and reshaping to the expected format.

```python
from clearvoice import ClearVoice
import soundfile as sf
import numpy as np
import librosa

# Initialize model
myClearVoice = ClearVoice(
    task='speech_enhancement',
    model_names=['MossFormer2_SE_48K']
)

# Load audio and prepare input
audio, sr = sf.read('samples/input.wav')

# Resample to required 48000 Hz if needed
if sr != 48000:
    audio = librosa.resample(audio, orig_sr=sr, target_sr=48000)

# Reshape to [batch, length] format
if len(audio.shape) < 2:
    audio = np.reshape(audio, [1, audio.shape[0]])
audio = audio.astype(np.float32)

# Process audio: input shape [batch, length], output shape [batch, length]
output_wav = myClearVoice(audio, False)

# Save output
sf.write('samples/output_enhanced.wav', output_wav[0, :], 48000)
```

--------------------------------

### Speech Quality Assessment: Directory Evaluation (Python)

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Performs batch speech quality assessment across multiple audio files within specified directories. It calculates mean scores for each metric across all processed files, providing an overall quality summary. This is useful for evaluating model performance on a dataset.

```python
from speechscore import SpeechScore
import pprint

# Initialize metrics
mySpeechScore = SpeechScore([
    'PESQ', 'STOI', 'SISDR', 'FWSEGSNR', 'DNSMOS', 'BSSEval'
])

# Evaluate all files in directories and return mean scores
scores = mySpeechScore(
    test_path='audios/noisy/',
    reference_path='audios/clean/',
    window=None,
    score_rate=16000,
    return_mean=True
)

pprint.pprint(scores)
# Output format:
# {
#     'Mean_Score': {
#         'PESQ': 1.141619324684143,
#         'STOI': 0.8585249663711918,
#         'SISDR': 4.778657656271212,
#         'FWSEGSNR': 9.079539440199575,
#         'DNSMOS': {
#             'BAK': 1.9004393746158654,
#             'OVRL': 1.8606212162135691,
#             'P808_MOS': 2.5821499824523926,
#             'SIG': 2.6799127209039266
#         },
#         'BSSEval': {
#             'ISR': 23.728811184377903,
#             'SAR': 4.839625092004949,
#             'SDR': 4.9270216975279135
#         }
#     },
#     'audio_1.wav': { ... },  # Individual file scores
#     'audio_2.wav': { ... }
# }

# Print only mean scores
pprint.pprint(scores['Mean_Score'])
```

--------------------------------

### Audio-Visual Target Speaker Extraction - Python

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Extracts a target speaker's audio from multi-speaker recordings using visual cues from face or lip movements. The ClearVoice model processes video files or lists of files specified in an .scp file.

```python
from clearvoice import ClearVoice

# Initialize audio-visual target speaker extraction model
myClearVoice = ClearVoice(
    task='target_speaker_extraction',
    model_names=['AV_MossFormer2_TSE_16K']
)

# Process directory of video files
myClearVoice(
    input_path='samples/path_to_input_videos_tse',
    online_write=True,
    output_path='samples/path_to_output_videos_tse'
)

# Process video files listed in .scp file
myClearVoice(
    input_path='samples/scp/video_samples.scp',
    online_write=True,
    output_path='samples/path_to_output_videos_tse_scp'
)
```

--------------------------------

### Windowed Speech Quality Assessment (Python)

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Evaluates speech quality metrics on time-windowed segments of audio files for temporal analysis. This allows for detailed examination of how speech quality changes over time within a single utterance. The results are returned for each specified time window.

```python
from speechscore import SpeechScore

# Initialize metrics
mySpeechScore = SpeechScore(['PESQ', 'STOI', 'SNR', 'SSNR'])

# Evaluate with 2-second windows
scores_windowed = mySpeechScore(
    test_path='audios/noisy.wav',
    reference_path='audios/clean.wav',
    window=2.0,           # 2-second window segments
    score_rate=16000,
    return_mean=False
)

# Returns metric values for each time window
# Useful for analyzing quality changes over time
```

--------------------------------

### Speech Super-Resolution (Bandwidth Extension) - Python

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Enhances low-resolution audio to a high-resolution 48kHz sampling rate using the ClearVoice library. It can process audio files directly or be used in a pipeline with speech enhancement.

```python
from clearvoice import ClearVoice

# Initialize super-resolution model
myClearVoice_SR = ClearVoice(
    task='speech_super_resolution',
    model_names=['MossFormer2_SR_48K']
)

# Process low-resolution audio
output_wav = myClearVoice_SR(
    input_path='samples/input_sr.wav',
    online_write=False
)
myClearVoice_SR.write(output_wav, output_path='samples/output_48k.wav')

# Combined enhancement and super-resolution pipeline
myClearVoice_SE = ClearVoice(
    task='speech_enhancement',
    model_names=['MossFormer2_SE_48K']
)
myClearVoice_SR = ClearVoice(
    task='speech_super_resolution',
    model_names=['MossFormer2_SR_48K']
)

# Step 1: Enhance noisy speech
output_enhanced = myClearVoice_SE(
    input_path='samples/input.wav',
    online_write=False
)
myClearVoice_SE.write(output_enhanced, output_path='samples/enhanced.wav')

# Step 2: Apply super-resolution to enhanced speech
output_sr = myClearVoice_SR(
    input_path='samples/enhanced.wav',
    online_write=False
)
myClearVoice_SR.write(output_sr, output_path='samples/final_48k.wav')
```

--------------------------------

### Speech Quality Assessment (Single File) - Python

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Evaluates speech quality metrics for a single audio file against a reference file. This function supports both intrusive and non-intrusive metrics and allows for processing the full audio or specific windows.

```python
from speechscore import SpeechScore
import pprint

# Initialize metrics
mySpeechScore = SpeechScore([
    'PESQ', 'STOI', 'SISDR', 'SNR', 'DNSMOS', 'NISQA'
])

# Evaluate single file with reference (intrusive metrics)
scores = mySpeechScore(
    test_path='audios/noisy.wav',
    reference_path='audios/clean.wav',
    window=None,          # Process full audio without windowing
    score_rate=16000,     # Sampling rate for metric computation
    return_mean=False
)

pprint.pprint(scores)
```

--------------------------------

### Speech Quality Assessment: Single File (Python)

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Evaluates speech quality metrics for a single audio file without a reference. It utilizes the SpeechScore library to compute various metrics like PESQ, STOI, SISDR, etc. This method is useful for assessing the quality of a single utterance or recording.

```python
from speechscore import SpeechScore

# Initialize metrics
mySpeechScore = SpeechScore([
    'PESQ', 'STOI', 'SISDR', 'FWSEGSNR', 'DNSMOS', 'BSSEval'
])

# Non-intrusive evaluation (no reference required)
scores_non_intrusive = mySpeechScore(
    test_path='audios/noisy.wav',
    reference_path=None
)
```

--------------------------------

### Save Separated Speakers - Python

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Saves individual separated speaker audio streams to WAV files. It iterates through the separated audio data and writes each speaker's audio to a uniquely named file using the soundfile library.

```python
import soundfile as sf

# Assuming output_wav is a numpy array containing separated audio
# and num_spks is the number of speakers
for spk in range(num_spks):
    output_file = f'samples/output_speaker{spk+1}.wav'
    sf.write(output_file, output_wav[spk, 0, :], 16000)
```

--------------------------------

### Speech Separation Processing

Source: https://context7.com/modelscope/clearervoice-studio/llms.txt

Separates mixed audio into individual speaker streams using either file I/O or Numpy array input. Handles resampling and reshaping for Numpy array processing.

```python
from clearvoice import ClearVoice
import soundfile as sf
import numpy as np
import librosa

# Initialize speech separation model
myClearVoice = ClearVoice(
    task='speech_separation',
    model_names=['MossFormer2_SS_16K']
)

# File I/O mode: process single mixed audio file
output_wav = myClearVoice(
    input_path='samples/input_ss.wav',
    online_write=False
)
myClearVoice.write(output_wav, output_path='samples/output_separated.wav')

# Numpy array mode for batch processing
num_spks = 2
audio, sr = sf.read('samples/input_ss.wav')

# Resample to 16000 Hz if needed
if sr != 16000:
    audio = librosa.resample(audio, orig_sr=sr, target_sr=16000)

# Reshape to [batch, length]
if len(audio.shape) < 2:
    audio = np.reshape(audio, [1, audio.shape[0]])
audio = audio.astype(np.float32)

# Process: input [batch, length], output [num_speakers, batch, length]
output_wav = myClearVoice(audio, False)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.