├── .github
    └── workflows
    │   └── publish-to-pypi.yml
├── .gitignore
├── LICENSE
├── README.md
├── dasp_pytorch
    ├── __init__.py
    ├── functional.py
    ├── modules.py
    └── signal.py
├── docs
    ├── assets
    │   ├── box.svg
    │   ├── code-slash.svg
    │   ├── dasp-no-bg.png
    │   ├── gear.svg
    │   ├── gpu-card.svg
    │   └── logos
    │   │   ├── aim.png
    │   │   ├── qm.png
    │   │   └── ukri.png
    ├── cover.css
    └── index.html
├── examples
    ├── auto_eq.py
    ├── blind_estimation.py
    ├── demo.py
    ├── quickstart.ipynb
    ├── reverse_eng.py
    ├── style_transfer.py
    └── virtual_analog.py
├── pyproject.toml
└── setup.py


/.github/workflows/publish-to-pypi.yml:
--------------------------------------------------------------------------------
  1 | name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
  2 | 
  3 | on: push
  4 | 
  5 | jobs:
  6 |   build:
  7 |     name: Build distribution 📦
  8 |     runs-on: ubuntu-latest
  9 | 
 10 |     steps:
 11 |     - uses: actions/checkout@v4
 12 |     - name: Set up Python
 13 |       uses: actions/setup-python@v4
 14 |       with:
 15 |         python-version: "3.x"
 16 |     - name: Install pypa/build
 17 |       run: >-
 18 |         python3 -m
 19 |         pip install
 20 |         build
 21 |         --user
 22 |     - name: Build a binary wheel and a source tarball
 23 |       run: python3 -m build
 24 |     - name: Store the distribution packages
 25 |       uses: actions/upload-artifact@v3
 26 |       with:
 27 |         name: python-package-distributions
 28 |         path: dist/
 29 | 
 30 |   publish-to-pypi:
 31 |     name: >-
 32 |       Publish Python 🐍 distribution 📦 to PyPI
 33 |     if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
 34 |     needs:
 35 |     - build
 36 |     runs-on: ubuntu-latest
 37 |     environment:
 38 |       name: pypi
 39 |       url: https://pypi.org/p/dasp-pytorch  # Replace <package-name> with your PyPI project name
 40 |     permissions:
 41 |       id-token: write  # IMPORTANT: mandatory for trusted publishing
 42 | 
 43 |     steps:
 44 |     - name: Download all the dists
 45 |       uses: actions/download-artifact@v3
 46 |       with:
 47 |         name: python-package-distributions
 48 |         path: dist/
 49 |     - name: Publish distribution 📦 to PyPI
 50 |       uses: pypa/gh-action-pypi-publish@release/v1
 51 | 
 52 |   github-release:
 53 |     name: >-
 54 |       Sign the Python 🐍 distribution 📦 with Sigstore
 55 |       and upload them to GitHub Release
 56 |     needs:
 57 |     - publish-to-pypi
 58 |     runs-on: ubuntu-latest
 59 | 
 60 |     permissions:
 61 |       contents: write  # IMPORTANT: mandatory for making GitHub Releases
 62 |       id-token: write  # IMPORTANT: mandatory for sigstore
 63 | 
 64 |     steps:
 65 |     - name: Download all the dists
 66 |       uses: actions/download-artifact@v3
 67 |       with:
 68 |         name: python-package-distributions
 69 |         path: dist/
 70 |     - name: Sign the dists with Sigstore
 71 |       uses: sigstore/gh-action-sigstore-python@v1.2.3
 72 |       with:
 73 |         inputs: >-
 74 |           ./dist/*.tar.gz
 75 |           ./dist/*.whl
 76 |     - name: Create GitHub Release
 77 |       env:
 78 |         GITHUB_TOKEN: ${{ github.token }}
 79 |       run: >-
 80 |         gh release create
 81 |         '${{ github.ref_name }}'
 82 |         --repo '${{ github.repository }}'
 83 |         --notes ""
 84 |     - name: Upload artifact signatures to GitHub Release
 85 |       env:
 86 |         GITHUB_TOKEN: ${{ github.token }}
 87 |       # Upload to GitHub Release using the `gh` CLI.
 88 |       # `dist/` contains the built packages, and the
 89 |       # sigstore-produced signatures and certificates.
 90 |       run: >-
 91 |         gh release upload
 92 |         '${{ github.ref_name }}' dist/**
 93 |         --repo '${{ github.repository }}'
 94 | 
 95 |   publish-to-testpypi:
 96 |     name: Publish Python 🐍 distribution 📦 to TestPyPI
 97 |     needs:
 98 |     - build
 99 |     runs-on: ubuntu-latest
100 | 
101 |     environment:
102 |       name: testpypi
103 |       url: https://test.pypi.org/p/dasp-pytorch
104 | 
105 |     permissions:
106 |       id-token: write  # IMPORTANT: mandatory for trusted publishing
107 | 
108 |     steps:
109 |     - name: Download all the dists
110 |       uses: actions/download-artifact@v3
111 |       with:
112 |         name: python-package-distributions
113 |         path: dist/
114 |     - name: Publish distribution 📦 to TestPyPI
115 |       uses: pypa/gh-action-pypi-publish@release/v1
116 |       with:
117 |         repository-url: https://test.pypi.org/legacy/


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | *.py,cover
 51 | .hypothesis/
 52 | .pytest_cache/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | target/
 76 | 
 77 | # Jupyter Notebook
 78 | .ipynb_checkpoints
 79 | 
 80 | # IPython
 81 | profile_default/
 82 | ipython_config.py
 83 | 
 84 | # pyenv
 85 | .python-version
 86 | 
 87 | # pipenv
 88 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 89 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 90 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 91 | #   install all needed dependencies.
 92 | #Pipfile.lock
 93 | 
 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 95 | __pypackages__/
 96 | 
 97 | # Celery stuff
 98 | celerybeat-schedule
 99 | celerybeat.pid
100 | 
101 | # SageMath parsed files
102 | *.sage.py
103 | 
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 | 
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 | 
117 | # Rope project settings
118 | .ropeproject
119 | 
120 | # mkdocs documentation
121 | /site
122 | 
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 | 
128 | # Pyre type checker
129 | .pyre/
130 | 
131 | data/
132 | audio/
133 | logs/
134 | outputs/
135 | .vscode


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 | 
  3 | <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/dasp-no-bg.png" width="200px">
  4 | 
  5 | # dasp
  6 | 
  7 | <i> Differentiable audio signal processors in PyTorch </i>
  8 | 
  9 | </div>
 10 | 
 11 | <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/box.svg" width="30px"> &nbsp; Includes reverberation, distortion, dynamic range processing, equalization, stereo processing.
 12 | 
 13 | <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/gear.svg" width="30px"> &nbsp; Enables virtual analog modeling, blind parameter estimation, automated DSP, and style transfer.
 14 | 
 15 | <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/gpu-card.svg" width="30px"> &nbsp; Batching with operation on both CPU and GPU accelerators for fast training and reduced bottlenecks.
 16 | 
 17 | <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/code-slash.svg" width="30px"> &nbsp; Open source and free to use for academic and commercial applications under Apache 2.0 license.
 18 | 
 19 | ## Installation 
 20 | 
 21 | ```
 22 | pip install dasp-pytorch
 23 | ```
 24 | 
 25 | Or, for a local installation.
 26 | 
 27 | ```
 28 | git clone https://github.com/csteinmetz1/dasp-pytorch
 29 | cd dasp-pytorch
 30 | pip install -e .
 31 | ```
 32 | 
 33 | ## Examples
 34 | 
 35 | `dasp-pytorch` is a Python library for constructing differentiable audio signal processors using PyTorch. 
 36 | These differentiable processors can be used standalone or within the computation graph of neural networks. 
 37 | We provide purely functional interfaces for all processors that enable ease-of-use and portability across projects. 
 38 | Unless oterhwise stated, all effect functions expect 3-dim tensors with shape `(batch_size, num_channels, num_samples)` as input and output. 
 39 | Using an effect in your computation graph is as simple as calling the function with the input tensor as argument. 
 40 | 
 41 | ### Quickstart
 42 | 
 43 | Here is a minimal example to demonstrate reverse engineering the drive value of a simple distortion effect using gradient descent. 
 44 | 
 45 | Try it for yourself: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/csteinmetz1/dasp-pytorch/blob/main/examples/quickstart.ipynb)
 46 | 
 47 | ```python
 48 | import torch
 49 | import torchaudio
 50 | import dasp_pytorch
 51 | 
 52 | # Load audio
 53 | x, sr = torchaudio.load("audio/short_riff.wav")
 54 | 
 55 | # create batch dim
 56 | # (batch_size, n_channels, n_samples)
 57 | x = x.unsqueeze(0)
 58 | 
 59 | # apply some distortion with 16 dB drive
 60 | drive = torch.tensor([16.0])
 61 | y = dasp_pytorch.functional.distortion(x, sr, drive)
 62 | 
 63 | # create a parameter to optimizer
 64 | drive_hat = torch.nn.Parameter(torch.tensor(0.0))
 65 | optimizer = torch.optim.Adam([drive_hat], lr=0.01)
 66 | 
 67 | # optimize the parameter
 68 | n_iters = 2500
 69 | for n in range(n_iters):
 70 |     # apply distortion with the estimated parameter
 71 |     y_hat = dasp_pytorch.functional.distortion(x, sr, drive_hat)
 72 | 
 73 |     # compute distance between estimate and target
 74 |     loss = torch.nn.functional.mse_loss(y_hat, y)
 75 | 
 76 |     # optimize
 77 |     optimizer.zero_grad()
 78 |     loss.backward()
 79 |     optimizer.step()
 80 |     print(
 81 |         f"step: {n+1}/{n_iters}, loss: {loss.item():.3e}, drive: {drive_hat.item():.3f}\r"
 82 |     )
 83 |     
 84 | ```
 85 | 
 86 | For the remaining examples we will use the [GuitarSet](https://guitarset.weebly.com/) dataset. 
 87 | You can download the data using the following commands:
 88 | ```bash
 89 | mkdir data
 90 | wget https://zenodo.org/records/3371780/files/audio_mono-mic.zip
 91 | unzip audio_mono-mic.zip
 92 | rm audio_mono-mic.zip
 93 | ```
 94 | 
 95 | ### More examples
 96 | 
 97 | - [Virtual Analog Modeling](examples/virtual_analog.py)
 98 | - [Automatic Equalization](examples/auto_eq.py)
 99 | - [Audio Production Style Transfer](examples/style_transfer.py)
100 | 
101 | ## Audio Processors
102 | 
103 | <table>
104 |     <tr>
105 |         <th>Audio Processor</th>
106 |         <th>Functional Interface</th>
107 |     </tr>
108 |     <tr>
109 |         <td>Gain</td>
110 |         <td><code>gain()</code></td>
111 |     </tr>
112 |     <tr>
113 |         <td>Distortion</td>
114 |         <td><code>distortion()</code></td>
115 |     </tr>
116 |     <tr>
117 |         <td>Parametric Equalizer</td>
118 |         <td><code>parametric_eq()</code></td>
119 |     </tr>
120 |     <tr>
121 |         <td>Dynamic range compressor</td>
122 |         <td><code>compressor()</code></td>
123 |     </tr>
124 |     <tr>
125 |         <td>Dynamic range expander</td>
126 |         <td><code>expander()</code></td>
127 |     </tr>    
128 |     <tr>
129 |         <td>Reverberation</td>
130 |         <td><code>noise_shaped_reverberation()</code></td>
131 |     </tr>
132 |     <tr>
133 |         <td>Stereo Widener</td>
134 |         <td><code>stereo_widener()</code></td>
135 |     </tr>
136 |     <tr>
137 |         <td>Stereo Panner</td>
138 |         <td><code>stereo_panner()</code></td>
139 |     </tr>
140 |     <tr>
141 |         <td>Stereo Bus</td>
142 |         <td><code>stereo_bus()</code></td>
143 |     </tr>
144 | </table>
145 | 
146 | ## Citations
147 | 
148 | If you use this library consider citing these papers:
149 | 
150 | Differentiable parametric EQ and dynamic range compressor
151 | ```bibtex
152 | @article{steinmetz2022style,
153 |   title={Style transfer of audio effects with differentiable signal processing},
154 |   author={Steinmetz, Christian J and Bryan, Nicholas J and Reiss, Joshua D},
155 |   journal={arXiv preprint arXiv:2207.08759},
156 |   year={2022}
157 | }
158 | ```
159 | 
160 | Differentiable artificial reveberation with frequency-band noise shaping
161 | ```bibtex
162 | @inproceedings{steinmetz2021filtered,
163 |   title={Filtered noise shaping for time domain room impulse 
164 |          response estimation from reverberant speech},
165 |   author={Steinmetz, Christian J and Ithapu, Vamsi Krishna and Calamia, Paul},
166 |   booktitle={WASPAA},
167 |   year={2021},
168 |   organization={IEEE}
169 | }
170 | ```
171 | 
172 | Differentiable IIR filters
173 | ```bibtex
174 | @inproceedings{nercessian2020neural,
175 |   title={Neural parametric equalizer matching using differentiable biquads},
176 |   author={Nercessian, Shahan},
177 |   booktitle={DAFx},
178 |   year={2020}
179 | }
180 | ```
181 | 
182 | ```bibtex
183 | @inproceedings{colonel2022direct,
184 |   title={Direct design of biquad filter cascades with deep learning 
185 |           by sampling random polynomials},
186 |   author={Colonel, Joseph T and Steinmetz, Christian J and 
187 |           Michelen, Marcus and Reiss, Joshua D},
188 |   booktitle={ICASSP},
189 |   year={2022},
190 |   organization={IEEE}
191 | ```
192 | 
193 | ## Acknowledgements
194 | 
195 | Supported by the EPSRC UKRI Centre for Doctoral Training in Artificial Intelligence and Music (EP/S022694/1).
196 | 
197 | <p float="left">
198 |     <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/logos/qm.png" height="50px"> &nbsp; &nbsp; 
199 |     <img src="https://github.com/csteinmetz1/dasp-pytorch/raw/main/docs/assets/logos/aim.png"  height="50px"> &nbsp; &nbsp; 
200 |     <img src="https://github.com/csteinmetz1/dasp-pytorch/blob/main/docs/assets/logos/ukri.png"  height="50px"> &nbsp; &nbsp; 
201 | </p>


--------------------------------------------------------------------------------
/dasp_pytorch/__init__.py:
--------------------------------------------------------------------------------
 1 | from dasp_pytorch.functional import (
 2 |     gain,
 3 |     stereo_bus,
 4 |     stereo_panner,
 5 |     stereo_widener,
 6 |     noise_shaped_reverberation,
 7 |     compressor,
 8 |     distortion,
 9 |     parametric_eq,
10 | )
11 | 
12 | from dasp_pytorch.modules import (
13 |     Processor,
14 |     Compressor,
15 |     ParametricEQ,
16 |     NoiseShapedReverb,
17 |     Gain,
18 |     Distortion,
19 | )
20 | 


--------------------------------------------------------------------------------
/dasp_pytorch/functional.py:
--------------------------------------------------------------------------------
  1 | import torch
  2 | import numpy as np
  3 | import scipy.signal
  4 | import dasp_pytorch.signal
  5 | 
  6 | from functools import partial
  7 | from typing import Dict, List
  8 | 
  9 | 
 10 | def gain(x: torch.Tensor, sample_rate: int, gain_db: torch.Tensor):
 11 |     """Apply gain in dB to audio tensor.
 12 | 
 13 |     The same gain will be applied to each audio channel in the tensor.
 14 | 
 15 |     Args:
 16 |         x (torch.Tensor): Input audio tensor with shape (bs, chs, seq_len)
 17 |         sample_rate (int): Audio sample rate.
 18 |         gain_db (torch.Tensor): Gain in dB with shape (bs)
 19 | 
 20 |     Returns:
 21 |         torch.Tensor: Output audio tensor with shape (bs, chs, seq_len)
 22 | 
 23 |     """
 24 |     bs, chs, seq_len = x.size()
 25 | 
 26 |     gain_db = gain_db.view(bs, 1, 1)
 27 |     # convert gain from db to linear
 28 |     gain_lin = 10 ** (gain_db.repeat(1, chs, 1) / 20.0)
 29 |     return x * gain_lin
 30 | 
 31 | 
 32 | def stereo_bus(x: torch.tensor, sample_rate: int, send_db: torch.Tensor):
 33 |     """Stereo bus with controllable send levels.
 34 | 
 35 |     Given a tensor containing a set of audio tracks, create a stereo bus by summing the tracks
 36 |     according to the relative send levels. The result will be a stereo signal. Note that all
 37 |     input tracks are expected to be stereo.
 38 | 
 39 |     Args:
 40 |         x (torch.Tensor): Input audio tensor with shape (bs, 2, tracks, seq_len)
 41 |         sample_rate (int): Audio sample rate.
 42 |         send_db (torch.Tensor): Send levels in dB with shape (bs, tracks, 1)
 43 | 
 44 |     Returns:
 45 |         torch.Tensor: Output audio tensor with shape (bs, 2, seq_len)
 46 | 
 47 |     """
 48 |     bs, chs, tracks, seq_len = x.size()
 49 | 
 50 |     assert chs == 2, "Input tensor must have shape (bs, 2, tracks, seq_len)"
 51 | 
 52 |     # convert send levels from db to linear
 53 |     sends_lin = 10 ** (send_db.view(bs, 1, tracks, 1) / 20.0)
 54 | 
 55 |     # apply send levels
 56 |     x_bus = x * sends_lin
 57 | 
 58 |     # sum tracks to stereo bus
 59 |     x_bus = x_bus.sum(dim=2, keepdim=False)
 60 | 
 61 |     # apply send levels
 62 |     return x_bus
 63 | 
 64 | 
 65 | def distortion(x: torch.Tensor, sample_rate: int, drive_db: torch.Tensor):
 66 |     """Simple soft-clipping distortion with drive control.
 67 | 
 68 |     Args:
 69 |         x (torch.Tensor): Input audio tensor with shape (bs, chs, seq_len)
 70 |         sample_rate (int): Audio sample rate.
 71 |         drive_db (torch.Tensor): Drive in dB with shape (bs)
 72 | 
 73 |     Returns:
 74 |         torch.Tensor: Output audio tensor with shape (bs, chs, seq_len)
 75 | 
 76 |     """
 77 |     bs, chs, seq_len = x.size()
 78 |     return torch.tanh(x * (10 ** (drive_db.view(bs, chs, -1) / 20.0)))
 79 | 
 80 | 
 81 | def advanced_distortion(
 82 |     x: torch.Tensor,
 83 |     sample_rate: float,
 84 |     input_gain_db: torch.Tensor,
 85 |     output_gain_db: torch.Tensor,
 86 |     tone: torch.Tensor,
 87 |     dc_offset: torch.Tensor,
 88 | ):
 89 |     """
 90 | 
 91 |     Args:
 92 |         x (torch.Tensor): Input audio tensor with shape (bs, ..., seq_len)
 93 |         sample_rate (float): Audio sample rate.
 94 |         input_gain_db (torch.Tensor): Input gain in dB with shape (bs, ...)
 95 |         output_gain_db (torch.Tensor): Output gain in dB with shape (bs, ...)
 96 |         tone (torch.Tensor): Tone control with shape (bs, ...)
 97 |         dc_offset (torch.Tensor): DC offset with shape (bs, ...)
 98 | 
 99 |     The tone filter is implemented as a weighted sum of 1st order highpass and lowpass filters.
100 |     This is based on the design of the Boss guituar pedal modelled in [2]. Their design uses a
101 |     highpass with corner frequency 1.16 kHz and a lowpass with corner frequency 320 Hz.
102 | 
103 |     [1] Colonel, Joseph T., Marco Comunità, and Joshua Reiss.
104 |         "Reverse Engineering Memoryless Distortion Effects with Differentiable Waveshapers."
105 |         153rd Convention of the Audio Engineering Society. Audio Engineering Society, 2022.
106 | 
107 |     [2] Yeh, David Te-Mao.
108 |         Digital implementation of musical distortion circuits by analysis and simulation.
109 |         Stanford University, 2009.
110 |     """
111 |     raise NotImplementedError
112 | 
113 | 
114 | def graphic_eq(x: torch.Tensor, sample_rate: float):
115 |     raise NotImplementedError
116 | 
117 | 
118 | def parametric_eq(
119 |     x: torch.Tensor,
120 |     sample_rate: float,
121 |     low_shelf_gain_db: torch.Tensor,
122 |     low_shelf_cutoff_freq: torch.Tensor,
123 |     low_shelf_q_factor: torch.Tensor,
124 |     band0_gain_db: torch.Tensor,
125 |     band0_cutoff_freq: torch.Tensor,
126 |     band0_q_factor: torch.Tensor,
127 |     band1_gain_db: torch.Tensor,
128 |     band1_cutoff_freq: torch.Tensor,
129 |     band1_q_factor: torch.Tensor,
130 |     band2_gain_db: torch.Tensor,
131 |     band2_cutoff_freq: torch.Tensor,
132 |     band2_q_factor: torch.Tensor,
133 |     band3_gain_db: torch.Tensor,
134 |     band3_cutoff_freq: torch.Tensor,
135 |     band3_q_factor: torch.Tensor,
136 |     high_shelf_gain_db: torch.Tensor,
137 |     high_shelf_cutoff_freq: torch.Tensor,
138 |     high_shelf_q_factor: torch.Tensor,
139 | ):
140 |     """Six-band Parametric Equalizer.
141 | 
142 |     Low-shelf -> Band 1 -> Band 2 -> Band 3 -> Band 4 -> High-shelf
143 | 
144 |     [1] Välimäki, Vesa, and Joshua D. Reiss.
145 |         "All about audio equalization: Solutions and frontiers."
146 |         Applied Sciences 6.5 (2016): 129.
147 | 
148 |     [2] Nercessian, Shahan.
149 |         "Neural parametric equalizer matching using differentiable biquads."
150 |         Proc. Int. Conf. Digital Audio Effects (eDAFx-20). 2020.
151 | 
152 |     [3] Colonel, Joseph T., Christian J. Steinmetz, et al.
153 |         "Direct design of biquad filter cascades with deep learning by sampling random polynomials."
154 |         IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), 2022.
155 | 
156 |     [4] Steinmetz, Christian J., Nicholas J. Bryan, and Joshua D. Reiss.
157 |         "Style Transfer of Audio Effects with Differentiable Signal Processing."
158 |         Journal of the Audio Engineering Society. Vol. 70, Issue 9, 2022, pp. 708-721.
159 | 
160 |     Args:
161 |         x (torch.Tensor): Time domain tensor with shape (bs, chs, seq_len)
162 |         sample_rate (float): Audio sample rate.
163 |         low_shelf_gain_db (torch.Tensor): Low-shelf filter gain in dB.
164 |         low_shelf_cutoff_freq (torch.Tensor): Low-shelf filter cutoff frequency in Hz.
165 |         low_shelf_q_factor (torch.Tensor): Low-shelf filter Q-factor.
166 |         band0_gain_db (torch.Tensor): Band 1 filter gain in dB.
167 |         band0_cutoff_freq (torch.Tensor): Band 1 filter cutoff frequency in Hz.
168 |         band0_q_factor (torch.Tensor): Band 1 filter Q-factor.
169 |         band1_gain_db (torch.Tensor): Band 2 filter gain in dB.
170 |         band1_cutoff_freq (torch.Tensor): Band 2 filter cutoff frequency in Hz.
171 |         band1_q_factor (torch.Tensor): Band 2 filter Q-factor.
172 |         band2_gain_db (torch.Tensor): Band 3 filter gain in dB.
173 |         band2_cutoff_freq (torch.Tensor): Band 3 filter cutoff frequency in Hz.
174 |         band2_q_factor (torch.Tensor): Band 3 filter Q-factor.
175 |         band3_gain_db (torch.Tensor): Band 4 filter gain in dB.
176 |         band3_cutoff_freq (torch.Tensor): Band 4 filter cutoff frequency in Hz.
177 |         band3_q_factor (torch.Tensor): Band 4 filter Q-factor.
178 |         high_shelf_gain_db (torch.Tensor): High-shelf filter gain in dB.
179 |         high_shelf_cutoff_freq (torch.Tensor): High-shelf filter cutoff frequency in Hz.
180 |         high_shelf_q_factor (torch.Tensor): High-shelf filter Q-factor.
181 | 
182 |     Returns:
183 |         y (torch.Tensor): Filtered signal.
184 |     """
185 |     bs, chs, seq_len = x.size()
186 | 
187 |     # reshape to move everything to batch dim
188 |     # x = x.view(-1, 1, seq_len)
189 |     low_shelf_gain_db = low_shelf_gain_db.view(-1, 1, 1)
190 |     low_shelf_cutoff_freq = low_shelf_cutoff_freq.view(-1, 1, 1)
191 |     low_shelf_q_factor = low_shelf_q_factor.view(-1, 1, 1)
192 |     band0_gain_db = band0_gain_db.view(-1, 1, 1)
193 |     band0_cutoff_freq = band0_cutoff_freq.view(-1, 1, 1)
194 |     band0_q_factor = band0_q_factor.view(-1, 1, 1)
195 |     band1_gain_db = band1_gain_db.view(-1, 1, 1)
196 |     band1_cutoff_freq = band1_cutoff_freq.view(-1, 1, 1)
197 |     band1_q_factor = band1_q_factor.view(-1, 1, 1)
198 |     band2_gain_db = band2_gain_db.view(-1, 1, 1)
199 |     band2_cutoff_freq = band2_cutoff_freq.view(-1, 1, 1)
200 |     band2_q_factor = band2_q_factor.view(-1, 1, 1)
201 |     band3_gain_db = band3_gain_db.view(-1, 1, 1)
202 |     band3_cutoff_freq = band3_cutoff_freq.view(-1, 1, 1)
203 |     band3_q_factor = band3_q_factor.view(-1, 1, 1)
204 |     high_shelf_gain_db = high_shelf_gain_db.view(-1, 1, 1)
205 |     high_shelf_cutoff_freq = high_shelf_cutoff_freq.view(-1, 1, 1)
206 |     high_shelf_q_factor = high_shelf_q_factor.view(-1, 1, 1)
207 | 
208 |     eff_bs = x.size(0)
209 | 
210 |     # six second order sections
211 |     sos = torch.zeros(eff_bs, 6, 6).type_as(low_shelf_gain_db)
212 |     # ------------ low shelf ------------
213 |     b, a = dasp_pytorch.signal.biquad(
214 |         low_shelf_gain_db,
215 |         low_shelf_cutoff_freq,
216 |         low_shelf_q_factor,
217 |         sample_rate,
218 |         "low_shelf",
219 |     )
220 |     sos[:, 0, :] = torch.cat((b, a), dim=-1)
221 |     # ------------ band0 ------------
222 |     b, a = dasp_pytorch.signal.biquad(
223 |         band0_gain_db,
224 |         band0_cutoff_freq,
225 |         band0_q_factor,
226 |         sample_rate,
227 |         "peaking",
228 |     )
229 |     sos[:, 1, :] = torch.cat((b, a), dim=-1)
230 |     # ------------ band1 ------------
231 |     b, a = dasp_pytorch.signal.biquad(
232 |         band1_gain_db,
233 |         band1_cutoff_freq,
234 |         band1_q_factor,
235 |         sample_rate,
236 |         "peaking",
237 |     )
238 |     sos[:, 2, :] = torch.cat((b, a), dim=-1)
239 |     # ------------ band2 ------------
240 |     b, a = dasp_pytorch.signal.biquad(
241 |         band2_gain_db,
242 |         band2_cutoff_freq,
243 |         band2_q_factor,
244 |         sample_rate,
245 |         "peaking",
246 |     )
247 |     sos[:, 3, :] = torch.cat((b, a), dim=-1)
248 |     # ------------ band3 ------------
249 |     b, a = dasp_pytorch.signal.biquad(
250 |         band3_gain_db,
251 |         band3_cutoff_freq,
252 |         band3_q_factor,
253 |         sample_rate,
254 |         "peaking",
255 |     )
256 |     sos[:, 4, :] = torch.cat((b, a), dim=-1)
257 |     # ------------ high shelf ------------
258 |     b, a = dasp_pytorch.signal.biquad(
259 |         high_shelf_gain_db,
260 |         high_shelf_cutoff_freq,
261 |         high_shelf_q_factor,
262 |         sample_rate,
263 |         "high_shelf",
264 |     )
265 |     sos[:, 5, :] = torch.cat((b, a), dim=-1)
266 | 
267 |     x_out = dasp_pytorch.signal.sosfilt_via_fsm(sos, x)
268 | 
269 |     # move channels back
270 |     x_out = x_out.view(bs, chs, seq_len)
271 | 
272 |     return x_out
273 | 
274 | 
275 | def compressor(
276 |     x: torch.Tensor,
277 |     sample_rate: float,
278 |     threshold_db: torch.Tensor,
279 |     ratio: torch.Tensor,
280 |     attack_ms: torch.Tensor,
281 |     release_ms: torch.Tensor,
282 |     knee_db: torch.Tensor,
283 |     makeup_gain_db: torch.Tensor,
284 |     eps: float = 1e-8,
285 |     lookahead_samples: int = 0,
286 | ):
287 |     """Dynamic range compressor.
288 | 
289 |     This compressor is based on the standard feedforward digital compressor design [1].
290 |     To make the implementation differentiable the the simple compressor proposed in [2] is used.
291 |     However, the original design utilized a single time constant for the attack and release
292 |     ballisitics in order to parallelize the branching recursive smoothing filter.
293 |     This implementation builds on this using approximate ballisitics similar to those
294 |     introduced in [3]. This involves applying two 1-pole lowpass filters to the gain reduction curve,
295 |     each with different time constants. The final smoothed gain reduction curve is then computed
296 |     by combining these two smoothed curves, setting only one to be active at a time based on
297 |     the level of the gain reduction curve in relation to the threshold.
298 | 
299 |     [1] Giannoulis, Dimitrios, Michael Massberg, and Joshua D. Reiss.
300 |         "Digital Dynamic Range Compressor Design - A Tutorial and Analysis."
301 |         Journal of Audio Engineering Society. Vol. 60, Issue 6, 2012, pp. 399-408.
302 | 
303 |     [2] Steinmetz, Christian J., Nicholas J. Bryan, and Joshua D. Reiss.
304 |         "Style Transfer of Audio Effects with Differentiable Signal Processing."
305 |         Journal of the Audio Engineering Society. Vol. 70, Issue 9, 2022, pp. 708-721.
306 | 
307 |     [3] Colonel, Joseph, and Joshua D. Reiss.
308 |         "Approximating Ballistics in a Differentiable Dynamic Range Compressor."
309 |         153rd Convention of the Audio Engineering Society. Audio Engineering Society, 2022.
310 | 
311 |     Args:
312 |         x (torch.Tensor): Audio tensor with shape (bs, chs, seq_len).
313 |         sample_rate (float): Audio sampling rate.
314 |         threshold_db (torch.Tensor): Threshold at which to begin gain reduction.
315 |         ratio (torch.Tensor): Amount to reduce gain as a function of the distance above threshold.
316 |         attack_ms (torch.Tensor): Attack time in milliseconds.
317 |         release_ms (torch.Tensor): Release time in milliseconds.
318 |         knee_db (torch.Tensor): Softness of the knee. Higher = softer. (Must be positive)
319 |         makeup_gain_db (torch.Tensor): Apply gain after compression to restore signal level.
320 |         eps (float): Epsilon value for numerical stability. Default: 1e-8
321 | 
322 |     Returns:
323 |         y (torch.Tensor): Compressed signal.
324 |     """
325 |     bs, chs, seq_len = x.size()  # check shape
326 | 
327 |     # if multiple channels are present create sum side-chain
328 |     x_side = x.sum(dim=1, keepdim=True)
329 |     x_side = x_side.view(-1, 1, seq_len)
330 |     threshold_db = threshold_db.view(-1, 1, 1)
331 |     ratio = ratio.view(-1, 1, 1)
332 |     attack_ms = attack_ms.view(-1, 1, 1)
333 |     release_ms = release_ms.view(-1, 1, 1)
334 |     knee_db = knee_db.view(-1, 1, 1)
335 |     makeup_gain_db = makeup_gain_db.view(-1, 1, 1)
336 |     eff_bs = x_side.size(0)
337 | 
338 |     # compute time constants
339 |     normalized_attack_time = sample_rate * (attack_ms / 1e3)
340 |     # normalized_release_time = sample_rate * (release_ms / 1e3)
341 |     constant = torch.tensor([9.0]).type_as(attack_ms)
342 |     alpha_A = torch.exp(-torch.log(constant) / normalized_attack_time)
343 |     # alpha_R = torch.exp(-torch.log(constant) / normalized_release_time)
344 |     # note that release time constant is not used in the smoothing filter
345 | 
346 |     # compute energy in db
347 |     x_db = 20 * torch.log10(torch.abs(x_side).clamp(eps))
348 | 
349 |     # static characteristic with soft knee
350 |     x_sc = x_db.clone()
351 | 
352 |     # when signal is less than (T - W/2) leave as x_db
353 | 
354 |     # when signal is at the threshold engage knee
355 |     idx1 = x_db >= (threshold_db - (knee_db / 2))
356 |     idx2 = x_db <= (threshold_db + (knee_db / 2))
357 |     idx = torch.logical_and(idx1, idx2)
358 |     x_sc_below = x_db + ((1 / ratio) - 1) * (
359 |         (x_db - threshold_db + (knee_db / 2)) ** 2
360 |     ) / (2 * knee_db)
361 |     x_sc[idx] = x_sc_below[idx]
362 | 
363 |     # when signal is above threshold linear response
364 |     idx = x_db > (threshold_db + (knee_db / 2))
365 |     x_sc_above = threshold_db + ((x_db - threshold_db) / ratio)
366 |     x_sc[idx] = x_sc_above[idx]
367 | 
368 |     # output of gain computer
369 |     g_c = x_sc - x_db
370 | 
371 |     # design attack/release smoothing filter
372 |     b = torch.cat(
373 |         [(1 - alpha_A), torch.zeros(eff_bs, 1, 1).type_as(alpha_A)],
374 |         dim=-1,
375 |     ).squeeze(1)
376 |     a = torch.cat(
377 |         [torch.ones(eff_bs, 1, 1).type_as(alpha_A), -alpha_A],
378 |         dim=-1,
379 |     ).squeeze(1)
380 |     g_c_attack = dasp_pytorch.signal.lfilter_via_fsm(g_c, b, a)
381 | 
382 |     # look-ahead by delaying the input signal in relation to gain reduction
383 |     if lookahead_samples > 0:
384 |         x = torch.roll(x, lookahead_samples, dims=-1)
385 |         x[:, :, :lookahead_samples] = 0
386 | 
387 |     # add makeup gain in db
388 |     g_s = g_c_attack + makeup_gain_db
389 | 
390 |     # convert db gains back to linear
391 |     g_lin = 10 ** (g_s / 20.0)
392 | 
393 |     # apply time-varying gain and makeup gain
394 |     y = x * g_lin
395 | 
396 |     # move channels back to the channel dimension
397 |     y = y.view(bs, chs, seq_len)
398 | 
399 |     return y
400 | 
401 | 
402 | def expander():
403 |     raise NotImplementedError
404 | 
405 | 
406 | def noise_shaped_reverberation(
407 |     x: torch.Tensor,
408 |     sample_rate: float,
409 |     band0_gain: torch.Tensor,
410 |     band1_gain: torch.Tensor,
411 |     band2_gain: torch.Tensor,
412 |     band3_gain: torch.Tensor,
413 |     band4_gain: torch.Tensor,
414 |     band5_gain: torch.Tensor,
415 |     band6_gain: torch.Tensor,
416 |     band7_gain: torch.Tensor,
417 |     band8_gain: torch.Tensor,
418 |     band9_gain: torch.Tensor,
419 |     band10_gain: torch.Tensor,
420 |     band11_gain: torch.Tensor,
421 |     band0_decay: torch.Tensor,
422 |     band1_decay: torch.Tensor,
423 |     band2_decay: torch.Tensor,
424 |     band3_decay: torch.Tensor,
425 |     band4_decay: torch.Tensor,
426 |     band5_decay: torch.Tensor,
427 |     band6_decay: torch.Tensor,
428 |     band7_decay: torch.Tensor,
429 |     band8_decay: torch.Tensor,
430 |     band9_decay: torch.Tensor,
431 |     band10_decay: torch.Tensor,
432 |     band11_decay: torch.Tensor,
433 |     mix: torch.Tensor,
434 |     num_samples: int = 65536,
435 |     num_bandpass_taps: int = 1023,
436 | ):
437 |     """Artificial reverberation using frequency-band noise shaping.
438 | 
439 |     This differentiable artificial reverberation model is based on the idea of
440 |     filtered noise shaping, similar to that proposed in [1]. This approach leverages
441 |     the well known idea that a room impulse response (RIR) can be modeled as the direct sound,
442 |     a set of early reflections, and a decaying noise-like tail [2].
443 | 
444 |     [1] Steinmetz, Christian J., Vamsi Krishna Ithapu, and Paul Calamia.
445 |         "Filtered noise shaping for time domain room impulse response estimation from reverberant speech."
446 |         2021 IEEE Workshop on Applications of Signal Processing to Audio and Acoustics (WASPAA). IEEE, 2021.
447 | 
448 |     [2] Moorer, James A.
449 |         "About this reverberation business."
450 |         Computer Music Journal (1979): 13-28.
451 | 
452 |     Args:
453 |         x (torch.Tensor): Input audio signal. Shape (bs, chs, seq_len).
454 |         sample_rate (float): Audio sample rate.
455 |         band0_gain (torch.Tensor): Gain for first octave band on (0,1). Shape (bs, 1).
456 |         band1_gain (torch.Tensor): Gain for second octave band on (0,1). Shape (bs, 1).
457 |         band2_gain (torch.Tensor): Gain for third octave band on (0,1). Shape (bs, 1).
458 |         band3_gain (torch.Tensor): Gain for fourth octave band on (0,1). Shape (bs, 1).
459 |         band4_gain (torch.Tensor): Gain for fifth octave band on (0,1). Shape (bs, 1).
460 |         band5_gain (torch.Tensor): Gain for sixth octave band on (0,1). Shape (bs, 1).
461 |         band6_gain (torch.Tensor): Gain for seventh octave band on (0,1). Shape (bs, 1).
462 |         band7_gain (torch.Tensor): Gain for eighth octave band on (0,1). Shape (bs, 1).
463 |         band8_gain (torch.Tensor): Gain for ninth octave band on (0,1). Shape (bs, 1).
464 |         band9_gain (torch.Tensor): Gain for tenth octave band on (0,1). Shape (bs, 1).
465 |         band10_gain (torch.Tensor): Gain for eleventh octave band on (0,1). Shape (bs, 1).
466 |         band11_gain (torch.Tensor): Gain for twelfth octave band on (0,1). Shape (bs, 1).
467 |         band0_decays (torch.Tensor): Decay parameter for first octave band (0,1). Shape (bs, 1).
468 |         band1_decays (torch.Tensor): Decay parameter for second octave band (0,1). Shape (bs, 1).
469 |         band2_decays (torch.Tensor): Decay parameter for third octave band (0,1). Shape (bs, 1).
470 |         band3_decays (torch.Tensor): Decay parameter for fourth octave band (0,1). Shape (bs, 1).
471 |         band4_decays (torch.Tensor): Decay parameter for fifth octave band (0,1). Shape (bs, 1).
472 |         band5_decays (torch.Tensor): Decay parameter for sixth octave band (0,1). Shape (bs, 1).
473 |         band6_decays (torch.Tensor): Decay parameter for seventh octave band (0,1). Shape (bs, 1).
474 |         band7_decays (torch.Tensor): Decay parameter for eighth octave band (0,1). Shape (bs, 1).
475 |         band8_decays (torch.Tensor): Decay parameter for ninth octave band (0,1). Shape (bs, 1).
476 |         band9_decays (torch.Tensor): Decay parameter for tenth octave band (0,1). Shape (bs, 1).
477 |         band10_decays (torch.Tensor): Decay parameter for eleventh octave band (0,1). Shape (bs, 1).
478 |         band11_decays (torch.Tensor): Decay parameter for twelfth octave band (0,1). Shape (bs, 1).
479 |         mix (torch.Tensor): Mix between dry and wet signal. Shape (bs, 1).
480 |         num_samples (int, optional): Number of samples to use for IR generation. Defaults to 88200.
481 |         num_bandpass_taps (int, optional): Number of filter taps for the octave band filterbank filters. Must be odd. Defaults to 1023.
482 | 
483 |     Returns:
484 |         y (torch.Tensor): Reverberated signal. Shape (bs, chs, seq_len).
485 | 
486 |     """
487 |     assert num_bandpass_taps % 2 == 1, "num_bandpass_taps must be odd"
488 | 
489 |     bs, chs, seq_len = x.size()
490 |     assert chs <= 2, "only mono/stereo signals are supported"
491 | 
492 |     # if mono copy to stereo
493 |     if chs == 1:
494 |         x = x.repeat(1, 2, 1)
495 |         chs = 2
496 | 
497 |     # stack gains and decays into a single tensor
498 |     band_gains = torch.stack(
499 |         [
500 |             band0_gain,
501 |             band1_gain,
502 |             band2_gain,
503 |             band3_gain,
504 |             band4_gain,
505 |             band5_gain,
506 |             band6_gain,
507 |             band7_gain,
508 |             band8_gain,
509 |             band9_gain,
510 |             band10_gain,
511 |             band11_gain,
512 |         ],
513 |         dim=1,
514 |     )
515 |     band_gains = band_gains.unsqueeze(-1)
516 | 
517 |     band_decays = torch.stack(
518 |         [
519 |             band0_decay,
520 |             band1_decay,
521 |             band2_decay,
522 |             band3_decay,
523 |             band4_decay,
524 |             band5_decay,
525 |             band6_decay,
526 |             band7_decay,
527 |             band8_decay,
528 |             band9_decay,
529 |             band10_decay,
530 |             band11_decay,
531 |         ],
532 |         dim=1,
533 |     )
534 |     band_decays = band_decays.unsqueeze(-1)
535 | 
536 |     # create the octave band filterbank filters
537 |     filters = dasp_pytorch.signal.octave_band_filterbank(num_bandpass_taps, sample_rate)
538 |     filters = filters.type_as(x)
539 |     num_bands = filters.shape[0]
540 | 
541 |     # reshape gain, decay, and mix parameters
542 |     band_gains = band_gains.view(bs, 1, num_bands, 1)
543 |     band_decays = band_decays.view(bs, 1, num_bands, 1)
544 |     mix = mix.view(bs, 1, 1)
545 | 
546 |     # generate white noise for IR generation
547 |     pad_size = num_bandpass_taps - 1
548 |     wn = torch.randn(bs * 2, num_bands, num_samples + pad_size).type_as(x)
549 | 
550 |     # filter white noise signals with each bandpass filter
551 |     wn_filt = torch.nn.functional.conv1d(
552 |         wn,
553 |         filters,
554 |         groups=num_bands,
555 |         # padding=self.num_taps -1,
556 |     )
557 |     # shape: (bs * 2, num_bands, num_samples)
558 |     wn_filt = wn_filt.view(bs, 2, num_bands, num_samples)
559 | 
560 |     # apply bandwise decay parameters (envelope)
561 |     t = torch.linspace(0, 1, steps=num_samples).type_as(x)  # timesteps
562 |     band_decays = (band_decays * 10.0) + 1.0
563 |     env = torch.exp(-band_decays * t.view(1, 1, 1, -1))
564 |     wn_filt *= env * band_gains
565 | 
566 |     # sum signals to create impulse shape: bs, 2, 1, num_samp
567 |     w_filt_sum = wn_filt.mean(2, keepdim=True)
568 | 
569 |     # apply impulse response for each batch item (vectorized)
570 |     x_pad = torch.nn.functional.pad(x, (num_samples - 1, 0))
571 |     vconv1d = torch.vmap(partial(torch.nn.functional.conv1d, groups=2), in_dims=0)
572 |     y = vconv1d(x_pad, torch.flip(w_filt_sum, dims=[-1]))
573 | 
574 |     # create a wet/dry mix
575 |     y = (1 - mix) * x + mix * y
576 | 
577 |     return y
578 | 
579 | 
580 | def stereo_widener(x: torch.Tensor, sample_rate: float, width: torch.Tensor):
581 |     """Stereo widener using mid-side processing.
582 | 
583 |     Args:
584 |         x (torch.Tensor): Stereo audio tensor of shape (bs, 2, seq_len)
585 |         sample_rate (float): Audio sample rate (Hz).
586 |         width (torch.Tensor): Stereo width control. Higher is wider. has shape (bs)
587 | 
588 |     """
589 |     bs, chs, seq_len = x.size()
590 |     assert chs == 2, "Input tensor must have shape (bs, 2, seq_len)"
591 | 
592 |     sqrt2 = np.sqrt(2)
593 |     mid = (x[..., 0, :] + x[..., 1, :]) / sqrt2
594 |     side = (x[..., 0, :] - x[..., 1, :]) / sqrt2
595 | 
596 |     # amplify mid and side signal separately:
597 |     mid *= 2 * (1 - width)
598 |     side *= 2 * width
599 | 
600 |     # covert back to stereo
601 |     left = (mid + side) / sqrt2
602 |     right = (mid - side) / sqrt2
603 | 
604 |     return torch.stack((left, right), dim=-2)
605 | 
606 | 
607 | def stereo_panner(x: torch.Tensor, sample_rate: float, pan: torch.Tensor):
608 |     """Take a mono single and pan across the stereo field.
609 | 
610 |     Args:
611 |         x (torch.Tensor): Monophonic audio tensor of shape (bs, num_tracks, seq_len).
612 |         sample_rate (float): Audio sample rate (Hz).
613 |         pan (torch.Tensor): Pan value on the range from 0 to 1.
614 | 
615 |     Returns:
616 |         x (torch.Tensor): Stereo audio tensor with panning of shape (bs, num_tracks, 2, seq_len)
617 |     """
618 |     bs, num_tracks, seq_len = x.size()
619 |     # first scale the linear [0, 1] to [0, pi/2]
620 |     theta = pan * (np.pi / 2)
621 | 
622 |     # compute gain coefficients
623 |     left_gain = torch.sqrt(((np.pi / 2) - theta) * (2 / np.pi) * torch.cos(theta))
624 |     right_gain = torch.sqrt(theta * (2 / np.pi) * torch.sin(theta))
625 | 
626 |     # make stereo
627 |     x = x.unsqueeze(1)
628 |     x = x.repeat(1, 2, 1, 1)
629 | 
630 |     # apply panning
631 |     left_gain = left_gain.view(bs, 1, num_tracks, 1)
632 |     right_gain = right_gain.view(bs, 1, num_tracks, 1)
633 |     gains = torch.cat((left_gain, right_gain), dim=1)
634 |     x *= gains
635 | 
636 |     return x
637 | 


--------------------------------------------------------------------------------
/dasp_pytorch/modules.py:
--------------------------------------------------------------------------------
  1 | import torch
  2 | from dasp_pytorch.functional import (
  3 |     gain,
  4 |     distortion,
  5 |     compressor,
  6 |     parametric_eq,
  7 |     noise_shaped_reverberation,
  8 | )
  9 | 
 10 | from typing import Dict, List
 11 | 
 12 | 
 13 | def denormalize(norm_val, max_val, min_val):
 14 |     return (norm_val * (max_val - min_val)) + min_val
 15 | 
 16 | 
 17 | def normalize(val, min_val, max_val):
 18 |     return (val - min_val) / (max_val - min_val)
 19 | 
 20 | 
 21 | class Processor:
 22 |     def __init__(self):
 23 |         pass
 24 | 
 25 |     def process_normalized(self, x: torch.Tensor, param_tensor: torch.Tensor):
 26 |         """Run the processor using normalized parameters on (0,1) in a tensor.
 27 | 
 28 |         This function assumes that the parameters in the tensor are in the same
 29 |         order as the parameter defined in the processor.
 30 | 
 31 |         Args:
 32 |             x (torch.Tensor): Input audio tensor (batch, channels, samples)
 33 |             param_tensor (torch.Tensor): Tensor of parameters on (0,1) (batch, num_params)
 34 | 
 35 |         Returns:
 36 |             torch.Tensor: Output audio tensor
 37 |         """
 38 |         # extract parameters from tensor
 39 |         param_dict = self.extract_param_dict(param_tensor)
 40 | 
 41 |         # denormalize parameters to full range
 42 |         denorm_param_dict = self.denormalize_param_dict(param_dict)
 43 | 
 44 |         # now process audio with denormalized parameters
 45 |         y = self.process_fn(
 46 |             x,
 47 |             self.sample_rate,
 48 |             **denorm_param_dict,
 49 |         )
 50 | 
 51 |         return y
 52 | 
 53 |     def process(self, x: torch.Tensor, *args):
 54 |         return self.process_fn(x, *args)
 55 | 
 56 |     def extract_param_dict(self, param_tensor: torch.Tensor):
 57 |         # check the number of parameters in tensor matches the number of processor parameters
 58 |         if param_tensor.shape[1] != len(self.param_ranges):
 59 |             raise ValueError(
 60 |                 f"Parameter tensor has {param_tensor.shape[1]} parameters, but processor has {len(self.param_ranges)} parameters."
 61 |             )
 62 | 
 63 |         # extract parameters from tensor
 64 |         param_dict = {}
 65 |         for param_idx, param_name in enumerate(self.param_ranges.keys()):
 66 |             param_dict[param_name] = param_tensor[:, param_idx]
 67 | 
 68 |         return param_dict
 69 | 
 70 |     def denormalize_param_dict(self, param_dict: dict):
 71 |         """Given parameters on (0,1) restore them to the ranges expected by the processor.
 72 | 
 73 |         Args:
 74 |             param_dict (dict): Dictionary of parameter tensors on (0,1).
 75 | 
 76 |         Returns:
 77 |             dict: Dictionary of parameter tensors on their full range.
 78 | 
 79 |         """
 80 |         denorm_param_dict = {}
 81 |         for param_name, param_tensor in param_dict.items():
 82 |             # check for out of range parameters
 83 |             if param_tensor.min() < 0 or param_tensor.max() > 1:
 84 |                 raise ValueError(f"Parameter {param_name} of is out of range.")
 85 |             param_val_denorm = denormalize(
 86 |                 param_tensor,
 87 |                 self.param_ranges[param_name][1],
 88 |                 self.param_ranges[param_name][0],
 89 |             )
 90 |             denorm_param_dict[param_name] = param_val_denorm
 91 |         return denorm_param_dict
 92 | 
 93 | 
 94 | class Gain(Processor):
 95 |     def __init__(
 96 |         self,
 97 |         sample_rate: int,
 98 |         min_gain_db: float = -24.0,
 99 |         max_gain_db: float = 24.0,
100 |     ):
101 |         super().__init__()
102 |         self.sample_rate = sample_rate
103 |         self.process_fn = gain
104 |         self.param_ranges = {
105 |             "gain_db": (min_gain_db, max_gain_db),
106 |         }
107 |         self.num_params = len(self.param_ranges)
108 | 
109 | 
110 | class Distortion(Processor):
111 |     def __init__(
112 |         self,
113 |         min_gain_db: float = 0.0,
114 |         max_gain_db: float = 24.0,
115 |     ):
116 |         super().__init__()
117 |         self.process_fn = distortion
118 |         self.param_ranges = {
119 |             "gain_db": (min_gain_db, max_gain_db),
120 |         }
121 |         self.num_params = len(self.param_ranges)
122 | 
123 | 
124 | class ParametricEQ(Processor):
125 |     def __init__(
126 |         self,
127 |         sample_rate: int,
128 |         min_gain_db: float = -20.0,
129 |         max_gain_db: float = 20.0,
130 |         min_q_factor: float = 0.1,
131 |         max_q_factor: float = 6.0,
132 |     ):
133 |         super().__init__()
134 |         self.sample_rate = sample_rate
135 |         self.process_fn = parametric_eq
136 |         self.param_ranges = {
137 |             "low_shelf_gain_db": (min_gain_db, max_gain_db),
138 |             "low_shelf_cutoff_freq": (20, 2000),
139 |             "low_shelf_q_factor": (min_q_factor, max_q_factor),
140 |             "band0_gain_db": (min_gain_db, max_gain_db),
141 |             "band0_cutoff_freq": (80, 2000),
142 |             "band0_q_factor": (min_q_factor, max_q_factor),
143 |             "band1_gain_db": (min_gain_db, max_gain_db),
144 |             "band1_cutoff_freq": (2000, 8000),
145 |             "band1_q_factor": (min_q_factor, max_q_factor),
146 |             "band2_gain_db": (min_gain_db, max_gain_db),
147 |             "band2_cutoff_freq": (8000, 12000),
148 |             "band2_q_factor": (min_q_factor, max_q_factor),
149 |             "band3_gain_db": (min_gain_db, max_gain_db),
150 |             "band3_cutoff_freq": (12000, (sample_rate // 2) - 1000),
151 |             "band3_q_factor": (min_q_factor, max_q_factor),
152 |             "high_shelf_gain_db": (min_gain_db, max_gain_db),
153 |             "high_shelf_cutoff_freq": (4000, (sample_rate // 2) - 1000),
154 |             "high_shelf_q_factor": (min_q_factor, max_q_factor),
155 |         }
156 |         self.num_params = len(self.param_ranges)
157 | 
158 | 
159 | class Compressor(Processor):
160 |     def __init__(
161 |         self,
162 |         sample_rate: int,
163 |         min_threshold_db: float = -60.0,
164 |         max_threshold_db: float = 0.0,
165 |         min_ratio: float = 1.0,
166 |         max_ratio: float = 20.0,
167 |         min_attack_ms: float = 5.0,
168 |         max_attack_ms: float = 100.0,
169 |         min_release_ms: float = 5.0,
170 |         max_release_ms: float = 100.0,
171 |         min_knee_db: float = 0.0,
172 |         max_knee_db: float = 12.0,
173 |         min_makeup_gain_db: float = 0.0,
174 |         max_makeup_gain_db: float = 12.0,
175 |     ):
176 |         super().__init__()
177 |         self.sample_rate = sample_rate
178 |         self.process_fn = compressor
179 |         self.param_ranges = {
180 |             "threshold_db": (min_threshold_db, max_threshold_db),
181 |             "ratio": (min_ratio, max_ratio),
182 |             "attack_ms": (min_attack_ms, max_attack_ms),
183 |             "release_ms": (min_release_ms, max_release_ms),
184 |             "knee_db": (min_knee_db, max_knee_db),
185 |             "makeup_gain_db": (min_makeup_gain_db, max_makeup_gain_db),
186 |         }
187 |         self.num_params = len(self.param_ranges)
188 | 
189 | 
190 | class NoiseShapedReverb(Processor):
191 |     def __init__(
192 |         self,
193 |         sample_rate,
194 |         min_band_gain: float = 0.0,
195 |         max_band_gain: float = 1.0,
196 |         min_band_decay: float = 0.0,
197 |         max_band_decay: float = 1.0,
198 |         min_mix: float = 0.0,
199 |         max_mix: float = 1.0,
200 |     ):
201 |         super().__init__()
202 |         self.sample_rate = sample_rate
203 |         self.process_fn = noise_shaped_reverberation
204 |         self.param_ranges = {
205 |             "band0_gain": (min_band_gain, max_band_gain),
206 |             "band1_gain": (min_band_gain, max_band_gain),
207 |             "band2_gain": (min_band_gain, max_band_gain),
208 |             "band3_gain": (min_band_gain, max_band_gain),
209 |             "band4_gain": (min_band_gain, max_band_gain),
210 |             "band5_gain": (min_band_gain, max_band_gain),
211 |             "band6_gain": (min_band_gain, max_band_gain),
212 |             "band7_gain": (min_band_gain, max_band_gain),
213 |             "band8_gain": (min_band_gain, max_band_gain),
214 |             "band9_gain": (min_band_gain, max_band_gain),
215 |             "band10_gain": (min_band_gain, max_band_gain),
216 |             "band11_gain": (min_band_gain, max_band_gain),
217 |             "band0_decay": (min_band_decay, max_band_decay),
218 |             "band1_decay": (min_band_decay, max_band_decay),
219 |             "band2_decay": (min_band_decay, max_band_decay),
220 |             "band3_decay": (min_band_decay, max_band_decay),
221 |             "band4_decay": (min_band_decay, max_band_decay),
222 |             "band5_decay": (min_band_decay, max_band_decay),
223 |             "band6_decay": (min_band_decay, max_band_decay),
224 |             "band7_decay": (min_band_decay, max_band_decay),
225 |             "band8_decay": (min_band_decay, max_band_decay),
226 |             "band9_decay": (min_band_decay, max_band_decay),
227 |             "band10_decay": (min_band_decay, max_band_decay),
228 |             "band11_decay": (min_band_decay, max_band_decay),
229 |             "mix": (min_mix, max_mix),
230 |         }
231 |         self.num_params = len(self.param_ranges)
232 | 


--------------------------------------------------------------------------------
/dasp_pytorch/signal.py:
--------------------------------------------------------------------------------
  1 | import math
  2 | import torch
  3 | import numpy as np
  4 | import scipy.signal
  5 | 
  6 | 
  7 | def fft_freqz(b, a, n_fft: int = 512):
  8 |     B = torch.fft.rfft(b, n_fft)
  9 |     A = torch.fft.rfft(a, n_fft)
 10 |     H = B / A
 11 |     return H
 12 | 
 13 | 
 14 | def fft_sosfreqz(sos: torch.Tensor, n_fft: int = 512):
 15 |     """Compute the complex frequency response via FFT of cascade of biquads
 16 | 
 17 |     Args:
 18 |         sos (torch.Tensor): Second order filter sections with shape (bs, n_sections, 6)
 19 |         n_fft (int): FFT size. Default: 512
 20 |     Returns:
 21 |         H (torch.Tensor): Overall complex frequency response with shape (bs, n_bins)
 22 |     """
 23 |     bs, n_sections, n_coeffs = sos.size()
 24 |     assert n_coeffs == 6  # must be second order
 25 |     for section_idx in range(n_sections):
 26 |         b = sos[:, section_idx, :3]
 27 |         a = sos[:, section_idx, 3:]
 28 |         if section_idx == 0:
 29 |             H = fft_freqz(b, a, n_fft=n_fft)
 30 |         else:
 31 |             H *= fft_freqz(b, a, n_fft=n_fft)
 32 |     return H
 33 | 
 34 | 
 35 | def freqdomain_fir(x, H, n_fft):
 36 |     X = torch.fft.rfft(x, n_fft)
 37 |     Y = X * H.type_as(X)
 38 |     y = torch.fft.irfft(Y, n_fft)
 39 |     return y
 40 | 
 41 | 
 42 | def octave_band_filterbank(num_taps: int, sample_rate: float):
 43 |     # create octave-spaced bandpass filters
 44 |     bands = [
 45 |         31.5,
 46 |         63,
 47 |         125,
 48 |         250,
 49 |         500,
 50 |         1000,
 51 |         2000,
 52 |         4000,
 53 |         8000,
 54 |         16000,
 55 |     ]
 56 |     num_bands = len(bands) + 2
 57 |     filts = []  # storage for computed filter coefficients
 58 | 
 59 |     # lowest band is a lowpass
 60 |     filt = scipy.signal.firwin(
 61 |         num_taps,
 62 |         12,
 63 |         fs=sample_rate,
 64 |     )
 65 |     filt = torch.from_numpy(filt.astype("float32"))
 66 |     filt = torch.flip(filt, dims=[0])
 67 |     filts.append(filt)
 68 | 
 69 |     for fc in bands:
 70 |         f_min = fc / np.sqrt(2)
 71 |         f_max = fc * np.sqrt(2)
 72 |         f_max = np.clip(f_max, a_min=0, a_max=(sample_rate / 2) * 0.999)
 73 |         filt = scipy.signal.firwin(
 74 |             num_taps,
 75 |             [f_min, f_max],
 76 |             fs=sample_rate,
 77 |             pass_zero=False,
 78 |         )
 79 |         filt = torch.from_numpy(filt.astype("float32"))
 80 |         filt = torch.flip(filt, dims=[0])
 81 |         filts.append(filt)
 82 | 
 83 |     # highest is a highpass
 84 |     filt = scipy.signal.firwin(num_taps, 18000, fs=sample_rate, pass_zero=False)
 85 |     filt = torch.from_numpy(filt.astype("float32"))
 86 |     filt = torch.flip(filt, dims=[0])
 87 |     filts.append(filt)
 88 | 
 89 |     filts = torch.stack(filts, dim=0)  # stack coefficients into single filter
 90 |     filts = filts.unsqueeze(1)  # shape: num_bands x 1 x num_taps
 91 | 
 92 |     return filts
 93 | 
 94 | 
 95 | def lfilter_via_fsm(x: torch.Tensor, b: torch.Tensor, a: torch.Tensor = None):
 96 |     """Use the frequency sampling method to approximate an IIR filter.
 97 |     The filter will be applied along the final dimension of x.
 98 |     Args:
 99 |         x (torch.Tensor): Time domain signal with shape (bs, 1, timesteps)
100 |         b (torch.Tensor): Numerator coefficients with shape (bs, N).
101 |         a (torch.Tensor): Denominator coefficients with shape (bs, N).
102 |     Returns:
103 |         y (torch.Tensor): Filtered time domain signal with shape (bs, 1, timesteps)
104 |     """
105 |     bs, chs, seq_len = x.size()  # enforce shape
106 |     assert chs == 1
107 | 
108 |     # round up to nearest power of 2 for FFT
109 |     n_fft = 2 ** torch.ceil(torch.log2(torch.tensor(x.shape[-1] + x.shape[-1] - 1)))
110 |     n_fft = n_fft.int()
111 | 
112 |     # move coefficients to same device as x
113 |     b = b.type_as(x)
114 | 
115 |     if a is None:
116 |         # directly compute FFT of numerator coefficients
117 |         H = torch.fft.rfft(b, n_fft)
118 |     else:
119 |         a = a.type_as(x)
120 |         # compute complex response as ratio of polynomials
121 |         H = fft_freqz(b, a, n_fft=n_fft)
122 | 
123 |     # add extra dims to broadcast filter across
124 |     for _ in range(x.ndim - 2):
125 |         H = H.unsqueeze(1)
126 | 
127 |     # apply as a FIR filter in the frequency domain
128 |     y = freqdomain_fir(x, H, n_fft)
129 | 
130 |     # crop
131 |     y = y[..., : x.shape[-1]]
132 | 
133 |     return y
134 | 
135 | 
136 | def sosfilt_via_fsm(sos: torch.Tensor, x: torch.Tensor):
137 |     """Use the frequency sampling method to approximate a cascade of second order IIR filters.
138 | 
139 |     The filter will be applied along the final dimension of x.
140 |     Args:
141 |         sos (torch.Tensor): Tensor of coefficients with shape (bs, n_sections, 6).
142 |         x (torch.Tensor): Time domain signal with shape (bs, ... , timesteps)
143 | 
144 |     Returns:
145 |         y (torch.Tensor): Filtered time domain signal with shape (bs, ..., timesteps)
146 |     """
147 |     bs = x.size(0)
148 | 
149 |     # round up to nearest power of 2 for FFT
150 |     n_fft = 2 ** torch.ceil(torch.log2(torch.tensor(x.shape[-1] + x.shape[-1] - 1)))
151 |     n_fft = n_fft.int()
152 | 
153 |     # compute complex response as ratio of polynomials
154 |     H = fft_sosfreqz(sos, n_fft=n_fft)
155 | 
156 |     # add extra dims to broadcast filter across
157 |     for _ in range(x.ndim - 2):
158 |         H = H.unsqueeze(1)
159 | 
160 |     # apply as a FIR filter in the frequency domain
161 |     y = freqdomain_fir(x, H, n_fft)
162 | 
163 |     # crop
164 |     y = y[..., : x.shape[-1]]
165 | 
166 |     return y
167 | 
168 | 
169 | def one_pole_butter_lowpass(
170 |     f_c: torch.Tensor,
171 |     sample_rate: float,
172 | ):
173 |     """
174 | 
175 |     This function is correct.
176 | 
177 |     """
178 |     f_c = f_c.view(-1, 1)
179 |     w_d = 2 * np.pi * (f_c / sample_rate)  # digital frequency in radians
180 |     w_c = torch.tan(w_d / 2)  # apply pre-warping for analog frequency
181 | 
182 |     a0 = 1 + w_c
183 |     a1 = w_c - 1
184 |     b0 = w_c
185 |     b1 = w_c
186 | 
187 |     b = torch.cat([b0, b1], dim=-1)
188 |     a = torch.cat([a0, a1], dim=-1)
189 | 
190 |     # normalize
191 |     b = b / a0
192 |     a = a / a0
193 | 
194 |     print("ba", b.shape, a.shape)
195 | 
196 |     return b, a
197 | 
198 | 
199 | def one_pole_filter(
200 |     cutoff_hz: torch.Tensor,
201 |     filter_type: str,
202 |     sample_rate: float = 2.0,
203 | ):
204 |     """Design a simple 1-pole highpass or lowpass IIR filter.
205 | 
206 |     Filtering is performed along the final dimension of the input tensor.
207 | 
208 |     Args:
209 |         cutoff_hz (torch.Tensor): Lowpass filter centre frequency (normalized 0,1) with shape (bs). (Higher = more smoothing)
210 |         filter_type (str): Specify either "highpass" or "lowpass". (Note this parameter cannot be optimize with gradient descent.)
211 |         sample_rate (float): Sample rate of the input signal.
212 | 
213 |     Returns:
214 |         b, a (torch.Tensor). Coefficient tensors with shape (bs, 2).
215 |     """
216 |     # setup shape for broadcasting
217 |     bs = cutoff_hz.shape[0]
218 |     cutoff_hz = cutoff_hz.view(bs, 1)
219 |     nyquist = sample_rate // 2
220 | 
221 |     # compute coefficients
222 |     if filter_type == "highpass":
223 |         a1 = cutoff_hz / nyquist
224 |     elif filter_type == "lowpass":
225 |         a1 = -1 + (cutoff_hz / nyquist)
226 |     else:
227 |         raise ValueError(f"Invalid filter_type = {filter_type}.")
228 | 
229 |     print(a1)
230 | 
231 |     a0 = torch.ones(bs, 1).type_as(a1)
232 | 
233 |     b0 = 1 - torch.abs(a1)
234 |     b1 = torch.zeros(bs, 1).type_as(a1)
235 | 
236 |     b = torch.cat([b0, b1], dim=1)
237 |     a = torch.cat([a0, a1], dim=1)
238 | 
239 |     return b, a
240 | 
241 | 
242 | def biquad(
243 |     gain_db: torch.Tensor,
244 |     cutoff_freq: torch.Tensor,
245 |     q_factor: torch.Tensor,
246 |     sample_rate: float,
247 |     filter_type: str = "peaking",
248 | ):
249 |     bs = gain_db.size(0)
250 |     # reshape params
251 |     gain_db = gain_db.view(bs, -1)
252 |     cutoff_freq = cutoff_freq.view(bs, -1)
253 |     q_factor = q_factor.view(bs, -1)
254 | 
255 |     A = 10 ** (gain_db / 40.0)
256 |     w0 = 2 * math.pi * (cutoff_freq / sample_rate)
257 |     alpha = torch.sin(w0) / (2 * q_factor)
258 |     cos_w0 = torch.cos(w0)
259 |     sqrt_A = torch.sqrt(A)
260 | 
261 |     if filter_type == "high_shelf":
262 |         b0 = A * ((A + 1) + (A - 1) * cos_w0 + 2 * sqrt_A * alpha)
263 |         b1 = -2 * A * ((A - 1) + (A + 1) * cos_w0)
264 |         b2 = A * ((A + 1) + (A - 1) * cos_w0 - 2 * sqrt_A * alpha)
265 |         a0 = (A + 1) - (A - 1) * cos_w0 + 2 * sqrt_A * alpha
266 |         a1 = 2 * ((A - 1) - (A + 1) * cos_w0)
267 |         a2 = (A + 1) - (A - 1) * cos_w0 - 2 * sqrt_A * alpha
268 |     elif filter_type == "low_shelf":
269 |         b0 = A * ((A + 1) - (A - 1) * cos_w0 + 2 * sqrt_A * alpha)
270 |         b1 = 2 * A * ((A - 1) - (A + 1) * cos_w0)
271 |         b2 = A * ((A + 1) - (A - 1) * cos_w0 - 2 * sqrt_A * alpha)
272 |         a0 = (A + 1) + (A - 1) * cos_w0 + 2 * sqrt_A * alpha
273 |         a1 = -2 * ((A - 1) + (A + 1) * cos_w0)
274 |         a2 = (A + 1) + (A - 1) * cos_w0 - 2 * sqrt_A * alpha
275 |     elif filter_type == "peaking":
276 |         b0 = 1 + alpha * A
277 |         b1 = -2 * cos_w0
278 |         b2 = 1 - alpha * A
279 |         a0 = 1 + (alpha / A)
280 |         a1 = -2 * cos_w0
281 |         a2 = 1 - (alpha / A)
282 |     elif filter_type == "low_pass":
283 |         b0 = (1 - cos_w0) / 2
284 |         b1 = 1 - cos_w0
285 |         b2 = (1 - cos_w0) / 2
286 |         a0 = 1 + alpha
287 |         a1 = -2 * cos_w0
288 |         a2 = 1 - alpha
289 |     elif filter_type == "high_pass":
290 |         b0 = (1 + cos_w0) / 2
291 |         b1 = -(1 + cos_w0)
292 |         b2 = (1 + cos_w0) / 2
293 |         a0 = 1 + alpha
294 |         a1 = -2 * cos_w0
295 |         a2 = 1 - alpha
296 |     else:
297 |         raise ValueError(f"Invalid filter_type: {filter_type}.")
298 | 
299 |     b = torch.stack([b0, b1, b2], dim=1).view(bs, -1)
300 |     a = torch.stack([a0, a1, a2], dim=1).view(bs, -1)
301 | 
302 |     # normalize
303 |     b = b.type_as(gain_db) / a0
304 |     a = a.type_as(gain_db) / a0
305 | 
306 |     return b, a
307 | 


--------------------------------------------------------------------------------
/docs/assets/box.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-box" viewBox="0 0 16 16">
2 |   <path d="M8.186 1.113a.5.5 0 0 0-.372 0L1.846 3.5 8 5.961 14.154 3.5 8.186 1.113zM15 4.239l-6.5 2.6v7.922l6.5-2.6V4.24zM7.5 14.762V6.838L1 4.239v7.923l6.5 2.6zM7.443.184a1.5 1.5 0 0 1 1.114 0l7.129 2.852A.5.5 0 0 1 16 3.5v8.662a1 1 0 0 1-.629.928l-7.185 2.874a.5.5 0 0 1-.372 0L.63 13.09a1 1 0 0 1-.63-.928V3.5a.5.5 0 0 1 .314-.464L7.443.184z"/>
3 | </svg>


--------------------------------------------------------------------------------
/docs/assets/code-slash.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-code-slash" viewBox="0 0 16 16">
2 |   <path d="M10.478 1.647a.5.5 0 1 0-.956-.294l-4 13a.5.5 0 0 0 .956.294l4-13zM4.854 4.146a.5.5 0 0 1 0 .708L1.707 8l3.147 3.146a.5.5 0 0 1-.708.708l-3.5-3.5a.5.5 0 0 1 0-.708l3.5-3.5a.5.5 0 0 1 .708 0zm6.292 0a.5.5 0 0 0 0 .708L14.293 8l-3.147 3.146a.5.5 0 0 0 .708.708l3.5-3.5a.5.5 0 0 0 0-.708l-3.5-3.5a.5.5 0 0 0-.708 0z"/>
3 | </svg>


--------------------------------------------------------------------------------
/docs/assets/dasp-no-bg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/csteinmetz1/dasp-pytorch/c9ae0126e1c441979b93995da061503a0abdceff/docs/assets/dasp-no-bg.png


--------------------------------------------------------------------------------
/docs/assets/gear.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-gear" viewBox="0 0 16 16">
2 |   <path d="M8 4.754a3.246 3.246 0 1 0 0 6.492 3.246 3.246 0 0 0 0-6.492zM5.754 8a2.246 2.246 0 1 1 4.492 0 2.246 2.246 0 0 1-4.492 0z"/>
3 |   <path d="M9.796 1.343c-.527-1.79-3.065-1.79-3.592 0l-.094.319a.873.873 0 0 1-1.255.52l-.292-.16c-1.64-.892-3.433.902-2.54 2.541l.159.292a.873.873 0 0 1-.52 1.255l-.319.094c-1.79.527-1.79 3.065 0 3.592l.319.094a.873.873 0 0 1 .52 1.255l-.16.292c-.892 1.64.901 3.434 2.541 2.54l.292-.159a.873.873 0 0 1 1.255.52l.094.319c.527 1.79 3.065 1.79 3.592 0l.094-.319a.873.873 0 0 1 1.255-.52l.292.16c1.64.893 3.434-.902 2.54-2.541l-.159-.292a.873.873 0 0 1 .52-1.255l.319-.094c1.79-.527 1.79-3.065 0-3.592l-.319-.094a.873.873 0 0 1-.52-1.255l.16-.292c.893-1.64-.902-3.433-2.541-2.54l-.292.159a.873.873 0 0 1-1.255-.52l-.094-.319zm-2.633.283c.246-.835 1.428-.835 1.674 0l.094.319a1.873 1.873 0 0 0 2.693 1.115l.291-.16c.764-.415 1.6.42 1.184 1.185l-.159.292a1.873 1.873 0 0 0 1.116 2.692l.318.094c.835.246.835 1.428 0 1.674l-.319.094a1.873 1.873 0 0 0-1.115 2.693l.16.291c.415.764-.42 1.6-1.185 1.184l-.291-.159a1.873 1.873 0 0 0-2.693 1.116l-.094.318c-.246.835-1.428.835-1.674 0l-.094-.319a1.873 1.873 0 0 0-2.692-1.115l-.292.16c-.764.415-1.6-.42-1.184-1.185l.159-.291A1.873 1.873 0 0 0 1.945 8.93l-.319-.094c-.835-.246-.835-1.428 0-1.674l.319-.094A1.873 1.873 0 0 0 3.06 4.377l-.16-.292c-.415-.764.42-1.6 1.185-1.184l.292.159a1.873 1.873 0 0 0 2.692-1.115l.094-.319z"/>
4 | </svg>


--------------------------------------------------------------------------------
/docs/assets/gpu-card.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-gpu-card" viewBox="0 0 16 16">
2 |   <path d="M4 8a1.5 1.5 0 1 1 3 0 1.5 1.5 0 0 1-3 0Zm7.5-1.5a1.5 1.5 0 1 0 0 3 1.5 1.5 0 0 0 0-3Z"/>
3 |   <path d="M0 1.5A.5.5 0 0 1 .5 1h1a.5.5 0 0 1 .5.5V4h13.5a.5.5 0 0 1 .5.5v7a.5.5 0 0 1-.5.5H2v2.5a.5.5 0 0 1-1 0V2H.5a.5.5 0 0 1-.5-.5Zm5.5 4a2.5 2.5 0 1 0 0 5 2.5 2.5 0 0 0 0-5ZM9 8a2.5 2.5 0 1 0 5 0 2.5 2.5 0 0 0-5 0Z"/>
4 |   <path d="M3 12.5h3.5v1a.5.5 0 0 1-.5.5H3.5a.5.5 0 0 1-.5-.5v-1Zm4 1v-1h4v1a.5.5 0 0 1-.5.5h-3a.5.5 0 0 1-.5-.5Z"/>
5 | </svg>


--------------------------------------------------------------------------------
/docs/assets/logos/aim.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/csteinmetz1/dasp-pytorch/c9ae0126e1c441979b93995da061503a0abdceff/docs/assets/logos/aim.png


--------------------------------------------------------------------------------
/docs/assets/logos/qm.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/csteinmetz1/dasp-pytorch/c9ae0126e1c441979b93995da061503a0abdceff/docs/assets/logos/qm.png


--------------------------------------------------------------------------------
/docs/assets/logos/ukri.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/csteinmetz1/dasp-pytorch/c9ae0126e1c441979b93995da061503a0abdceff/docs/assets/logos/ukri.png


--------------------------------------------------------------------------------
/docs/cover.css:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Globals
  3 |  */
  4 | 
  5 | /* Links */
  6 | a,
  7 | a:focus,
  8 | a:hover {
  9 |     color: #000;
 10 | }
 11 | 
 12 | /* Custom default button */
 13 | .btn-secondary,
 14 | .btn-secondary:hover,
 15 | .btn-secondary:focus {
 16 |     color: #333;
 17 |     text-shadow: none;
 18 |     /* Prevent inheritance from `body` */
 19 |     background-color: rgba(0, 0, 0, 0.0);
 20 |     border: .1rem solid #000;
 21 | }
 22 | 
 23 | 
 24 | /*
 25 |  * Base structure
 26 |  */
 27 | 
 28 | html,
 29 | body {
 30 |     height: 100%;
 31 |     background-color: #fff;
 32 | }
 33 | 
 34 | body {
 35 |     display: -ms-flexbox;
 36 |     display: -webkit-box;
 37 |     display: flex;
 38 |     -ms-flex-pack: center;
 39 |     -webkit-box-pack: center;
 40 |     justify-content: center;
 41 |     color: #000;
 42 | }
 43 | 
 44 | .cover-container {
 45 |     max-width: 36em;
 46 | }
 47 | 
 48 | 
 49 | /*
 50 |  * Header
 51 |  */
 52 | .masthead {
 53 |     margin-bottom: 2rem;
 54 | }
 55 | 
 56 | .masthead-brand {
 57 |     margin-bottom: 0;
 58 | }
 59 | 
 60 | .nav-masthead .nav-link {
 61 |     padding: .25rem 0;
 62 |     font-weight: 700;
 63 |     color: #000;
 64 |     background-color: transparent;
 65 |     border-bottom: .25rem solid transparent;
 66 | }
 67 | 
 68 | .nav-masthead .nav-link:hover,
 69 | .nav-masthead .nav-link:focus {
 70 |     border-bottom-color: #000;
 71 | }
 72 | 
 73 | .nav-masthead .nav-link+.nav-link {
 74 |     margin-left: 1rem;
 75 | }
 76 | 
 77 | .nav-masthead .active {
 78 |     color: #000;
 79 |     border-bottom-color: #000;
 80 | }
 81 | 
 82 | @media (min-width: 48em) {
 83 |     .masthead-brand {
 84 |         float: left;
 85 |     }
 86 | 
 87 |     .nav-masthead {
 88 |         float: right;
 89 |     }
 90 | }
 91 | 
 92 | 
 93 | /*
 94 |  * Cover
 95 |  */
 96 | .cover {
 97 |     padding: 0 1.5rem;
 98 | }
 99 | 
