def test_gridsearcher(self):
def func(param_dict):
x, y = param_dict['x'], param_dict['y']
return x * x + y * y
from NeuroTools.parameters import ParameterSpace, ParameterRange
grid = ParameterSpace({
'x': ParameterRange([-2., -1., 0., 1., 2.]),
'y': ParameterRange([-2., -1., 0., 1., 2.])
})
gs = optimizers.GridSearcher(grid, func)
retdict = gs.search()
self.failUnlessEqual(retdict['min_value'], 0.)
self.failUnlessEqual(retdict['min_params'], {'x': 0., 'y': 0.})
def make_param_dict_list():
"""
create a list of parameter dictionaries for the model network.
"""
# there is certainly a way to do this with NeuroTools.
import numpy
rates = numpy.linspace(start=10., stop=100., num=5)
weights = numpy.linspace(start=0.1, stop=1.0, num=5)
from NeuroTools.parameters import ParameterSet, ParameterSpace, ParameterRange
params = ParameterSpace(
ParameterSet({
'rate': ParameterRange(rates),
'weight': ParameterRange(weights)
}))
dictlist = [p.as_dict() for p in params.iter_inner()]
return dictlist
def make_param_dict_list(N):
"""
create a list of parameter dictionaries for the model network.
"""
N_snr, N_seeds = 5, 10
from NeuroTools.parameters import ParameterSpace, ParameterRange
import numpy
params = ParameterSpace({
'N':
N,
'snr':
ParameterRange(list(numpy.linspace(0.1, 2.0, N_snr))),
'kernelseed':
ParameterRange(list([12345 + k for k in range(N_seeds)]))
})
dictlist = [p.as_dict() for p in params.iter_inner()]
return dictlist
def parameter_scan(p=None):
if p is None:
p = default_parameters()
#p.K2 = ParameterRange([0.7,0.0])
# p.dt = ParameterRange([1.,6.77,10.,1000.]) # ms
#p.td = ParameterRange([0.])#,6.,20.])
#p.t1 = ParameterRange([0.]) # ms
#p.t2 = ParameterRange([0.]) # ms
#g = 0.8
#p.c1 = ParameterRange([0.14*g])
#p.c2 = ParameterRange([0.12*g])
p.sigma_c = ParameterRange([0.1, 0.4, 0.8])
p.K2 = ParameterRange([0., 0.7, 1.4])
create_figure()
for experiment in p.iter_inner():
name = make_name(experiment, p.range_keys())
print name
plot_receptive_field(p=experiment, label=name)
from NeuroTools.parameters import ParameterSet
from NeuroTools.parameters import ParameterRange
from NeuroTools.parameters import ParameterTable
p = ParameterSet({})
p.orientation = ParameterTable("""
# RS RSa RSb FS FSa FSb
RS 15. 15. 12 13 12 1
FS 15. 15. 9 2 2 9
LGN 0. 12. 0 2 0 0
V2 3. 2. 2 2 9 7
M1 0. 0. 8 2 2 1
""")
p.a = 23
p.b = ParameterSet({})
p.b.s = ParameterRange([1, 2, 3])
p.b.w = ParameterTable("""
# RS FS
all 1. 0.
none -1. -2.
""")
p.name = 'first experiment'
p.simulator = 'pyNN'
p.export('exported_model_parameters.tex', format='latex', **{'indent': 1.5})
if is_exe(exe_file):
return exe_file
################################################################################
# Main simulation parameterspaces
################################################################################
PS = {}
PS['simres_RS'] = ParameterSpace({
'morphology':
os.path.join('morphologies',
'C120398A-P1.CNG_sansAxon.hoc'), #L4 Stellate Cell, rat
'rm':
ParameterRange([11250]),
'Ra':
ParameterRange([150]),
'cm':
ParameterRange([0.9]),
'custom_code':
ParameterRange([['add_spines.hoc']]),
'active':
ParameterRange([False]),
'v_init':
ParameterRange([-66.]), #Beierlein
'pop_params_n':
ParameterRange([4000]),
'pop_geom':
ParameterRange([[500, -250, 250]]),
'tau1':
import NeuroTools.stgen as stgen
sg = stgen.StGen()
from NeuroTools.parameters import ParameterSpace
from NeuroTools.parameters import ParameterRange
from NeuroTools.sandbox import make_name
# creating a ParameterSpace
p = ParameterSpace({})
# adding fixed parameters
p.nu = 20. # rate [Hz]
p.duration = 1000.
# adding ParameterRanges
p.c = ParameterRange([0.0, 0.01, 0.1, 0.5])
p.jitter = ParameterRange([
0.0,
1.0,
5.0,
])
# calculation of the ParameterSpace dimension and the labels of the parameters
# containing a range
dims, labels = p.parameter_space_dimension_labels()
print "dimensions: ", dims
print ' labels: ', labels
def calc_cc(p):
"""
p.gL = 25.
p.tref = 2.
# Parameters for running
p.timestep = 0.1
p.min_delay = 0.1
p.max_delay = 5.1
p.runtime = 500000.
# Parameters for number and connections
p.r0 = 1400. # excitatory input rate
p.ri = 1647. # inhibitory input rate
p.je = 0.015 # excitatory synaptic weight
p.ji = -0.015 # inhibitory synaptic weight
p.cb = ParameterRange(numpy.arange(
1., 1.001,
0.05)) # between-cell correlation of background input (NSD input)
p.N = 1000 # number of daughter cells for MIP
p.r = ParameterRange(numpy.arange(100., 101., 400.)) # MIP rate
p.c = ParameterRange(numpy.array([0.05])) # with-pool correlation in MIP
p.q = ParameterRange(numpy.arange(
0.2, 0.2501, 0.05)) # between-cell correlation of MIP input (SD input)
p.edge = ParameterRange(numpy.array([0.])) # range of temporal jitter of MIP
dims, labels = p.parameter_space_dimension_labels()
results = numpy.empty(dims)
for experiment in p.iter_inner():
name = make_name(experiment, p.range_keys())
print name
model = st.Striatum()
model.run(sim, experiment, name)
Having fixed the background noise we are just studying now how different
signal to noise ratios are integrated by the neurons.
Laurent Perrinet, INCM, CNRS
$ Id $
"""
import os, sys, numpy, pylab, shelve
N, N_exp = 1000, 6
t_smooth = 100. # width (in ms) of the integration window
from NeuroTools.parameters import ParameterSpace, ParameterRange
snr = 2.0 * numpy.linspace(0.1, 2.0, N_exp)
p = ParameterSpace({'snr': ParameterRange(list(snr))})
name = sys.argv[0].split('.')[
0] # name of the current script withpout the '.py' part
results = shelve.open('results/mat-' + name)
try:
temporal_ON = results['temporal_ON']
temporal_OFF = results['temporal_OFF']
lower_edges = results['lower_edges']
params = results['params']
#if (params == retina.params): raise('Parameters have changed')
except:
from retina import *
retina = Retina(N)
p.E_ex = 0.
p.E_in = -70.
p.ie = 0.
p.cm = 500.
p.gL = 25.
p.tref = 2.
# Parameters for running
p.timestep = 0.1
p.min_delay = 0.1
p.max_delay = 5.1
p.runtime = 100000.
# Parameters for number and connections
p.r0 = 2000. # excitatory input rate
p.ri = 1647. # inhibitory input rate
p.je = 0.015 # excitatory synaptic weight
p.ji = -0.015 # inhibitory synaptic weight
p.cb = ParameterRange(numpy.arange(0., 1.001,
0.05)) # between-cell correlation
dims, labels = p.parameter_space_dimension_labels()
results = numpy.empty(dims)
for experiment in p.iter_inner():
name = make_name(experiment, p.range_keys())
print name
model = st.Striatum()
model.run(sim, experiment, name)
index = p.parameter_space_index(experiment)
results[index] = 0