PhilTorch $\Huge \overset{🔥}{\Phi}$

PhilTorch provides differentiable, time-domain linear digital filters for PyTorch.

• Differentiate through filter coefficients, inputs, and initial states with PyTorch autograd.
• Process batched signals and filters whose coefficients vary at every time step.
• Compute in the time domain without FFTs, through a pure functional API with no stateful objects.
• Run on native CPU, CUDA, and MPS kernels.

News

• 2025-12-06: We presented our paper, Accelerating Automatic Differentiation of Direct Form Digital Filters, at the Differentiable Systems and Scientific Machine Learning Workshop at EurIPS 2025. The poster is available here.
• 2025-11-10: PhilTorch was first presented at the Audio Developer Conference 2025. The presentation slides are available here.
• 2025-10-31: Our short paper describing the LTI filter implementation in PhilTorch was accepted by the Differentiable Systems and Scientific Machine Learning Workshop at EurIPS 2025. The preprint is available here.

Installation

PhilTorch requires its compiled philtorch._C extension; there is no pure-PyTorch fallback when the extension is missing.

PyPI wheels

python -m pip install philtorch

Wheels contain no CUDA kernels. They are built against one PyTorch minor release and are not guaranteed to work with other minor releases, so build from source if you use CUDA or a different PyTorch minor release.

Source builds

Install PyTorch first with the PyTorch installation selector, then build PhilTorch against it without build isolation:

python -m pip install "setuptools>=77.0.3" "setuptools_scm>=8" wheel
python -m pip install --no-binary=philtorch --no-build-isolation philtorch

The build compiles a CUDA extension when torch.cuda.is_available() is true and CUDA_HOME is set, and a CPU-only C++ extension otherwise. On a headless build server with no visible GPU, set PHILTORCH_FORCE_CUDA=1 to compile the CUDA extension anyway. In that case the installed PyTorch must be a CUDA build, and TORCH_CUDA_ARCH_LIST must also be set to the target architectures (e.g. TORCH_CUDA_ARCH_LIST="8.0 8.6"), because there is no GPU to infer them from. On macOS, when the installed PyTorch supports OpenMP, the build also needs Homebrew llvm and libomp, unless PHILTORCH_DISABLE_OPENMP=1 is set.

For an editable install from Git, clone with submodules:

git clone --branch v0.5 --recurse-submodules https://github.com/yoyolicoris/philtorch.git
cd philtorch
python -m pip install torch  # Choose the correct CPU or CUDA build first.
python -m pip install "setuptools>=77.0.3" "setuptools_scm>=8" wheel
python -m pip install --editable . --no-build-isolation

Package versions come from Git tags through setuptools_scm, so keep the tag metadata when building from a checkout.

Development version

Development builds from dev are published to TestPyPI:

python -m pip install -i https://test.pypi.org/simple/ philtorch

Quickstart

Filtering with SciPy-designed coefficients

import torch
from scipy.signal import butter

from philtorch.lti import filtfilt, lfilter, lfilter_zi

x = torch.randn(201, dtype=torch.float64)

b_np, a_np = butter(3, 0.05)
# Normalize so that a0 = 1, then drop a0 from the denominator.
b = torch.from_numpy(b_np / a_np[0])
a = torch.from_numpy(a_np[1:] / a_np[0])

# lfilter_zi takes (a, b), the reverse of SciPy's lfilter_zi(b, a).
zi = lfilter_zi(a, b)

y, _ = lfilter(b, a, x, zi=zi * x[0])
y_zero_phase = filtfilt(b, a, x)

Module overview

• philtorch: Root module.
  • lpv: Functions under it are for linear parameter-varying filters.
    • fir:
      • Finite Impulse Response filters.
    • allpole:
      • All-pole filters.
    • lfilter:
      • Parameter-varying version of scipy.signal.lfilter. It supports not only transposed direct form II but also transposed direct form I, direct form I, and direct form II structures.
    • state_space:
      • Parameter-varying state-space models.
    • state_space_recursion:
      • The core recursion function for state-space models.
    • linear_recurrence:
      • A linear recurrence function with scalar coefficients.
  • lti: Functions under it are for linear time-invariant filters.
    • fir:
      • Finite Impulse Response filters.
    • lfilter:
      • A differentiable version of scipy.signal.lfilter. It supports not only transposed direct form II but also transposed direct form I, direct form I, and direct form II structures.
    • filtfilt:
      • A differentiable version of scipy.signal.filtfilt.
    • lfilter_zi:
      • A differentiable version of scipy.signal.lfilter_zi.
    • lfiltic:
      • A differentiable version of scipy.signal.lfiltic.
    • state_space:
      • State-space models.
    • diag_state_space:
      • State-space models with diagonalisable state matrix.
    • state_space_recursion:
      • The core recursion function for state-space models.
    • linear_recurrence:
      • A linear recurrence function with scalar coefficients.
    • comb_filter:
      • Delayed all-pole comb filters.
    • cubic_spline:
      • Cubic-spline interpolation for integer upsampling.
  • utils: Utility functions.
  • mat: Matrix operations.
  • poly: Polynomial operations.