100 | .cover .btn-lg {
101 |     padding: .75rem 1.25rem;
102 |     font-weight: 700;
103 | }
104 | 
105 | 
106 | /*
107 |  * Footer
108 |  */
109 | .mastfoot {
110 |     color: #000;
111 | }


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html lang="en">
  3 | 
  4 | <head>
  5 |   <meta charset="utf-8">
  6 |   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
  7 |   <meta name="description" content="dasp: differentiable audio signal processors in PyTorch">
  8 |   <meta name="author" content="Christian J. Steinmetz">
  9 |   <link rel="icon" href="/docs/4.0/assets/img/favicons/favicon.ico">
 10 |   <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet"
 11 |     integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
 12 |   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.1/font/bootstrap-icons.css">
 13 | 
 14 |   <title>dasp</title>
 15 | 
 16 |   <!-- Custom styles for this template -->
 17 |   <link href="cover.css" rel="stylesheet">
 18 | </head>
 19 | 
 20 | <body class="text-center">
 21 | 
 22 |   <div class="cover-container d-flex h-100 p-3 mx-auto flex-column">
 23 | 
 24 |     <header class="masthead mb-auto">
 25 |       <div class="inner">
 26 |         <h3 class="masthead-brand"></h3>
 27 |         <!-- <nav class="nav nav-masthead justify-content-center">
 28 |           <a class="nav-link active" href="#">Home</a>
 29 |           <a class="nav-link" href="#">Features</a>
 30 |           <a class="nav-link" href="#">Contact</a>
 31 |           </nav> -->
 32 |       </div>
 33 |     </header>
 34 | 
 35 | 
 36 |     <main role="main" class="inner cover mb-5">
 37 |       <img src="assets/dasp-no-bg.png" alt="The logo for the dasp Python library." width="50%">
 38 |       <h1 class="cover-heading">dasp</h1>
 39 |       <p class="lead">Differentiable audio signal processors in PyTorch</p>
 40 |     </main>
 41 | 
 42 |     <div class="mt-3 mb-5" style="text-align: left;">
 43 |       <div class="row">
 44 |         <div class="col-2">
 45 |           <h1><i class="bi bi-box"></i></h1>
 46 |         </div>
 47 |         <div class="col-10 mt-2">
 48 |           <p>Includes reverberation, distortion, dynamic range processing,
 49 |             equalization, stereo processing and more to come.</p>
 50 |         </div>
 51 |       </div>
 52 | 
 53 |       <div class="row">
 54 |         <div class="col-2">
 55 |           <h1><i class="bi bi-gear"></i></h1>
 56 |         </div>
 57 |         <div class="col-10 mt-2">
 58 |           <p>Enable applications in virtual
 59 |             analog modeling, blind parameter estimation, automated DSP, and style transfer.</p>
 60 |         </div>
 61 |       </div>
 62 |       <div class="row">
 63 |         <div class="col-2">
 64 |           <h1><i class="bi bi-gpu-card"></i></h1>
 65 |         </div>
 66 |         <div class="col-10 mt-2">
 67 |           <p>Supports batching and operation on both CPU and GPU accelerators for fast
 68 |             training and reduced bottlenecks.</p>
 69 |         </div>
 70 |       </div>
 71 | 
 72 |       <div class="row">
 73 |         <div class="col-2">
 74 |           <h1><i class="bi bi-code-slash"></i></h1>
 75 |         </div>
 76 |         <div class="col-10 mt-2">
 77 |           <p>Open source and free to use for academic and commercial applications under the permissive <a
 78 |               href="https://www.apache.org/licenses/LICENSE-2.0">Apache
 79 |               2.0</a> license.</p>
 80 |         </div>
 81 |       </div>
 82 |     </div>
 83 | 
 84 |     <div class="mt-5 mb-5">
 85 |       <p> Interested in trying <img src="assets/dasp-no-bg.png" width="8%"> <b>dasp</b> before release? <br> Submit
 86 |         your email for early access.</a>
 87 |       </p>
 88 |       <!-- modify this form HTML and place wherever you want your form -->
 89 |     </div>
 90 | 
 91 |     <form class="form-inline" action="https://formspree.io/f/xeqbnqbl" method="POST">
 92 |       <div class="form-group mb-2">
 93 |         <label class="sr-only">
 94 |           <input class="form-control" type="email" name="email" placeholder="Enter email">
 95 |         </label>
 96 |         <!-- your other form fields go here -->
 97 |       </div>
 98 |       <button type="submit" class="btn btn-primary mb-2">Submit</button>
 99 |     </form>
