I'm interested in transforming a binned spike sequence in a oscillation by means of the use of convolution between spikes and a kernel function. My question is about what is the kernel function that is better adapted to this situation and which are the parameters that best define the conversion?
The convolution operation is the same as applying an FIR filter and the kernel function would the parameters of the filter. So the question is what do you want to do with the spikes? The answer to that question will guide what sort of kernel function to use.
Could you explain how the oscillation you want to generate should be related to the sequence of spikes?
If the height of your delta spikes is a number between 0 and 1 that can be thought of as representing probability (of that event occurring), then convolving with a kernel that is a probability distribution (e.g., a normal distribution) can be thought of as adding noise to the original data. Is there a type of noise that is appropriate for your data - a normal distribution is often a good starting point?
What kind of oscillation you want to generate? Is there any special shape of this oscillation? In principle, the convolution with kernel function will shape the resulting signal. So you have to set up some kernel function parameters.
Before answering, it is important to understand the question you raised. I think you need to inform this forum about the signal (show a figure) - and how you would like the resulting signal to look like after your kernel has acted on the signal. That would help us in trying to provide solutions.
I study neuronal signal extracellularly recorded (spikes) in rodents. Each recorded action potential can be interpreted as a event in a time serie. So, I have a binned sequence of 0 (no spike) or 1(spike event) for each t. My intention is to obtain a spectrogram with the oscillatory pattern of the spikes sequence. In several papers the authors propose a convolution between spike and a since function (sin(x)/x). Or a gaussian function. Obviously, I need to show in the spectrogram, information about rhythmic or oscillatory patterns that can be detected through the convolved curve.
My doubt is in the parameters defining the kernel. For example, this is my code
dt=0.001;
x= -100:dt:100;
s = sinc(x);
or for gaussian kernel
sigma = 1;
s = exp(-(x/sigma).^2/2)/(sigma*sqrt(2*pi));
z = conv(spikes,s);
z=z(floor(length(s)/2):end-ceil(length(s)/2));
Different values of dt shows different spectrograms. I need to define dt that better reflect the oscillatory behavior of the neuronal spikes.
Thank's for your attention
OK, so you are looking to low-pass filter your spikes to get at the underlying oscillatory shape. What you describe above with the sinc and the Gaussian fns are impulse responses of FIR filters. So depending on the frequency band of interest and your sampling frequency you can design your kernels. You should look into FIR filter design to get a better handle on this.
good luck
There is a problem with this approach when considering spectrogram. Finite time step is a source of distortions. It is possible to get distortions in spectrogram due to similar phase as time resolution may be poor. The best signal representation is time of events [t1, t2, t3, ...] if this data is available.
Spectral function can be chosen by recording single spike and spectrum calculation. This function can be used as basis for spectral reconstruction unless spectral analysis needs smoothing.
Sinc in frequency domain, is based on assumption of rectangular spike in time domain. Gaussian in frequency domain, is based on assumption of Gaussian spike in time domain. If spike is exponential decay, Lorentzian function may be suitable. There are numerous other functions that can be used as approximations of different real signal spikes.
Matlab example with sinc function, when convolution is done directly in frequency domain:
%spikes=[t1, t2, t3, ...]; vector of spike events
%T is time or duration of single rectangular spike
f=0:df:F; %defined frequencies
Spectrum=zeros(1,length(f)); %initial zero values
%spectrum of each spike is calculated and added
for k=1:length(spikes)
Spectrum=Spectrum+sinc(T*f).*exp(-i*pi*(2*spikes(k)+T)*f);
end
Spectrum=T*Spectrum;
The convolution rule to convolving a function f(t) with a Dirac Delta function (what you are calling a spike) is that it is equal to that function f(t) alone; this also known as the shifting rule. For a train of Dirac Deltas, aka comb, each Dirac Delta is shifted by some time lag or spatial lag, so, the result would be equal to your functional shifted by that amount, i.e. f(t-t0). Where t0 is the shifted portion of the spike. See Bracewell's "Fourier Transforms and Applications" for further information.
If I understood correctly your problem, you are not interested in spectral features which are connected to the specific shape of the spike, but only in searching for periodic behavior on a time scale much larger than the typical separation between spikes. In other words, you should ignore spectral features at frequencies greater than the inverse of the sampling time.
If this is true the convolution kernel is largely arbitrary, the only basic requirement is that its width is 1/(2 tau), where tau is the sampling time (this is basically the uncertainty principle).
In order to obtain a significant result for your spectrogram you should
- fix a time scale T which typically contains several spikes
- for a given t, select all the spikes in the interval [t-T/2,t+T/2]
- work as suggested in the matlab example of https://www.researchgate.net/profile/Julius_Barzdziukas/ using the selected spikes (note that it is important to take into account the phase factor) and a kernel of you choice which satisfy the uncertainty constraint
- discard all the frequencies larger than 1/tau
- take the square module of the result
- repeat for t+Dt, where Dt is less or equal than T (the chunks of your spectrogram could overlap)