Design for Filters

[nbecker]

I'm very happy to see that sionna-0.9.0 now has some support for filters. I have a few suggestions about the design. Bear in mind my background is from decades of experience in signal processing and communications, but new to tensorflow (TF) and it's limitations/performance tradeoffs.

1. Stateless filters (filter function) are fine for burst-mode simulations, but is not convenient for continuous-mode simulations. In that case it is better for filters to be objects with internal state. The state represents the input history, and in the case of decimating filters, the decimation phase. This allows processing to proceed in blocks of some convenient size that will fit in memory.

2. Efficient design of upsampling (interpolation) and downsampling (decimation) filters is well-known, with all processing at the low sample rate. The use of external upsampling (zero insertion) and downsampling (sample dropping) is not efficient. I don't know if TF would support efficient implementations well. (I'm assuming here the convolution is implemented in the time domain, as it would be for small filters).

3. Two common use cases in comm. filters are complex x complex -> complex, and complex x real -> complex, the latter needing 1/2 the multiplications and easily implemented as 2 real x real -> real (the common RRC filter is an example). I'm guessing that the easiest way to take advantage of this in TF is to code them as different object types.

In the past I've coded in c++ 9 filter objects: plain filters, decimating, and interpolating: each with 3 types: real x real, complex x real, and complex x complex (the type polymorphism is handled by c++ templates). I could provide this code if it is of interest.

Perhaps a more elegant example (which I didn't write) in Julia is here:
https://github.com/JuliaDSP/DSP.jl/blob/master/src/Filters/stream_filt.jl
which combines interpolation/decimation (my approach is simple brute force).

Thanks again for initiating this effort,
Neal Becker

[jhoydis]

Thanks for these pertinent comments and suggestions.

1. For the time being, all simulations in Sionna are burst-mode. We did not yet have the need for continuous-mode simulations. For this reason, filters with internal state are not on our current feature roadmap. Would you have a specific use-case in mind for which this would be needed?

2. Indeed, the current implementation could be made more efficient. This would be a welcome contribution. Were you thinking about a polyphase structure here?

3. Good point. For the case complex x real, we could save some multiplications. This will be fixed in the next release.

[nbecker]

Attached is a toy implementation of polyphase interpolation applied to upsampling RRC filter.
It's a toy because it mixes python and tf, I'm not expert on tf.
Also conjugate is not implemented (too bad it's an argument to call, instead of __init__)

No idea how to efficiently implement decimator in tf, probably needs to be part of convolve (for np, I use my own c++ code for both efficient interpolation and decimation). The idea is very simple, the non-efficient way is first compute all the samples y_i, then throw away most of them (downsampling). The efficient way is don't compute the ones you'd throw away.

import tensorflow as tf
from sionna.signal import RootRaisedCosineFilter
from scipy.signal import convolve

def pad (u, n):
    if len(u) == n:
        return u
    return np.hstack ((u, np.zeros (n - len (u), dtype=u.dtype)))
                      
class InterpRRCFilter (RootRaisedCosineFilter):
    def __init__(self,
                 span_in_symbols,
                 samples_per_symbol,
                 beta,
                 window=None,
                 normalize=True,
                 trainable=False,
                 dtype=tf.float32,
                 **kwargs):
        super().__init__(span_in_symbols,
                         samples_per_symbol,
                         beta,
                         window,
                         normalize,
                         trainable,
                         dtype,
                         **kwargs)
        interp = self.interp = samples_per_symbol
        h = self.coefficients.numpy()
        self.hs = [pad (h[i::interp], int (np.ceil (len (h)/interp))) for i in range (interp)]

    def call (self, x, padding='full', conjugate=False):
        # h = self.
        # dtype = tf.as_dtype(self.dtype)
        # if conjugate and dtype.is_complex:
        #     h = tf.math.conj(h)
        z = ([convolve (x, h, padding) for h in self.hs])
        ys = tf.convert_to_tensor ([convolve (x, h, padding) for h in self.hs])
        out = tf.reshape (tf.transpose (ys), -1)
        return out

if __name__ == '__main__':
    f = InterpRRCFilter (8, 4, 0.25)
    u = tf.zeros (64)
    v = tf.tensor_scatter_nd_update (u, [[0]], [1.0])
    w = f (v)
    import matplotlib.pyplot as plt
    plt.plot (w, 'x')
    plt.show()