100 | 
101 |     <footer class=" mastfoot mt-5">
102 |       <div class="inner">
103 |         <p>Built by researchers at the <a href="https://c4dm.eecs.qmul.ac.uk/"><b>Centre for Digital Music</b></a>.
104 |         </p>
105 |       </div>
106 | 
107 |     </footer>
108 |   </div>
109 | 
110 | 
111 | 
112 |   <!-- Bootstrap core JavaScript
113 |     ================================================== -->
114 |   <!-- Placed at the end of the document so the pages load faster -->
115 |   <script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
116 |     integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
117 |     crossorigin="anonymous"></script>
118 |   <script>window.jQuery || document.write('<script src="../../assets/js/vendor/jquery-slim.min.js"><\/script>')</script>
119 |   <script src="../../assets/js/vendor/popper.min.js"></script>
120 |   <script src="../../dist/js/bootstrap.min.js"></script>
121 | </body>
122 | 
123 | </html>


--------------------------------------------------------------------------------
/examples/auto_eq.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import glob
  3 | import torch
  4 | import auraloss
  5 | import torchaudio
  6 | import numpy as np
  7 | import dasp_pytorch
  8 | import matplotlib.pyplot as plt
  9 | 
 10 | from tqdm import tqdm
 11 | from typing import List
 12 | 
 13 | # In this example we will train a neural network to perform automatic equalization.
 14 | # We train the network to estimate the parameters of a parametric equalizer.
 15 | # Using the DAPS dataset, we corrupt speech examples with "bad" equalization and train the network to recover the original signal.
 16 | 
 17 | 
 18 | def plot_loss(log_dir, loss_history: List[float]):
 19 |     fig, ax = plt.subplots()
 20 |     ax.plot(loss_history)
 21 |     ax.set_xlabel("Iteration")
 22 |     ax.set_ylabel("Loss")
 23 |     plt.grid(c="lightgray")
 24 |     outfilepath = os.path.join(log_dir, "loss.png")
 25 |     plt.savefig(outfilepath, dpi=300)
 26 |     plt.close("all")
 27 | 
 28 | 
 29 | def plot_response(
 30 |     y: torch.Tensor,
 31 |     x_hat: torch.Tensor,
 32 |     x: torch.Tensor,
 33 |     sample_rate: int = 44100,
 34 |     epoch: int = 0,
 35 | ):
 36 |     fig, ax = plt.subplots(figsize=(6, 4))
 37 | 
 38 |     # compute frequency response of y
 39 |     Y = torch.fft.rfft(y)
 40 |     Y = torch.abs(Y)
 41 |     Y_db = 20 * torch.log10(Y + 1e-8)
 42 | 
 43 |     # compute frequency response of x_hat
 44 |     X_hat = torch.fft.rfft(x_hat)
 45 |     X_hat = torch.abs(X_hat)
 46 |     X_hat_db = 20 * torch.log10(X_hat + 1e-8)
 47 | 
 48 |     # compute frequency response of x
 49 |     X = torch.fft.rfft(x)
 50 |     X = torch.abs(X)
 51 |     X_db = 20 * torch.log10(X + 1e-8)
 52 | 
 53 |     # compute frequency axis
 54 |     freqs = torch.fft.fftfreq(x.shape[-1], d=1 / sample_rate)
 55 |     freqs = freqs[: X.shape[-1] - 1]  # take only positive frequencies
 56 |     X_db = X_db[:, : X.shape[-1] - 1]
 57 |     X_hat_db = X_hat_db[:, : X_hat.shape[-1] - 1]
 58 |     Y_db = Y_db[:, : Y.shape[-1] - 1]
 59 | 
 60 |     # smooth frequency response
 61 |     kernel_size = 1023
 62 |     X_db = torch.nn.functional.avg_pool1d(
 63 |         X_db.unsqueeze(0),
 64 |         kernel_size=kernel_size,
 65 |         stride=1,
 66 |         padding=kernel_size // 2,
 67 |     )
 68 |     X_hat_db = torch.nn.functional.avg_pool1d(
 69 |         X_hat_db.unsqueeze(0),
 70 |         kernel_size=kernel_size,
 71 |         stride=1,
 72 |         padding=kernel_size // 2,
 73 |     )
 74 |     Y_db = torch.nn.functional.avg_pool1d(
 75 |         Y_db.unsqueeze(0),
 76 |         kernel_size=kernel_size,
 77 |         stride=1,
 78 |         padding=kernel_size // 2,
 79 |     )
 80 | 
 81 |     # plot frequency response
 82 |     ax.plot(freqs, Y_db[0].squeeze().cpu().numpy(), label="input", alpha=0.7)
 83 |     ax.plot(freqs, X_hat_db[0].cpu().squeeze().numpy(), label="pred", alpha=0.7)
 84 |     ax.plot(
 85 |         freqs,
 86 |         X_db[0].squeeze().cpu().numpy(),
 87 |         label="target",
 88 |         alpha=0.7,
 89 |         c="gray",
 90 |         linestyle="--",
 91 |     )
 92 |     ax.set_xlabel("Frequency (Hz)")
 93 |     ax.set_ylabel("Magnitude (dB)")
 94 |     ax.set_xlim(100, 20000)
 95 |     ax.set_xscale("log")
 96 |     plt.legend()
 97 |     plt.grid(c="lightgray")
 98 |     plt.tight_layout()
 99 |     plt.savefig(f"outputs/auto_eq/audio/epoch={epoch:03d}_response.png", dpi=300)
