julius-tf 0.1.0__tar.gz

julius_tf-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__
+*.egg-info
+build
+env
+env_old
+dist
+.ipynb_checkpoints
+*.ipynb
+.coverage
+htmlcov
+docs

julius_tf-0.1.0/LICENSE

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

julius_tf-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: julius-tf
+Version: 0.1.0
+Summary: Nice DSP sweets: resampling, FFT Convolutions — a TensorFlow port of Alexandre Défossez's julius, differentiable and with GPU support.
+Project-URL: Homepage, https://github.com/LarocheC/julius-tf
+Project-URL: Repository, https://github.com/LarocheC/julius-tf
+Project-URL: Original project (PyTorch), https://github.com/adefossez/julius
+Author-email: Alexandre Défossez <alexandre.defossez@gmail.com>, Clément Laroche <clement.laroche@gmail.com>
+Maintainer-email: Clément Laroche <clement.laroche@gmail.com>
+License: MIT License
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9.0
+Requires-Dist: tensorflow>=2.11.0
+Provides-Extra: dev
+Requires-Dist: coverage>=7.0; extra == 'dev'
+Requires-Dist: flake8>=5.0; extra == 'dev'
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: numpy>=1.21; extra == 'dev'
+Requires-Dist: pdoc3>=0.10; extra == 'dev'
+Requires-Dist: resampy==0.4.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Julius, fast TensorFlow based DSP for audio and 1D signals
+
+![linter badge](https://github.com/LarocheC/julius-tf/workflows/linter/badge.svg)
+![tests badge](https://github.com/LarocheC/julius-tf/workflows/tests/badge.svg)
+![cov badge](https://github.com/LarocheC/julius-tf/workflows/cov%3E90%25/badge.svg)
+
+Julius contains different Digital Signal Processing algorithms implemented
+with TensorFlow, so that they are differentiable and available on GPU.
+Note that all the modules implemented here can be used inside a `tf.function`.
+
+> **`julius-tf` is a TensorFlow port of [`julius`](https://github.com/adefossez/julius),
+> the PyTorch DSP library by [Alexandre Défossez](https://github.com/adefossez).** The DSP
+> algorithms and the public API are his work; this project re-implements them on top of
+> TensorFlow. See [Credits](#credits) for full attribution.
+
+For now, I have implemented:
+
+- [julius.resample](https://LarocheC.github.io/julius-tf/julius/resample.html): fast sinc resampling.
+- [julius.fftconv](https://LarocheC.github.io/julius-tf/julius/fftconv.html): FFT based convolutions.
+- [julius.lowpass](https://LarocheC.github.io/julius-tf/julius/lowpass.html): FIR low pass filter banks.
+- [julius.filters](https://LarocheC.github.io/julius-tf/julius/filters.html): FIR high pass and band pass filters.
+- [julius.bands](https://LarocheC.github.io/julius-tf/julius/bands.html): Decomposition of a waveform signal over mel-scale frequency bands.
+
+Along that, you might found useful utilities in:
+
+- [julius.core](https://LarocheC.github.io/julius-tf/julius/core.html): DSP related functions.
+- [julius.utils](https://LarocheC.github.io/julius-tf/julius/utils.html): Generic utilities.
+
+<p align="center">
+<img src="./logo.png" alt="Representation of the convolutions filters used for the efficient resampling."
+width="500px"></p>
+
+## News
+
+- `julius-tf` ports the whole library from PyTorch to __TensorFlow__. The public API of the
+  original `julius` is preserved: modules are `tf.Module`s, callable just like before, and
+  usable inside a `tf.function`. The dated entries below are the upstream `julius` releases
+  whose behavior this port reproduces.
+- 23/06/2026: __`julius-tf` 0.1.0:__ first release on PyPI — TensorFlow port reproducing
+  upstream `julius` 0.2.8. Install with `pip install julius-tf`.
+- 03/06/2026: __`julius` 0.2.8 released:__: Switching to pyproject.toml, now requires python >= 3.9. Bug fix with -O flag (thanks @aiknownc)
+- 19/09/2022: __`julius` 0.2.7 released:__: fixed ONNX compat (thanks @iver56). I know I missed the 0.2.6 one...
+- 28/07/2021: __`julius` 0.2.5 released:__: support for setting a custom output length when resampling.
+- 22/06/2021: __`julius` 0.2.4 released:__: adding highpass and band passfilters.
+  Extra linting and type checking of the code. New `unfold` implemention, up to
+  x6 faster FFT convolutions and more efficient memory usage.
+- 26/01/2021: __`julius` 0.2.2 released:__ fixing normalization of filters in lowpass and resample to avoid very low frequencies to be leaked.
+  Switch from zero padding to replicate padding (uses first/last value instead of 0) to avoid discontinuities with strong artifacts.
+- 20/01/2021: `julius` implementation of resampling is now officially <a href="https://github.com/pytorch/audio/pull/1087">part of Torchaudio.</a>
+
+## Installation
+
+`julius-tf` requires python >= 3.9 and TensorFlow >= 2.11. To install:
+```bash
+pip3 install -U julius-tf
+```
+The import name stays `julius` (i.e. `pip install julius-tf` then `import julius`).
+
+
+## Usage
+
+See the [Julius documentation][docs] for the usage of Julius. Hereafter you will find a few examples
+to get you quickly started:
+
+```python3
+import julius
+import tensorflow as tf
+
+signal = tf.random.normal((6, 4, 1024))
+# Resample from a sample rate of 100 to 70. The old and new sample rate must be integers,
+# and resampling will be fast if they form an irreductible fraction with small numerator
+# and denominator (here 10 and 7). Any shape is supported, last dim is time.
+resampled_signal = julius.resample_frac(signal, 100, 70)
+
+# Low pass filter with a `0.1 * sample_rate` cutoff frequency.
+low_freqs = julius.lowpass_filter(signal, 0.1)
+
+# Fast convolutions with FFT, useful for large kernels
+conv = julius.FFTConv1d(4, 10, 512)
+convolved = conv(signal)
+
+# Decomposition over frequency bands in the Waveform domain
+bands = julius.split_bands(signal, n_bands=10, sample_rate=100)
+# Decomposition with n_bands frequency bands evenly spaced in mel space.
+# Input shape can be `[*, T]`, output will be `[n_bands, *, T]`.
+random_eq = tf.reduce_sum(tf.random.uniform((10, 1, 1, 1)) * bands, axis=0)
+```
+
+## Algorithms
+
+### Resample
+
+This is an implementation of the [sinc resample algorithm][resample] by Julius O. Smith.
+It is the same algorithm than the one used in [resampy][resampy] but to run efficiently on GPU it
+is limited to fractional changes of the sample rate. It will be fast if the old and new sample rate
+are small after dividing them by their GCD. For instance going from a sample rate of 2000 to 3000 (2, 3 after removing the GCD)
+will be extremely fast, while going from 20001 to 30001 will not.
+Julius resampling is faster than resampy even on CPU, and when running on GPU it makes resampling a completely negligible part of your pipeline
+(except of course for weird cases like going from a sample rate of 20001 to 30001).
+
+
+### FFTConv1d
+
+Computing convolutions with very large kernels (>= 128) and a stride of 1 can be much faster
+using FFT. This implements the same API as `tf.keras.layers.Conv1D` / `tf.nn.conv1d`
+(using the channels-first `[B, C, T]` convention) but with a FFT backend. Dilation and groups
+are not supported.
+FFTConv will be faster on CPU even for relatively small tensors (a few dozen channels, kernel size
+of 128). On CUDA, due to the higher parallelism, regular convolution can be faster in many cases,
+but for kernel sizes above 128, for a large number of channels or batch size, FFTConv1d
+will eventually be faster (basically when you no longer have idle cores that can hide
+the true complexity of the operation).
+
+### LowPass
+
+Classical Finite Impulse Reponse windowed sinc lowpass filter. It will use FFT convolutions automatically
+if the filter size is large enough. This is the basic block from which you can build
+high pass and band pass filters (see `julius.filters`).
+
+### Bands
+
+Decomposition of a signal over frequency bands in the waveform domain. This can be useful for
+instance to perform parametric EQ (see [Usage](#usage) above).
+
+## Benchmarks
+
+You can find speed tests (and comparisons to reference implementations) on the
+[benchmark][bench]. The CPU benchmarks are run on a Mac Book Pro 2020, with a 2.4 GHz
+8-core intel CPU i9. The GPUs benchmark are run on Nvidia V100 with 16GB of memory.
+We also compare the validity of our implementations, as compared to reference ones like `resampy`
+or `tf.nn.conv1d`.
+
+
+
+## Running tests
+
+Clone this repository, then
+```bash
+pip3 install '.[dev]'
+python3 -m unittest discover -s tests
+```
+
+To run the benchmarks:
+```
+pip3 install .[dev]'
+python3 -m bench.gen
+```
+
+
+## License
+
+`julius-tf` is released under the MIT license, the same license as the original `julius`.
+The license retains the original copyright of Alexandre Défossez (2020) alongside the
+copyright for the TensorFlow port (2026). See [LICENSE](./LICENSE).
+
+## Credits
+
+This project is a TensorFlow port of [`julius`](https://github.com/adefossez/julius) by
+[**Alexandre Défossez**](https://github.com/adefossez). All of the DSP algorithms, the
+overall design, and the public API originate from his original PyTorch implementation —
+full credit for the underlying work goes to him. This repository only re-implements those
+algorithms on top of TensorFlow.
+
+- Original project: https://github.com/adefossez/julius (MIT, © 2020 Alexandre Défossez)
+- TensorFlow port: Clément Laroche ([@LarocheC](https://github.com/LarocheC))
+
+## Thanks
+
+This package is named in the honor of
+[Julius O. Smith](https://ccrma.stanford.edu/~jos/),
+whose books and website were a gold mine of information for learning about DSP. Go checkout his website if you want
+to learn more about DSP.
+
+
+[resample]: https://ccrma.stanford.edu/~jos/resample/resample.html
+[resampy]: https://resampy.readthedocs.io/
+[docs]:  https://LarocheC.github.io/julius-tf/julius/index.html
+[bench]:  ./bench.md

julius_tf-0.1.0/README.md

@@ -0,0 +1,178 @@
+# Julius, fast TensorFlow based DSP for audio and 1D signals
+
+![linter badge](https://github.com/LarocheC/julius-tf/workflows/linter/badge.svg)
+![tests badge](https://github.com/LarocheC/julius-tf/workflows/tests/badge.svg)
+![cov badge](https://github.com/LarocheC/julius-tf/workflows/cov%3E90%25/badge.svg)
+
+Julius contains different Digital Signal Processing algorithms implemented
+with TensorFlow, so that they are differentiable and available on GPU.
+Note that all the modules implemented here can be used inside a `tf.function`.
+
+> **`julius-tf` is a TensorFlow port of [`julius`](https://github.com/adefossez/julius),
+> the PyTorch DSP library by [Alexandre Défossez](https://github.com/adefossez).** The DSP
+> algorithms and the public API are his work; this project re-implements them on top of
+> TensorFlow. See [Credits](#credits) for full attribution.
+
+For now, I have implemented:
+
+- [julius.resample](https://LarocheC.github.io/julius-tf/julius/resample.html): fast sinc resampling.
+- [julius.fftconv](https://LarocheC.github.io/julius-tf/julius/fftconv.html): FFT based convolutions.
+- [julius.lowpass](https://LarocheC.github.io/julius-tf/julius/lowpass.html): FIR low pass filter banks.
+- [julius.filters](https://LarocheC.github.io/julius-tf/julius/filters.html): FIR high pass and band pass filters.
+- [julius.bands](https://LarocheC.github.io/julius-tf/julius/bands.html): Decomposition of a waveform signal over mel-scale frequency bands.
+
+Along that, you might found useful utilities in:
+
+- [julius.core](https://LarocheC.github.io/julius-tf/julius/core.html): DSP related functions.
+- [julius.utils](https://LarocheC.github.io/julius-tf/julius/utils.html): Generic utilities.
+
+<p align="center">
+<img src="./logo.png" alt="Representation of the convolutions filters used for the efficient resampling."
+width="500px"></p>
+
+## News
+
+- `julius-tf` ports the whole library from PyTorch to __TensorFlow__. The public API of the
+  original `julius` is preserved: modules are `tf.Module`s, callable just like before, and
+  usable inside a `tf.function`. The dated entries below are the upstream `julius` releases
+  whose behavior this port reproduces.
+- 23/06/2026: __`julius-tf` 0.1.0:__ first release on PyPI — TensorFlow port reproducing
+  upstream `julius` 0.2.8. Install with `pip install julius-tf`.
+- 03/06/2026: __`julius` 0.2.8 released:__: Switching to pyproject.toml, now requires python >= 3.9. Bug fix with -O flag (thanks @aiknownc)
+- 19/09/2022: __`julius` 0.2.7 released:__: fixed ONNX compat (thanks @iver56). I know I missed the 0.2.6 one...
+- 28/07/2021: __`julius` 0.2.5 released:__: support for setting a custom output length when resampling.
+- 22/06/2021: __`julius` 0.2.4 released:__: adding highpass and band passfilters.
+  Extra linting and type checking of the code. New `unfold` implemention, up to
+  x6 faster FFT convolutions and more efficient memory usage.
+- 26/01/2021: __`julius` 0.2.2 released:__ fixing normalization of filters in lowpass and resample to avoid very low frequencies to be leaked.
+  Switch from zero padding to replicate padding (uses first/last value instead of 0) to avoid discontinuities with strong artifacts.
+- 20/01/2021: `julius` implementation of resampling is now officially <a href="https://github.com/pytorch/audio/pull/1087">part of Torchaudio.</a>
+
+## Installation
+
+`julius-tf` requires python >= 3.9 and TensorFlow >= 2.11. To install:
+```bash
+pip3 install -U julius-tf
+```
+The import name stays `julius` (i.e. `pip install julius-tf` then `import julius`).
+
+
+## Usage
+
+See the [Julius documentation][docs] for the usage of Julius. Hereafter you will find a few examples
+to get you quickly started:
+
+```python3
+import julius
+import tensorflow as tf
+
+signal = tf.random.normal((6, 4, 1024))
+# Resample from a sample rate of 100 to 70. The old and new sample rate must be integers,
+# and resampling will be fast if they form an irreductible fraction with small numerator
+# and denominator (here 10 and 7). Any shape is supported, last dim is time.
+resampled_signal = julius.resample_frac(signal, 100, 70)
+
+# Low pass filter with a `0.1 * sample_rate` cutoff frequency.
+low_freqs = julius.lowpass_filter(signal, 0.1)
+
+# Fast convolutions with FFT, useful for large kernels
+conv = julius.FFTConv1d(4, 10, 512)
+convolved = conv(signal)
+
+# Decomposition over frequency bands in the Waveform domain
+bands = julius.split_bands(signal, n_bands=10, sample_rate=100)
+# Decomposition with n_bands frequency bands evenly spaced in mel space.
+# Input shape can be `[*, T]`, output will be `[n_bands, *, T]`.
+random_eq = tf.reduce_sum(tf.random.uniform((10, 1, 1, 1)) * bands, axis=0)
+```
+
+## Algorithms
+
+### Resample
+
+This is an implementation of the [sinc resample algorithm][resample] by Julius O. Smith.
+It is the same algorithm than the one used in [resampy][resampy] but to run efficiently on GPU it
+is limited to fractional changes of the sample rate. It will be fast if the old and new sample rate
+are small after dividing them by their GCD. For instance going from a sample rate of 2000 to 3000 (2, 3 after removing the GCD)
+will be extremely fast, while going from 20001 to 30001 will not.
+Julius resampling is faster than resampy even on CPU, and when running on GPU it makes resampling a completely negligible part of your pipeline
+(except of course for weird cases like going from a sample rate of 20001 to 30001).
+
+
+### FFTConv1d
+
+Computing convolutions with very large kernels (>= 128) and a stride of 1 can be much faster
+using FFT. This implements the same API as `tf.keras.layers.Conv1D` / `tf.nn.conv1d`
+(using the channels-first `[B, C, T]` convention) but with a FFT backend. Dilation and groups
+are not supported.
+FFTConv will be faster on CPU even for relatively small tensors (a few dozen channels, kernel size
+of 128). On CUDA, due to the higher parallelism, regular convolution can be faster in many cases,
+but for kernel sizes above 128, for a large number of channels or batch size, FFTConv1d
+will eventually be faster (basically when you no longer have idle cores that can hide
+the true complexity of the operation).
+
+### LowPass
+
+Classical Finite Impulse Reponse windowed sinc lowpass filter. It will use FFT convolutions automatically
+if the filter size is large enough. This is the basic block from which you can build
+high pass and band pass filters (see `julius.filters`).
+
+### Bands
+
+Decomposition of a signal over frequency bands in the waveform domain. This can be useful for
+instance to perform parametric EQ (see [Usage](#usage) above).
+
+## Benchmarks
+
+You can find speed tests (and comparisons to reference implementations) on the
+[benchmark][bench]. The CPU benchmarks are run on a Mac Book Pro 2020, with a 2.4 GHz
+8-core intel CPU i9. The GPUs benchmark are run on Nvidia V100 with 16GB of memory.
+We also compare the validity of our implementations, as compared to reference ones like `resampy`
+or `tf.nn.conv1d`.
+
+
+
+## Running tests
+
+Clone this repository, then
+```bash
+pip3 install '.[dev]'
+python3 -m unittest discover -s tests
+```
+
+To run the benchmarks:
+```
+pip3 install .[dev]'
+python3 -m bench.gen
+```
+
+
+## License
+
+`julius-tf` is released under the MIT license, the same license as the original `julius`.
+The license retains the original copyright of Alexandre Défossez (2020) alongside the
+copyright for the TensorFlow port (2026). See [LICENSE](./LICENSE).
+
+## Credits
+
+This project is a TensorFlow port of [`julius`](https://github.com/adefossez/julius) by
+[**Alexandre Défossez**](https://github.com/adefossez). All of the DSP algorithms, the
+overall design, and the public API originate from his original PyTorch implementation —
+full credit for the underlying work goes to him. This repository only re-implements those
+algorithms on top of TensorFlow.
+
+- Original project: https://github.com/adefossez/julius (MIT, © 2020 Alexandre Défossez)
+- TensorFlow port: Clément Laroche ([@LarocheC](https://github.com/LarocheC))
+
+## Thanks
+
+This package is named in the honor of
+[Julius O. Smith](https://ccrma.stanford.edu/~jos/),
+whose books and website were a gold mine of information for learning about DSP. Go checkout his website if you want
+to learn more about DSP.
+
+
+[resample]: https://ccrma.stanford.edu/~jos/resample/resample.html
+[resampy]: https://resampy.readthedocs.io/
+[docs]:  https://LarocheC.github.io/julius-tf/julius/index.html
+[bench]:  ./bench.md

julius_tf-0.1.0/bench/__init__.py

@@ -0,0 +1,6 @@
+"""
+This package contains benchmarking code.
+The following content is automatically generated from `bench.gen`
+
+.. include:: ../bench.md
+"""

julius_tf-0.1.0/bench/fftconv.py

@@ -0,0 +1,46 @@
+# File under the MIT license, see the LICENSE file for details.
+# Original author: Alexandre Défossez (adefossez), 2020
+# TensorFlow port: Clément Laroche (LarocheC), 2026
+
+import argparse
+
+import tensorflow as tf
+
+from julius import fft_conv1d
+from julius.core import conv1d
+from julius.utils import Chrono, MarkdownTable
+
+
+def test(table, kernel_size, block_ratio=5, device="cpu"):
+    tf_device = "/GPU:0" if device == "cuda" else "/CPU:0"
+    with tf.device(tf_device):
+        x = tf.random.normal((32, 32, 1024 * 10))
+        w = tf.random.normal((64, 32, kernel_size))
+
+        with Chrono() as chrono_ref:
+            y_ref = conv1d(x, w)
+
+        with Chrono() as chrono_fft:
+            y_fft = fft_conv1d(x, w, block_ratio=block_ratio)
+
+        delta = format(float(tf.reduce_mean(tf.abs(y_ref - y_fft))), ".1e")
+    table.line(
+        [kernel_size,  int(1000 * chrono_fft.duration), int(1000 * chrono_ref.duration), delta])
+
+
+def main():
+    parser = argparse.ArgumentParser("fftconv.py")
+    parser.add_argument("-d", "--device", default="cpu")
+    parser.add_argument("-b", "--block_ratio", default=5, type=float)
+    args = parser.parse_args()
+
+    table = MarkdownTable(
+        ["Kernel size", "FFT (ms)", "No FFT (ms)", "  Delta"])
+    table.header()
+
+    for kernel_size in [8, 32, 64, 128, 256, 1024, 2048]:
+        test(table, kernel_size, block_ratio=args.block_ratio, device=args.device)
+
+
+if __name__ == "__main__":
+    main()

julius_tf-0.1.0/bench/gen.py

@@ -0,0 +1,70 @@
+import subprocess as sp
+import tensorflow as tf
+
+
+def run_bench(name, *args, device="cpu"):
+    args = list(args)
+    args += ["-d", device]
+    if device == "cuda" and not tf.config.list_physical_devices('GPU'):
+        return "Not available /!\\"
+    return sp.check_output(["python3", "-m", f"bench.{name}"] + args).decode('utf8')
+
+
+def main():
+    template = f"""\
+## Benchmarking and verification of Julius
+
+In order to verify the correctness and speed of the implementations in Julius,
+we compare ourselves to different reference implementations, comparing speed and
+checking how far we are.
+
+### ResampleFrac
+
+We compare `julius.resample` to `resampy`, on an input of size (32, 8 * 44100),
+i.e. a batch of size 16 of 8 second of audio at 44.1kHz.
+We use the same number of zero crossing as `resampy` for this benchmark.
+The small delta is probably
+due to the different window function used.
+
+
+On CPU we have:
+
+{run_bench('resample')}
+
+On GPU we have:
+
+{run_bench('resample', device='cuda')}
+
+### FFTConv1d
+
+We compare to `tf.nn.conv1d`, on a input of size [32, 32, 10240],
+for a convolution with 32 input channels, 64 output channels and various kernel sizes.
+
+On CPU we have:
+
+{run_bench('fftconv')}
+
+On GPU we have:
+
+{run_bench('fftconv', device='cuda')}
+
+### LowPassFilter
+
+We do not compare to anything, but measure the attenuation in dB of a pure tone
+at `0.9 * cutoff`, at the `cutoff`, and at `1.1 * cutoff`.
+Note that our implementation automatically choses to use FFTConv1d or not when appropriate.
+
+On CPU we have:
+
+{run_bench('lowpass')}
+
+On GPU we have:
+
+{run_bench('lowpass', device='cuda')}
+
+"""
+    print(template)
+
+
+if __name__ == "__main__":
+    main()

julius_tf-0.1.0/bench/lowpass.py

@@ -0,0 +1,45 @@
+# File under the MIT license, see the LICENSE file for details.
+# Original author: Alexandre Défossez (adefossez), 2020
+# TensorFlow port: Clément Laroche (LarocheC), 2026
+
+import argparse
+
+import tensorflow as tf
+
+from julius import lowpass_filter
+from julius.core import pure_tone, volume
+from julius.utils import Chrono, MarkdownTable
+
+
+def test(table, freq, zeros, fft=None, device="cpu"):
+    sr = 44_100
+    tf_device = "/GPU:0" if device == "cuda" else "/CPU:0"
+
+    attns = []
+    for ratio in [0.9, 1, 1.1]:
+        with tf.device(tf_device):
+            x = pure_tone(ratio * freq * sr, sr, 4)
+            with Chrono() as chrono:
+                y = lowpass_filter(x, freq, fft=fft, zeros=zeros)
+            attns.append(format(float(volume(y) - volume(x)), ".2f"))
+
+    table.line([freq] + attns + [int(1000 * chrono.duration)])
+
+
+def main():
+    parser = argparse.ArgumentParser("lowpass.py")
+    parser.add_argument("-d", "--device", default="cpu")
+    parser.add_argument("--fft", action="store_true", default=None)
+    parser.add_argument("--no_fft", action="store_false", dest="fft")
+    parser.add_argument("--zeros", default=8, type=float)
+    args = parser.parse_args()
+
+    table = MarkdownTable(
+        ["Freq.", "Attn. 0.9 (dB)", "Attn 1.0 (dB)", "Attn 1.1 (dB)", "Time (ms)"])
+    table.header()
+    for freq in [0.005, 0.01, 0.1, 0.2, 0.4]:
+        test(table, freq, zeros=args.zeros, fft=args.fft, device=args.device)
+
+
+if __name__ == "__main__":
+    main()

julius_tf-0.1.0/bench/resample.py

@@ -0,0 +1,53 @@
+# File under the MIT license, see the LICENSE file for details.
+# Original author: Alexandre Défossez (adefossez), 2020
+# TensorFlow port: Clément Laroche (LarocheC), 2026
+
+import argparse
+import math
+
+import resampy
+import tensorflow as tf
+
+from julius import resample_frac
+from julius.utils import Chrono, MarkdownTable
+
+
+def test(table, old_sr, new_sr, device="cpu"):
+    tf_device = "/GPU:0" if device == "cuda" else "/CPU:0"
+    with tf.device(tf_device):
+        x = tf.random.normal((16, 8 * old_sr * int(math.ceil(44_100 / old_sr))))
+
+        with Chrono() as chrono:
+            y = resample_frac(x, old_sr, new_sr, zeros=56)
+    dur_julius = int(1000 * chrono.duration)
+
+    if device == "cpu":
+        with Chrono() as chrono:
+            y_resampy = tf.constant(
+                resampy.resample(x.numpy(), old_sr, new_sr), dtype=tf.float32)
+        dur_resampy = int(1000 * chrono.duration)
+
+        delta = float(tf.reduce_mean(tf.abs(y_resampy - y)))
+        table.line([old_sr, new_sr, dur_julius, dur_resampy, format(delta, ".1%")])
+    else:
+        table.line([old_sr, new_sr, dur_julius])
+
+
+def main():
+    parser = argparse.ArgumentParser("resample.py")
+    parser.add_argument("-d", "--device", default="cpu")
+    args = parser.parse_args()
+
+    if args.device == "cpu":
+        table = MarkdownTable(["Old sr", "New sr", "Julius (ms)", "Resampy (ms)", "Delta (%)"])
+    else:
+        table = MarkdownTable(["Old sr", "New sr", "Julius (ms)"])
+    table.header()
+
+    rates = [(2, 1), (1, 2), (4, 5), (10, 11), (44100, 16000), (20001, 30001)]
+    for old_sr, new_sr in rates:
+        test(table, old_sr, new_sr, device=args.device)
+
+
+if __name__ == "__main__":
+    main()

julius_tf-0.1.0/julius/__init__.py

@@ -0,0 +1,42 @@
+# File under the MIT license, see the LICENSE file for details.
+# Original author: Alexandre Défossez (adefossez), 2020
+# TensorFlow port: Clément Laroche (LarocheC), 2026
+
+# flake8: noqa
+"""
+.. image:: ../logo.png
+
+Julius contains different Digital Signal Processing algorithms implemented
+with TensorFlow, so that they are differentiable and available on GPU.
+Note that all the modules implemented here can be used inside a `tf.function`.
+
+For now, I have implemented:
+
+- `julius.resample`: fast sinc resampling.
+- `julius.fftconv`: FFT based convolutions.
+- `julius.lowpass`: FIR low pass filter banks.
+- `julius.filters`: FIR high pass and band pass filters.
+- `julius.bands`: Decomposition of a waveform signal over mel-scale frequency bands.
+
+Along that, you might found useful utilities in:
+
+- `julius.core`: DSP related functions.
+- `julius.utils`: Generic utilities.
+
+
+Please checkout [the Github repository](https://github.com/LarocheC/julius-tf) for other informations.
+For a verification of the speed and correctness of Julius, check the benchmark module `bench`.
+
+
+This package is named in this honor of
+[Julius O. Smith](https://ccrma.stanford.edu/~jos/),
+whose books and website were a gold mine of information for me to learn about DSP. Go checkout his website if you want
+to learn more about DSP.
+"""
+
+from .bands import SplitBands, split_bands
+from .fftconv import fft_conv1d, FFTConv1d
+from .filters import bandpass_filter, BandPassFilter
+from .filters import highpass_filter, highpass_filters, HighPassFilter, HighPassFilters
+from .lowpass import lowpass_filter, lowpass_filters, LowPassFilters, LowPassFilter
+from .resample import resample_frac, ResampleFrac