teaching/scientificComputing
Archived
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Improved point processes. Added index.

Browse Source
This commit is contained in:
Jan Benda
2015-11-21 23:09:07 +01:00
parent 788d6aa8ab
commit a945268bee
12 changed files with 271 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
pointprocesses/lecture/isimethod.py
View File

@@ -2,9 +2,9 @@ import matplotlib.pyplot as plt
import numpy as np
from IPython import embed
figsize=(6,3)
def set_rc():
plt.rcParams['xtick.labelsize'] = 8
plt.rcParams['ytick.labelsize'] = 8
plt.rcParams['xtick.major.size'] = 5
plt.rcParams['xtick.minor.size'] = 5
plt.rcParams['xtick.major.width'] = 2
@@ -17,13 +17,17 @@ def set_rc():
plt.rcParams['ytick.direction'] = "out"
def create_spikes(isi=0.08, duration=0.5, seed=57111):
times = np.arange(0., duration, isi)
def create_spikes(nspikes=11, duration=0.5, seed=1000):
rng = np.random.RandomState(seed)
times += rng.randn(len(times)) * (isi / 2.5)
times = np.delete(times, np.nonzero(times < 0))
times = np.delete(times, np.nonzero(times > duration))
times = np.sort(times)
x = np.linspace(0.0, 1.0, nspikes)
# double gaussian rate profile:
rate = np.exp(-0.5*((x-0.35)/0.25)**2.0)
rate += 1.*np.exp(-0.5*((x-0.9)/0.05)**2.0)
isis = 1.0/rate
isis += rng.randn(len(isis))*0.2
times = np.cumsum(isis)
times *= 1.05*duration/times[-1]
times += 0.01
return times
@@ -34,33 +38,38 @@ def gaussian(sigma, dt):
def setup_axis(spikes_ax, rate_ax):
spikes_ax.spines["left"].set_visible(False)
spikes_ax.spines["right"].set_visible(False)
spikes_ax.spines["top"].set_visible(False)
spikes_ax.yaxis.set_ticks_position('left')
spikes_ax.xaxis.set_ticks_position('bottom')
spikes_ax.set_yticks([0, 1.0])
spikes_ax.set_ylim([0, 1.05])
spikes_ax.set_ylabel("spikes", fontsize=9)
spikes_ax.text(-0.125, 1.2, "A", transform=spikes_ax.transAxes, size=10)
spikes_ax.set_xlim([0, 0.5])
spikes_ax.set_xticklabels(np.arange(0., 600, 100))
spikes_ax.set_yticks([])
spikes_ax.set_ylim(-0.2, 1.0)
#spikes_ax.set_ylabel("Spikes")
spikes_ax.text(-0.1, 0.5, "Spikes", transform=spikes_ax.transAxes, rotation='vertical', va='center')
#spikes_ax.text(-0.125, 1.2, "A", transform=spikes_ax.transAxes)
spikes_ax.set_xlim(-1, 500)
#spikes_ax.set_xticklabels(np.arange(0., 600, 100))
rate_ax.spines["right"].set_visible(False)
rate_ax.spines["top"].set_visible(False)
rate_ax.yaxis.set_ticks_position('left')
rate_ax.xaxis.set_ticks_position('bottom')
rate_ax.set_xlabel('time[ms]', fontsize=9)
rate_ax.set_ylabel('firing rate [Hz]', fontsize=9)
rate_ax.text(-0.125, 1.15, "B", transform=rate_ax.transAxes, size=10)
rate_ax.set_xlim([0, 0.5])
rate_ax.set_xticklabels(np.arange(0., 600, 100))
rate_ax.set_xlabel('Time [ms]')
#rate_ax.set_ylabel('Firing rate [Hz]')
rate_ax.text(-0.1, 0.5, "Rate [Hz]", transform=rate_ax.transAxes, rotation='vertical', va='center')
#rate_ax.text(-0.125, 1.15, "B", transform=rate_ax.transAxes)
rate_ax.set_xlim(0, 500)
#rate_ax.set_xticklabels(np.arange(0., 600, 100))
rate_ax.set_ylim(0, 60)
rate_ax.set_yticks(np.arange(0,65,20))
def plot_bin_method():
dt = 1e-5
duration = 0.5
spike_times = create_spikes(0.018, duration)
spike_times = create_spikes()
t = np.arange(0., duration, dt)
bins = np.arange(0, 0.55, 0.05)
@@ -69,24 +78,25 @@ def plot_bin_method():
plt.xkcd()
set_rc()
fig = plt.figure()
fig.set_size_inches(5., 2.5)
fig.set_size_inches(*figsize)
fig.set_facecolor('white')
spikes = plt.subplot2grid((7,1), (0,0), rowspan=3, colspan=1)
rate_ax = plt.subplot2grid((7,1), (3,0), rowspan=4, colspan=1)
setup_axis(spikes, rate_ax)
spikes.set_ylim([0., 1.25])
spikes.vlines(spike_times, 0., 1., color="darkblue", lw=1.25)
spikes.vlines(np.hstack((0,bins)), 0., 1.25, color="red", lw=1.5, linestyles='--')
for ti in spike_times:
ti *= 1000.0
spikes.plot([ti, ti], [0., 1.], '-b', lw=2)
#spikes.vlines(1000.0*spike_times, 0., 1., color="darkblue", lw=1.25)
for tb in 1000.0*bins :
spikes.plot([tb, tb], [-2.0, 0.75], '-', color="#777777", lw=1, clip_on=False)
#spikes.vlines(1000.0*np.hstack((0,bins)), -2.0, 1.25, color="#777777", lw=1, linestyles='-', clip_on=False)
for i,c in enumerate(count):
spikes.text(bins[i] + bins[1]/2, 1.05, str(c), fontdict={'color':'red', 'size':9})
spikes.set_xlim([0, duration])
spikes.text(1000.0*(bins[i]+0.5*bins[1]), 1.1, str(c), color='#CC0000', ha='center')
rate = count / 0.05
rate_ax.step(bins, np.hstack((rate, rate[-1])), where='post')
rate_ax.set_xlim([0., duration])
rate_ax.set_ylim([0., 100.])
rate_ax.set_yticks(np.arange(0,105,25))
rate_ax.step(1000.0*bins, np.hstack((rate, rate[-1])), color='#FF9900', where='post')
fig.tight_layout()
fig.savefig("binmethod.pdf")
plt.close()
@@ -95,66 +105,66 @@ def plot_bin_method():
def plot_conv_method():
dt = 1e-5
duration = 0.5
spike_times = create_spikes(0.05, duration)
kernel_time, kernel = gaussian(0.02, dt)
spike_times = create_spikes()
kernel_time, kernel = gaussian(0.015, dt)
t = np.arange(0., duration, dt)
rate = np.zeros(t.shape)
rate[np.asarray(np.round(spike_times/dt), dtype=int)] = 1
rate[np.asarray(np.round(spike_times[:-1]/dt), dtype=int)] = 1
rate = np.convolve(rate, kernel, mode='same')
rate = np.roll(rate, -1)
plt.xkcd()
set_rc()
fig = plt.figure()
fig.set_size_inches(5., 2.5)
fig.set_size_inches(*figsize)
fig.set_facecolor('white')
spikes = plt.subplot2grid((7,1), (0,0), rowspan=3, colspan=1)
rate_ax = plt.subplot2grid((7,1), (3,0), rowspan=4, colspan=1)
setup_axis(spikes, rate_ax)
spikes.vlines(spike_times, 0., 1., color="darkblue", lw=1.5, zorder=2)
for i in spike_times:
spikes.plot(kernel_time + i, kernel/np.max(kernel), color="orange", lw=0.75, zorder=1)
spikes.set_xlim([0, duration])
#spikes.vlines(1000.0*spike_times, 0., 1., color="darkblue", lw=1.5, zorder=2)
for ti in spike_times:
ti *= 1000.0
spikes.plot([ti, ti], [0., 1.], '-b', lw=2)
spikes.plot(1000*kernel_time + ti, kernel/np.max(kernel), color='#cc0000', lw=1, zorder=1)
rate_ax.plot(t, rate, color="darkblue", lw=1, zorder=2)
rate_ax.fill_between(t, rate, np.zeros(len(rate)), color="red", alpha=0.5)
rate_ax.set_xlim([0, duration])
rate_ax.set_ylim([0, 50])
rate_ax.set_yticks(np.arange(0,75,25))
rate_ax.plot(1000.0*t, rate, color='#FF9900', lw=2, zorder=2)
rate_ax.fill_between(1000.0*t, rate, np.zeros(len(rate)), color='#FFFF66')
#rate_ax.fill_between(t, rate, np.zeros(len(rate)), color="red", alpha=0.5)
#rate_ax.set_ylim([0, 50])
#rate_ax.set_yticks(np.arange(0,75,25))
fig.tight_layout()
fig.savefig("convmethod.pdf")
def plot_isi_method():
spike_times = create_spikes(0.055, 0.5, 1000)
spike_times = create_spikes()
plt.xkcd()
set_rc()
fig = plt.figure()
fig.set_size_inches(5., 2.5)
fig.set_size_inches(*figsize)
fig.set_facecolor('white')
spikes = plt.subplot2grid((7,1), (0,0), rowspan=3, colspan=1)
rate = plt.subplot2grid((7,1), (3,0), rowspan=4, colspan=1)
setup_axis(spikes, rate)
spikes.vlines(spike_times, 0., 1., color="darkblue", lw=1.25)
spike_times = np.hstack((0, spike_times))
spike_times = np.hstack((0.005, spike_times))
#spikes.vlines(1000*spike_times, 0., 1., color="blue", lw=2)
for i in range(1, len(spike_times)):
t_start = spike_times[i-1]
t = spike_times[i]
t_start = 1000*spike_times[i-1]
t = 1000*spike_times[i]
spikes.plot([t_start, t_start], [0., 1.], '-b', lw=2)
spikes.annotate(s='', xy=(t_start, 0.5), xytext=(t,0.5), arrowprops=dict(arrowstyle='<->'), color='red')
spikes.text(t_start+0.01, 0.75,
"{0:.1f}".format((t - t_start)*1000),
fontdict={'color':'red', 'size':7})
spikes.text(0.5*(t_start+t), 0.75,
"{0:.0f}".format((t - t_start)),
color='#CC0000', ha='center')
#spike_times = np.hstack((0, spike_times))
i_rate = 1./np.diff(spike_times)
rate.step(spike_times, np.hstack((i_rate, i_rate[-1])),color="darkblue", lw=1.25, where="post")
rate.set_ylim([0, 50])
rate.set_yticks(np.arange(0,75,25))
rate.step(1000*spike_times, np.hstack((i_rate, i_rate[-1])),color='#FF9900', lw=2, where="post")
fig.tight_layout()
fig.savefig("isimethod.pdf")