100 | 
101 | 
102 | class TCNBlock(torch.nn.Module):
103 |     def __init__(
104 |         self,
105 |         in_channels: int,
106 |         out_channels: int,
107 |         kernel_size: int,
108 |         dilation: int = 1,
109 |     ):
110 |         super().__init__()
111 |         self.conv1 = torch.nn.Conv1d(
112 |             in_channels,
113 |             out_channels,
114 |             kernel_size,
115 |             dilation=dilation,
116 |             stride=2,
117 |         )
118 |         self.relu1 = torch.nn.PReLU(out_channels)
119 |         self.bn1 = torch.nn.BatchNorm1d(out_channels)
120 |         self.conv2 = torch.nn.Conv1d(
121 |             out_channels,
122 |             out_channels,
123 |             kernel_size,
124 |             dilation=1,
125 |         )
126 |         self.relu2 = torch.nn.PReLU(out_channels)
127 |         self.bn2 = torch.nn.BatchNorm1d(out_channels)
128 | 
129 |     def forward(self, x: torch.Tensor):
130 |         x = self.bn1(self.relu1(self.conv1(x)))
131 |         x = self.bn2(self.relu2(self.conv2(x)))
132 |         return x
133 | 
134 | 
135 | class ParameterNetwork(torch.nn.Module):
136 |     def __init__(self, num_control_params: int, ch_dim: int = 256) -> None:
137 |         super().__init__()
138 |         self.num_control_params = num_control_params
139 | 
140 |         # we will use a simple TCN to estimate a single conditioning parameter
141 |         # this network is about 8M parameters
142 |         self.blocks = torch.nn.ModuleList()
143 |         self.blocks.append(TCNBlock(1, ch_dim, 7, dilation=1))
144 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=2))
145 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=4))
146 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=8))
147 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=16))
148 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=1))
149 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=2))
150 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=4))
151 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=8))
152 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=16))
153 | 
154 |         self.mlp = torch.nn.Sequential(
155 |             torch.nn.Linear(ch_dim, 256),
156 |             torch.nn.ReLU(),
157 |             torch.nn.Linear(256, 256),
158 |             torch.nn.ReLU(),
159 |             torch.nn.Linear(256, num_control_params),
160 |         )
161 | 
162 |     def forward(self, x: torch.Tensor):
163 |         for block in self.blocks:
164 |             x = block(x)
165 |         x = x.mean(dim=-1)  # aggregate over time
166 |         return torch.sigmoid(self.mlp(x))  # map to parmeter
167 | 
168 | 
169 | class AudioEffectDataset(torch.nn.Module):
170 |     def __init__(
171 |         self,
172 |         filepaths: List[str],
173 |         length: int = 131072,
174 |     ) -> None:
175 |         super().__init__()
176 |         self.length = length
177 | 
178 |         assert len(filepaths) > 0, "No files found."
179 | 
180 |         self.examples = []
181 |         # create example of length `length` from each file
182 |         print("Creating dataset...")
183 |         for filepath in tqdm(filepaths):
184 |             md = torchaudio.info(filepath)
185 |             if md.num_frames < length:
186 |                 continue
187 |             num_examples = md.num_frames // length
188 |             for n in range(num_examples):
189 |                 frame_offset = n * length
190 | 
191 |                 frame, sr = torchaudio.load(
192 |                     filepath,
193 |                     frame_offset=frame_offset,
194 |                     num_frames=length,
195 |                     backend="soundfile",
196 |                 )
197 | 
198 |                 # check for silence
199 |                 if torch.max(torch.abs(frame)) < 1e-4:
200 |                     continue
201 | 
202 |                 self.examples.append((filepath, frame_offset))
203 | 
204 |         self.examples = self.examples
205 | 
206 |     def __len__(self):
207 |         return len(self.examples)
208 | 
209 |     def __getitem__(self, idx: int):
210 |         filepath, frame_offset = self.examples[idx]
211 | 
212 |         # read segment of audio from file
213 |         x, sr = torchaudio.load(
214 |             filepath,
215 |             frame_offset=frame_offset,
216 |             num_frames=self.length,
217 |             backend="soundfile",
218 |         )
219 | 
220 |         x *= 0.5  # apply some headroom
221 | 
222 |         # clamp to [-1,1] to ensure within range
223 |         x = torch.clamp(x, -1, 1)
224 | 
225 |         return x
226 | 
227 | 
228 | def train(
229 |     root_dir: str,
230 |     lr: float = 2e-3,
231 |     batch_size: int = 16,
232 |     num_epochs: int = 1000,
233 |     use_gpu: bool = False,
234 |     log_dir: str = "outputs/auto_eq",
235 |     sample_rate: int = 44100,
236 | ):
237 |     os.makedirs(log_dir, exist_ok=True)  # create log directory
238 |     equalizer = dasp_pytorch.ParametricEQ(
239 |         sample_rate, max_q_factor=1.0
240 |     )  # create instance of equalizer
241 |     net = ParameterNetwork(equalizer.num_params)  # create parameter estimation network
242 |     optimizer = torch.optim.Adam(net.parameters(), lr=lr)  # create optimizer
243 | 
244 |     # create dataset
245 |     filepaths = glob.glob(os.path.join(root_dir, "*.wav"))
246 |     train_filepaths = filepaths[: int(len(filepaths) * 0.8)]
247 |     val_filepaths = filepaths[int(len(filepaths) * 0.8) :]
248 |     dataset = AudioEffectDataset(train_filepaths)
249 |     dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size)
250 | 
251 |     # use a frequency domain loss function
252 |     criterion = auraloss.freq.MultiResolutionSTFTLoss(
253 |         fft_sizes=[128, 256, 512, 1024, 2048, 4096, 8192],
254 |         hop_sizes=[64, 128, 256, 512, 1024, 2048, 4096],
255 |         win_lengths=[128, 256, 512, 1024, 2048, 4096, 8192],
256 |         w_sc=0.0,
257 |         w_phs=0.0,
258 |         w_lin_mag=1.0,
259 |         w_log_mag=1.0,
260 |         perceptual_weighting=True,
261 |         sample_rate=sample_rate,
262 |     )
263 | 
264 |     # move to GPU if available
265 |     if use_gpu:
266 |         net.cuda()
267 |         criterion.cuda()
268 | 
269 |     # main training loop
270 |     epoch_loss_history = []
271 |     for epoch in range(num_epochs):
272 |         net.train()  # make sure network is in train mode
273 |         # iterate over the dataset
274 |         print("Epoch:", epoch + 1)
275 |         batch_loss_history = []
276 |         pbar = tqdm(dataloader)
277 |         for batch, data in enumerate(pbar):
278 |             x = data  # input
279 | 
280 |             # move to GPU if available
281 |             if use_gpu:
282 |                 x = x.cuda()
283 | 
284 |             # 0. create corrupted example with random parameters
285 |             with torch.no_grad():
286 |                 # torch.manual_seed(42)
287 |                 param_tensor = torch.rand(x.shape[0], equalizer.num_params).type_as(x)
288 |                 y = equalizer.process_normalized(x, param_tensor)
289 |                 peaks, _ = torch.max(torch.abs(y), dim=-1)  # normalize to [-1,1]
290 |                 peaks = peaks.unsqueeze(-1)
291 |                 y /= peaks
292 |                 # set random gain between -24 dB and 0 dB
293 |                 gain_db = torch.rand(x.shape[0], 1, 1) * -24
294 |                 gain_db = gain_db.type_as(x)
295 |                 y *= 10 ** (gain_db / 20)
296 | 
297 |             # 1. estimate parameters with network
298 |             # we show the network the "corrupted" signal
299 |             p_hat = net(y)
300 | 
301 |             # 2. apply effect with estimated normalized parameters
302 |             # we apply the effect to the "corrupted" signal to recover the original
303 |             x_hat = equalizer.process_normalized(y, p_hat)
304 |             x_hat = torch.tanh(x_hat)  # normalize to [-1,1]
305 | 
306 |             # 3. compute loss between the original and recovered signal
307 |             loss = criterion(x_hat, x)
308 | 
309 |             # 4. optimize
310 |             optimizer.zero_grad()
311 |             loss.backward()
312 |             optimizer.step()
313 | 
314 |             batch_loss_history.append(loss.item())
315 |             pbar.set_description(f"loss: {np.mean(batch_loss_history):.4e}")
316 | 
317 |         # plot loss and validate at the end of each epoch
318 |         epoch_loss_history.append(np.mean(batch_loss_history))
319 |         plot_loss(log_dir, epoch_loss_history)
320 | 
321 |         if (epoch + 1) % 10 == 0:  # validate every 10 epochs
322 |             validate(
323 |                 epoch + 1,
324 |                 val_filepaths,
325 |                 net,
326 |                 equalizer,
327 |                 log_dir=log_dir,
328 |                 use_gpu=use_gpu,
329 |             )
330 | 
331 | 
332 | def validate(
333 |     epoch: int,
334 |     filepaths: List[str],
335 |     net: torch.nn.Module,
336 |     equalizer: dasp_pytorch.Processor,
337 |     log_dir: str = "logs",
338 |     use_gpu: bool = False,
339 | ):
340 |     audio_log_dir = os.path.join(log_dir, "audio")
341 |     os.makedirs(audio_log_dir, exist_ok=True)
342 | 
343 |     # evaluate the network
344 |     net.eval()
345 | 
346 |     # use one of the validation files
347 |     filepath = np.random.choice(filepaths)
348 |     print(filepath)
349 | 
350 |     # load audio
351 |     x, sr = torchaudio.load(filepath, backend="soundfile")
352 | 
353 |     # pick random segment
354 |     start = np.random.randint(0, x.shape[-1] - 131072)
355 |     x = x[:, start : start + 131072]
356 | 
357 |     if use_gpu:
358 |         x = x.cuda()
359 | 
360 |     # apply random equalization (corrupt)
361 |     with torch.no_grad():
362 |         # random parameters on (0,1)
363 |         param_tensor = torch.rand(1, equalizer.num_params).type_as(x)
364 | 
365 |         # apply effect with random parameters
366 |         y = equalizer.process_normalized(x.unsqueeze(0), param_tensor)
367 | 
368 |         # normalize to [-1,1]
369 |         y /= torch.max(torch.abs(y))
370 | 
371 |         # predict parameters with network to recover original
372 |         p_hat = net(y)
373 | 
374 |         # apply effect with estimated normalized parameters
375 |         x_hat = equalizer.process_normalized(y, p_hat).squeeze(0)
376 | 
377 |     # plot the responses
378 |     plot_response(y.squeeze(0), x_hat, x, epoch=epoch)
379 | 
380 |     # save the results
381 |     target_filename = f"epoch={epoch:03d}_target.wav"
382 |     corrupt_filename = f"epoch={epoch:03d}_corrupt.wav"
383 |     pred_filename = f"epoch={epoch:03d}_pred.wav"
384 |     target_filepath = os.path.join(audio_log_dir, target_filename)
385 |     corrupt_filepath = os.path.join(audio_log_dir, corrupt_filename)
386 |     pred_filepath = os.path.join(audio_log_dir, pred_filename)
387 |     torchaudio.save(target_filepath, x.cpu(), sr, backend="soundfile")
388 |     torchaudio.save(corrupt_filepath, y.squeeze(0).cpu(), sr, backend="soundfile")
389 |     torchaudio.save(pred_filepath, x_hat.cpu(), sr, backend="soundfile")
390 | 
391 | 
392 | if __name__ == "__main__":
393 |     # provide path to the DAPS dataset (we use the `produced` subset)
394 |     train("/import/c4dm-datasets/daps_dataset/produced/", use_gpu=True)
395 | 


