TorchLPC

torchlpc provides a PyTorch implementation of the Linear Predictive Coding (LPC) filter, also known as all-pole filter. It's fast, differentiable, and supports batched inputs with time-varying filter coefficients.

Given an input signal $\mathbf{x}\in {\mathbb{R}}^T$ and time-varying LPC coefficients $\mathbf{A}\in {\mathbb{R}}^{T\times N}$ with an order of $N$, the LPC filter is defined as:

$$y_t=x_t-\sum _{i=1}^N{A}_{t,i}{y}_{t-i}.$$

Usage

import torch
from torchlpc import sample_wise_lpc

# Create a batch of 10 signals, each with 100 time steps
x = torch.randn(10, 100)

# Create a batch of 10 sets of LPC coefficients, each with 100 time steps and an order of 3
A = torch.randn(10, 100, 3)

# Apply LPC filtering
y = sample_wise_lpc(x, A)

# Optionally, you can provide initial values for the output signal (default is 0)
zi = torch.randn(10, 3)
y = sample_wise_lpc(x, A, zi=zi)

Installation

pip install torchlpc

or from source

pip install git+https://github.com/DiffAPF/torchlpc.git

Derivation of the gradients of the LPC filter

The details of the derivation can be found in our preprints¹². We show that, given the instataneous gradient $\frac{\partial \mathcal{L}}{\partial y_t}$ where $\mathcal{L}$ is the loss function, the gradients of the LPC filter with respect to the input signal $\mathbf{x}$ and the filter coefficients $\mathbf{A}$ can be expresssed also through a time-varying filter:

$$\frac{\partial \mathcal{L}}{\partial x_t}=\frac{\partial \mathcal{L}}{\partial y_t}-\sum _{i=1}^N{A}_{t+i,i}\frac{\partial \mathcal{L}}{\partial x_{t+i}}$$

$$\frac{\partial \mathcal{L}}{\partial \mathbf{A}}=-\left|\begin{array}{cccc}\frac{\partial \mathcal{L}}{\partial x_1}& 0& \dots & 0\\ 0& \frac{\partial \mathcal{L}}{\partial x_2}& \dots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \dots & \frac{\partial \mathcal{L}}{\partial x_t}\end{array}\right|\left|\begin{array}{cccc}{y}_0& y_{-1}& \dots & y_{-N+1}\\ y_1& y_0& \dots & y_{-N+2}\\ ⋮& ⋮& \ddots & ⋮\\ y_{T-1}& y_{T-2}& \dots & y_{T-N}\end{array}\right|.$$

Gradients for the initial condition $y_t{|}_{t\le 0}$

The initial conditions provide an entry point at $t=1$ for filtering, as we cannot evaluate $t=-\mathrm{\infty }$. Let us assume $A_{t,:}{|}_{t\le 0}=0$ so $y_t{|}_{t\le 0}=x_t{|}_{t\le 0}$, which also means $\frac{\partial \mathcal{L}}{\partial y_t}{|}_{t\le 0}=\frac{\partial \mathcal{L}}{\partial x_t}{|}_{t\le 0}$. Thus, the initial condition gradients are

$$\frac{\partial \mathcal{L}}{\partial y_t}=\frac{\partial \mathcal{L}}{\partial x_t}=-\sum _{i=1-t}^N{A}_{t+i,i}\frac{\partial \mathcal{L}}{\partial x_{t+i}}\text{for }-N<t\le 0.$$

In practice, we pad $N$ and $N\times N$ zeros to the beginning of $\frac{\partial \mathcal{L}}{\partial \mathbf{y}}$ and $\mathbf{A}$ before evaluating $\frac{\partial \mathcal{L}}{\partial \mathbf{x}}$. The first $N$ outputs are the gradients to $y_t{|}_{t\le 0}$ and the rest are to $x_t{|}_{t>0}$.

Time-invariant filtering

In the time-invariant setting, $A_{t,i}=A_{1,i}\mathrm{\forall }t\in [1,T]$ and the filter is simplified to

$$y_t=x_t-\sum _{i=1}^N{a}_i{y}_{t-i},\mathbf{a}=A_{1,:}.$$

The gradients $\frac{\partial \mathcal{L}}{\partial \mathbf{x}}$ are filtering $\frac{\partial \mathcal{L}}{\partial \mathbf{y}}$ with $\mathbf{a}$ backwards in time, same as in the time-varying case. $\frac{\partial \mathcal{L}}{\partial \mathbf{a}}$ is simply doing a vector-matrix multiplication:

$$\frac{\partial \mathcal{L}}{\partial {\mathbf{a}}^T}=-\frac{\partial \mathcal{L}}{\partial {\mathbf{x}}^T}\left|\begin{array}{cccc}{y}_0& y_{-1}& \dots & y_{-N+1}\\ y_1& y_0& \dots & y_{-N+2}\\ ⋮& ⋮& \ddots & ⋮\\ y_{T-1}& y_{T-2}& \dots & y_{T-N}\end{array}\right|.$$

This algorithm is more efficient than ³ because it only needs one pass of filtering to get the two gradients while the latter needs two.

TODO

• Use PyTorch C++ extension for faster computation.
• Use native CUDA kernels for GPU computation.
• Add examples.

Related Projects

• torchcomp: differentiable compressors that use torchlpc for differentiable backpropagation.
• jaxpole: equivalent implementation in JAX by @rodrigodzf.

Citation

If you find this repository useful in your research, please cite our work with the following BibTex entries:

@inproceedings{ycy2024diffapf,
    title={Differentiable All-pole Filters for Time-varying Audio Systems},
    author={Chin-Yun Yu and Christopher Mitcheltree and Alistair Carson and Stefan Bilbao and Joshua D. Reiss and György Fazekas},
    booktitle={International Conference on Digital Audio Effects (DAFx)},
    year={2024},
    pages={345--352},
}

@inproceedings{ycy2024golf,
    title     = {Differentiable Time-Varying Linear Prediction in the Context of End-to-End Analysis-by-Synthesis},
    author    = {Chin-Yun Yu and György Fazekas},
    year      = {2024},
    booktitle = {Proc. Interspeech},
    pages     = {1820--1824},
    doi       = {10.21437/Interspeech.2024-1187},
}

Footnotes

1. Differentiable All-pole Filters for Time-varying Audio Systems. ↩

2. Differentiable Time-Varying Linear Prediction in the Context of End-to-End Analysis-by-Synthesis. ↩

3. Singing Voice Synthesis Using Differentiable LPC and Glottal-Flow-Inspired Wavetables. ↩