diff --git a/.codeboarding/Audio_Processing_Utilities.md b/.codeboarding/Audio_Processing_Utilities.md
new file mode 100644
index 00000000..4626b3d0
--- /dev/null
+++ b/.codeboarding/Audio_Processing_Utilities.md
@@ -0,0 +1,115 @@
+```mermaid
+
+graph LR
+
+ AudioAdapter["AudioAdapter"]
+
+ FFMPEGProcessAudioAdapter["FFMPEGProcessAudioAdapter"]
+
+ AudioConvertor["AudioConvertor"]
+
+ AudioSpectrogram["AudioSpectrogram"]
+
+ AudioAdapter -- "uses" --> FFMPEGProcessAudioAdapter
+
+ Dataset -- "uses" --> AudioAdapter
+
+ Separator -- "uses" --> AudioAdapter
+
+ Dataset -- "uses" --> AudioConvertor
+
+ Separator -- "uses" --> AudioConvertor
+
+ Dataset -- "uses" --> AudioSpectrogram
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `Audio Processing Utilities` component in Spleeter provides a robust set of tools for handling, transforming, and augmenting audio data. It is fundamental to Spleeter's operation as it underpins all audio input, output, and manipulation required for source separation and dataset preparation.
+
+
+
+### AudioAdapter
+
+This abstract component defines the interface for loading and saving audio waveforms. It provides methods for converting audio descriptors into usable waveform data and manages the default audio adapter instance, which is typically `FFMPEGProcessAudioAdapter`. It also includes error handling for audio loading operations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.adapter.AudioAdapter` (29:199)
+
+
+
+
+
+### FFMPEGProcessAudioAdapter
+
+A concrete implementation of the `AudioAdapter` that leverages FFmpeg for efficient audio loading and saving. It handles the actual interaction with the FFmpeg process to perform audio conversions and manipulations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.ffmpeg.FFMPEGProcessAudioAdapter` (34:184)
+
+
+
+
+
+### AudioConvertor
+
+This component specializes in converting audio properties, specifically between decibels (dB) and gain. It offers utilities for transforming spectrogram data into a decibel representation and vice-versa, which is essential for audio normalization, dynamic range compression, and other signal processing tasks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.convertor.AudioConvertor` (1:1)
+
+
+
+
+
+### AudioSpectrogram
+
+This component focuses on transformations related to audio spectrograms, primarily for data augmentation purposes. It includes functionalities like time stretching and pitch shifting, which are vital for generating diverse training data for machine learning models, thereby improving model robustness and generalization.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.spectrogram.AudioSpectrogram` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/CLI_Application.md b/.codeboarding/CLI_Application.md
new file mode 100644
index 00000000..ac89588c
--- /dev/null
+++ b/.codeboarding/CLI_Application.md
@@ -0,0 +1,181 @@
+```mermaid
+
+graph LR
+
+ CLI_Application["CLI Application"]
+
+ Audio_Adapter["Audio Adapter"]
+
+ Separator["Separator"]
+
+ Estimator_TensorFlow_["Estimator (TensorFlow)"]
+
+ Dataset_Provider["Dataset Provider"]
+
+ Model_Provider["Model Provider"]
+
+ Configuration_Loader["Configuration Loader"]
+
+ CLI_Application -- "uses" --> Audio_Adapter
+
+ CLI_Application -- "uses" --> Separator
+
+ CLI_Application -- "uses" --> Estimator_TensorFlow_
+
+ CLI_Application -- "uses" --> Dataset_Provider
+
+ CLI_Application -- "uses" --> Model_Provider
+
+ CLI_Application -- "uses" --> Configuration_Loader
+
+ click CLI_Application href "https://github.com/deezer/spleeter/blob/main/.codeboarding//CLI_Application.md" "Details"
+
+ click Separator href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Separator.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `CLI Application` in Spleeter serves as the primary user interface, orchestrating various core functionalities based on user commands. It acts as a dispatcher, delegating tasks to specialized components for audio processing, model training, and separation.
+
+
+
+### CLI Application
+
+The main entry point for Spleeter, responsible for parsing command-line arguments (`train`, `separate`, `evaluate`) and coordinating the overall workflow. It initializes and invokes other core components to fulfill user requests.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.__main__` (1:1)
+
+
+
+
+
+### Audio Adapter
+
+Provides a unified interface for handling audio input and output operations. It abstracts the underlying audio processing backend, allowing Spleeter to load audio from various sources and save separated tracks in different formats.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.adapter` (1:1)
+
+
+
+
+
+### Separator
+
+Encapsulates the logic for performing audio source separation. It initializes the necessary machine learning model (Estimator) and uses the Audio Adapter to process input audio and save the separated output tracks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.separator` (1:1)
+
+
+
+
+
+### Estimator (TensorFlow)
+
+Represents the underlying machine learning model, specifically a TensorFlow Estimator, responsible for the actual source separation or model training. It processes audio features and generates the separated audio streams or updates model parameters during training.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.model.functions.unet` (198:202)
+
+- `tensorflow.estimator.Estimator` (1:1)
+
+
+
+
+
+### Dataset Provider
+
+Manages the preparation and provision of datasets for model training and validation. It handles the loading and preprocessing of audio data into a format suitable for the Estimator.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.dataset` (1:1)
+
+
+
+
+
+### Model Provider
+
+Handles operations related to the management of trained models, such as writing probe files to indicate model availability or status.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.model.provider.github` (1:1)
+
+
+
+
+
+### Configuration Loader
+
+Responsible for loading and parsing configuration files, particularly those defining model parameters and other operational settings for Spleeter.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.utils.configuration` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Core_ML_Model.md b/.codeboarding/Core_ML_Model.md
new file mode 100644
index 00000000..51961f60
--- /dev/null
+++ b/.codeboarding/Core_ML_Model.md
@@ -0,0 +1,155 @@
+```mermaid
+
+graph LR
+
+ EstimatorSpecBuilder["EstimatorSpecBuilder"]
+
+ model_fn["model_fn"]
+
+ UNetModel["UNetModel"]
+
+ BLSTMModel["BLSTMModel"]
+
+ InputProviderFactory["InputProviderFactory"]
+
+ GithubModelProvider["GithubModelProvider"]
+
+ model_fn -- "instantiates and delegates to" --> EstimatorSpecBuilder
+
+ EstimatorSpecBuilder -- "uses" --> UNetModel
+
+ EstimatorSpecBuilder -- "uses" --> BLSTMModel
+
+ EstimatorSpecBuilder -- "uses" --> InputProviderFactory
+
+ GithubModelProvider -- "provides model configurations/weights to" --> EstimatorSpecBuilder
+
+ InputProviderFactory -- "provides data to" --> model_fn
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `Core ML Model` subsystem in Spleeter is central to its functionality, encapsulating the machine learning logic for audio source separation. It defines the TensorFlow model graph and manages its behavior across prediction, evaluation, and training modes. This subsystem integrates neural network architectures like BLSTM and U-Net, which are the backbone of Spleeter's separation capabilities.
+
+
+
+### EstimatorSpecBuilder
+
+This class is the architect of the TensorFlow `EstimatorSpec`, which comprehensively defines the model's graph. It orchestrates the entire data flow from feature engineering (STFT, spectrograms) to applying the core separation models (U-Net or BLSTM), computing masks, performing inverse STFT, and setting up loss functions and optimizers based on the operational mode (predict, train, eval). Its fundamental role lies in unifying all model-related computations into a coherent TensorFlow graph.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `EstimatorSpecBuilder` (0:0)
+
+
+
+
+
+### model_fn
+
+Serving as the primary entry point for a TensorFlow `Estimator`, `model_fn` acts as a high-level orchestrator. It instantiates the `EstimatorSpecBuilder` and delegates the actual model construction based on the `tf.estimator.ModeKeys` (PREDICT, EVAL, TRAIN). This function is fundamental because it's the direct interface for TensorFlow's Estimator API, enabling the Spleeter model to be trained, evaluated, and used for predictions within the TensorFlow ecosystem.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `model_fn` (0:0)
+
+
+
+
+
+### UNetModel
+
+This component embodies the U-Net neural network architecture, a deep learning model adapted for spectrogram-based audio source separation. The `apply_unet` function applies this architecture to input spectrograms, performing the core separation task. It's fundamental as it represents one of the primary neural network models responsible for the actual separation of audio sources.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `apply_unet` (0:0)
+
+
+
+
+
+### BLSTMModel
+
+This component represents the Bidirectional Long Short-Term Memory (BLSTM) neural network architecture, another common choice for sequence modeling tasks, applied here for audio source separation. The `apply_blstm` function applies this architecture to input spectrograms. It's fundamental as it offers an alternative or complementary core neural network model for the separation task, providing flexibility in model choice.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `apply_blstm` (0:0)
+
+
+
+
+
+### InputProviderFactory
+
+This factory class is responsible for generating and providing input data (e.g., audio waveforms, spectrograms) to the model during training, evaluation, or prediction. It handles the initial data preparation and feeding mechanism for the model, ensuring that the model receives data in the correct format and flow.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `InputProviderFactory` (0:0)
+
+
+
+
+
+### GithubModelProvider
+
+This component is a concrete implementation of a `ModelProvider` that specifically handles the downloading and management of pre-trained models from GitHub. It includes crucial functionality like checksum verification to ensure model integrity. It's fundamental as it provides the means to load pre-trained weights, which are essential for using Spleeter without training from scratch and for ensuring reproducibility.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `GithubModelProvider` (0:0)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Dataset_Management.md b/.codeboarding/Dataset_Management.md
new file mode 100644
index 00000000..fb0dd378
--- /dev/null
+++ b/.codeboarding/Dataset_Management.md
@@ -0,0 +1,133 @@
+```mermaid
+
+graph LR
+
+ Dataset_Management["Dataset Management"]
+
+ Audio_Adapter["Audio Adapter"]
+
+ Audio_Convertor["Audio Convertor"]
+
+ Audio_Spectrogram_Augmentor["Audio Spectrogram Augmentor"]
+
+ Tensor_Utilities["Tensor Utilities"]
+
+ Dataset_Management -- "uses" --> Audio_Adapter
+
+ Dataset_Management -- "uses" --> Audio_Convertor
+
+ Dataset_Management -- "uses" --> Audio_Spectrogram_Augmentor
+
+ Dataset_Management -- "uses" --> Tensor_Utilities
+
+ click Dataset_Management href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Dataset_Management.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+These components are fundamental because they collectively form the backbone of the data preparation pipeline for audio separation models. Dataset Management is the orchestrator; without it, there's no structured way to feed data to the models. It defines the entire data flow. Audio Adapter is the gateway to raw audio. Without it, Dataset Management cannot access or load any audio files, making the entire process impossible. Audio Convertor ensures data consistency and proper scaling. Spectrograms need to be in a suitable format (e.g., decibels) for model training, and this component handles that crucial transformation. Audio Spectrogram Augmentor is vital for model robustness and generalization. By artificially increasing the diversity of the training data, it prevents overfitting and improves the model's performance on unseen audio. It also provides the core spectrogram computation. Tensor Utilities are essential for efficient data handling within the TensorFlow framework. They provide the necessary tools to build, manage, and optimize the data pipelines, ensuring that data is presented to the model in the correct format and efficiently. Together, these components ensure that the audio data is correctly loaded, preprocessed, augmented, and formatted, making them indispensable for the training and validation of audio separation models.
+
+
+
+### Dataset Management
+
+This component, primarily implemented in `spleeter/dataset.py`, is the central orchestrator for preparing audio datasets for machine learning models. It manages the entire lifecycle from raw audio input to augmented, model-ready data. Its responsibilities include loading audio, applying various preprocessing steps like spectrogram conversion and decibel normalization, and performing data augmentation techniques such as time stretching and pitch shifting. It leverages TensorFlow's data API to build efficient and scalable data pipelines for training and validation. This component is crucial for generating diverse and robust datasets essential for training and validating audio separation models.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.dataset` (0:0)
+
+
+
+
+
+### Audio Adapter
+
+This component, found in `spleeter/audio/adapter.py`, provides a standardized interface for interacting with audio files. Its primary purpose is to abstract the complexities of loading and saving audio waveforms, converting raw audio descriptors into a usable waveform format. It also manages the default audio processing backend (e.g., FFMPEG) and includes robust error handling for audio loading failures. `Dataset Management` relies on this component to load audio data from disk.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.adapter` (0:0)
+
+
+
+
+
+### Audio Convertor
+
+This component, located in `spleeter/audio/convertor.py`, specializes in the transformation of audio properties, particularly focusing on conversions between decibels (dB) and gain. It offers utilities to convert spectrogram data into a decibel representation and vice-versa. These conversions are vital for audio normalization, consistent processing, and ensuring that audio levels are appropriately handled before being fed into machine learning models. `Dataset Management` uses its functions for normalizing spectrograms.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.convertor` (0:0)
+
+
+
+
+
+### Audio Spectrogram Augmentor
+
+This component, implemented in `spleeter/audio/spectrogram.py`, is dedicated to data augmentation techniques applied to audio spectrograms. It implements operations such as time stretching and pitch shifting, which are crucial for generating variations of existing audio data. It also provides the core functionality for computing spectrograms from audio waveforms. By augmenting the dataset, this component helps improve the generalization capabilities and robustness of machine learning models, preventing overfitting and enhancing performance on diverse audio inputs. `Dataset Management` heavily relies on this component for spectrogram computation and data augmentation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.spectrogram` (0:0)
+
+
+
+
+
+### Tensor Utilities
+
+This component, located in `spleeter/utils/tensor.py`, provides a collection of utility functions specifically designed for TensorFlow tensor operations and dataset manipulation. These utilities include functions for checking and setting tensor shapes, creating datasets from CSV files, and applying synchronous operations to tensors. `Dataset Management` uses these utilities to build and manage its TensorFlow data pipelines efficiently.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.utils.tensor` (0:0)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Model_Provisioning.md b/.codeboarding/Model_Provisioning.md
new file mode 100644
index 00000000..558dcb9c
--- /dev/null
+++ b/.codeboarding/Model_Provisioning.md
@@ -0,0 +1,93 @@
+```mermaid
+
+graph LR
+
+ ModelProvider["ModelProvider"]
+
+ GithubModelProvider["GithubModelProvider"]
+
+ compute_file_checksum["compute_file_checksum"]
+
+ GithubModelProvider -- "inherits from" --> ModelProvider
+
+ GithubModelProvider -- "calls" --> compute_file_checksum
+
+ ModelProvider -- "uses" --> GithubModelProvider
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `Model Provisioning` subsystem in Spleeter is responsible for the discovery, download, and local management of pre-trained Spleeter models and their configurations. It provides an abstraction layer that allows other components to easily obtain necessary model assets, ensuring integrity and availability.
+
+
+
+### ModelProvider
+
+This is an abstract base class that defines the standardized interface for any model provider within Spleeter. Its primary purpose is to ensure consistency in how models are retrieved and managed, regardless of their origin. It mandates the implementation of a `download` method for concrete providers and offers a `get` method that handles the logic of checking for local model availability, downloading if necessary, and marking the model directory with a probe file.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `ModelProvider:download` (-1:-1)
+
+- `ModelProvider:get` (-1:-1)
+
+- `ModelProvider:default` (-1:-1)
+
+
+
+
+
+### GithubModelProvider
+
+This is a concrete implementation of the `ModelProvider` abstract base class, specifically designed to fetch models hosted on GitHub. It manages the intricacies of interacting with GitHub repositories, including constructing download URLs, retrieving checksums for validation, and handling the actual download and extraction of model archives. It leverages the `compute_file_checksum` utility to ensure the integrity of downloaded files.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `GithubModelProvider:download` (-1:-1)
+
+
+
+
+
+### compute_file_checksum
+
+This is a utility function responsible for calculating the SHA256 checksum of a given file. It reads the file in chunks and updates the hash, returning the final hexadecimal digest.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `compute_file_checksum` (-1:-1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Separator_Core.md b/.codeboarding/Separator_Core.md
new file mode 100644
index 00000000..4f08c9a9
--- /dev/null
+++ b/.codeboarding/Separator_Core.md
@@ -0,0 +1,133 @@
+```mermaid
+
+graph LR
+
+ Separator["Separator"]
+
+ AudioAdapter["AudioAdapter"]
+
+ ModelProvider["ModelProvider"]
+
+ Estimator["Estimator"]
+
+ InputProviderFactory["InputProviderFactory"]
+
+ Separator -- "composes and delegates to" --> Estimator
+
+ Separator -- "composes and delegates to" --> AudioAdapter
+
+ Separator -- "composes and delegates to" --> ModelProvider
+
+ Separator -- "composes and delegates to" --> InputProviderFactory
+
+ click Separator href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Separator.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+Abstract Components Overview of Spleeter
+
+
+
+### Separator
+
+The `Separator` class is the core component for performing audio source separation. It initializes and manages a TensorFlow `Estimator` for model inference, handles loading model configurations and weights, and provides methods for separating audio waveforms. It abstracts the complexities of the underlying machine learning model and its execution, offering a high-level interface for users to perform separation. It can also leverage multiprocessing for concurrent separation tasks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.separator.Separator` (72:347)
+
+
+
+
+
+### AudioAdapter
+
+The `AudioAdapter` component is responsible for abstracting audio input/output operations. It provides methods to load audio waveforms from various sources (e.g., files) and save separated audio tracks to specified destinations with different codecs and bitrates.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.adapter.AudioAdapter` (29:199)
+
+
+
+
+
+### ModelProvider
+
+The `ModelProvider` component is responsible for locating and providing access to the pre-trained TensorFlow models used for separation. It ensures that the `Separator` can find and load the necessary model checkpoints from their respective storage locations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.model.provider.github.ModelProvider` (0:0)
+
+
+
+
+
+### Estimator
+
+The TensorFlow `Estimator` is a high-level TensorFlow API that simplifies machine learning programming. In Spleeter, it's used by the `Separator` to perform the actual inference (prediction) of separated audio sources based on the loaded model. It manages the TensorFlow graph and session for execution.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `tensorflow.estimator.Estimator` (0:0)
+
+
+
+
+
+### InputProviderFactory
+
+The `InputProviderFactory` is responsible for creating an `InputProvider` instance, which prepares the input data (waveforms) into a format suitable for the TensorFlow `Estimator`. This involves handling audio descriptors and converting them into a dictionary of features that the model expects.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.dataset.InputProviderFactory` (0:0)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 00000000..0065ec72
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,193 @@
+```mermaid
+
+graph LR
+
+ CLI_Application["CLI Application"]
+
+ Separator_Core["Separator Core"]
+
+ Dataset_Management["Dataset Management"]
+
+ Audio_Processing_Utilities["Audio Processing Utilities"]
+
+ Core_ML_Model["Core ML Model"]
+
+ Model_Provisioning["Model Provisioning"]
+
+ CLI_Application -- "initiates separation" --> Separator_Core
+
+ CLI_Application -- "initiates dataset preparation" --> Dataset_Management
+
+ Separator_Core -- "orchestrates inference" --> Core_ML_Model
+
+ Separator_Core -- "receives predictions" --> Core_ML_Model
+
+ Separator_Core -- "requests audio processing" --> Audio_Processing_Utilities
+
+ Separator_Core -- "receives processed audio" --> Audio_Processing_Utilities
+
+ Separator_Core -- "requests model" --> Model_Provisioning
+
+ Separator_Core -- "receives model" --> Model_Provisioning
+
+ Dataset_Management -- "provides training data" --> Core_ML_Model
+
+ Dataset_Management -- "requests audio processing" --> Audio_Processing_Utilities
+
+ Dataset_Management -- "receives processed audio" --> Audio_Processing_Utilities
+
+ Audio_Processing_Utilities -- "provides feature engineering" --> Core_ML_Model
+
+ Core_ML_Model -- "requests configuration" --> Model_Provisioning
+
+ Core_ML_Model -- "receives configuration" --> Model_Provisioning
+
+ click CLI_Application href "https://github.com/deezer/spleeter/blob/main/.codeboarding//CLI_Application.md" "Details"
+
+ click Separator_Core href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Separator_Core.md" "Details"
+
+ click Dataset_Management href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Dataset_Management.md" "Details"
+
+ click Audio_Processing_Utilities href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Audio_Processing_Utilities.md" "Details"
+
+ click Core_ML_Model href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Core_ML_Model.md" "Details"
+
+ click Model_Provisioning href "https://github.com/deezer/spleeter/blob/main/.codeboarding//Model_Provisioning.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The architecture of `spleeter` is designed around a clear separation of concerns, enabling efficient audio source separation and model management. The analysis consolidates the initial CFG and source code insights into six fundamental components, each playing a critical role in the system's operation.
+
+
+
+### CLI Application
+
+The primary command-line interface for Spleeter, serving as the user's entry point. It parses user commands (e.g., `separate`, `evaluate`) and orchestrates the high-level flow by delegating tasks to the appropriate core components.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.__main__` (1:1)
+
+
+
+
+
+### Separator Core
+
+The central component responsible for executing the audio source separation process. It manages the TensorFlow model inference, handles input/output audio streams, and saves the separated tracks, abstracting the complexities of the underlying machine learning model.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.separator` (1:1)
+
+
+
+
+
+### Dataset Management
+
+Manages the creation, preprocessing, and augmentation of audio datasets. This component is crucial for training and validating separation models, handling tasks such as audio segmentation, spectrogram harmonization, and data caching.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.dataset` (1:1)
+
+
+
+
+
+### Audio Processing Utilities
+
+A consolidated component providing a comprehensive set of utilities for handling and transforming audio data. This includes loading audio waveforms from various sources, converting between different audio representations (e.g., spectrograms to decibels), and performing data augmentation on spectrograms.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.audio.adapter` (1:1)
+
+- `spleeter.audio.convertor` (1:1)
+
+- `spleeter.audio.spectrogram` (1:1)
+
+
+
+
+
+### Core ML Model
+
+Encapsulates the core machine learning logic, including the definition of the TensorFlow model graph and its various modes (prediction, evaluation, training). It integrates the neural network architectures (like BLSTM and U-Net) that form the backbone of the Spleeter separation model, performing the actual computation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.model` (1:1)
+
+- `spleeter.model.functions.blstm` (93:97)
+
+- `spleeter.model.functions.unet` (198:202)
+
+
+
+
+
+### Model Provisioning
+
+Manages the discovery, download, and provision of pre-trained Spleeter models and their configurations. It acts as an abstraction layer for accessing model weights and configurations, ensuring that other components can easily obtain the necessary model assets.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `spleeter.model.provider` (1:1)
+
+- `spleeter.model.provider.github` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file