Plot instantaneous firing rate

[wagdy88]

Hello,

We would like to plot a time frequency analysis from the raster. We thought of calculating/adding the spikes within a sliding window to get a continuous signal from the discrete raster signals. Is there a way to do so in hnn_core?

Thanks
Mohamed

[jasmainak]

It sounds like you want to plot the histogram: https://jonescompneurolab.github.io/hnn-core/stable/generated/hnn_core.viz.plot_spikes_hist.html#hnn_core.viz.plot_spikes_hist

? Or is this different from that? I am a little lost why you would want to do time-frequency though ... you would get steps in your continuous signal, which will create artifacts in the time-frequency. Or am I missing something?

[jasmainak]

We can certainly implement if this is something that the comp neuro community typically look at ... an example figure from a paper would be helpful

[wagdy88]

@jasmainak
I tried the histogram and it's not the output we need. What we need is to get the collective spikes of the soma of different layers on a continuous line similar to how the dipole is drawn. The difference is that the dipole would represent LFP and the soma collective spikes would be representative of the soma spikes. Since the raster represents the soma activity, we were thinking this could be used to plot this. I can ask Dr. Sherif if he knows of other literature that has provided similar plot.

[jasmainak]

humm ... an example plot would really help!

we also have this: https://jonescompneurolab.github.io/hnn-core/stable/generated/hnn_core.CellResponse.html#hnn_core.CellResponse.mean_rates

@ntolley any suggestion how we could incorporate this in our API?

[wagdy88]

@jasmainak, Thanks for prompt response. What we need is more of the collective (or sum) of cells activity rather than the mean - hope that explains it.

[ntolley]

There's quite a few ways to achieve this. In the most general sense what you're looking to do is convolve the spike train with a kernel to calculate an "instantaneous spike rate". The choice of convolution kernel is up to you because instantaneous spike rate is a bit of an arbitrary term.

In the simplest case you use a square kernel with a predefined length, this gives you you a moving average/sliding window. But you could also consider an exponential kernel, or alternative shapes that don't produce a hard cutoff that is susceptible to artifacts in the output time series.

The elephant package provides a pretty decent explanation with functions that take care of this for you: https://elephant.readthedocs.io/en/latest/tutorials/statistics.html#2.3.-Instantaneous-rate

[ntolley]

It's a bit unclear to me how much functionality we should add to hnn-core since this is handled by existing packages, and there's a lot of degrees of freedom in how you carry it out.

@wagdy88 take a look at the link above and see if it fits your needs. I think with elephant you have to format the spiking data in a pretty specific way, so that might be good justification to incorporate some simple versions of their functions as methods of net.cell_response

[wagdy88]

Thanks @ntolley, will take a look at the link :)

[jasmainak]

package looks decent. @ntolley do you use it yourself? We could provide a function to export the spike train to their format?

[ntolley]

Not a bad idea @jasmainak. I've thought about this in the past (because I do use this package frequently), but the main isuse is their format requires other dependencies like quantities and neo

[ntolley]

@wagdy88 where do you see rate of discharge? That's a parameter used for their functions to generate artificial spike trained. This is the documentation for the instantaneous rate function:
https://elephant.readthedocs.io/en/latest/reference/_toctree/statistics/elephant.statistics.instantaneous_rate.html#elephant.statistics.instantaneous_rate

To calculate instantaneous firing rates you need to convert them into a neo spike train object:
https://neo.readthedocs.io/en/stable/api_reference.html#neo.core.SpikeTrain

[jasmainak]

we can nest the dependency inside the function so it's a dependency only for this function. On the other hand, if it's just numpy convolution, we can implement it easily. Your call ...

[ntolley]

I would lean towards nested dependencies through something like pip install hnn_core[analysis]. You would still need functions that parameterize the kernels that get convolved.

[wagdy88]

@ntolley I meant the part about creating the spiketrain from the raster. I tried using net.cell_response.spike.times but didn't work