122
pointprocesses/lecture/pointprocesses.tex
View File

@@ -102,8 +102,8 @@ kann mit den \"ublichen Gr\"o{\ss}en beschrieben werden.
= 1$.
\item Mittleres Intervall: $\mu_{ISI} = \langle T \rangle =
\frac{1}{n}\sum\limits_{i=1}^n T_i$.
\item Varianz der Intervalle: $\sigma_{ISI}^2 = \langle (T - \langle T
\rangle)^2 \rangle$\vspace{1ex}
\item Standardabweichung der Intervalle: $\sigma_{ISI} = \sqrt{\langle (T - \langle T
\rangle)^2 \rangle}$\vspace{1ex}
\item Variationskoeffizient (\enterm{coefficient of variation}): $CV_{ISI} =
\frac{\sigma_{ISI}}{\mu_{ISI}}$.
\item Diffusions Koeffizient: $D_{ISI} =
@@ -112,7 +112,7 @@ kann mit den \"ublichen Gr\"o{\ss}en beschrieben werden.
\begin{exercise}{isi_hist.m}{}
Schreibe eine Funktion \code{isi\_hist()}, die einen Vektor mit Interspikeintervallen
entgegennimmt und daraus ein normalisiertes Histogramm der Interspikeintervalle
entgegennimmt und daraus ein normiertes Histogramm der Interspikeintervalle
berechnet.
\end{exercise}
@@ -141,7 +141,7 @@ sichtbar.
Solche Ab\"angigkeiten werden durch die serielle Korrelation der
Intervalle quantifiziert. Das ist der Korrelationskoeffizient
zwischen aufeinander folgenden Intervallen getrennt durch \enterm{lag} $k$:
zwischen aufeinander folgenden Intervallen getrennt durch lag $k$:
\[ \rho_k = \frac{\langle (T_{i+k} - \langle T \rangle)(T_i - \langle T \rangle) \rangle}{\langle (T_i - \langle T \rangle)^2\rangle} = \frac{{\rm cov}(T_{i+k}, T_i)}{{\rm var}(T_i)}
= {\rm corr}(T_{i+k}, T_i) \]
\"Ublicherweise wird die Korrelation $\rho_k$ gegen den Lag $k$
@@ -215,10 +215,21 @@ unabh\"angig von den Zeitpunkten fr\"uherer Ereignisse
(\figref{hompoissonfig}). Die Wahrscheinlichkeit zu irgendeiner Zeit
ein Ereigniss in einem kleinen Zeitfenster der Breite $\Delta t$ zu
bekommen ist
\[ P = \lambda \cdot \Delta t \; . \]
\begin{equation}
\label{hompoissonprob}
P = \lambda \cdot \Delta t \; .
\end{equation}
Beim inhomogenen Poisson Prozess h\"angt die Rate $\lambda$ von der
Zeit ab: $\lambda = \lambda(t)$.
\begin{exercise}{poissonspikes.m}{}
Schreibe eine Funktion \code{poissonspikes()}, die die Spikezeiten
eines homogenen Poisson-Prozesses mit gegebener Rate in Hertz f\"ur
eine Anzahl von trials gegebener maximaler L\"ange in Sekunden in
einem \codeterm{cell-array} zur\"uckgibt. Benutze \eqnref{hompoissonprob}
um die Spikezeiten zu bestimmen.
\end{exercise}
\begin{figure}[t]
\includegraphics[width=1\textwidth]{poissonraster100hz}
\titlecaption{\label{hompoissonfig}Rasterplot von Spikes eines homogenen
@@ -234,7 +245,11 @@ Zeit ab: $\lambda = \lambda(t)$.
Der homogene Poissonprozess hat folgende Eigenschaften:
\begin{itemize}
\item Die Intervalle $T$ sind exponentiell verteilt: $p(T) = \lambda e^{-\lambda T}$ (\figref{hompoissonisihfig}).
\item Die Intervalle $T$ sind exponentiell verteilt (\figref{hompoissonisihfig}):
\begin{equation}
\label{poissonintervals}
p(T) = \lambda e^{-\lambda T} \; .
\end{equation}
\item Das mittlere Intervall ist $\mu_{ISI} = \frac{1}{\lambda}$ .
\item Die Varianz der Intervalle ist $\sigma_{ISI}^2 = \frac{1}{\lambda^2}$ .
\item Der Variationskoeffizient ist also immer $CV_{ISI} = 1$ .
@@ -248,19 +263,20 @@ Der homogene Poissonprozess hat folgende Eigenschaften:
\item Der Fano Faktor ist immer $F=1$ .
\end{itemize}
\begin{exercise}{hompoissonspikes.m}{}
Schreibe eine Funktion \code{hompoissonspikes()}, die die Spikezeiten
eines homogenen Poisson-Prozesses mit gegebener Rate in Hertz f\"ur
eine Anzahl von trials gegebener maximaler L\"ange in Sekunden in
einem \codeterm{cell-array} zur\"uckgibt. Benutze die exponentiell-verteilten
Interspikeintervalle \eqnref{poissonintervals}, um die Spikezeiten zu erzeugen.
\end{exercise}
\begin{figure}[t]
\includegraphics[width=0.48\textwidth]{poissoncounthistdist100hz10ms}\hfill
\includegraphics[width=0.48\textwidth]{poissoncounthistdist100hz100ms}
\titlecaption{\label{hompoissoncountfig}Z\"ahlstatistik von Poisson Spikes.}{}
\end{figure}
\begin{exercise}{poissonspikes.m}{}
Schreibe eine Funktion \code{poissonspikes()}, die die Spikezeiten
eines homogenen Poisson-Prozesses mit gegebener Rate in Hertz f\"ur
eine Anzahl von trials gegebener maximaler L\"ange in Sekunden in
einem \codeterm{cell-array} zur\"uckgibt.
\end{exercise}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Zeitabh\"angige Feuerraten}
@@ -295,16 +311,14 @@ Abbildung \ref{psthfig} n\"aher erl\"autert.
\subsection{Instantane Feuerrate}
\begin{figure}[tp]
\includegraphics[width=\columnwidth]{isimethod}
\titlecaption{Bestimmung des zeitabh\"angigen Feuerrate aus dem
Interspike Intervall.}{\textbf{A)} Skizze eines Rasterplots einer
einzelnen neuronalen Antwort. Jeder vertikale Strich notiert den
Zeitpunkt eines Aktionspotentials. Die Pfeile zwischen
aufeinanderfolgenden Aktionspotentialen und die Zahlen
illustrieren das Interspike Interval. \textbf{B)} Der Kehrwert
des Interspike Intervalls ist die Feuerrate.}\label{instrate}
\titlecaption{Instantane Feuerrate.}{Skizze eines Spiketrains
(oben). Jeder vertikale Strich notiert den Zeitpunkt eines
Aktionspotentials. Die Pfeile zwischen aufeinanderfolgenden
Aktionspotentialen mit den Zahlen in Millisekunden illustrieren
die Interspikeintervalle. Der Kehrwert des Interspikeintervalle
ergibt die instantane Feuerrate.}\label{instrate}
\end{figure}
Ein sehr einfacher Weg, die zeitabh\"angige Feuerrate zu bestimmen ist
@@ -321,6 +335,11 @@ Feuerrate k\"onnen f\"ur manche Analysen nachteilig sein. Au{\ss}erdem
wird die Feuerrate nie gleich Null, auch wenn lange keine Aktionspotentiale
generiert wurden.
\begin{exercise}{instantaneousRate.m}{}
Implementiere die Absch\"atzung der Feuerrate auf Basis der
instantanen Feuerrate. Plotte die Feuerrate als Funktion der Zeit.
\end{exercise}
\subsection{Peri-Stimulus-Zeit-Histogramm}
W\"ahrend die Instantane Rate den Kehrwert der Zeit von einem bis zum
@@ -343,12 +362,17 @@ oder durch Verfaltung mit einem Kern bestimmt werden. Beiden Methoden
gemeinsam ist die Notwendigkeit der Wahl einer zus\"atzlichen Zeitskala,
die der Beobachtungszeit $W$ in \eqnref{psthrate} entspricht.
\begin{exercise}{instantaneousRate.m}{}
Implementiere die Absch\"atzung der Feuerrate auf Basis der
instantanen Feuerrate. Plotte die Feuerrate als Funktion der Zeit.
\end{exercise}
\subsubsection{Binning-Methode}
\begin{figure}[tp]
\includegraphics[width=\columnwidth]{binmethod}
\titlecaption{Bestimmung des PSTH mit der Binning Methode.}{Der
gleiche Spiketrain wie in \figref{instrate}. Die grauen Linien
markieren die Grenzen der Bins und die Zahlen geben die Anzahl der Spikes
in jedem Bin an (oben). Die Feuerrate ergibt sich aus dem
mit der Binbreite normierten Zeithistogramm (unten).}\label{binpsth}
\end{figure}
Bei der Binning-Methode wird die Zeitachse in gleichm\"aßige
Abschnitte (Bins) eingeteilt und die Anzahl Aktionspotentiale, die in
die jeweiligen Bins fallen, gez\"ahlt (\figref{binpsth} A). Um diese
@@ -366,23 +390,23 @@ vorkommen k\"onnen nicht aufgl\"ost werden. Mit der Wahl der Binweite
wird somit eine Annahme \"uber die relevante Zeitskala des Spiketrains
gemacht.
\begin{figure}[tp]
\includegraphics[width=\columnwidth]{binmethod}
\titlecaption{Bestimmung des PSTH mit der Binning Methode.}{\textbf{A)}
Skizze eines Rasterplots einer einzelnen neuronalen Antwort. Jeder
vertikale Strich notiert den Zeitpunkt eines
Aktionspotentials. Die roten gestrichelten Linien stellen die
Grenzen der Bins dar und die Zahlen geben den Spike Count pro Bin
an. \textbf{B)} Die Feuerrate erh\"alt man indem das
Zeithistogramm mit der Binweite normiert.}\label{binpsth}
\end{figure}
\begin{exercise}{binnedRate.m}{}
Implementiere die Absch\"atzung der Feuerrate mit der ``binning''
Methode. Plotte das PSTH.
\end{exercise}
\subsubsection{Faltungsmethode}
\begin{figure}[tp]
\includegraphics[width=\columnwidth]{convmethod}
\titlecaption{Bestimmung des PSTH mit der Faltungsmethode.}{Der
gleiche Spiketrain wie in \figref{instrate}. Bei der Verfaltung
des Spiketrains mit einem Faltungskern wird jeder Spike durch den
Faltungskern ersetzt (oben). Bei korrekter Normierung des
Kerns ergibt sich die Feuerrate direkt aus der \"Uberlagerung der
Kerne.}\label{convrate}
\end{figure}
Bei der Faltungsmethode werden die harten Kanten der Bins der
Binning-Methode vermieden. Der Spiketrain wird mit einem Kern
verfaltet, d.h. jedes Aktionspotential wird durch den Kern ersetzt.
@@ -399,22 +423,12 @@ ersetzt (Abbildung \ref{convrate} A). Wenn der Kern richtig normiert
wurde (Integral gleich Eins), ergibt sich die Feuerrate direkt aus der
\"Uberlagerung der Kerne (Abb. \ref{convrate} B).
\begin{figure}[tp]
\includegraphics[width=\columnwidth]{convmethod}
\titlecaption{Schematische Darstellung der Faltungsmethode.}{\textbf{A)}
Rasterplot einer einzelnen neuronalen Antwort. Jeder vertikale
Strich notiert den Zeitpunkt eines Aktionspotentials. In der
Faltung werden die mit einer 1 notierten Aktionspotential durch
den Faltungskern ersetzt. \textbf{B)} Bei korrekter Normierung des
Kerns ergibt sich die Feuerrate direkt aus der \"Uberlagerung der
Kerne.}\label{convrate}
\end{figure}
Die Faltungsmethode f\"uhrt, anders als die anderen Methoden, zu einer
kontinuierlichen Funktion was insbesondere f\"ur spektrale Analysen
von Vorteil sein kann. Die Wahl der Kernbreite bestimmt, \"ahnlich zur
stetigen Funktion was insbesondere f\"ur spektrale Analysen von
Vorteil sein kann. Die Wahl der Kernbreite bestimmt, \"ahnlich zur
Binweite, die zeitliche Aufl\"osung von $r(t)$. Die Breite des Kerns
macht also auch wieder eine Annahme \"uber die relevante Zeitskala des Spiketrains.
macht also auch wieder eine Annahme \"uber die relevante Zeitskala des
Spiketrains.
\begin{exercise}{convolutionRate.m}{}
Verwende die Faltungsmethode um die Feuerrate zu bestimmen. Plotte
@@ -440,12 +454,12 @@ ausgeschnitten wird und diese dann gemittelt werde (\figref{stafig}).
\begin{figure}[t]
\includegraphics[width=\columnwidth]{sta}
\titlecaption{Spike-triggered Average eines P-Typ Elektrorezeptors
und Stimulusrekonstruktion.}{\textbf{A)} Der STA: der Rezeptor
und Stimulusrekonstruktion.}{Der STA (links): der Rezeptor
wurde mit einem ``white-noise'' Stimulus getrieben. Zeitpunkt 0
ist der Zeitpunkt des beobachteten Aktionspotentials. Die Kurve
ergibt sich aus dem gemittelten Stimulus je 50\,ms vor und nach
einem Aktionspotential. \textbf{B)} Stimulusrekonstruktion mittels
STA. Die Zellantwort wird mit dem STA gefaltet um eine
einem Aktionspotential. Stimulusrekonstruktion mittels
STA (rechts). Die Zellantwort wird mit dem STA gefaltet um eine
Rekonstruktion des Stimulus zu erhalten.}\label{stafig}
\end{figure}