Upload 146 files

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: beveradb

.github/ISSUE_TEMPLATE/BUG_REPORT.yml

@@ -0,0 +1,60 @@
+name: Bug report
+description: Report a problem you encountered
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: Describe the bug
+      description: Please provide a concise description of the bug.
+      placeholder: Bug description
+    validations:
+      required: true
+  - type: checkboxes
+    attributes:
+      label: Have you searched for existing issues?  🔎
+      description: Please search to see if there is already an issue for the problem you encountered.
+      options:
+        - label: I have searched and found no existing issues.
+          required: true
+  - type: markdown
+    attributes:
+      value: "---"
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots or Videos
+      description: Add screenshots, gifs, or videos to help explain your problem.
+      placeholder: Upload screenshots, gifs, and videos here.
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs
+      description: Please include the full stack trace of the errors you encounter.
+      render: shell
+  - type: markdown
+    attributes:
+      value: "---"
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System Info
+      description: Provide information about your system.
+      value: |
+        Operating System: 
+        Python version: 
+        Other...
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional Information
+      description: Add any other useful information about the problem here.
+      placeholder: Is there any additional helpful information you can share?
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/FEATURE_REQUEST.yml

@@ -0,0 +1,13 @@
+name: Feature request
+description: Suggest an idea for this project
+title: "[Feature]: "
+labels: ["enhancement", "feature"]
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Clearly and concisely describe what you would like to change, add, or implement.
+      placeholder: Tell us your idea.
+    validations:
+      required: true

.github/workflows/github-sponsors.yml

@@ -0,0 +1,25 @@
+name: Generate Sponsors README
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: 30 15 * * 0-6
+permissions:
+  contents: write
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout 🛎️
+        uses: actions/checkout@v4
+
+      - name: Generate Sponsors 💖
+        uses: JamesIves/github-sponsors-readme-action@v1
+        with:
+          token: ${{ secrets.SPONSORS_WORKFLOW_PAT }}
+          file: 'README.md'
+
+      - name: Deploy to GitHub Pages 🚀
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          branch: main
+          folder: '.'

.github/workflows/publish-to-docker.yml

@@ -0,0 +1,98 @@
+name: publish-to-docker
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - pyproject.toml
+      - Dockerfile.cpu
+      - Dockerfile.gpu
+      - Dockerfile.runpod
+  workflow_dispatch:
+
+jobs:
+  build-and-push-docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete huge unnecessary tools folder
+        run: rm -rf /opt/hostedtoolcache
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install TOML
+        run: pip install toml
+
+      - name: Get version from pyproject.toml
+        run: |
+          VERSION=$(python -c "import toml; print(toml.load('pyproject.toml')['tool']['poetry']['version'])")
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push Docker image for CPU
+        if: ${{ github.ref == 'refs/heads/main' }}
+        uses: docker/build-push-action@v5
+        with:
+          file: Dockerfile.cpu
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            beveradb/audio-separator:cpu-${{ env.VERSION }}
+            beveradb/audio-separator:cpu
+            beveradb/audio-separator:latest
+
+      - name: Build and push Docker image for CUDA 11 GPU
+        if: ${{ github.ref == 'refs/heads/main' }}
+        uses: docker/build-push-action@v5
+        with:
+          file: Dockerfile.cuda11
+          context: .
+          platforms: linux/amd64
+          push: true
+          tags: |
+            beveradb/audio-separator:gpu-${{ env.VERSION }}
+            beveradb/audio-separator:gpu
+
+      - name: Build and push Docker image for CUDA 12 GPU
+        if: ${{ github.ref == 'refs/heads/main' }}
+        uses: docker/build-push-action@v5
+        with:
+          file: Dockerfile.cuda12
+          context: .
+          platforms: linux/amd64
+          push: true
+          tags: |
+            beveradb/audio-separator:cuda12-${{ env.VERSION }}
+            beveradb/audio-separator:cuda12
+
+      # Deliberately commented out because Github CI can't build this runpod image due to disk space limits
+      # Instead, I build this (17GB) image locally and push it to Docker Hub manually.
+      # - name: Build and push Docker image for Runpod
+      #   if: ${{ github.ref == 'refs/heads/main' }}
+      #   uses: docker/build-push-action@v5
+      #   with:
+      #     file: Dockerfile.runpod
+      #     context: .
+      #     platforms: linux/amd64
+      #     push: true
+      #     tags: |
+      #       beveradb/audio-separator:runpod-${{ env.VERSION }}
+      #       beveradb/audio-separator:runpod

.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,25 @@
+name: publish-to-pypi
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - pyproject.toml
+  workflow_dispatch:
+
+jobs:
+  # Auto-publish when version is increased
+  publish-pypi:
+    # Only publish on `main` branch
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions: # Don't forget permissions
+      contents: write
+
+    steps:
+      - uses: etils-actions/pypi-auto-publish@v1
+        with:
+          pypi-token: ${{ secrets.PYPI_API_TOKEN }}
+          gh-token: ${{ secrets.GITHUB_TOKEN }}
+          parse-changelog: false

.github/workflows/run-integration-tests.yaml

@@ -0,0 +1,78 @@
+name: run-integration-tests
+
+on:
+  pull_request:
+
+jobs:
+  integration-test:
+    runs-on: self-hosted
+    env:
+      AUDIO_SEPARATOR_MODEL_DIR: ${{ github.workspace }}/models
+
+    steps:
+      - name: Checkout project
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+
+      - name: Install pipx
+        run: python -m pip install --user pipx && python -m pipx ensurepath
+
+      - name: Install poetry
+        run: python -m pipx install poetry
+
+      - name: Setup PATH
+        run: echo "/root/.local/bin" >> $GITHUB_PATH
+  
+      - name: Install system dependencies
+        run: |
+          apt-get update
+          apt-get install -y ffmpeg libsamplerate0 libsamplerate-dev
+  
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+          cache: poetry
+
+      - name: Create models directory
+        run: mkdir -p $AUDIO_SEPARATOR_MODEL_DIR
+
+      - name: Cache models directory
+        uses: actions/cache@v3
+        id: model-cache
+        with:
+          path: ${{ env.AUDIO_SEPARATOR_MODEL_DIR }}
+          key: model-cache-${{ hashFiles('tests/integration/test_cli_integration.py') }}
+          restore-keys: model-cache-
+
+      - name: Install Poetry dependencies
+        run: poetry install -E cpu
+
+      - name: Display model cache status
+        run: |
+          echo "Model cache hit: ${{ steps.model-cache.outputs.cache-hit == 'true' }}"
+          echo "Models directory contents:"
+          ls -la $AUDIO_SEPARATOR_MODEL_DIR || echo "Directory empty or doesn't exist"
+
+      - name: Run integration tests
+        run: poetry run pytest -sv --cov=audio_separator --cov-report=xml tests/integration
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-results
+          path: |
+            *.flac
+            tests/*.flac
+            **/temp_images/**/*.png
+            tests/**/temp_images/**/*.png

