Maximum decoding abilities of temporal patterns and synchronized firings: application to auditory neurons responding to click trains and amplitude modulated white noise

Abstract

Simultaneous recordings of an increasing number of neurons have recently become available, but few methods have been proposed to handle this activity. Here, we extract and investigate all the possible temporal neural activity patterns based on synchronized firings of neurons recorded on multiple electrodes, or based on bursts of single-electrode activity in cat primary auditory cortex. We apply this to responses to periodic click trains or sinusoïdal amplitude modulated noise by obtaining for each pattern its temporal modulation transfer function. An algorithm that maximizes the mutual information between all patterns and stimuli subsequently leads to the identification of patterns that optimally decode modulation frequency (MF). We show that stimulus information contained in multi-electrode synchronized firing is not redundant with single-electrode firings and leads to improved efficiency of MF decoding. We also show that the combined use of firing rate and temporal codes leads to a better discrimination of the MF.

Appendices

Appendix 1: algorithm for patterns extraction

We remind here that our algorithm uses ideas from datamining to discover frequent episodes in event sequences, like the APRIORI algorithm (Agrawal and Srikant 1994; Agrawal and Srikant 1995; Mannila et al. 1997). The algorithm uses two general ideas:

• 1) If a pattern of size s is found d times in the data, then necessarily all possible subsets of this pattern, and a fortiori the patterns of size s-1 to 2, are also found at least d times in the data. Reciprocally, if one pattern of size s-1 or 2 is found less than d times, then it cannot generate a pattern of size s found more than d times. As a consequence, the general scheme of the algorithm is to extract patterns of size two, then use them to find patterns of size three. The patterns of size three will be used to extract patterns of size four and so on.

• 2) we can obtain patterns of size s + 1 by concatenating the last channel of patterns of size s with the first channel of patterns of size two. All possible patterns of size s + 1 appearing more than d times are then tested by this algorithm because of the idea 1.

A more detailed description of the steps of the algorithms follows:

• 1) Detect all patterns of size two {C _i, C _j} following the three rules. The times when the first and last channel activity of each pattern occur are also stored.

• 2) Find patterns of size three: let us consider the pattern {C _i, C _j} found at the set of end times T ₁ (times of C _j) with a delay l ₁ between C _i and C _j, and the pattern {C _j, C _k} found at times T ₂ (times of C _j) with a delay l ₂ between C _j and C _k and such that $l_1 + l_2 \le d_2$ (rule number 2). Therefore, the intersection T ₃ between T ₁ and T ₂ is the set of times of C _j when the pattern {C _i, C _j, C _k} happens, with a delay of l ₁ + l ₂ between C _i and C _k. This new pattern is kept if T ₃ induces a repetition rate of the pattern greater than d ₁.

• 3) The process is iterated: patterns of size s are found by combining patterns of size s-1 with patterns of size two, given than the same channel is not repeated more than d ₃ times (rule number 3). The iteration stops when no new pattern following the three rules as previously defined is found.

A simplified pseudo-code would be

1.	//Vector of Spike Times of the i-th channel
2.	Events Ci  = {e 1 ,e 2 ,...,e Ni }
3.	//Patterns of size 1
4.	Compt_Pattern = 0
5.	For Channel from 1 to Nb_channels,
6.	Nb = length of Events Channel
7.	If Nb > d 1
8.	//A new pattern is found
9.	Compt_Pattern = Compt_Pattern +1;
10.	Patterns 1 (Compt_Pattern) = { Channel }
11.	EndIf
12.	EndFor
13.	//Patterns of size 2
14.	For Channel2 from 1 to Nb_channels,
15.	For Delay_Channels from 0 to d 2 by BinWidth
16.	Nb = Number of times that Delay_Channels ≤ Events Channel1 (j)- Events Channel2 (k) < Delay_Channel + BinWidth for k > j, j ∈ {1,..., length of Events Channel1 }, k ∈{1,..., length of Events Channel2 }
17.	If Nb > d 1
18.	//A new pattern is found
19.	Compt_Pattern = Compt_Pattern +1;
20.	Patterns 2 (Compt_Pattern) = { Channel1, Channel2 }
21.	Delays 2 (Compt_Pattern) = { Delay_Channels }
22.	Times 2 (Compt_Pattern) = { Start and end times of each occurence of this pattern }
23.	EndIf
24.	EndFor
25.	EndFor
26.	EndFor
27.	Stop_Loop = 0
28.	//Size of the pattern
29.	Size = 2
30.	//Patterns of size >2
31.	While Stop_Loop = 0
32.	Compt_Pattern = 0
33.	For i from 1 to length of Patterns Size
34.	For j from 1 to length of Patterns 2
35.	If last channel of Patterns Size (i) and first channel of Patterns 2 (j) are the same
36.	If Delays Size (i) + Delays 2 (j) ≤ d 2
37.	Times_New_Pattern = Intersection(end times in Times Size (i) , start times in Times 2 (j))
38.	If length of Times_New_Pattern > d 1
39.	//A new pattern is found
40.	Compt_Pattern = Compt_Pattern +1
41.	Patterns Size+1 (Compt_Pattern) = {Patterns Size (i) ,last channel of Patterns 2 (j)}
42.	Delays Size+1 (Compt_Pattern) = { Delays Size (i) + Delays 2 (j) }
43.	Times Size+1 (Compt_Pattern) = {Start and end times of each occurence of this pattern}
44.	EndIf
45.	EndIf
46.	EndIf
47.	EndFor
48.	EndFor
49.	If Patterns Size+1 is empty
50.	Stop_Loop = 1
51.	EndIf
52.	EndWhile

A Matlab code for this algorithm is provided in the supplementary material.

Appendix 2: Forward selection of variables maximizing the mutual information

A variable is a row of the matrix M(i,j), i.e. a fixed i. The procedure described in the methods section (step 3) corresponds to the following pseudo-code:

1.	IMAX = 0
2.	Stop_Loop = 0
3.	Selection = $\mathop {Arg\min }\limits_i \left( {H\left( {\left( {M\left( {i,j} \right)} \right)_j } \right)} \right)$
4.	While Stop_Loop = 0
5.	Clear New_I_max
6.	For $i \notin Selection$,
7.	Selection_Temp = Selection $\cup$ i
8.	New_I_max(i) = I (Selection_Temp,Stim.)
9.	EndFor
10.	If $\mathop {Max}\limits_i \left( {New\_I\_\max \left( i \right)} \right) > I^{MAX}$
11.	Selection = Selection ∪ $\mathop {ArgMax}\limits_i \left( {New\_I\_\max \left( i \right)} \right)$
12.	Else
13.	Stop_Loop = 1
14.	EndIf
15.	EndWhile