For detailed API reference, please refer to the docstring of each function.

Choose the right API

The supported high-level interfaces are exported from philtorch.lti for fixed coefficients and philtorch.lpv for coefficients that vary over time.

Comparison with scipy.signal

PhilTorch functions take PyTorch tensors, support autograd and batching, and keep the input dtype and device. Coefficients are normalized so that a0 = 1: divide SciPy's b and a by a[0], then pass a[1:] as the denominator, as in the Quickstart example.

Performance

Recursive filters are hard to parallelize, so PhilTorch implements custom C++ and CUDA kernels. With the default unroll_factor=1, the state-space paths (lfilter, state_space, and state_space_recursion) choose a kernel from the device and the filter order, which is the state size M:

✓ native kernel · loop: PyTorch recurrence loop · ✗ raises an error because no kernel exists for the device; use CPU or unroll_factor > 1 instead. ¹ Real dtypes only; complex inputs use the loop. ² float32 only.

Setting 1 < unroll_factor < sequence length switches to a block-unrolled PyTorch recursion, which computes blocks in parallel with matrix multiplications (background); larger values fall back to a plain PyTorch loop. It is slower than the native kernels but much faster than a naive loop. Good starting points are 8 on CPU and 16–32 on CUDA, but benchmark your own batch size, sequence length, state size, dtype, and device, for example with torch.utils.benchmark. Native kernels are fastest for first- and second-order filters, so prefer cascades or parallel banks of such sections, especially on CUDA.

Examples

Fibonacci numbers with state_space

philtorch.lti.state_space computes

\begin{aligned}
\mathbf{h}_{n+1} &= \mathbf{A} \mathbf{h}_n + \mathbf{B} \mathbf{x}_n, \\
\mathbf{y}_n &= \mathbf{C} \mathbf{h}_n + \mathbf{D} \mathbf{x}_n.
\end{aligned}

Setting the following, with $\mathbf{B} = \mathbf{D} = 0$ and no input, yields the Fibonacci numbers:

\mathbf{A} = \begin{bmatrix} 1 & 1 \\ 1 & 0 \end{bmatrix}, \qquad
\mathbf{C} = \begin{bmatrix} 1 & 0 \end{bmatrix}, \qquad
\mathbf{h}_0 = \begin{bmatrix} 1 \\ 0 \end{bmatrix}.

import torch

from philtorch.lti import state_space

A = torch.tensor([[1, 1], [1, 0]])
C = torch.tensor([1, 0])
x = torch.zeros(1, 10).long()
h0 = torch.tensor([1, 0])
y, _ = state_space(A, x, C=C, zi=h0)
print(y)

tensor([[ 1,  1,  2,  3,  5,  8, 13, 21, 34, 55]])

This produces the first ten Fibonacci numbers, where $F_n = F_{n-1} + F_{n-2}$ with $F_0 = F_1 = 1$.

Learning filter parameters

The low-pass estimation notebook demonstrates learning filter parameters by gradient descent.

Project links

• The contribution guide documents the development and pull-request workflow, and the PhilTorch Roadmap lists current priorities.
• The issue tracker is the place for bug reports and feature requests.
• PhilTorch is distributed under the MIT License; third-party notices are in LICENSES.

Paper and citation

PhilTorch's LTI direct-form filtering work is described in Accelerating Automatic Differentiation of Direct Form Digital Filters by Chin-Yun Yu and György Fazekas.

@inproceedings{yu2025accelerating,
  title={Accelerating Automatic Differentiation of Direct Form Digital Filters},
  author={Yu, Chin-Yun and Fazekas, György},
  booktitle={Differentiable Systems and Scientific Machine Learning Workshop at EurIPS 2025},
  year={2025},
  url={https://openreview.net/forum?id=ZhwIyvtBNB}
}