.github/workflows/run-unit-tests.yaml

@@ -0,0 +1,84 @@
+name: run-unit-tests
+
+on:
+  pull_request:
+
+jobs:
+  test-ubuntu:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout project
+        uses: actions/checkout@v4
+
+      - name: Install poetry
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: poetry # caching dependencies from poetry.lock
+
+      - name: Install Poetry dependencies (CPU)
+        run: poetry install -E cpu
+
+      - name: Run unit tests with coverage
+        run: poetry run pytest tests/unit
+
+  test-macos:
+    runs-on: macos-latest
+
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout project
+        uses: actions/checkout@v4
+
+      - name: Install poetry
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: poetry # caching dependencies from poetry.lock
+
+      - name: Install Poetry dependencies (CPU)
+        run: poetry install -E cpu
+
+      - name: Run unit tests with coverage
+        run: |
+          poetry run pytest tests/unit
+
+  test-windows:
+    runs-on: windows-latest
+
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout project
+        uses: actions/checkout@v4
+
+      - name: Install poetry
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: poetry # caching dependencies from poetry.lock
+
+      - name: Install Poetry dependencies (CPU)
+        run: poetry install -E cpu
+
+      - name: Run unit tests with coverage
+        run: poetry run pytest tests/unit

.gitignore

@@ -0,0 +1,177 @@
+# Andrew env
+.DS_Store
+.vscode
+
+# Andrew functional adds
+/tracks/
+/lyrics/
+/.cache/
+*.onnx
+*.pth
+*.wav
+/*.flac
+*.mp3
+tests/model-metrics/results
+tests/model-metrics/datasets
+temp_images
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 karaokenerds
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1,562 @@
----
-title: dgfsfxc-tgsacxs-otyhrhs
-emoji: 🎵
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 5.29.1
-app_file: app.py
-pinned: false
-short_description: ry46dgf35
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Audio Separator 🎶
+
+[![PyPI version](https://badge.fury.io/py/audio-separator.svg)](https://badge.fury.io/py/audio-separator)
+[![Conda Version](https://img.shields.io/conda/vn/conda-forge/audio-separator.svg)](https://anaconda.org/conda-forge/audio-separator)
+[![Docker pulls](https://img.shields.io/docker/pulls/beveradb/audio-separator.svg)](https://hub.docker.com/r/beveradb/audio-separator/tags)
+[![codecov](https://codecov.io/gh/karaokenerds/python-audio-separator/graph/badge.svg?token=N7YK4ET5JP)](https://codecov.io/gh/karaokenerds/python-audio-separator)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1gSlmSmna7f7fH6OjsiMEDLl-aJ9kGPkY?usp=sharing)
+[![Open In Huggingface](https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-sm.svg)](https://huggingface.co/spaces/theneos/audio-separator)
+
+**Summary:** Easy to use audio stem separation from the command line or as a dependency in your own Python project, using the amazing MDX-Net, VR Arch, Demucs and MDXC models available in UVR by @Anjok07 & @aufr33.
+
+Audio Separator is a Python package that allows you to separate an audio file into various stems, using models trained by @Anjok07 for use with [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui).
+
+The simplest (and probably most used) use case for this package is to separate an audio file into two stems, Instrumental and Vocals, which can be very useful for producing karaoke videos! However, the models available in UVR can separate audio into many more stems, such as Drums, Bass, Piano, and Guitar, and perform other audio processing tasks, such as denoising or removing echo/reverb.
+
+## Features
+
+- Separate audio into multiple stems, e.g. instrumental and vocals.
+- Supports all common audio formats (WAV, MP3, FLAC, M4A, etc.)
+- Ability to inference using a pre-trained model in PTH or ONNX format.
+- CLI support for easy use in scripts and batch processing.
+- Python API for integration into other projects.
+
+## Installation 🛠️
+
+### 🐳 Docker
+
+If you're able to use docker, you don't actually need to _install_ anything - there are [images published on Docker Hub](https://hub.docker.com/r/beveradb/audio-separator/tags) for GPU (CUDA) and CPU inferencing, for both `amd64` and `arm64` platforms.
+
+You probably want to volume-mount a folder containing whatever file you want to separate, which can then also be used as the output folder.
+
+For instance, if your current directory has the file `input.wav`, you could execute `audio-separator` as shown below (see [usage](#usage-) section for more details):
+
+```sh
+docker run -it -v `pwd`:/workdir beveradb/audio-separator input.wav
+```
+
+If you're using a machine with a GPU, you'll want to use the GPU specific image and pass in the GPU device to the container, like this:
+
+```sh
+docker run -it --gpus all -v `pwd`:/workdir beveradb/audio-separator:gpu input.wav
+```
+
+If the GPU isn't being detected, make sure your docker runtime environment is passing through the GPU correctly - there are [various guides](https://www.celantur.com/blog/run-cuda-in-docker-on-linux/) online to help with that.
+
+### 🎮 Nvidia GPU with CUDA or 🧪 Google Colab
+
+**Supported CUDA Versions:** 11.8 and 12.2
+
+💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
+ `ONNXruntime has CUDAExecutionProvider available, enabling acceleration`
+
+Conda:
+```sh
+conda install pytorch=*=*cuda* onnxruntime=*=*cuda* audio-separator -c pytorch -c conda-forge
+```
+
+Pip:
+```sh
+pip install "audio-separator[gpu]"
+```
+
+Docker:
+```sh
+beveradb/audio-separator:gpu
+```
+
+###  Apple Silicon, macOS Sonoma+ with M1 or newer CPU (CoreML acceleration)
+
+💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
+ `ONNXruntime has CoreMLExecutionProvider available, enabling acceleration`
+
+Pip:
+```sh
+pip install "audio-separator[cpu]"
+```
+
+### 🐢 No hardware acceleration, CPU only
+
+Conda:
+```sh
+conda install audio-separator-c pytorch -c conda-forge
+```
+
+Pip:
+```sh
+pip install "audio-separator[cpu]"
+```
+
+Docker:
+```sh
+beveradb/audio-separator
+```
+
+### 🎥 FFmpeg dependency
+
+💬 To test if `audio-separator` has been successfully configured to use FFmpeg, run `audio-separator --env_info`. The log will show `FFmpeg installed`.
+
+If you installed `audio-separator` using `conda` or `docker`, FFmpeg should already be available in your environment.
+
+You may need to separately install FFmpeg. It should be easy to install on most platforms, e.g.:
+
+🐧 Debian/Ubuntu:
+```sh
+apt-get update; apt-get install -y ffmpeg
+```
+
+ macOS:
+```sh
+brew update; brew install ffmpeg
+```
+
+## GPU / CUDA specific installation steps with Pip
+
+In theory, all you should need to do to get `audio-separator` working with a GPU is install it with the `[gpu]` extra as above.
+
+However, sometimes getting both PyTorch and ONNX Runtime working with CUDA support can be a bit tricky so it may not work that easily.
+
+You may need to reinstall both packages directly, allowing pip to calculate the right versions for your platform, for example:
+
+- `pip uninstall torch onnxruntime`
+- `pip cache purge`
+- `pip install --force-reinstall torch torchvision torchaudio`
+- `pip install --force-reinstall onnxruntime-gpu`
+
+I generally recommend installing the latest version of PyTorch for your environment using the command recommended by the wizard here:
+<https://pytorch.org/get-started/locally/>
+
+### Multiple CUDA library versions may be needed
+
+Depending on your CUDA version and environment, you may need to install specific version(s) of CUDA libraries for ONNX Runtime to use your GPU.
+
+🧪 Google Colab, for example, now uses CUDA 12 by default, but ONNX Runtime still needs CUDA 11 libraries to work.
+
+If you see the error `Failed to load library` or `cannot open shared object file` when you run `audio-separator`, this is likely the issue.
+
+You can install the CUDA 11 libraries _alongside_ CUDA 12 like so:
+```sh
+apt update; apt install nvidia-cuda-toolkit
+```
+
+If you encounter the following messages when running on Google Colab or in another environment:
+```
+[E:onnxruntime:Default, provider_bridge_ort.cc:1862 TryGetProviderInfo_CUDA] /onnxruntime_src/onnxruntime/core/session/provider_bridge_ort.cc:1539 onnxruntime::Provider& onnxruntime::ProviderLibrary::Get() [ONNXRuntimeError] : 1 : FAIL : Failed to load library libonnxruntime_providers_cuda.so with error: libcudnn_adv.so.9: cannot open shared object file: No such file or directory
+
+[W:onnxruntime:Default, onnxruntime_pybind_state.cc:993 CreateExecutionProviderInstance] Failed to create CUDAExecutionProvider. Require cuDNN 9.* and CUDA 12.*. Please install all dependencies as mentioned in the GPU requirements page (https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html#requirements), make sure they're in the PATH, and that your GPU is supported.
+```
+You can resolve this by running the following command:
+```sh
+python -m pip install ort-nightly-gpu --index-url=https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/ort-cuda-12-nightly/pypi/simple/
+```
+
+> Note: if anyone knows how to make this cleaner so we can support both different platform-specific dependencies for hardware acceleration without a separate installation process for each, please let me know or raise a PR!
+
+## Usage 🚀
+
+### Command Line Interface (CLI)
+
+You can use Audio Separator via the command line, for example:
+
+```sh
+audio-separator /path/to/your/input/audio.wav --model_filename UVR-MDX-NET-Inst_HQ_3.onnx
+```
+
+This command will download the specified model file, process the `audio.wav` input audio and generate two new files in the current directory, one containing vocals and one containing instrumental.
+
+**Note:** You do not need to download any files yourself - audio-separator does that automatically for you!
+
+To see a list of supported models, run `audio-separator --list_models`
+
+Any file listed in the list models output can be specified (with file extension) with the model_filename parameter (e.g. `--model_filename UVR_MDXNET_KARA_2.onnx`) and it will be automatically downloaded to the `--model_file_dir` (default: `/tmp/audio-separator-models/`) folder on first usage.
+
+### Listing and Filtering Available Models
+
+You can view all available models using the `--list_models` (or `-l`) flag:
+
+```sh
+audio-separator --list_models
+```
+
+The output shows a table with the following columns:
+- Model Filename: The filename to use with `--model_filename`
+- Arch: The model architecture (MDX, MDXC, Demucs, etc.)
+- Output Stems (SDR): The stems this model can separate, with Signal-to-Distortion Ratio scores where available
+- Friendly Name: A human-readable name describing the model
+
+#### Filtering Models
+
+You can filter and sort the model list by stem type using `--list_filter`. For example, to find models that can separate drums:
+
+```sh
+audio-separator -l --list_filter=drums
+```
+
+Example output:
+```
+-----------------------------------------------------------------------------------------------------------------------------------
+Model Filename        Arch    Output Stems (SDR)                                            Friendly Name
+-----------------------------------------------------------------------------------------------------------------------------------
+htdemucs_ft.yaml      Demucs  vocals (10.8), drums (10.1), bass (11.9), other               Demucs v4: htdemucs_ft
+hdemucs_mmi.yaml      Demucs  vocals (10.3), drums (9.7), bass (12.0), other                Demucs v4: hdemucs_mmi
+htdemucs.yaml         Demucs  vocals (10.0), drums (9.4), bass (11.3), other                Demucs v4: htdemucs
+htdemucs_6s.yaml      Demucs  vocals (9.7), drums (8.5), bass (10.0), guitar, piano, other  Demucs v4: htdemucs_6s
+```
+
+#### Limiting Results
+
+You can limit the number of results shown using `--list_limit`. This is useful for finding the best performing models for a particular stem. For example, to see the top 5 vocal separation models:
+
+```sh
+audio-separator -l --list_filter=vocals --list_limit=5
+```
+
+Example output:
+```
+--------------------------------------------------------------------------------------------------------------------------------------------------------------
+Model Filename                             Arch  Output Stems (SDR)                   Friendly Name
+--------------------------------------------------------------------------------------------------------------------------------------------------------------
+model_bs_roformer_ep_317_sdr_12.9755.ckpt  MDXC  vocals* (12.9), instrumental (17.0)  Roformer Model: BS-Roformer-Viperx-1297
+model_bs_roformer_ep_368_sdr_12.9628.ckpt  MDXC  vocals* (12.9), instrumental (17.0)  Roformer Model: BS-Roformer-Viperx-1296
+vocals_mel_band_roformer.ckpt              MDXC  vocals* (12.6), other                Roformer Model: MelBand Roformer | Vocals by Kimberley Jensen
+melband_roformer_big_beta4.ckpt            MDXC  vocals* (12.5), other                Roformer Model: MelBand Roformer Kim | Big Beta 4 FT by unwa
+mel_band_roformer_kim_ft_unwa.ckpt         MDXC  vocals* (12.4), other                Roformer Model: MelBand Roformer Kim | FT by unwa
+```
+
+#### JSON Output
+
+For programmatic use, you can output the model list in JSON format:
+
+```sh
+audio-separator -l --list_format=json
+```
+
+### Full command-line interface options
+
+```sh
+usage: audio-separator [-h] [-v] [-d] [-e] [-l] [--log_level LOG_LEVEL] [--list_filter LIST_FILTER] [--list_limit LIST_LIMIT] [--list_format {pretty,json}] [-m MODEL_FILENAME] [--output_format OUTPUT_FORMAT]
+                       [--output_bitrate OUTPUT_BITRATE] [--output_dir OUTPUT_DIR] [--model_file_dir MODEL_FILE_DIR] [--download_model_only] [--invert_spect] [--normalization NORMALIZATION]
+                       [--amplification AMPLIFICATION] [--single_stem SINGLE_STEM] [--sample_rate SAMPLE_RATE] [--use_soundfile] [--use_autocast] [--custom_output_names CUSTOM_OUTPUT_NAMES]
+                       [--mdx_segment_size MDX_SEGMENT_SIZE] [--mdx_overlap MDX_OVERLAP] [--mdx_batch_size MDX_BATCH_SIZE] [--mdx_hop_length MDX_HOP_LENGTH] [--mdx_enable_denoise] [--vr_batch_size VR_BATCH_SIZE]
+                       [--vr_window_size VR_WINDOW_SIZE] [--vr_aggression VR_AGGRESSION] [--vr_enable_tta] [--vr_high_end_process] [--vr_enable_post_process]
+                       [--vr_post_process_threshold VR_POST_PROCESS_THRESHOLD] [--demucs_segment_size DEMUCS_SEGMENT_SIZE] [--demucs_shifts DEMUCS_SHIFTS] [--demucs_overlap DEMUCS_OVERLAP]
+                       [--demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED] [--mdxc_segment_size MDXC_SEGMENT_SIZE] [--mdxc_override_model_segment_size] [--mdxc_overlap MDXC_OVERLAP]
+                       [--mdxc_batch_size MDXC_BATCH_SIZE] [--mdxc_pitch_shift MDXC_PITCH_SHIFT]
+                       [audio_files ...]
+
+Separate audio file into different stems.
+
+positional arguments:
+  audio_files                                            The audio file paths or directory to separate, in any common format.
+
+options:
+  -h, --help                                             show this help message and exit
+
+Info and Debugging:
+  -v, --version                                          Show the program's version number and exit.
+  -d, --debug                                            Enable debug logging, equivalent to --log_level=debug.
+  -e, --env_info                                         Print environment information and exit.
+  -l, --list_models                                      List all supported models and exit. Use --list_filter to filter/sort the list and --list_limit to show only top N results.
+  --log_level LOG_LEVEL                                  Log level, e.g. info, debug, warning (default: info).
+  --list_filter LIST_FILTER                              Filter and sort the model list by 'name', 'filename', or any stem e.g. vocals, instrumental, drums
+  --list_limit LIST_LIMIT                                Limit the number of models shown
+  --list_format {pretty,json}                            Format for listing models: 'pretty' for formatted output, 'json' for raw JSON dump
+
+Separation I/O Params:
+  -m MODEL_FILENAME, --model_filename MODEL_FILENAME     Model to use for separation (default: model_bs_roformer_ep_317_sdr_12.9755.yaml). Example: -m 2_HP-UVR.pth
+  --output_format OUTPUT_FORMAT                          Output format for separated files, any common format (default: FLAC). Example: --output_format=MP3
+  --output_bitrate OUTPUT_BITRATE                        Output bitrate for separated files, any ffmpeg-compatible bitrate (default: None). Example: --output_bitrate=320k
+  --output_dir OUTPUT_DIR                                Directory to write output files (default: <current dir>). Example: --output_dir=/app/separated
+  --model_file_dir MODEL_FILE_DIR                        Model files directory (default: /tmp/audio-separator-models/). Example: --model_file_dir=/app/models
+  --download_model_only                                  Download a single model file only, without performing separation.
+
+Common Separation Parameters:
+  --invert_spect                                         Invert secondary stem using spectrogram (default: False). Example: --invert_spect
+  --normalization NORMALIZATION                          Max peak amplitude to normalize input and output audio to (default: 0.9). Example: --normalization=0.7
+  --amplification AMPLIFICATION                          Min peak amplitude to amplify input and output audio to (default: 0.0). Example: --amplification=0.4
+  --single_stem SINGLE_STEM                              Output only single stem, e.g. Instrumental, Vocals, Drums, Bass, Guitar, Piano, Other. Example: --single_stem=Instrumental
+  --sample_rate SAMPLE_RATE                              Modify the sample rate of the output audio (default: 44100). Example: --sample_rate=44100
+  --use_soundfile                                        Use soundfile to write audio output (default: False). Example: --use_soundfile
+  --use_autocast                                         Use PyTorch autocast for faster inference (default: False). Do not use for CPU inference. Example: --use_autocast
+  --custom_output_names CUSTOM_OUTPUT_NAMES              Custom names for all output files in JSON format (default: None). Example: --custom_output_names='{"Vocals": "vocals_output", "Drums": "drums_output"}'
+
+MDX Architecture Parameters:
+  --mdx_segment_size MDX_SEGMENT_SIZE                    Larger consumes more resources, but may give better results (default: 256). Example: --mdx_segment_size=256
+  --mdx_overlap MDX_OVERLAP                              Amount of overlap between prediction windows, 0.001-0.999. Higher is better but slower (default: 0.25). Example: --mdx_overlap=0.25
+  --mdx_batch_size MDX_BATCH_SIZE                        Larger consumes more RAM but may process slightly faster (default: 1). Example: --mdx_batch_size=4
+  --mdx_hop_length MDX_HOP_LENGTH                        Usually called stride in neural networks, only change if you know what you're doing (default: 1024). Example: --mdx_hop_length=1024
+  --mdx_enable_denoise                                   Enable denoising during separation (default: False). Example: --mdx_enable_denoise
+
+VR Architecture Parameters:
+  --vr_batch_size VR_BATCH_SIZE                          Number of batches to process at a time. Higher = more RAM, slightly faster processing (default: 1). Example: --vr_batch_size=16
+  --vr_window_size VR_WINDOW_SIZE                        Balance quality and speed. 1024 = fast but lower, 320 = slower but better quality. (default: 512). Example: --vr_window_size=320
+  --vr_aggression VR_AGGRESSION                          Intensity of primary stem extraction, -100 - 100. Typically, 5 for vocals & instrumentals (default: 5). Example: --vr_aggression=2
+  --vr_enable_tta                                        Enable Test-Time-Augmentation; slow but improves quality (default: False). Example: --vr_enable_tta
+  --vr_high_end_process                                  Mirror the missing frequency range of the output (default: False). Example: --vr_high_end_process
+  --vr_enable_post_process                               Identify leftover artifacts within vocal output; may improve separation for some songs (default: False). Example: --vr_enable_post_process
+  --vr_post_process_threshold VR_POST_PROCESS_THRESHOLD  Threshold for post_process feature: 0.1-0.3 (default: 0.2). Example: --vr_post_process_threshold=0.1
+
+Demucs Architecture Parameters:
+  --demucs_segment_size DEMUCS_SEGMENT_SIZE              Size of segments into which the audio is split, 1-100. Higher = slower but better quality (default: Default). Example: --demucs_segment_size=256
+  --demucs_shifts DEMUCS_SHIFTS                          Number of predictions with random shifts, higher = slower but better quality (default: 2). Example: --demucs_shifts=4
+  --demucs_overlap DEMUCS_OVERLAP                        Overlap between prediction windows, 0.001-0.999. Higher = slower but better quality (default: 0.25). Example: --demucs_overlap=0.25
+  --demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED      Enable segment-wise processing (default: True). Example: --demucs_segments_enabled=False
+
+MDXC Architecture Parameters:
+  --mdxc_segment_size MDXC_SEGMENT_SIZE                  Larger consumes more resources, but may give better results (default: 256). Example: --mdxc_segment_size=256
+  --mdxc_override_model_segment_size                     Override model default segment size instead of using the model default value. Example: --mdxc_override_model_segment_size
+  --mdxc_overlap MDXC_OVERLAP                            Amount of overlap between prediction windows, 2-50. Higher is better but slower (default: 8). Example: --mdxc_overlap=8
+  --mdxc_batch_size MDXC_BATCH_SIZE                      Larger consumes more RAM but may process slightly faster (default: 1). Example: --mdxc_batch_size=4
+  --mdxc_pitch_shift MDXC_PITCH_SHIFT                    Shift audio pitch by a number of semitones while processing. May improve output for deep/high vocals. (default: 0). Example: --mdxc_pitch_shift=2
+```
+
+### As a Dependency in a Python Project
+
+You can use Audio Separator in your own Python project. Here's a minimal example using the default two stem (Instrumental and Vocals) model:
+
+```python
+from audio_separator.separator import Separator
+
+# Initialize the Separator class (with optional configuration properties, below)
+separator = Separator()
+
+# Load a machine learning model (if unspecified, defaults to 'model_mel_band_roformer_ep_3005_sdr_11.4360.ckpt')
+separator.load_model()
+
+# Perform the separation on specific audio files without reloading the model
+output_files = separator.separate('audio1.wav')
+
+print(f"Separation complete! Output file(s): {' '.join(output_files)}")
+```
+
+#### Batch processing and processing with multiple models
+
+You can process multiple files without reloading the model to save time and memory.
+
+You only need to load a model when choosing or changing models. See example below:
+
+```python
+from audio_separator.separator import Separator
+
+# Initialize the Separator class (with optional configuration properties, below)
+separator = Separator()
+
+# Load a model
+separator.load_model(model_filename='UVR-MDX-NET-Inst_HQ_3.onnx')
+
+# Separate multiple audio files without reloading the model
+output_files = separator.separate(['audio1.wav', 'audio2.wav', 'audio3.wav'])
+
+# Load a different model
+separator.load_model(model_filename='UVR_MDXNET_KARA_2.onnx')
+
+# Separate the same files with the new model
+output_files = separator.separate(['audio1.wav', 'audio2.wav', 'audio3.wav'])
+```
+
+You can also specify the path to a folder containing audio files instead of listing the full paths to each of them:
+```python
+from audio_separator.separator import Separator
+
+# Initialize the Separator class (with optional configuration properties, below)
+separator = Separator()
+
+# Load a model
+separator.load_model(model_filename='UVR-MDX-NET-Inst_HQ_3.onnx')
+
+# Separate all audio files located in a folder
+output_files = separator.separate('path/to/audio_directory')
+```
+
+#### Renaming Stems
+
+You can rename the output files by specifying the desired names. For example:
+```python
+output_names = {
+    "Vocals": "vocals_output",
+    "Instrumental": "instrumental_output",
+}
+output_files = separator.separate('audio1.wav', output_names)
+```
+In this case, the output file names will be: `vocals_output.wav` and `instrumental_output.wav`.
+
+You can also rename specific stems:
+
+- To rename the Vocals stem:
+  ```python
+  output_names = {
+      "Vocals": "vocals_output",
+  }
+  output_files = separator.separate('audio1.wav', output_names)
+  ```
+  > The output files will be named: `vocals_output.wav` and `audio1_(Instrumental)_model_mel_band_roformer_ep_3005_sdr_11.wav`
+- To rename the Instrumental stem:
+  ```python
+  output_names = {
+      "Instrumental": "instrumental_output",
+  }
+  output_files = separator.separate('audio1.wav', output_names)
+  ```
+  > The output files will be named: `audio1_(Vocals)_model_mel_band_roformer_ep_3005_sdr_11.wav` and `instrumental_output.wav`
+- List of stems for Demucs models:
+  - htdemucs_6s.yaml
+    ```python
+    output_names = {
+        "Vocals": "vocals_output",
+        "Drums": "drums_output",
+        "Bass": "bass_output",
+        "Other": "other_output",
+        "Guitar": "guitar_output",
+        "Piano": "piano_output",
+    }
+    ```
+  - Other Demucs models
+    ```python
+    output_names = {
+        "Vocals": "vocals_output",
+        "Drums": "drums_output",
+        "Bass": "bass_output",
+        "Other": "other_output",
+    }
+    ```
+
+## Parameters for the Separator class
+
+- **`log_level`:** (Optional) Logging level, e.g., INFO, DEBUG, WARNING. `Default: logging.INFO`
+- **`log_formatter`:** (Optional) The log format. Default: None, which falls back to '%(asctime)s - %(levelname)s - %(module)s - %(message)s'
+- **`model_file_dir`:** (Optional) Directory to cache model files in. `Default: /tmp/audio-separator-models/`
+- **`output_dir`:** (Optional) Directory where the separated files will be saved. If not specified, uses the current directory.
+- **`output_format`:** (Optional) Format to encode output files, any common format (WAV, MP3, FLAC, M4A, etc.). `Default: WAV`
+- **`normalization_threshold`:** (Optional) The amount by which the amplitude of the output audio will be multiplied. `Default: 0.9`
+- **`amplification_threshold`:** (Optional) The minimum amplitude level at which the waveform will be amplified. If the peak amplitude of the audio is below this threshold, the waveform will be scaled up to meet it. `Default: 0.0`
+- **`output_single_stem`:** (Optional) Output only a single stem, such as 'Instrumental' and 'Vocals'. `Default: None`
+- **`invert_using_spec`:** (Optional) Flag to invert using spectrogram. `Default: False`
+- **`sample_rate`:** (Optional) Set the sample rate of the output audio. `Default: 44100`
+- **`use_soundfile`:** (Optional) Use soundfile for output writing, can solve OOM issues, especially on longer audio.
+- **`use_autocast`:** (Optional) Flag to use PyTorch autocast for faster inference. Do not use for CPU inference. `Default: False`
+- **`mdx_params`:** (Optional) MDX Architecture Specific Attributes & Defaults. `Default: {"hop_length": 1024, "segment_size": 256, "overlap": 0.25, "batch_size": 1, "enable_denoise": False}`
+- **`vr_params`:** (Optional) VR Architecture Specific Attributes & Defaults. `Default: {"batch_size": 1, "window_size": 512, "aggression": 5, "enable_tta": False, "enable_post_process": False, "post_process_threshold": 0.2, "high_end_process": False}`
+- **`demucs_params`:** (Optional) Demucs Architecture Specific Attributes & Defaults. `Default: {"segment_size": "Default", "shifts": 2, "overlap": 0.25, "segments_enabled": True}`
+- **`mdxc_params`:** (Optional) MDXC Architecture Specific Attributes & Defaults. `Default: {"segment_size": 256, "override_model_segment_size": False, "batch_size": 1, "overlap": 8, "pitch_shift": 0}`
+
+## Requirements 📋
+
+Python >= 3.10
+
+Libraries: torch, onnx, onnxruntime, numpy, librosa, requests, six, tqdm, pydub
+
+## Developing Locally
+
+This project uses Poetry for dependency management and packaging. Follow these steps to setup a local development environment:
+
+### Prerequisites
+
+- Make sure you have Python 3.10 or newer installed on your machine.
+- Install Conda (I recommend Miniforge: [Miniforge GitHub](https://github.com/conda-forge/miniforge)) to manage your Python virtual environments
+
+### Clone the Repository
+
+Clone the repository to your local machine:
+
+```sh
+git clone https://github.com/YOUR_USERNAME/audio-separator.git
+cd audio-separator
+```
+
+Replace `YOUR_USERNAME` with your GitHub username if you've forked the repository, or use the main repository URL if you have the permissions.
+
+### Create and activate the Conda Environment
+
+To create and activate the conda environment, use the following commands:
+
+```sh
+conda env create
+conda activate audio-separator-dev
+```
+
+### Install Dependencies
+
+Once you're inside the conda env, run the following command to install the project dependencies:
+
+```sh
+poetry install
+```
+
+Install extra dependencies depending if you're running with GPU or CPU.
+```sh
+poetry install --extras "cpu"
+```
+or
+```sh
+poetry install --extras "gpu"
+```
+or
+```sh
+poetry install --extras "dml"
+```
+
+### Running the Command-Line Interface Locally
+
+You can run the CLI command directly within the virtual environment. For example:
+
+```sh
+audio-separator path/to/your/audio-file.wav
+```
+
+### Deactivate the Virtual Environment
+
+Once you are done with your development work, you can exit the virtual environment by simply typing:
+
+```sh
+conda deactivate
+```
+
+### Building the Package
+
+To build the package for distribution, use the following command:
+
+```sh
+poetry build
+```
+
+This will generate the distribution packages in the dist directory - but for now only @beveradb will be able to publish to PyPI.
+
+
+
+
+## Contributing 🤝
+
+Contributions are very much welcome! Please fork the repository and submit a pull request with your changes, and I'll try to review, merge and publish promptly!
+
+- This project is 100% open-source and free for anyone to use and modify as they wish.
+- If the maintenance workload for this repo somehow becomes too much for me I'll ask for volunteers to share maintainership of the repo, though I don't think that is very likely
+- Development and support for the MDX-Net separation models is part of the main [UVR project](https://github.com/Anjok07/ultimatevocalremovergui), this repo is just a CLI/Python package wrapper to simplify running those models programmatically. So, if you want to try and improve the actual models, please get involved in the UVR project and look for guidance there!
+
+## License 📄
+
+This project is licensed under the MIT [License](LICENSE).
+
+- **Please Note:** If you choose to integrate this project into some other project using the default model or any other model trained as part of the [UVR](https://github.com/Anjok07/ultimatevocalremovergui) project, please honor the MIT license by providing credit to UVR and its developers!
+
+## Credits 🙏
+
+- [Anjok07](https://github.com/Anjok07) - Author of [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui), which almost all of the code in this repo was copied from! Definitely deserving of credit for anything good from this project. Thank you!
+- [DilanBoskan](https://github.com/DilanBoskan) - Your contributions at the start of this project were essential to the success of UVR. Thank you!
+- [Kuielab & Woosung Choi](https://github.com/kuielab) - Developed the original MDX-Net AI code.
+- [KimberleyJSN](https://github.com/KimberleyJensen) - Advised and aided the implementation of the training scripts for MDX-Net and Demucs. Thank you!
+- [Hv](https://github.com/NaJeongMo/Colab-for-MDX_B) - Helped implement chunks into the MDX-Net AI code. Thank you!
+- [zhzhongshi](https://github.com/zhzhongshi) - Helped add support for the MDXC models in `audio-separator`. Thank you!
+
+## Contact 💌
+
+For questions or feedback, please raise an issue or reach out to @beveradb ([Andrew Beveridge](mailto:[email protected])) directly.
+
+## Sponsors
+
+<!-- sponsors --><!-- sponsors -->
+
+## Thanks to all contributors for their efforts
+
+<a href="https://github.com/nomadkaraoke/python-audio-separator/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=nomadkaraoke/python-audio-separator" />
+</a>

TODO.md

@@ -0,0 +1,20 @@
+# Audio-Separator TO-DO list
+
+If you see something here, Andrew is aware it needs to be done, and he will hopefully get to it soon but can't make any promises!
+This isn't his full time job, and he's doing his best to keep up with everything.
+
+If you'd like something to be done sooner, please consider trying to work on it yourself and submitting a pull request!
+If you don't know how to code, please consider learning - it's free, and anyone can do it! https://www.freecodecamp.org/learn/scientific-computing-with-python/
+
+## TODO:
+
+- Add unit tests to all uvr lib functions to ensure no obvious errors are missed
+- Add end-to-end tests which download all models and test separation with a very short input file for speed
+- Add ability for user to download all models ahead of time
+- Add tests for Windows, Linux and macOS separately
+- Add tests for Python 3.10, 3.11
+- Add support for MDXC models
+- Add support for Demucs models
+- Add support for Ensemble mode
+- Add support for Chaining multiple models
+- Add support for Splitting multiple stems from a single input file by running different models

audio_separator/separator/separator.py

@@ -956,4 +956,4 @@ class Separator:
 
                 return dict(sorted(filtered_list.items(), key=sort_key, reverse=True))
 
-        return simplified_list
+        return simplified_list

ensemble.py

@@ -5,27 +5,23 @@ import os
 import librosa
 import soundfile as sf
 import numpy as np
-import argparse
-import logging
+import argparse  # Add this line
 import gc
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 def stft(wave, nfft, hl):
-    wave_left = np.ascontiguousarray(wave[0])
-    wave_right = np.ascontiguousarray(wave[1])
-    spec_left = librosa.stft(wave_left, n_fft=nfft, hop_length=hl)
-    spec_right = librosa.stft(wave_right, n_fft=nfft, hop_length=hl)
-    spec = np.stack([spec_left, spec_right])
+    wave_left = np.asfortranarray(wave[0])
+    wave_right = np.asfortranarray(wave[1])
+    spec_left = librosa.stft(wave_left, n_fft=nfft, hop_length=hl, window='hann')
+    spec_right = librosa.stft(wave_right, n_fft=nfft, hop_length=hl, window='hann')
+    spec = np.asfortranarray([spec_left, spec_right])
     return spec
 
 def istft(spec, hl, length):
-    spec_left = np.ascontiguousarray(spec[0])
-    spec_right = np.ascontiguousarray(spec[1])
-    wave_left = librosa.istft(spec_left, hop_length=hl, length=length)
-    wave_right = librosa.istft(spec_right, hop_length=hl, length=length)
-    wave = np.stack([wave_left, wave_right])
+    spec_left = np.asfortranarray(spec[0])
+    spec_right = np.asfortranarray(spec[1])
+    wave_left = librosa.istft(spec_left, hop_length=hl, length=length, window='hann')
+    wave_right = librosa.istft(spec_right, hop_length=hl, length=length, window='hann')
+    wave = np.asfortranarray([wave_left, wave_right])
     return wave
 
 def absmax(a, *, axis):
@@ -68,17 +64,11 @@ def lambda_min(arr, axis=None, key=None, keepdims=False):
     else:
         return arr.flatten()[idxs]
 
-def average_waveforms(pred_track, weights, algorithm):
-    """
-    :param pred_track: shape = (num, channels, length)
-    :param weights: shape = (num, )
-    :param algorithm: One of avg_wave, median_wave, min_wave, max_wave, avg_fft, median_fft, min_fft, max_fft
-    :return: averaged waveform in shape (channels, length)
-    """
-    pred_track = np.asarray(pred_track)  # NumPy 2.0+ compatibility
-    final_length = pred_track.shape[-1]
-
+def average_waveforms(pred_track, weights, algorithm, chunk_length):
+    pred_track = np.array(pred_track)
+    pred_track = np.array([p[:, :chunk_length] if p.shape[1] > chunk_length else np.pad(p, ((0, 0), (0, chunk_length - p.shape[1])), 'constant') for p in pred_track])
     mod_track = []
+    
     for i in range(pred_track.shape[0]):
         if algorithm == 'avg_wave':
             mod_track.append(pred_track[i] * weights[i])
@@ -90,87 +80,113 @@ def average_waveforms(pred_track, weights, algorithm):
                 mod_track.append(spec * weights[i])
             else:
                 mod_track.append(spec)
-            del spec
-            gc.collect()
-    mod_track = np.asarray(mod_track)  # NumPy 2.0+ compatibility
+    pred_track = np.array(mod_track)
 
     if algorithm == 'avg_wave':
-        result = mod_track.sum(axis=0) / np.sum(weights)
+        pred_track = pred_track.sum(axis=0)
+        pred_track /= np.array(weights).sum()
     elif algorithm == 'median_wave':
-        result = np.median(mod_track, axis=0)
+        pred_track = np.median(pred_track, axis=0)
     elif algorithm == 'min_wave':
-        result = lambda_min(mod_track, axis=0, key=np.abs)
+        pred_track = lambda_min(pred_track, axis=0, key=np.abs)
     elif algorithm == 'max_wave':
-        result = lambda_max(mod_track, axis=0, key=np.abs)
+        pred_track = lambda_max(pred_track, axis=0, key=np.abs)
     elif algorithm == 'avg_fft':
-        result = mod_track.sum(axis=0) / np.sum(weights)
-        result = istft(result, 1024, final_length)
+        pred_track = pred_track.sum(axis=0)
+        pred_track /= np.array(weights).sum()
+        pred_track = istft(pred_track, 1024, chunk_length)
     elif algorithm == 'min_fft':
-        result = lambda_min(mod_track, axis=0, key=np.abs)
-        result = istft(result, 1024, final_length)
+        pred_track = lambda_min(pred_track, axis=0, key=np.abs)
+        pred_track = istft(pred_track, 1024, chunk_length)
     elif algorithm == 'max_fft':
-        result = absmax(mod_track, axis=0)
-        result = istft(result, 1024, final_length)
+        pred_track = absmax(pred_track, axis=0)
+        pred_track = istft(pred_track, 1024, chunk_length)
     elif algorithm == 'median_fft':
-        result = np.median(mod_track, axis=0)
-        result = istft(result, 1024, final_length)
-    
-    gc.collect()
-    return result
+        pred_track = np.median(pred_track, axis=0)
+        pred_track = istft(pred_track, 1024, chunk_length)
+
+    return pred_track
 
 def ensemble_files(args):
-    parser = argparse.ArgumentParser(description="Ensemble audio files")
-    parser.add_argument('--files', nargs='+', required=True, help="Input audio files")
-    parser.add_argument('--type', required=True, choices=['avg_wave', 'median_wave', 'max_wave', 'min_wave', 'avg_fft', 'median_fft', 'max_fft', 'min_fft'], help="Ensemble type")
-    parser.add_argument('--weights', nargs='+', type=float, default=None, help="Weights for each file")
-    parser.add_argument('--output', required=True, help="Output file path")
-    
-    args = parser.parse_args(args) if isinstance(args, list) else args
-    
-    logger.info(f"Ensemble type: {args.type}")
-    logger.info(f"Number of input files: {len(args.files)}")
-    weights = args.weights if args.weights else [1.0] * len(args.files)
-    if len(weights) != len(args.files):
-        logger.error("Number of weights must match number of audio files")
-        raise ValueError("Number of weights must match number of audio files")
-    logger.info(f"Weights: {weights}")
-    logger.info(f"Output file: {args.output}")
-    
-    data = []
-    sr = None
-    for f in args.files:
-        if not os.path.isfile(f):
-            logger.error(f"Cannot find file: {f}")
-            raise FileNotFoundError(f"Cannot find file: {f}")
-        logger.info(f"Reading file: {f}")
-        try:
-            wav, curr_sr = librosa.load(f, sr=None, mono=False)
-            if sr is None:
-                sr = curr_sr
-            elif sr != curr_sr:
-                logger.error("All audio files must have the same sample rate")
-                raise ValueError("All audio files must have the same sample rate")
-            logger.info(f"Waveform shape: {wav.shape} sample rate: {sr}")
-            data.append(wav)
-            del wav
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--files", type=str, required=True, nargs='+', help="Path to all audio-files to ensemble")
+    parser.add_argument("--type", type=str, default='avg_wave', help="One of avg_wave, median_wave, min_wave, max_wave, avg_fft, median_fft, min_fft, max_fft")
+    parser.add_argument("--weights", type=float, nargs='+', help="Weights to create ensemble. Number of weights must be equal to number of files")
+    parser.add_argument("--output", default="res.wav", type=str, help="Path to wav file where ensemble result will be stored")
+    if args is None:
+        args = parser.parse_args()
+    else:
+        args = parser.parse_args(args)
+
+    print('Ensemble type: {}'.format(args.type))
+    print('Number of input files: {}'.format(len(args.files)))
+    if args.weights is not None:
+        weights = np.array(args.weights)
+    else:
+        weights = np.ones(len(args.files))
+    print('Weights: {}'.format(weights))
+    print('Output file: {}'.format(args.output))
+
+    durations = [librosa.get_duration(filename=f) for f in args.files]
+    if not all(d == durations[0] for d in durations):
+        raise ValueError("All files must have the same duration")
+
+    total_duration = durations[0]
+    sr = librosa.get_samplerate(args.files[0])
+    chunk_duration = 30  # 30-second chunks
+    overlap_duration = 0.1  # 100 ms overlap
+    chunk_samples = int(chunk_duration * sr)
+    overlap_samples = int(overlap_duration * sr)
+    step_samples = chunk_samples - overlap_samples  # Step size reduced by overlap
+    total_samples = int(total_duration * sr)
+
+    # Align chunk length with hop_length
+    hop_length = 1024
+    chunk_samples = ((chunk_samples + hop_length - 1) // hop_length) * hop_length
+    step_samples = chunk_samples - overlap_samples
+
+    prev_chunk_tail = None  # To store the tail of the previous chunk for crossfading
+
+    with sf.SoundFile(args.output, 'w', sr, channels=2, subtype='FLOAT') as outfile:
+        for start in range(0, total_samples, step_samples):
+            end = min(start + chunk_samples, total_samples)
+            chunk_length = end - start
+            data = []
+
+            for f in args.files:
+                if not os.path.isfile(f):
+                    print('Error. Can\'t find file: {}. Check paths.'.format(f))
+                    exit()
+                # print(f'Reading chunk from file: {f} (start: {start/sr}s, duration: {(end-start)/sr}s)')
+                wav, _ = librosa.load(f, sr=sr, mono=False, offset=start/sr, duration=(end-start)/sr)
+                data.append(wav)
+
+            res = average_waveforms(data, weights, args.type, chunk_length)
+            res = res.astype(np.float32)
+            #print(f'Chunk result shape: {res.shape}')
+
+            # Crossfade with the previous chunk's tail
+            if start > 0 and prev_chunk_tail is not None:
+                new_data = res[:, :overlap_samples]
+                fade_out = np.linspace(1, 0, overlap_samples)
+                fade_in = np.linspace(0, 1, overlap_samples)
+                blended = prev_chunk_tail * fade_out + new_data * fade_in
+                outfile.write(blended.T)
+                outfile.write(res[:, overlap_samples:].T)
+            else:
+                outfile.write(res.T)
+
+            # Store the tail of the current chunk for the next iteration
+            if chunk_length > overlap_samples:
+                prev_chunk_tail = res[:, -overlap_samples:]
+            else:
+                prev_chunk_tail = res[:, :]
+
+            del data
+            del res
             gc.collect()
-        except Exception as e:
-            logger.error(f"Error reading audio file {f}: {str(e)}")
-            raise RuntimeError(f"Error reading audio file {f}: {str(e)}")
-    
-    try:
-        data = np.asarray(data)  # NumPy 2.0+ compatibility
-        res = average_waveforms(data, weights, args.type)
-        logger.info(f"Result shape: {res.shape}")
-        os.makedirs(os.path.dirname(args.output), exist_ok=True)
-        sf.write(args.output, res.T, sr, 'FLOAT')
-        logger.info(f"Output written to: {args.output}")
-        return args.output
-    except Exception as e:
-        logger.error(f"Error during ensemble processing: {str(e)}")
-        raise RuntimeError(f"Error during ensemble processing: {str(e)}")
-    finally:
-        gc.collect()
+
+    print(f'Ensemble completed. Output saved to: {args.output}')
 
 if __name__ == "__main__":
-    ensemble_files(sys.argv[1:])
+    ensemble_files(None)

models/te.txt

@@ -0,0 +1 @@
+

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "audio-separator"
-version = "0.33.0"
+version = "0.34.0"
 description = "Easy to use audio stem separation, using various models from UVR trained primarily by @Anjok07"
 authors = ["Andrew Beveridge <[email protected]>"]
 license = "MIT"

requirements.txt

@@ -1,9 +1,8 @@
-audio-separator[gpu]==0.34.0
-gradio==4.44.0
+audio-separator[gpu]==0.33.0
+scipy
+gradio
 yt_dlp
 pypresence
+youtube_dl
 validators
 matchering==2.0.6
-spaces
-gdown
-scipy