--------------------------------------------------------------------------------
/examples/blind_estimation.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import glob
  3 | import torch
  4 | import auraloss
  5 | import torchaudio
  6 | import numpy as np
  7 | import dasp_pytorch
  8 | from tqdm import tqdm
  9 | 
 10 | # In this example we will train a neural network to perform blind estimation of
 11 | # the audio effect parameters for a dynamic range compressor.
 12 | 
 13 | 
 14 | class TCNBlock(torch.nn.Module):
 15 |     def __init__(
 16 |         self,
 17 |         in_channels: int,
 18 |         out_channels: int,
 19 |         kernel_size: int,
 20 |         dilation: int = 1,
 21 |     ):
 22 |         super().__init__()
 23 |         self.conv1 = torch.nn.Conv1d(
 24 |             in_channels,
 25 |             out_channels,
 26 |             kernel_size,
 27 |             dilation=dilation,
 28 |             stride=2,
 29 |         )
 30 |         self.relu1 = torch.nn.ReLU()
 31 |         self.bn1 = torch.nn.BatchNorm1d(out_channels)
 32 |         self.conv2 = torch.nn.Conv1d(
 33 |             out_channels,
 34 |             out_channels,
 35 |             kernel_size,
 36 |             dilation=1,
 37 |         )
 38 |         self.relu2 = torch.nn.ReLU()
 39 |         self.bn2 = torch.nn.BatchNorm1d(out_channels)
 40 | 
 41 |     def forward(self, x: torch.Tensor):
 42 |         x = self.bn1(self.relu1(self.conv1(x)))
 43 |         x = self.bn2(self.relu2(self.conv2(x)))
 44 |         return x
 45 | 
 46 | 
 47 | class ParameterNetwork(torch.nn.Module):
 48 |     def __init__(self, num_control_params: int):
 49 |         super().__init__()
 50 |         self.num_control_params = num_control_params
 51 | 
 52 |         # we will use a simple TCN to estimate the parameters
 53 |         self.blocks = torch.nn.ModuleList()
 54 |         self.blocks.append(TCNBlock(1, 16, 3, dilation=1))
 55 |         self.blocks.append(TCNBlock(16, 32, 3, dilation=2))
 56 |         self.blocks.append(TCNBlock(32, 64, 3, dilation=4))
 57 |         self.blocks.append(TCNBlock(64, 128, 3, dilation=8))
 58 |         self.blocks.append(TCNBlock(128, 128, 3, dilation=16))
 59 | 
 60 |         self.linear = torch.nn.Linear(128, num_control_params)
 61 | 
 62 |     def forward(self, x: torch.Tensor):
 63 |         for block in self.blocks:
 64 |             x = block(x)
 65 |         x = x.mean(dim=-1)  # aggregate over time
 66 |         p = torch.sigmoid(self.linear(x))  # map to parmeters
 67 |         return p
 68 | 
 69 | 
 70 | class AudioEffectDataset(torch.nn.Module):
 71 |     def __init__(
 72 |         self, root_dir: str, processor: dasp_pytorch.Processor, length: int = 131072
 73 |     ) -> None:
 74 |         super().__init__()
 75 |         self.processor = processor
 76 |         self.length = length
 77 |         # find all audio files in the root directory
 78 |         filepaths = glob.glob(os.path.join(root_dir, "**/*.wav"), recursive=True)
 79 | 
 80 |         self.examples = []
 81 |         # create example of length `length` from each file
 82 |         for filepath in filepaths:
 83 |             md = torchaudio.info(filepath)
 84 |             if md.num_frames < length:
 85 |                 continue
 86 |             num_examples = md.num_frames // length
 87 |             for n in range(num_examples):
 88 |                 frame_offset = n * length
 89 |                 self.examples.append((filepath, frame_offset))
 90 | 
 91 |     def __len__(self):
 92 |         return len(self.examples)
 93 | 
 94 |     def __getitem__(self, idx: int):
 95 |         filepath, frame_offset = self.examples[idx]
 96 | 
 97 |         # read segment of audio from file
 98 |         x, sr = torchaudio.load(
 99 |             filepath,
100 |             frame_offset=frame_offset,
101 |             num_frames=self.length,
102 |             backend="soundfile",
103 |         )
104 |         x = x.unsqueeze(0)  # add batch dim
105 | 
106 |         # generate random parameters on (0,1)
107 |         param_tensor = torch.rand(1, self.processor.num_params)
108 | 
109 |         # apply effect with random parameters
110 |         with torch.no_grad():
111 |             y = self.processor.process_normalized(x, param_tensor)
112 | 
113 |         # remove batch dim
114 |         x = x.squeeze(0)
115 |         y = y.squeeze(0)
116 | 
117 |         return x, y
118 | 
119 | 
120 | def train(
121 |     root_dir: str,
122 |     lr: float = 1e-4,
123 |     batch_size: int = 8,
124 |     num_epochs: int = 100,
125 |     use_gpu: bool = False,
126 | ):
127 |     # create instance of compressor
128 |     compressor = dasp_pytorch.Compressor(44100)
129 | 
130 |     # create parameter estimation network
131 |     net = ParameterNetwork(compressor.num_params)
132 | 
133 |     # create optimizer
134 |     optimizer = torch.optim.Adam(net.parameters(), lr=lr)
135 | 
136 |     # create dataset
137 |     dataset = AudioEffectDataset(root_dir, compressor)
138 |     dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size)
139 | 
140 |     # use a frequency domain loss function
141 |     criterion = auraloss.freq.STFTLoss()
142 | 
143 |     # move to GPU if available
144 |     if use_gpu:
145 |         net.cuda()
146 |         criterion.cuda()
147 | 
148 |     # main training loop
149 |     for epoch in range(num_epochs):
150 |         # iterate over the dataset
151 |         print("Epoch:", epoch + 1)
152 |         loss_history = []
153 |         pbar = tqdm(dataloader)
154 |         for batch, data in enumerate(pbar):
155 |             x, y = data  # input, output
156 | 
157 |             # move to GPU if available
158 |             if use_gpu:
159 |                 x = x.cuda()
160 |                 y = y.cuda()
161 | 
162 |             # 1. estimate parameters with network
163 |             p_hat = net(y)
164 | 
165 |             # 2. apply effect with estimated normalized parameters
166 |             y_hat = compressor.process_normalized(x, p_hat)
167 | 
168 |             # 3. compute loss
169 |             loss = criterion(y_hat, y)
170 | 
171 |             # 4. optimize
172 |             optimizer.zero_grad()
173 |             loss.backward()
174 |             optimizer.step()
175 | 
176 |             loss_history.append(loss.item())
177 |             pbar.set_description(f"loss: {np.mean(loss_history):.4e}")
178 | 
179 | 
180 | if __name__ == "__main__":
181 |     train("data/", use_gpu=True)
182 | 


