IIR filter example

[coreyker]

I was curious about using DDSP to learn the parameters of an IIR filter, but there don't seem to be any DDSP examples in this vein. I'm not sure if that is because this is plain inadvisable, or just because it hasn't been considered useful/high priority at this point.

A 2-pole filter with real coefficients would look something like this:

def two_pole_filter(radius, angle, xin):
	
	a1 = -2 * radius * tf.cos(angle)
	a2 = radius * radius
	
	def y(xn, yn_1, yn_2):
		return xn - a1 * yn_1 - a2*yn_2 # difference equation

	ys = tf.zeros(len(xn)) # placeholder for output
	yn_2 = 0 # initial state
	yn_1 = 0 # initial state
	
       # filter loop
	for n,xn in enumerate(xin):
		yn = y(xn, yn_1, yn_2)
		yn_2 = yn_1
		yn_1 = yn

		ys[n] = yn
	
	return ys

I'm not very experienced with tensorflow, so I've probably made some obvious errors. In any case, I am curious whether an approach like this could be viable with in the DDSP framework? I.e., in order to learn the radius and angle parameters of the filter poles?

Unrolling the filter loop will lead to really high powers of the coefficients a1 and a2, which may lead to numerical problems (and maybe vanishing/exploding gradients?)?

Anyway, if anyone has given this some thought already, I'd be keen to hear their thoughts

[coreyker]

I suppose the way around this is to i) compute the impulse response of the filter, ii) truncate the result, and iii) use the fft_convolve function from the ddsp.core library. The z-transform of the IIR filter can be expanded using partial fraction expansion (PFE) into a modal representation. Each mode represents a decaying exponential (with its own frequency, decay time, and initial magnitude and phase). These parameters could be made trainable in a custom layer (much like the ExpDecayReverb function in ddsp.effects.

[jesseengel]

Hi, sorry for the delayed reply. IIR filters are definitely an exciting area to explore, just haven't had real time to check them out yet among all the other things, but it's definitely on the todo list (we even mention them in the original paper I think).

I think the real problem to figure out is computational efficiency during training, as a giant for loop over time steps can be quite inefficient if done wrong (it amounts to unrolling the backprop across tens of thousands of loop cycles). Similarly doing an FIR expansion could be quite expensive too for higher-order terms, because you might need to apply a different filter each time step (as opposed to currently each frame).

I think the most promising approach is to play around with a custom op or leverage a more efficient loop like tf.scan, like I said, just haven't had time to play around with this, but it would be a great research project if someone wants to try it.

[coreyker]

No problem for the delayed reply. Thanks for replying at all :)

It's interesting to read your observations, e.g., that the real problem is one of computational efficiency, and not one of stability. Just to clarify then is it accurate to say: you don't think vanishing/exploding gradients would be an obstacle when back propagating through an IIR filter? This is one of the reasons why vanilla RNNs have been superseded by LSTMs, GRUs, so my intuition says these problems would resurface when implementing a DDSP-based IIR filter.

[jesseengel]

I think it's an open question, but an IIR is fundamentally a linear function, so I'm more optimistic than say trying to run a RNN for 10k+ timesteps.

[jesseengel]

Related work: https://dafx2020.mdw.ac.at/proceedings/papers/DAFx2020_paper_52.pdf

[cifkao]

Related work (PyTorch): https://github.com/schufo/umss

[jonnor]

Related work (PyTorch): https://intro2ddsp.github.io/filters/iir_torch.html