-
Notifications
You must be signed in to change notification settings - Fork 0
/
simon5_plots.py
234 lines (156 loc) · 9.78 KB
/
simon5_plots.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
import os
import numpy as np
import dotmap
from SimonsPythonHelpers import nestedPrint
from helpers.parameters import flattenExtendedParamsets, crossAllParamsets
from helpers.simulation import run_simulation
#from figures.figuretype_OneParamAndRepetitions_Accuracy import makeFig
from figures.repetitiondetail import make_singlerun_figures
from figures.repetitionsummary import make_repetitionsummary_figures
import figures
def define_extended_simulation_parameters(metaparams,baseParams):
"""
The helpers of baseParams that should be re-run with a list of settings each.
Node paths of extendedParams have to match those in baseParams.
"""
extendedParams = dotmap.DotMap()
#extendedParams.neurongroups.outputs.userecovery = [True,False]
#extendedParams.neurongroups.inputs.rate = [ 10 , 15 ] # Hz
#extendedParams.neurongroups.outputs.projMult = np.r_[0.2:4.2:0.2]
extendedParams.neurongroups.outputs.projMult = np.r_[0.2:2.2:0.2]
#extendedParams.neurongroups.outputs.projMult = np.r_[2.2:4.2:0.2]
#extendedParams.neurongroups.outputs.projMult = [ 1.0 , 1.5 , 1.8 ]
extendedParams.connectionsets.con1.stdprule.learningrate = 1/32.0 * np.array([0.5 , 1.0 , 2.0]) # eta in Auryn
##extendedParams.connectionsets.con1.stdprule.learningrate = 1/32.0 * np.r_[0.2:4.2:0.2]
return extendedParams
def define_base_simulation_parameters(metaparams):
ms = 1e-3 # a millisecond.
simparams = dotmap.DotMap()
simparams.general.outfileprefix = metaparams.data_basename # dont need this: #+ "_repetition"+str(repetitionID+1)
simparams.general.testingProtocol_durations = [ 200 ] #1500 #116
simparams.general.testingProtocol_phasetypes = [1] # 0=noise, 1=patterns, 2=test type A, 3=test type B, ...
#simparams.general.testingProtocol_durations = [300,300,900] # in seconds
#simparams.general.testingProtocol_phasetypes = [0,1,3] # 0=noise, 1=patterns, 2=test type A, 3=test type B, ...
simparams.general.simtime = sum(simparams.general.testingProtocol_durations)
detailedtracking = False
simparams.neurongroups.inputs.N = 2000
#simparams.neurongroups.inputs.type = "PoissonGroup"
#simparams.neurongroups.inputs.type = "FileInputGroup"
#simparams.neurongroups.inputs.type = "StructuredPoissonGroup"
simparams.neurongroups.inputs.type = "PolychronousPoissonGroup"
# only needed by PoissonGroup and StructuredPoissonGroup:
simparams.neurongroups.inputs.rate = 10 # Hz
simparams.neurongroups.inputs.randomseed = 1459350219 # will be redefined in run_simulation()
# only needed by FileInputGroup:
simparams.neurongroups.inputs.rasfilename = '../sim_simon1.data/simon1_fileinputs.ras'
# only needed by StructuredPoissonGroup and PolychronousPoissonGroup:
simparams.neurongroups.inputs.patternduration = 100*ms
simparams.neurongroups.inputs.patterninterval = 200*ms
simparams.neurongroups.inputs.numberofstimuli = 1 # how many different patterns
simparams.neurongroups.inputs.patternOccurrencesFilename = metaparams.data_basename+'_patterntimes.tiser'
# only needed by PolychronousPoissonGroup:
simparams.neurongroups.inputs.N_presenting = 600
simparams.neurongroups.inputs.N_subpresenting = 600
simparams.neurongroups.outputs.type = "IzhikevichGroup" # not used yet
simparams.neurongroups.outputs.N = 1
simparams.neurongroups.outputs.projMult = 1.5
simparams.neurongroups.outputs.userecovery = False
# Things to test:
# projMult ; input rate ; learningrate ; (STDP shape) ; (use_recovery) ; (dt) ; ...
## without recovery: best is projMult=0.8 with learningrate * 2
# projMult = 0.5 * ms/dt; // without recovery: learning works (*2), but then the neuron hardly ever manages to produce a spike!
# projMult = 0.8 * ms/dt; // 8.0; without recov: one-spike responses already at lr/1 ! But 2/6 do not learn within 400s. /2 seems to work more often than not, but always only after 400s. *2 surprisingly also works nicely! surprisingly well! best! *4 doesn't work. *3 hardly ever works.
# projMult = 1.0 * ms/dt; // 8.0; // without recovery: works for lr 1 with double spike. lr/2 looses 2nd spike :) (but takes longer than 400s to start sometimes, on /3 is takes more than 1600s often.)
# projMult = 1.5 * ms/dt; // 8.0; // without recovery: only works for learningrate between /1 and /3
## with recovery:
# projMult = 1.5 * ms/dt; // 8.0; // with recovery! works with learningrate /4 to *10 and beyond.
# projMult = 50.5 * ms/dt; // 8.0;
simparams.connectionsets.con1.presynaptic = "inputs"
simparams.connectionsets.con1.postsynaptic = "outputs"
simparams.connectionsets.con1.initialweight = 0.85
# simparams.connectionsets.con1.stdprule.A_plus = 0.588
# simparams.connectionsets.con1.stdprule.A_minus = -1
# simparams.connectionsets.con1.stdprule.tau_plus = 28.6 *ms
# simparams.connectionsets.con1.stdprule.tau_minus = 28.6 *ms #22e-3
# simparams.connectionsets.con1.stdprule.learningrate = 0.0325 *1 # eta in Auryn
simparams.connectionsets.con1.stdprule.A_plus = 1
simparams.connectionsets.con1.stdprule.A_minus = -0.85
simparams.connectionsets.con1.stdprule.tau_plus = 16.8 *ms
simparams.connectionsets.con1.stdprule.tau_minus = 33.7 *ms #22e-3
simparams.connectionsets.con1.stdprule.learningrate = 1/32.0/1.0 # eta in Auryn
recordingparams = simparams.recordings
recordingparams.detailedtracking = detailedtracking
recordingparams.inputs.samplinginterval_poprate = 0.1 # seconds
recordingparams.outputs.samplinginterval_rate = 0.1 # seconds
recordingparams.outputs.samplinginterval_membranes = 'dt' # seconds
recordingparams.outputs.samplinginterval_ampa = 'dt' # seconds
recordingparams.outputs.samplinginterval_nmda = 'dt' # seconds
recordingparams.con1.samplinginterval_weightsum = 1 # seconds
recordingparams.con1.samplinginterval_weightstats = 0.1 # seconds
if simparams.general.simtime > 1000:
recordingparams.con1.samplinginterval_weightmatrix = 10 # seconds
elif simparams.general.simtime > 50:
recordingparams.con1.samplinginterval_weightmatrix = 1 # seconds
else:
recordingparams.con1.samplinginterval_weightmatrix = 0.1 # seconds
# possible future feature?:
duration = 0.5;
membraneViews = [ 0 , 4 , 40 , simparams.general.simtime-1 ]
recordingparams.dtintervalsAsFloats.starttimes = membraneViews
recordingparams.dtintervalsAsFloats.stoptimes = (np.asarray(membraneViews) + duration).tolist()
recordingparams.dtintervalsAsStrings.starttimes = ''
recordingparams.dtintervalsAsStrings.stoptimes = ''
for mi in xrange(len(membraneViews)):
#recordingparams.dtintervalslist[mi].start = float(membraneViews[mi])
#recordingparams.dtintervalslist[mi].stop = float(membraneViews[mi])+duration
recordingparams.dtintervalsAsStrings.starttimes += str(float(membraneViews[mi])) + " ";
recordingparams.dtintervalsAsStrings.stoptimes += str(float(membraneViews[mi] + duration)) + " ";
return simparams
def define_meta_parameters():
#### Define meta settings: executable, etc... ####
metaparams = dotmap.DotMap()
metaparams.executable_path = '../build/debug/examples/'
metaparams.executable_file = 'sim_simon5'
metaparams.data_path = './datafig/'+metaparams.executable_file+'.data/'
metaparams.data_basename = 'simon5'
metaparams.figures_path = './datafig/'+metaparams.executable_file+'.figures/'
metaparams.figures_basename = metaparams.data_basename
metaparams.numRepetitions = 8
for repetitionID in xrange(metaparams.numRepetitions):
metaparams.repetitionFoldernames[repetitionID] = 'repetition_'+str(repetitionID+1)
return metaparams
def make_figures(allsimparams ,metaparams):
os.system( 'mkdir -p ' +metaparams.figures_path)
figures.makeFiguretype_OneParamAndRepetitions_Accuracy(allsimparams, metaparams)
if allsimparams[0].recordings.detailedtracking:
make_repetitionsummary_figures(allsimparams ,metaparams)
# if metaparams.numRepetitions < 5:
make_singlerun_figures(allsimparams ,metaparams)
def main():
params = dotmap.DotMap()
#### Define meta settings: executable, etc... ####
params.metaparams = define_meta_parameters()
##### Define simulation settings: ####
params.baseParams = define_base_simulation_parameters(params.metaparams)
params.extendedParams = define_extended_simulation_parameters(params.metaparams,params.baseParams)
##### Rearrange them: #####
params.flatParamLists = flattenExtendedParamsets(params.metaparams, params.baseParams, params.extendedParams)
params.allsimparams = crossAllParamsets(params.baseParams, params.flatParamLists.copy())
#nestedPrint(allsimparams)
##### Run simulation(s) #####
run_simulation(params, True)
##### Plot results #####
try:
#figures.makeFiguretype_TwoParamImage_Accuracy(params,paramStringX='connectionsets.con1.weightdependence.attractorLocation',paramStringY='connectionsets.con1.weightdependence.attractorStrength')
figures.makeFiguretype_OneParamAndRepetitions_Accuracy(params,paramString='neurongroups.outputs.projMult')
figures.makeFiguretype_OneParamAndRepetitions_Accuracy(params,paramString='connectionsets.con1.stdprule.learningrate')
if params.baseParams.recordings.detailedtracking:
#figures.makeFiguretype_OneParamAndRepetitions_ResponseDevelopment(params,paramString='neurongroups.outputs.projMult')
pass
#make_figures(allsimparams,metaparams)
except IOError as e:
print e.message
print e
print type(e)
if __name__ == "__main__":
main()