--------------------------------------------------------------------------------
/examples/demo.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import torch
  3 | import torchaudio
  4 | from dasp_pytorch import (
  5 |     distortion,
  6 |     compressor,
  7 |     parametric_eq,
  8 |     noise_shaped_reverberation,
  9 | )
 10 | 
 11 | if __name__ == "__main__":
 12 |     use_gpu = torch.cuda.is_available()
 13 | 
 14 |     if use_gpu:
 15 |         torch.set_default_device("cuda")
 16 | 
 17 |     os.makedirs("outputs/demo", exist_ok=True)
 18 | 
 19 |     if not os.path.exists("outputs/demo/idmt-rock-input-varying-gain.wav"):
 20 |         os.system(
 21 |             "wget csteinmetz1.github.io/sounds/assets/amps/idmt-rock-input-varying-gain.wav -O outputs/demo/idmt-rock-input-varying-gain.wav"
 22 |         )
 23 | 
 24 |     # load DI guitar sample
 25 |     x, sr = torchaudio.load(
 26 |         "outputs/demo/idmt-rock-input-varying-gain.wav", backend="soundfile"
 27 |     )
 28 | 
 29 |     start_idx = int(49.0 * sr)
 30 |     end_idx = start_idx + 441000
 31 |     x = x[0:1, start_idx:end_idx]
 32 | 
 33 |     # add batch dim
 34 |     x = x.unsqueeze(0)
 35 | 
 36 |     if use_gpu:
 37 |         x = x.cuda()
 38 | 
 39 |     # process with chain of effects
 40 |     y = parametric_eq(
 41 |         x,
 42 |         sr,
 43 |         low_shelf_gain_db=torch.tensor([-12.0]),
 44 |         low_shelf_cutoff_freq=torch.tensor([1000]),
 45 |         low_shelf_q_factor=torch.tensor([0.5]),
 46 |         band0_gain_db=torch.tensor([0.0]),
 47 |         band0_cutoff_freq=torch.tensor([1000]),
 48 |         band0_q_factor=torch.tensor([0.5]),
 49 |         band1_gain_db=torch.tensor([0.0]),
 50 |         band1_cutoff_freq=torch.tensor([1000]),
 51 |         band1_q_factor=torch.tensor([0.5]),
 52 |         band2_gain_db=torch.tensor([0.0]),
 53 |         band2_cutoff_freq=torch.tensor([1000]),
 54 |         band2_q_factor=torch.tensor([0.5]),
 55 |         band3_gain_db=torch.tensor([0.0]),
 56 |         band3_cutoff_freq=torch.tensor([1000]),
 57 |         band3_q_factor=torch.tensor([0.5]),
 58 |         high_shelf_gain_db=torch.tensor([12.0]),
 59 |         high_shelf_cutoff_freq=torch.tensor([4000]),
 60 |         high_shelf_q_factor=torch.tensor([0.5]),
 61 |     )
 62 |     y = compressor(
 63 |         y,
 64 |         sr,
 65 |         threshold_db=torch.tensor([-12.0]),
 66 |         ratio=torch.tensor([4.0]),
 67 |         attack_ms=torch.tensor([10.0]),
 68 |         release_ms=torch.tensor([100.0]),
 69 |         knee_db=torch.tensor([12.0]),
 70 |         makeup_gain_db=torch.tensor([0.0]),
 71 |     )
 72 | 
 73 |     y = distortion(y, sr, drive_db=torch.tensor([42.0]))
 74 | 
 75 |     y = parametric_eq(
 76 |         y,
 77 |         sr,
 78 |         low_shelf_gain_db=torch.tensor([0.0]),
 79 |         low_shelf_cutoff_freq=torch.tensor([1000]),
 80 |         low_shelf_q_factor=torch.tensor([0.5]),
 81 |         band0_gain_db=torch.tensor([0.0]),
 82 |         band0_cutoff_freq=torch.tensor([1000]),
 83 |         band0_q_factor=torch.tensor([0.5]),
 84 |         band1_gain_db=torch.tensor([0.0]),
 85 |         band1_cutoff_freq=torch.tensor([1000]),
 86 |         band1_q_factor=torch.tensor([0.5]),
 87 |         band2_gain_db=torch.tensor([0.0]),
 88 |         band2_cutoff_freq=torch.tensor([1000]),
 89 |         band2_q_factor=torch.tensor([0.5]),
 90 |         band3_gain_db=torch.tensor([0.0]),
 91 |         band3_cutoff_freq=torch.tensor([1000]),
 92 |         band3_q_factor=torch.tensor([0.5]),
 93 |         high_shelf_gain_db=torch.tensor([-18.0]),
 94 |         high_shelf_cutoff_freq=torch.tensor([4000]),
 95 |         high_shelf_q_factor=torch.tensor([0.5]),
 96 |     )
 97 | 
 98 |     y = noise_shaped_reverberation(
 99 |         y,
100 |         sr,
101 |         band0_gain=torch.tensor([0.8]),
102 |         band1_gain=torch.tensor([0.4]),
103 |         band2_gain=torch.tensor([0.2]),
104 |         band3_gain=torch.tensor([0.5]),
105 |         band4_gain=torch.tensor([0.5]),
106 |         band5_gain=torch.tensor([0.5]),
107 |         band6_gain=torch.tensor([0.5]),
108 |         band7_gain=torch.tensor([0.6]),
109 |         band8_gain=torch.tensor([0.7]),
110 |         band9_gain=torch.tensor([0.8]),
111 |         band10_gain=torch.tensor([0.9]),
112 |         band11_gain=torch.tensor([1.0]),
113 |         band0_decay=torch.tensor([0.5]),
114 |         band1_decay=torch.tensor([0.5]),
115 |         band2_decay=torch.tensor([0.5]),
116 |         band3_decay=torch.tensor([0.5]),
117 |         band4_decay=torch.tensor([0.5]),
118 |         band5_decay=torch.tensor([0.5]),
119 |         band6_decay=torch.tensor([0.5]),
120 |         band7_decay=torch.tensor([0.5]),
121 |         band8_decay=torch.tensor([0.5]),
122 |         band9_decay=torch.tensor([0.5]),
123 |         band10_decay=torch.tensor([0.5]),
124 |         band11_decay=torch.tensor([0.5]),
125 |         mix=torch.tensor([0.15]),
126 |     )
127 | 
128 |     y = y.squeeze(0)
129 |     x = x.squeeze(0)
130 |     print(y.shape)
131 | 
132 |     y = y / torch.max(torch.abs(y))
133 |     x = x / torch.max(torch.abs(x))
134 | 
135 |     torchaudio.save(
136 |         "outputs/demo/idmt-rock-input-varying-input.wav",
137 |         x.cpu(),
138 |         sr,
139 |         backend="soundfile",
140 |     )
141 | 
142 |     torchaudio.save(
143 |         "outputs/demo/idmt-rock-input-varying-output.wav",
144 |         y.cpu(),
145 |         sr,
146 |         backend="soundfile",
147 |     )
148 | 


--------------------------------------------------------------------------------
/examples/quickstart.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |   "cells": [
 3 |     {
 4 |       "cell_type": "code",
 5 |       "execution_count": null,
 6 |       "metadata": {
 7 |         "id": "Q32l5f06ohtz"
 8 |       },
 9 |       "outputs": [],
10 |       "source": [
11 |         "!pip install dasp-pytorch"
12 |       ]
13 |     },
14 |     {
15 |       "cell_type": "code",
16 |       "execution_count": null,
17 |       "metadata": {
18 |         "id": "MsHHumIypsAy"
19 |       },
20 |       "outputs": [],
21 |       "source": [
22 |         "!wget https://csteinmetz1.github.io/sounds/assets/short_riff.wav"
23 |       ]
24 |     },
25 |     {
26 |       "cell_type": "code",
27 |       "execution_count": null,
28 |       "metadata": {
29 |         "id": "VGSU9x2VojWg"
30 |       },
31 |       "outputs": [],
32 |       "source": [
33 |         "import torch\n",
34 |         "import torchaudio\n",
35 |         "import dasp_pytorch"
36 |       ]
37 |     },
38 |     {
39 |       "cell_type": "code",
40 |       "execution_count": null,
41 |       "metadata": {
42 |         "id": "MOhyTl3mopSi"
43 |       },
44 |       "outputs": [],
45 |       "source": [
46 |         "# Load audio\n",
47 |         "x, sr = torchaudio.load(\"short_riff.wav\")\n",
48 |         "\n",
49 |         "# create batch dim\n",
50 |         "# (batch_size, n_channels, n_samples)\n",
51 |         "x = x.unsqueeze(0)\n",
52 |         "\n",
53 |         "# apply some distortion with 16 dB drive\n",
54 |         "drive = torch.tensor([16.0])\n",
55 |         "y = dasp_pytorch.functional.distortion(x, sr, drive)\n",
56 |         "\n",
57 |         "# create a parameter to optimizer\n",
58 |         "drive_hat = torch.nn.Parameter(torch.tensor(0.0))\n",
59 |         "optimizer = torch.optim.Adam([drive_hat], lr=0.01)\n",
60 |         "\n",
61 |         "# optimize the parameter\n",
62 |         "n_iters = 2500\n",
63 |         "for n in range(n_iters):\n",
64 |         "    # apply distortion with the estimated parameter\n",
65 |         "    y_hat = dasp_pytorch.functional.distortion(x, sr, drive_hat)\n",
66 |         "\n",
67 |         "    # compute distance between estimate and target\n",
68 |         "    loss = torch.nn.functional.mse_loss(y_hat, y)\n",
69 |         "\n",
70 |         "    # optimize\n",
71 |         "    optimizer.zero_grad()\n",
72 |         "    loss.backward()\n",
73 |         "    optimizer.step()\n",
74 |         "    print(\n",
75 |         "        f\"step: {n+1}/{n_iters}, loss: {loss.item():.3e}, drive: {drive_hat.item():.3f}\\r\"\n",
76 |         "    )\n"
77 |       ]
78 |     }
79 |   ],
80 |   "metadata": {
81 |     "colab": {
82 |       "provenance": []
83 |     },
84 |     "kernelspec": {
85 |       "display_name": "Python 3",
86 |       "name": "python3"
87 |     },
88 |     "language_info": {
89 |       "name": "python"
90 |     }
91 |   },
92 |   "nbformat": 4,
93 |   "nbformat_minor": 0
94 | }
95 | 


