LGN-Retinal filter

Treating the retina and the LGN together as a spatio-temporal filter is a common trait in the models that we are going to work with in this project. In this series of articles I am going to develop and explain the mechanism that I have developed to model this particular stage of processing.

Structure of the filter

In this particular example we are dealing with a separable spatio-temporal filter. That is, we can write our filter as a product of the spatial part and the temporal part. In the following sections, we will describe them in this given order.

Spatial filter

In order to calculate the spatial filter we need two things. First, how wide our filters are going to be and then the resolution level. So lx and ly will stand for the size of the receptive filters (in degrees) for the x and y direction respectively. The same will go for dx and dy with respect to the resolution. With this in our hands we then can proceed to create a 2 dimensional structure for our functions with the help of the mesh functions:

``` ## Spatial parameters x = np.arange(-lx/2, lx/2, dx) y = np.arange(-ly/2, ly/2, dy) X, Y = np.meshgrid(x, y) # Create the 2D dimensional coordinates ```
Now that we have the function it is just a matter of calculating the function with the appropiate formula:

``` R = np.sqrt(X**2 + Y**2) # Distance center = (17.0 / sigma_center**2) * np.exp(-(R / sigma_center)**2) surround = (16.0 / sigma_surround**2) * np.exp(-(R / sigma_surround)**2) Z = surround - center ```
With the formula in our hands we can plot it as a countour line to have an idea of how it looks like in space:
``` # Plot countour map plt.contourf(X, Y, Z, 50, alpha=0.75, cmap=plt.cm.hot) plt.colorbar() C = plt.contour(X, Y, Z, 10, colors='black', linewidth=.5) plt.clabel(C, inline=10, fontsize=10) plt.show() ```

We can also show a view when y=0 in order to offer a side view of the plot in order to gain further insight in the structure of it:

Temporal filter

The behaviour of the temporal filters in time is usually called bi-phasic response. This consists in a response that initially grows in time for the mean level but then it goes bellow to the mean level to finally return at it in time window of the order 200ms approximately. The particular function and parameters that we are going to use to illustrate this behaviour were taken from the paper by Cai et Al (Reference bellow). But first, we have to define our kernel size and resolution as in the code down here:

``` # First the kernel size and resolution kernel_size = 200 dt_kernel = 1.0 t = np.arange(0, kernel_size * dt_kernel, dt_kernel) # Time vector ```
Now, we construct the function in the following way:
``` ## Temporal parameters K1 = 1.05 K2 = 0.7 c1 = 0.14 c2 = 0.12 n1 = 7.0 n2 = 8.0 t1 = -6.0 t2 = -6.0 td = 6.0 p1 = K1 * ((c1*(t - t1))**n1 * np.exp(-c1*(t - t1))) / ((n1**n1) * np.exp(-n1)) p2 = K2 * ((c2*(t - t2))**n2 * np.exp(-c2*(t - t2))) / ((n2**n2) * np.exp(-n2)) p3 = p1 - p2 ```
We plot the function to have an idea of how it looks now:

Spatio-Temporal Filter

Finally, in order to have build the kernel, given that our filter is separable, we just have to multiply the temporal the temporal part by the spatial part at each point in space:
```     # Initialize and fill the spatio-temporal kernel
kernel = np.zeros((kernel_size, int(lx/dx), int(ly/dy)))

for k, p3 in enumerate(p3):
kernel[k,...] = p3 * Z
```

Which we can show now in the following plot:

References

• Cai, Daqing, Gregory C. Deangelis, and Ralph D. Freeman. "Spatiotemporal receptive field organization in the lateral geniculate nucleus of cats and kittens." Journal of Neurophysiology 78.2 (1997): 1045-1061.