# Firing Rate induced by a Sinus Grating

Now that we know how to do convolutions with our center-surround kernel we can chose any other kind of stimulus to carry this out. In the neuoscience of vision it is very common to use a sinus grating in a wide array of experimental setings so we are going to use it now. In short, in this post we are going to see the see what signal does a center-surround kernel produces when is convolved with a sinus grating.

## Center-Surround Kernel

In order to do the convolution we are going to define the kernel in the usual way using a function that we have utilized from our work before:

# First we define the size and resolution of the space in which the convolution is going to happen dx = 0.05 dy = 0.05 lx = 6.0 # In degrees ly = 6.0 # In degrees # Now we define the temporal parameters of the kernel dt_kernel = 5.0 # ms kernel_duration = 150 # ms kernel_size = int(kernel_duration / dt_kernel) # Now the center surround parameters factor = 1 # Controls the overall size of the center-surround pattern sigma_center = 0.25 * factor # Corresponds to 15' sigma_surround = 1 * factor # Corresponds to 1 degree # Finally we create the kernel kernel_on = create_kernel(dx, lx, dy, ly, sigma_surround, sigma_center, dt_kernel, kernel_size)

## Sinus Grating

Now we are going to construct our sinus grating. But first, we need to think on how long our stimulus is going to last which is a function of how long the we want to simulate the convolution and of the resolutions of the stimulus and the simulation:

## Now we define the temporal l parameters of the sinus grating dt_stimuli = 5.0 # ms # We also need to add how long do we want to convolve dt = 1.0 # Simulation resolution T_simulation = 1 * 10 ** 3.0 # ms T_simulation += int(kernel_size * dt_kernel) # Add the size of the kernel Nt_simulation = int(T_simulation / dt) # Number of simulation points N_stimuli = int(T_simulation / dt_stimuli) # Number of stimuli points

Finally we now present the parameters that determine the sinus grating. First the spatial frequency (K), followed by the spatial phase (Phi) and orientation (Theta). Furthermore we have also a parameter for the amplitude and the temporal frequency:

# And now the spatial parameters of the sinus grating K = 0.8 # Cycles per degree Phi = 0 # Spatial phase Theta = 0 # Orientation A = 1 # Amplitude # Temporal frequency of sine grating w = 3 # Hz

Now with all the spatial parameters in our possession we can call the function that produces the sine grating, we define it as the following function that we present below:

stimuli = sine_grating(dx, lx, dy, ly, A, K, Phi, Theta, dt_stimuli, N_stimuli, w) def sine_grating(dx, Lx, dy, Ly, A, K, Phi, Theta, dt_stimuli, N_stimuli, w): ''' Returns a sine grating stimuli ''' Nx = int(Lx / dx) Ny = int(Ly / dy) # Transform to appropriate units K = K * 2 * np.pi # Transforms K to cycles per degree w = w / 1000.0 # Transforms w to kHz x = np.arange(-Lx/2, Lx/2, dx) y = np.arange(-Ly/2, Ly/2, dy) X, Y = np.meshgrid(x, y) Z = A * np.cos(K * X *cos(Theta) + K * Y * sin(Theta) - Phi) t = np.arange(0, N_stimuli * dt_stimuli, dt_stimuli) f_t = np.cos(w * 2 * np.pi * t ) stimuli = np.zeros((N_stimuli, Nx, Ny)) for k, time_component in enumerate(f_t): stimuli[k, ...] = Z * time_component return stimuli

## Convolution

Now that we have the stimulus and the kernel we can do the convolution, in order to do that we use again our functions and indexes that we use in the last post:

## Now we can do the convolution # First we define the necessary indexes to the convolution signal_indexes, delay_indexes, stimuli_indexes = create_standar_indexes(dt, dt_kernel, dt_stimuli, kernel_size, Nt_simulation) working_indexes, kernel_times = create_extra_indexes(kernel_size, Nt_simulation) # Now we calculate the signal signal = np.zeros(Nt_simulation) for index in signal_indexes: signal[index] = convolution(index, kernel_times, delay_indexes, stimuli_indexes, kernel_on, stimuli)

We can visualize signal with the following code:

#Plot the signal t = np.arange(kernel_size*dt_kernel, T_simulation, dt) plt.plot(t, signal[signal_indexes]) plt.show()

We can see that the signal is also a sinus with a frequency that is consistent with the one from the sinus grating.

## No comments:

Post a Comment