--------------------------------------------------------------------------------
/examples/reverse_eng.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import torchaudio
 3 | import dasp_pytorch
 4 | 
 5 | # In this example we will demonstrate the use of dasp_pytorch to reverse engineer
 6 | # a distortion effect. We will use a simple distortion effect with a single parameter.
 7 | # We will then use dasp_pytorch to estimate the parameter value from a target signal using gradient decent.
 8 | # This is not a realisitic example, since we know the true drive parameter value, but it demonstrates
 9 | # how to use gradient descent to estimate parameters.
10 | 
11 | # Load audio
12 | x, sr = torchaudio.load("audio/short_riff.wav")
13 | 
14 | # create batch dim
15 | # dasp expects (batch_size, n_channels, n_samples)
16 | x = x.unsqueeze(0)
17 | 
18 | # apply some distortion with 16 dB drive
19 | drive = torch.tensor([16.0])
20 | y = dasp_pytorch.functional.distortion(x, drive)
21 | 
22 | # create a parameter to optimizer
23 | drive_hat = torch.nn.Parameter(torch.tensor(0.0))
24 | optimizer = torch.optim.Adam([drive_hat], lr=0.01)
25 | 
26 | # optimize the parameter
27 | n_iters = 2500
28 | for n in range(n_iters):
29 |     # apply distortion with the estimated parameter
30 |     y_hat = dasp_pytorch.functional.distortion(x, drive_hat)
31 | 
32 |     # compute distance between estimate and target
33 |     loss = torch.nn.functional.mse_loss(y_hat, y)
34 | 
35 |     # optimize
36 |     optimizer.zero_grad()
37 |     loss.backward()
38 |     optimizer.step()
39 |     print(
40 |         f"step: {n+1}/{n_iters}, loss: {loss.item():.3f}, drive: {drive_hat.item():.3f}"
41 |     )
42 | 


--------------------------------------------------------------------------------
/examples/style_transfer.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import glob
  3 | import torch
  4 | import auraloss
  5 | import torchaudio
  6 | import numpy as np
  7 | import matplotlib.pyplot as plt
  8 | 
  9 | from tqdm import tqdm
 10 | from typing import List, Optional
 11 | from dasp_pytorch import ParametricEQ, Compressor, NoiseShapedReverb, Gain
 12 | 
 13 | 
 14 | def plot_loss(log_dir, loss_history: List[float]):
 15 |     fig, ax = plt.subplots()
 16 |     ax.plot(loss_history)
 17 |     ax.set_xlabel("Iteration")
 18 |     ax.set_ylabel("Loss")
 19 |     plt.grid(c="lightgray")
 20 |     outfilepath = os.path.join(log_dir, "loss.png")
 21 |     plt.savefig(outfilepath, dpi=300)
 22 |     plt.close("all")
 23 | 
 24 | 
 25 | class TCNBlock(torch.nn.Module):
 26 |     def __init__(
 27 |         self,
 28 |         in_channels: int,
 29 |         out_channels: int,
 30 |         kernel_size: int,
 31 |         dilation: int = 1,
 32 |     ):
 33 |         super().__init__()
 34 |         self.conv1 = torch.nn.Conv1d(
 35 |             in_channels,
 36 |             out_channels,
 37 |             kernel_size,
 38 |             dilation=dilation,
 39 |             stride=2,
 40 |         )
 41 |         self.relu1 = torch.nn.PReLU(out_channels)
 42 |         self.bn1 = torch.nn.BatchNorm1d(out_channels)
 43 |         self.conv2 = torch.nn.Conv1d(
 44 |             out_channels,
 45 |             out_channels,
 46 |             kernel_size,
 47 |             dilation=1,
 48 |         )
 49 |         self.relu2 = torch.nn.PReLU(out_channels)
 50 |         self.bn2 = torch.nn.BatchNorm1d(out_channels)
 51 | 
 52 |     def forward(self, x: torch.Tensor):
 53 |         x = self.bn1(self.relu1(self.conv1(x)))
 54 |         x = self.bn2(self.relu2(self.conv2(x)))
 55 |         return x
 56 | 
 57 | 
 58 | class Encoder(torch.nn.Module):
 59 |     def __init__(self, embed_dim: int, ch_dim: int = 256) -> None:
 60 |         super().__init__()
 61 |         self.embed_dim = embed_dim
 62 | 
 63 |         # we will use a simple TCN to estimate a single conditioning parameter
 64 |         self.blocks = torch.nn.ModuleList()
 65 |         self.blocks.append(TCNBlock(1, ch_dim, 7, dilation=1))
 66 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=2))
 67 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=4))
 68 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=8))
 69 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=16))
 70 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=1))
 71 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=2))
 72 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=4))
 73 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=8))
 74 |         self.blocks.append(TCNBlock(ch_dim, ch_dim, 7, dilation=16))
 75 | 
 76 |         self.mlp = torch.nn.Sequential(
 77 |             torch.nn.Linear(ch_dim, 256),
 78 |             torch.nn.ReLU(),
 79 |             torch.nn.Linear(256, 256),
 80 |             torch.nn.ReLU(),
 81 |             torch.nn.Linear(256, embed_dim),
 82 |         )
 83 | 
 84 |     def forward(self, x: torch.Tensor):
 85 |         for block in self.blocks:
 86 |             x = block(x)
 87 |         x = x.mean(dim=-1)  # aggregate over time
 88 |         return self.mlp(x)  # map to latent
 89 | 
 90 | 
 91 | class ParameterProjector(torch.nn.Module):
 92 |     def __init__(self, embed_dim: int, num_control_params: int, num_hidden: int = 256):
 93 |         super().__init__()
 94 |         self.embed_dim = embed_dim
 95 |         self.num_hidden = num_hidden
 96 |         self.num_control_params = num_control_params
 97 | 
 98 |         self.layers = torch.nn.Sequential(
 99 |             torch.nn.Linear(embed_dim, num_hidden),
100 |             torch.nn.ReLU(),
101 |             torch.nn.Linear(num_hidden, num_hidden),
102 |             torch.nn.ReLU(),
103 |             torch.nn.Linear(num_hidden, num_control_params),
104 |         )
105 | 
106 |     def forward(self, x: torch.Tensor):
107 |         return torch.sigmoid(self.layers(x))
108 | 
109 | 
110 | class StyleTransferModel(torch.nn.Module):
111 |     def __init__(self, sample_rate: int) -> None:
112 |         super().__init__()
113 | 
114 |         # create efffects
115 |         self.equalizer = ParametricEQ(sample_rate)
116 |         self.compressor = Compressor(sample_rate)
117 |         self.reverb = NoiseShapedReverb(sample_rate)
118 |         self.gain = Gain(sample_rate)
119 | 
120 |         # create networks
121 |         self.encoder = Encoder(512)
122 |         self.equalizer_projector = ParameterProjector(
123 |             self.encoder.embed_dim * 2, self.equalizer.num_params
124 |         )
125 |         self.compressor_projector = ParameterProjector(
126 |             self.encoder.embed_dim * 2, self.compressor.num_params
127 |         )
128 |         self.reverb_projector = ParameterProjector(
129 |             self.encoder.embed_dim * 2, self.reverb.num_params
130 |         )
131 |         self.gain_projector = ParameterProjector(
132 |             self.encoder.embed_dim * 2, self.gain.num_params
133 |         )
134 | 
135 |     def forward(self, input: torch.Tensor, ref: torch.Tensor):
136 |         # process the input and reference with encoder
137 |         z_input = self.encoder(input)
138 |         z_ref = self.encoder(ref)
139 | 
140 |         # combine the input and reference embeddings
141 |         z = torch.cat((z_input, z_ref), dim=-1)
142 | 
143 |         # estimate parameters for each effect
144 |         equalizer_params = self.equalizer_projector(z)
145 |         compressor_params = self.compressor_projector(z)
146 |         reverb_params = self.reverb_projector(z)
147 |         gain_params = self.gain_projector(z)
148 | 
149 |         # process audio with estimated parameters
150 |         y = input.clone()
151 |         y = self.equalizer.process_normalized(y, equalizer_params)
152 |         y = self.compressor.process_normalized(y, compressor_params)
153 |         y = self.reverb.process_normalized(y, reverb_params)
154 |         y = self.gain.process_normalized(y, gain_params)
155 | 
156 |         return y
157 | 
158 | 
159 | class AudioFileDataset(torch.nn.Module):
160 |     def __init__(
161 |         self,
162 |         filepaths: List[str],
163 |         length: int = 131072,
164 |     ) -> None:
165 |         super().__init__()
166 |         self.length = length
167 | 
168 |         assert len(filepaths) > 0, "No files found."
169 | 
170 |         self.examples = []
171 |         # create example of length `length` from each file
172 |         print("Creating dataset...")
173 |         for filepath in tqdm(filepaths):
174 |             md = torchaudio.info(filepath)
175 |             if md.num_frames < length:
176 |                 continue
177 |             num_examples = md.num_frames // length
178 |             for n in range(num_examples):
179 |                 frame_offset = n * length
180 | 
181 |                 frame, sr = torchaudio.load(
182 |                     filepath,
183 |                     frame_offset=frame_offset,
184 |                     num_frames=length,
185 |                     backend="soundfile",
186 |                 )
187 | 
188 |                 # check for silence
189 |                 if torch.max(torch.abs(frame)) < 1e-4:
190 |                     continue
191 | 
192 |                 self.examples.append((filepath, frame_offset))
193 | 
194 |         self.examples = self.examples
195 | 
196 |     def __len__(self):
197 |         return len(self.examples)
198 | 
199 |     def __getitem__(self, idx: int):
200 |         filepath, frame_offset = self.examples[idx]
201 | 
202 |         # read segment of audio from file
203 |         x, sr = torchaudio.load(
204 |             filepath,
205 |             frame_offset=frame_offset,
206 |             num_frames=self.length,
207 |             backend="soundfile",
208 |         )
209 | 
210 |         # clamp to [-1,1] to ensure within range
211 |         x = torch.clamp(x, -1, 1)
212 | 
213 |         return x
214 | 
215 | 
216 | def validate(
217 |     model: torch.nn.Module,
218 |     val_dataloader: torch.utils.data.DataLoader,
219 |     num_examples: int = 1,
220 |     use_gpu: bool = False,
221 |     epoch: int = 0,
222 |     log_dir: str = "outputs/style_transfer",
223 | ):
224 |     model.eval()
225 | 
226 |     for batch_idx, batch in enumerate(val_dataloader):
227 |         if batch_idx >= num_examples:
228 |             break
229 | 
230 |         input = batch
231 | 
232 |         if use_gpu:
233 |             input = input.cuda()
234 | 
235 |         with torch.no_grad():
236 |             input_a, input_b, ref_a, ref_b, output_a = step(input, model)
237 | 
238 |         # save audio examples
239 |         input_a_filepath = os.path.join(
240 |             log_dir, "audio", f"epoch={epoch}_input_a_{batch_idx}.wav"
241 |         )
242 |         input_b_filepath = os.path.join(
243 |             log_dir, "audio", f"epoch={epoch}_input_b_{batch_idx}.wav"
244 |         )
245 |         ref_a_filepath = os.path.join(
246 |             log_dir, "audio", f"epoch={epoch}_ref_a_{batch_idx}.wav"
247 |         )
248 |         ref_b_filepath = os.path.join(
249 |             log_dir, "audio", f"epoch={epoch}_ref_b_{batch_idx}.wav"
250 |         )
251 |         output_a_filepath = os.path.join(
252 |             log_dir, "audio", f"epoch={epoch}_output_a_{batch_idx}.wav"
253 |         )
254 |         torchaudio.save(
255 |             input_a_filepath, input_a.cpu().squeeze(0), 44100, backend="soundfile"
256 |         )
257 |         torchaudio.save(
258 |             input_b_filepath, input_b.cpu().squeeze(0), 44100, backend="soundfile"
259 |         )
260 |         torchaudio.save(
261 |             ref_a_filepath, ref_a.cpu().squeeze(0), 44100, backend="soundfile"
262 |         )
263 |         torchaudio.save(
264 |             ref_b_filepath, ref_b.cpu().squeeze(0), 44100, backend="soundfile"
265 |         )
266 |         torchaudio.save(
267 |             output_a_filepath, output_a.cpu().squeeze(0), 44100, backend="soundfile"
268 |         )
269 | 
270 | 
271 | def step(input: torch.Tensor, model: torch.nn.Module):
272 |     # generate reference by randomly processing input
273 |     # torch.manual_seed(1)
274 |     rand_equalizer_params = torch.rand(
275 |         input.shape[0],
276 |         model.equalizer.num_params,
277 |     ).type_as(input)
278 |     rand_compressor_params = torch.rand(
279 |         input.shape[0],
280 |         model.compressor.num_params,
281 |     ).type_as(input)
282 |     rand_reverb_params = torch.rand(
283 |         input.shape[0],
284 |         model.reverb.num_params,
285 |     ).type_as(input)
286 |     rand_gain_params = torch.rand(
287 |         input.shape[0],
288 |         model.gain.num_params,
289 |     ).type_as(input)
290 | 
291 |     # process input with random parameters
292 |     # randomly disable the effects
293 |     ref = input.clone()
294 |     # if torch.rand(1) < 0.5:
295 |     ref = model.equalizer.process_normalized(ref, rand_equalizer_params)
296 |     # if torch.rand(1) < 0.5:
297 |     ref = model.compressor.process_normalized(ref, rand_compressor_params)
298 |     # if torch.rand(1) < 0.5:
299 |     ref = model.reverb.process_normalized(ref, rand_reverb_params)
300 | 
301 |     # ref = model.gain.process_normalized(ref, rand_gain_params)
302 | 
303 |     # if not stereo already, convert to stereo
304 |     # if ref.shape[1] == 1:
305 |     #    ref = ref.repeat(1, 2, 1)
306 | 
307 |     # peak normalize reference recordings
308 |     peak, _ = torch.max(torch.abs(ref), dim=-1, keepdim=True)
309 |     ref = ref / peak
310 | 
311 |     # apply random gain from -24 dB to 0 dB
312 |     gain_db = torch.rand(input.shape[0], 1, 1).type_as(input) * 24
313 |     gain_lin = torch.pow(10, -gain_db / 20)
314 |     ref = ref * gain_lin
315 | 
316 |     # apply random gain to input
317 |     gain_db = torch.rand(input.shape[0], 1, 1).type_as(input) * 24
318 |     gain_lin = torch.pow(10, -gain_db / 20)
319 |     input = input * gain_lin
320 | 
321 |     # split into A and B sections
322 |     input_a, input_b = torch.chunk(input, 2, dim=-1)
323 |     ref_a, ref_b = torch.chunk(ref, 2, dim=-1)
324 | 
325 |     # forward pass
326 |     output_a = model(input_a, torch.mean(ref_b, dim=1, keepdim=True))
327 | 
328 |     return input_a, input_b, ref_a, ref_b, output_a
329 | 
330 | 
331 | def train(
332 |     model: torch.nn.Module,
333 |     train_dataloader: torch.utils.data.DataLoader,
334 |     val_dataloader: Optional[torch.utils.data.DataLoader] = None,
335 |     lr: float = 1e-4,
336 |     epochs: int = 250,
337 |     use_gpu: bool = False,
338 |     log_dir: str = "outputs/style_transfer",
339 | ):
340 |     optimizer = torch.optim.Adam(model.parameters(), lr=lr)
341 |     loss_fn = auraloss.freq.MultiResolutionSTFTLoss()
342 |     scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, epochs)
343 | 
344 |     if use_gpu:
345 |         model = model.cuda()
346 |         loss_fn = loss_fn.cuda()
347 | 
348 |     epoch_loss_history = []
349 |     for epoch in range(epochs):
350 |         pbar = tqdm(train_dataloader)
351 |         loss_history = []
352 |         model.train()
353 |         for batch in pbar:
354 |             input = batch
355 | 
356 |             if use_gpu:
357 |                 input = input.cuda()
358 | 
359 |             # forward pass
360 |             input_a, input_b, ref_a, ref_b, output_a = step(input, model)
361 | 
362 |             # compute loss on A section
363 |             loss = loss_fn(output_a, ref_a)
364 |             loss_history.append(loss.item())
365 |             pbar.set_description(f"Epoch {epoch} Loss: {np.mean(loss_history):.4f}")
366 | 
367 |             optimizer.zero_grad()
368 |             loss.backward()
369 |             optimizer.step()
370 |             scheduler.step()
371 | 
372 |         epoch_loss_history.append(np.mean(loss_history))
373 |         plot_loss(log_dir, epoch_loss_history)
374 |         validate(
375 |             model,
376 |             val_dataloader,
377 |             epoch=epoch + 1,
378 |             log_dir=log_dir,
379 |             use_gpu=use_gpu,
380 |         )
381 | 
382 | 
383 | if __name__ == "__main__":
384 |     sample_rate = 44100
385 |     log_dir = "outputs/style_transfer"
386 |     os.makedirs(log_dir, exist_ok=True)
387 |     os.makedirs(os.path.join(log_dir, "audio"), exist_ok=True)
388 |     model = StyleTransferModel(sample_rate)
389 | 
390 |     filepaths = glob.glob(
391 |         "/import/c4dm-datasets/VocalSet1-2/data_by_singer/**/*.wav",
392 |         recursive=True,
393 |     )
394 |     train_filepaths = filepaths[: int(len(filepaths) * 0.8)]
395 |     val_filepaths = filepaths[int(len(filepaths) * 0.8) :]
396 | 
397 |     # train_filepaths = train_filepaths[:1]
398 |     # val_filepaths = train_filepaths[:1]
399 | 
400 |     train_dataset = AudioFileDataset(train_filepaths, length=262144)
401 |     train_dataloader = torch.utils.data.DataLoader(
402 |         train_dataset,
403 |         batch_size=8,
404 |         shuffle=True,
405 |         num_workers=8,
406 |     )
407 | 
408 |     val_dataset = AudioFileDataset(val_filepaths, length=262144)
409 |     val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=1)
410 | 
411 |     train(
412 |         model,
413 |         train_dataloader,
414 |         val_dataloader=val_dataloader,
415 |         log_dir=log_dir,
416 |         use_gpu=True,
417 |     )
418 | 


--------------------------------------------------------------------------------
/examples/virtual_analog.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import torch
  3 | import auraloss
  4 | import torchaudio
  5 | import numpy as np
  6 | import matplotlib.pyplot as plt
  7 | 
  8 | from tqdm import tqdm
  9 | from dasp_pytorch import ParametricEQ
 10 | 
 11 | # This is a good example of how to chain processors together to create a more complex effect.
 12 | # In this case, we create our own torch.nn.Module using the processor functions.
 13 | 
 14 | 
 15 | def plot_waveforms(
 16 |     src: torch.Tensor,
 17 |     target: torch.Tensor,
 18 |     pred: torch.Tensor,
 19 |     num_segments: int = 6,
 20 |     segment_length: int = 4096,
 21 |     amp_name: str = "amp",
 22 | ):
 23 |     fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(8, 6))
 24 |     axs = np.reshape(axs, -1)
 25 | 
 26 |     for n in range(num_segments):
 27 |         start_idx = np.random.randint(0, src.shape[-1] - segment_length)
 28 |         stop_idx = start_idx + segment_length
 29 |         # axs[n].plot(
 30 |         #    src[0, start_idx:stop_idx].numpy(),
 31 |         #    label="src",
 32 |         #    alpha=0.7,
 33 |         # )
 34 |         axs[n].plot(
 35 |             target[0, start_idx:stop_idx].numpy(),
 36 |             label="target",
 37 |             alpha=0.7,
 38 |         )
 39 |         axs[n].plot(
 40 |             pred[0, start_idx:stop_idx].numpy(),
 41 |             label="pred",
 42 |             alpha=0.7,
 43 |         )
 44 |         axs[n].grid(c="lightgray")
 45 |         if n == 0:
 46 |             axs[n].legend()
 47 | 
 48 |     plt.savefig(f"outputs/virtual_analog/{amp_name}/audio.png", dpi=300)
 49 |     plt.close("all")
 50 | 
 51 | 
 52 | def measure_response(
 53 |     equalizer: torch.nn.Module,
 54 |     filter_params: torch.Tensor,
 55 |     sample_rate: float,
 56 |     N: int = 16384,
 57 |     use_gpu: bool = False,
 58 | ):
 59 |     impulse = torch.zeros(1, 1, N)
 60 |     impulse[0, 0, 0] = 1.0
 61 | 
 62 |     if use_gpu:
 63 |         impulse = impulse.cuda()
 64 | 
 65 |     # pass impulse through model
 66 |     with torch.no_grad():
 67 |         y = equalizer.process_normalized(
 68 |             impulse,
 69 |             torch.sigmoid(filter_params),
 70 |         )
 71 | 
 72 |     fft_output = np.fft.fft(y.squeeze().numpy())
 73 |     freqs = np.fft.fftfreq(N, 1 / sample_rate)
 74 | 
 75 |     # Calculate the magnitude in dB and phase
 76 |     magnitude = 20 * np.log10(np.abs(fft_output))
 77 |     phase = np.angle(fft_output)
 78 | 
 79 |     freqs = freqs[: N // 2]
 80 |     magnitude = magnitude[: N // 2]
 81 | 
 82 |     return freqs, magnitude
 83 | 
 84 | 
 85 | def plot_system(
 86 |     model: torch.nn.Module,
 87 |     sample_rate: float,
 88 |     use_gpu: bool = False,
 89 |     amp_name: str = "amp",
 90 | ):
 91 |     # plot response of pre and post filters
 92 |     fig, axs = plt.subplots(1, 3, figsize=(8, 3), sharex=False, sharey=False)
 93 | 
 94 |     # -------------------------- plot pre-filter --------------------------
 95 |     freqs, magnitude = measure_response(
 96 |         model.equalizer, model.pre_filter_params, sample_rate
 97 |     )
 98 | 
 99 |     # Magnitude response
100 |     axs[0].plot(freqs, magnitude)
101 |     axs[0].set_title("Pre-filter")
102 |     axs[0].set_xlabel("Frequency (Hz)")
103 |     axs[0].set_ylabel("Magnitude (dB)")
104 |     axs[0].set_xlim(100, 20000)
105 |     axs[0].set_ylim(-80, 80)
106 |     axs[0].set_xscale("log")
107 |     axs[0].grid(c="lightgray")
108 | 
109 |     # -------------------------- plot nonlinearity --------------------------
110 |     x = torch.linspace(-3, 3, 1000)
111 | 
112 |     if use_gpu:
113 |         x = x.cuda()
114 | 
115 |     with torch.no_grad():
116 |         y = model.mlp_nonlinearity(x.unsqueeze(1)).squeeze(1)
117 | 
118 |     x = x.cpu()
119 |     y = y.cpu()
120 | 
121 |     axs[1].plot(x, y)
122 |     axs[1].grid(c="lightgray")
123 |     axs[1].set_title("Nonlinearity")
124 |     axs[1].set_xlim(-3, 3)
125 |     axs[1].set_ylim(-3, 3)
126 |     axs[1].set_aspect("equal", "box")
127 | 
128 |     # -------------------------- plot post-filter --------------------------
129 | 
130 |     freqs, magnitude = measure_response(
131 |         model.equalizer, model.post_filter_params, sample_rate
132 |     )
133 | 
134 |     # Magnitude response
135 |     axs[2].plot(freqs, magnitude)
136 |     axs[2].set_title("Post-filter")
137 |     axs[2].set_xlabel("Frequency (Hz)")
138 |     axs[2].set_ylabel("Magnitude (dB)")
139 |     axs[2].set_xlim(100, 20000)
140 |     axs[2].set_ylim(-80, 80)
141 |     axs[2].set_xscale("log")
142 |     axs[2].grid(c="lightgray")
143 | 
144 |     plt.tight_layout()
145 |     plt.savefig(f"outputs/virtual_analog/{amp_name}/system.png", dpi=300)
146 |     plt.close("all")
147 | 
148 | 
149 | def plot_loss(loss_history: list, amp_name: str = "amp"):
150 |     plt.figure()
151 |     plt.plot(loss_history)
152 |     plt.grid(c="lightgray")
153 |     plt.xlabel("Epoch")
154 |     plt.ylabel("Loss")
155 |     plt.savefig(f"outputs/virtual_analog/{amp_name}/loss.png", dpi=300)
156 |     plt.close("all")
157 | 
158 | 
159 | class FileDataset(torch.utils.data.Dataset):
160 |     def __init__(self, src_filepath: str, target_filepath: str, length: int = 65536):
161 |         self.length = length
162 | 
163 |         # load files into RAM
164 |         src, sr = torchaudio.load(src_filepath, backend="soundfile")
165 |         target, sr = torchaudio.load(target_filepath, backend="soundfile")
166 | 
167 |         self.examples = []
168 |         # create examples by slicing the audio into segments of length `length`
169 |         num_segments = src.shape[-1] // length
170 |         for n in range(num_segments):
171 |             start_idx = n * length
172 |             stop_idx = start_idx + length
173 |             src_segment = src[0:1, start_idx:stop_idx]
174 |             target_segment = target[0:1, start_idx:stop_idx]
175 |             self.examples.append((src_segment, target_segment))
176 | 
177 |         self.examples = self.examples * 100
178 | 
179 |     def __len__(self):
180 |         return len(self.examples)
181 | 
182 |     def __getitem__(self, idx: int):
183 |         src_segment, target_segment = self.examples[idx]
184 |         return src_segment, target_segment
185 | 
186 | 
187 | class DistortionModel(torch.nn.Module):
188 |     def __init__(self, sample_rate: int):
189 |         """Create a distortion model using a pre and post filter.
190 | 
191 |         This is based on the use of filtering and non-linearity to
192 |         model distortion based effects. We will optimize the parameters of the
193 |         pre and post filters to create a distortion effect.
194 | 
195 |         """
196 |         super().__init__()
197 |         self.sample_rate = sample_rate
198 |         # the equalizer object does not contain internal state
199 |         # so we can use the same equalizer for the pre and post filters
200 |         self.equalizer = ParametricEQ(sample_rate, min_gain_db=-48.0, max_gain_db=48.0)
201 | 
202 |         # self.input_gain = torch.nn.Parameter(torch.tensor(0.0))
203 |         # create parameters for the pre and post filters (these will be optimized)
204 |         self.pre_filter_params = torch.nn.Parameter(
205 |             torch.rand(1, self.equalizer.num_params) * 0.1
206 |         )
207 |         self.dc_offset = torch.nn.Parameter(torch.tensor(0.0))
208 |         self.mlp_nonlinearity = torch.nn.Sequential(
209 |             torch.nn.Linear(1, 128),
210 |             torch.nn.ReLU(),
211 |             torch.nn.Linear(128, 128),
212 |             torch.nn.ReLU(),
213 |             torch.nn.Linear(128, 128),
214 |             torch.nn.ReLU(),
215 |             torch.nn.Linear(128, 128),
216 |             torch.nn.ReLU(),
217 |             torch.nn.Linear(128, 1),
218 |         )
219 |         self.post_filter_params = torch.nn.Parameter(
220 |             torch.rand(1, self.equalizer.num_params) * 0.1
221 |         )
222 | 
223 |     def forward(self, x: torch.Tensor):
224 |         """Apply the distortion effect to the input signal using the internal parameters.
225 | 
226 |         Args:
227 |             x (torch.Tensor): Input signal with shape (batch_size, n_channels, n_samples)
228 | 
229 |         """
230 |         batch_size, n_channels, n_samples = x.shape
231 | 
232 |         # apply input gain
233 |         # x = x * torch.sigmoid(self.input_gain) * 24.0
234 | 
235 |         # apply pre-filter
236 |         y = self.equalizer.process_normalized(
237 |             x,
238 |             torch.sigmoid(self.pre_filter_params),
239 |         )
240 |         # apply dc offset
241 |         # y = y + self.dc_offset
242 |         # y = torch.tanh(y)  # apply non-linearity
243 |         y = self.mlp_nonlinearity(y.permute(0, 2, 1)).permute(0, 2, 1)
244 |         # apply post-filter
245 |         y = self.equalizer.process_normalized(
246 |             y,
247 |             torch.sigmoid(self.post_filter_params),
248 |         )
249 | 
250 |         return y
251 | 
252 | 
253 | def train_nonlinearity(
254 |     nonlinearity: torch.nn.Module,
255 |     lr: float = 1e-5,
256 |     n_iters: int = 20000,
257 |     batch_size: int = 32,
258 | ):
259 |     optimizer = torch.optim.Adam(nonlinearity.parameters(), lr=lr)
260 |     scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, n_iters)
261 | 
262 |     print("Training nonlinearity...")
263 |     pbar = tqdm(range(n_iters))
264 |     for _ in pbar:
265 |         x = torch.rand(batch_size, 1) * 6.0 - 3.0
266 |         y = torch.tanh(x)
267 |         y_hat = nonlinearity(x)
268 |         loss = torch.nn.functional.mse_loss(y_hat, y)
269 |         loss.backward()
270 |         optimizer.step()
271 |         scheduler.step()
272 |         pbar.set_description(f"Loss: {loss.item():.3e}")
273 | 
274 | 
275 | def train(
276 |     model: torch.nn.Module,
277 |     dataloader: torch.utils.data.DataLoader,
278 |     sample_rate: int,
279 |     lr: float = 1e-2,
280 |     epochs: int = 10,
281 |     use_gpu: bool = False,
282 |     pretrain_nonlinearity: bool = False,
283 | ):
284 |     if pretrain_nonlinearity:
285 |         train_nonlinearity(model.mlp_nonlinearity)
286 | 
287 |     # loss function in frequency domain
288 |     fd_loss_fn = auraloss.freq.MultiResolutionSTFTLoss(
289 |         fft_sizes=[128, 256, 512, 1024, 2048, 4096, 8192],
290 |         hop_sizes=[64, 128, 256, 512, 1024, 2048, 4096],
291 |         win_lengths=[128, 256, 512, 1024, 2048, 4096, 8192],
292 |         w_sc=0.0,
293 |         w_phs=0.0,
294 |         w_lin_mag=1.0,
295 |         w_log_mag=1.0,
296 |         perceptual_weighting=True,
297 |         sample_rate=sample_rate,
298 |     )
299 |     td_loss_fn = torch.nn.MSELoss()
300 | 
301 |     # create optimizer
302 |     optimizer = torch.optim.Adam(model.parameters(), lr=lr)
303 |     scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, epochs)
304 | 
305 |     if use_gpu:
306 |         model.cuda()
307 |         fd_loss_fn.cuda()
308 | 
309 |     epoch_loss_history = []
310 |     for epoch in range(epochs):
311 |         pbar = tqdm(dataloader)
312 |         loss_history = []
313 |         for batch in pbar:
314 |             src, target = batch
315 | 
316 |             if use_gpu:
317 |                 src = src.cuda()
318 |                 target = target.cuda()
319 | 
320 |             # apply distortion model with current parameters
321 |             y_hat = model(src)
322 | 
323 |             # compute loss between estimate and target
324 |             freq_loss = fd_loss_fn(y_hat, target)
325 |             time_loss = td_loss_fn(y_hat, target)
326 |             loss = freq_loss + (time_loss * 100.0)
327 | 
328 |             # optimize
329 |             optimizer.zero_grad()
330 |             loss.backward()
331 |             optimizer.step()
332 |             scheduler.step()
333 | 
334 |             loss_history.append(loss.item())
335 | 
336 |             pbar.set_description(
337 |                 f"Epoch: {epoch+1}/{epochs}  Loss: {np.mean(loss_history):.3e}"
338 |             )
339 |         # average loss over epoch
340 |         epoch_loss_history.append(np.mean(loss_history))
341 |         # plot_waveforms(src, target, y_hat)
342 |         plot_system(model, amp_name=amp_name, sample_rate=sample_rate, use_gpu=use_gpu)
343 |         plot_loss(epoch_loss_history, amp_name=amp_name)
344 | 
345 |     return epoch_loss_history
346 | 
347 | 
348 | if __name__ == "__main__":
349 |     amps = {
350 |         "65twin-reverb": {
351 |             "src": "audio/amps/idmt-rock-input-varying-gain.wav",
352 |             "target": "audio/amps/idmt-rock-clean1-65twin-reverb.wav",
353 |         },
354 |         "jazz-amp": {
355 |             "src": "audio/amps/idmt-rock-input-varying-gain.wav",
356 |             "target": "audio/amps/idmt-rock-clean2-jazz-amp-120.wav",
357 |         },
358 |         "orange-dual-terror": {
359 |             "src": "audio/amps/idmt-rock-input-varying-gain.wav",
360 |             "target": "audio/amps/idmt-rock-crunch1-orange-dual-terror.wav",
361 |         },
362 |         "british-blue-tube-30": {
363 |             "src": "audio/amps/idmt-rock-input-varying-gain.wav",
364 |             "target": "audio/amps/idmt-rock-crunch2-british-blue-tube-30tb.wav",
365 |         },
366 |         "brit-8000": {
367 |             "src": "audio/amps/idmt-rock-input-varying-gain.wav",
368 |             "target": "audio/amps/idmt-rock-high-gain1-brit-8000.wav",
369 |         },
370 |         "mesa-triple-rectifier": {
371 |             "src": "audio/amps/idmt-rock-input-varying-gain.wav",
372 |             "target": "audio/amps/idmt-rock-high-gain2-mesa-triple-rectifier.wav",
373 |         },
374 |     }
375 | 
376 |     # check if the audio/amp directory exists, otherwise download it
377 |     for amp_name, amp_files in amps.items():
378 |         for filepath in amp_files.values():
379 |             if not os.path.exists(filepath):
380 |                 filepath = filepath.replace("audio/", "")
381 |                 print(f"Downloading: {filepath}")
382 |                 os.makedirs("audio/amps", exist_ok=True)
383 |                 os.system(
384 |                     f"wget csteinmetz1.github.io/sounds/assets/{filepath} -O audio/{filepath}"
385 |                 )
386 | 
387 |     # train one model for each amp
388 |     for amp_name, amp_files in amps.items():
389 |         src_filepath = amp_files["src"]
390 |         target_filepath = amp_files["target"]
391 | 
392 |         dataset = FileDataset(src_filepath, target_filepath, length=32768)
393 |         dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
394 | 
395 |         # directory for outputs
396 |         os.makedirs("outputs/virtual_analog", exist_ok=True)
397 |         log_dir = f"outputs/virtual_analog/{amp_name}"
398 |         os.makedirs(log_dir, exist_ok=True)
399 |         os.makedirs(f"{log_dir}/audio", exist_ok=True)
400 | 
401 |         # construct grey-box distortion model
402 |         model = DistortionModel(sample_rate=44100)
403 | 
404 |         # train the model!
405 |         loss_history = train(
406 |             model,
407 |             dataloader,
408 |             sample_rate=44100,
409 |             pretrain_nonlinearity=True,
410 |             use_gpu=True,
411 |         )
412 | 
413 |         # run the final model and plot the results
414 |         model.cpu()
415 |         model.eval()
416 | 
417 |         src, sr = torchaudio.load(src_filepath, backend="soundfile")
418 |         target, sr = torchaudio.load(target_filepath, backend="soundfile")
419 |         src = src[0:1, :]
420 |         target = target[0:1, :]
421 | 
422 |         with torch.no_grad():
423 |             y_hat = model(src.unsqueeze(0)).squeeze(0)
424 | 
425 |         plot_waveforms(src, target, y_hat, amp_name=amp_name)
426 |         plot_system(model, amp_name=amp_name, sample_rate=44100)
427 |         plot_loss(loss_history, amp_name=amp_name)
428 | 
429 |         # save audio
430 |         filename = os.path.basename(target_filepath).replace(".wav", "")
431 |         torchaudio.save(
432 |             f"outputs/virtual_analog/{amp_name}/audio/{filename}-pred.wav",
433 |             y_hat,
434 |             sr,
435 |             backend="soundfile",
436 |         )
437 |         torchaudio.save(
438 |             f"outputs/virtual_analog/{amp_name}/audio/{filename}-input.wav",
439 |             src,
440 |             sr,
441 |             backend="soundfile",
442 |         )
443 |         torchaudio.save(
444 |             f"outputs/virtual_analog/{amp_name}/audio/{filename}-target.wav",
445 |             target,
446 |             sr,
447 |             backend="soundfile",
448 |         )
449 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | 
 2 | [project]
 3 | name = "dasp-pytorch"
 4 | version = "0.0.1"
 5 | description = "Differentiable audio processors in PyTorch."
 6 | authors = [
 7 |     { name = "Christian Steinmetz" },
 8 |     { email = "c.j.steinmetz@qmul.ac.uk" },
 9 | ]
10 | dependencies = ["torch", "numpy",  "scipy"]
11 | readme = "README.md"
12 | requires-python = ">=3.7"
13 | license = {text = "Apache License 2.0"}
14 | classifiers = [
15 |     "License :: OSI Approved :: Apache Software License",
16 |     "Topic :: Multimedia :: Sound/Audio",
17 |     "Topic :: Scientific/Engineering",
18 | ]
19 | 
20 | [build-system]
21 | # Minimum requirements for the build system to execute.
22 | requires = ["setuptools", "wheel", "attrs"]
23 | build-backend = "setuptools.build_meta"
24 | 
25 | [project.optional-dependencies]
26 | extra = ["matplotlib", "librosa"]
27 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | # Inspired from https://github.com/kennethreitz/setup.py
 3 | 
 4 | from pathlib import Path
 5 | from setuptools import setup, find_packages
 6 | 
 7 | NAME = "dasp-pytorch"
 8 | DESCRIPTION = "Differentiable audio processors in PyTorch"
 9 | URL = "https://github.com/csteinmetz1/dasp-pytorch"
10 | EMAIL = "c.j.steinmetz@qmul.ac.uk"
11 | AUTHOR = "Christian Steinmetz"
12 | REQUIRES_PYTHON = ">=3.8.0"
13 | VERSION = "0.0.1"
14 | 
15 | HERE = Path(__file__).parent
16 | 
17 | try:
18 |     with open(HERE / "README.md", encoding="utf-8") as f:
19 |         long_description = "\n" + f.read()
20 | except FileNotFoundError:
21 |     long_description = DESCRIPTION
22 | 
23 | setup(
24 |     name=NAME,
25 |     version=VERSION,
26 |     description=DESCRIPTION,
27 |     long_description=long_description,
28 |     long_description_content_type="text/markdown",
29 |     author=AUTHOR,
30 |     author_email=EMAIL,
31 |     python_requires=REQUIRES_PYTHON,
32 |     url=URL,
33 |     packages=["dasp_pytorch"],
34 |     install_requires=["torch", "numpy", "scipy"],
35 |     extras_require={"extra": ["matplotlib",  "librosa",]},
36 |     include_package_data=True,
37 |     license="Apache License 2.0",
38 |     classifiers=[
39 |         "License :: OSI Approved :: Apache Software License",
40 |         "Topic :: Multimedia :: Sound/Audio",
41 |         "Topic :: Scientific/Engineering",
42 |     ],
43 | )


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