def subplot(self, subplotspec): gs = gridspec.GridSpecFromSubplotSpec(2, 4, subplot_spec=subplotspec) plots = {} dsv = param_filter_query(self.datastore, sheet_name=[ 'V1_Exc_L4', 'V1_Inh_L4', 'V1_Exc_L2/3', 'V1_Inh_L2/3' ]) for i, sheet in enumerate(dsv.sheets()): dsv1 = param_filter_query(dsv, sheet_name=sheet, value_name='LGNAfferentOrientation') plots[sheet + 'A'] = (PerNeuronValuePlot(dsv1, ParameterSet({})), gs[0, i], {}) dsv1 = param_filter_query( dsv, sheet_name=sheet, value_name='orientation preference', analysis_algorithm= 'PeriodicTuningCurvePreferenceAndSelectivity_VectorAverage', st_contrast=100) plots[sheet + 'B'] = (PerNeuronValuePlot(dsv1, ParameterSet({})), gs[1, i], { 'title': None }) return plots
def string_table_ParameterSet(tablestring): """Convert a table written as a multi-line string into a dict of dicts.""" tabledict = ParameterSet({}) rows = tablestring.strip().split('\n') column_headers = rows[0].split() for row in rows[1:]: row = row.split() row_header = row[0] tabledict[row_header] = ParameterSet({}) for col_header, item in zip(column_headers[1:], row[1:]): tabledict[row_header][col_header] = float(item) return tabledict
def theta_E(self, im, X_, Y_, w): try: assert (self.slip.N_X == im.shape[1]) except: from NeuroTools.parameters import ParameterSet from SLIP import Image from LogGabor import LogGabor self.slip = Image( ParameterSet({ 'N_X': im.shape[1], 'N_Y': im.shape[0] })) self.lg = LogGabor(self.slip) im_ = im.sum(axis=-1) im_ = im_ * np.exp(-.5 * ((.5 + .5 * self.slip.x - Y_)**2 + (.5 + .5 * self.slip.y - X_)**2) / w**2) E = np.zeros((self.N_theta, )) for i_theta, theta in enumerate(self.thetas): params = { 'sf_0': self.sf_0, 'B_sf': self.B_sf, 'theta': theta, 'B_theta': np.pi / self.N_theta } FT_lg = self.lg.loggabor(0, 0, **params) E[i_theta] = np.sum( np.absolute( self.slip.FTfilter(np.rot90(im_, -1), FT_lg, full=True))**2) return E
def run(parameters, sim_list): sim_time = parameters.sim_time spike_interval = parameters.spike_interval stgen = StGen() seed = parameters.seed stgen.seed(seed) model_parameters = ParameterSet({ 'system': parameters.system, 'input_spike_times': stgen.poisson_generator(1000.0 / spike_interval, t_stop=sim_time, array=True), 'cell_type': parameters.cell.type, 'cell_parameters': parameters.cell.params, 'plasticity': { 'short_term': None, 'long_term': None }, 'weights': parameters.weights, 'delays': parameters.delays, }) networks = MultiSim(sim_list, SimpleNetwork, model_parameters) networks.run(sim_time) spike_data = networks.get_spikes() vm_data = networks.get_v() networks.end() return spike_data, vm_data, model_parameters
def get_pe(self, pe): if type(pe) is tuple: return ParameterSet({'N_X': pe[0], 'N_Y': pe[1]}) elif type(pe) is ParameterSet: return pe elif type(pe) is dict: return ParameterSet(pe) elif type(pe) is np.ndarray: return ParameterSet({'N_X': pe.shape[0], 'N_Y': pe.shape[1]}) elif type(pe) is str: im = imread(pe) if not type(im) is np.ndarray: # loading an image failed return ParameterSet(pe) else: return ParameterSet({'N_X': im.shape[0], 'N_Y': im.shape[1]}) else: self.log.error('could not guess what the init variable is')
def setup_experiments(simulation_name,sim): # Read parameters if len(sys.argv) > 1: parameters_url = sys.argv[1] else: raise ValueError , "No parameter file supplied" parameters = ParameterSet(parameters_url) # Create results directory timestamp = datetime.now().strftime('%Y%m%d-%H%M%S') Global.root_directory = parameters.results_dir + simulation_name + '_' + timestamp + '/' os.mkdir(Global.root_directory) parameters.save(Global.root_directory + "parameters", expand_urls=True) setup_logging() return parameters
def __init__(self, initializer): import types ps = initializer # try to create a ParameterSet from ps if # it is not one already if not isinstance(ps, ParameterSet): # create ParameterSet, but allowing SchemaBase derived objects ps = ParameterSet(ps, update_namespace=schema_checkers_namespace) # convert each element for x in ps.flat(): key = x[0] value = x[1] if isinstance(value, SchemaBase): self.flat_add(key, value) else: self.flat_add(key, Subclass(type=type(value)))
def __init__(self, initializer): import types ps = initializer # try to create a ParameterSet from ps if # it is not one already if not isinstance(ps, ParameterSet): # create ParameterSet, but allowing SchemaBase derived objects ps = ParameterSet(ps, update_namespace=schema_checkers_namespace) # convert each element for x in ps.flat(): key = x[0] value = x[1] if isinstance(value, SchemaBase): self.flat_add(key, value) else: self.flat_add(key, Subclass(type=type(value)))
def __init__(self, N=100): # simulator specific simulation_params = ParameterSet({ 'dt': 0.1, # discretization step in simulations (ms) 'simtime': 40000 * 0.1, # float; (ms) 'syn_delay': 1.0, # float; (ms) 'kernelseed': 4321097, # array with one element per thread 'connectseed': 12345789 # seed for random generator(s) used during simulation }) # these may change self.params = ParameterSet( { 'simulation': simulation_params, 'N': N, 'noise_std': 6.0, # (nA??) standard deviation of the internal noise 'snr': 1.0, # (nA??) size of the input signal 'weight': 1.0 }, label="fiber_params") print self.params.pretty()
def subplot(self, subplotspec): gs = gridspec.GridSpecFromSubplotSpec(12, 18, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) return { 'Layer4Exc': (PlotTuningCurve( self.datastore, ParameterSet({ 'parameter_name': 'orientation', 'neurons': self.parameters.l4_exc_neurons, 'sheet_name': 'V1_Exc_L4' })), gs[0:3, :], {}), 'Layer4Inh': (PlotTuningCurve( self.datastore, ParameterSet({ 'parameter_name': 'orientation', 'neurons': self.parameters.l4_inh_neurons, 'sheet_name': 'V1_Inh_L4' })), gs[3:6, :], {}), 'Layer23Exc': (PlotTuningCurve( self.datastore, ParameterSet({ 'parameter_name': 'orientation', 'neurons': self.parameters.l23_exc_neurons, 'sheet_name': 'V1_Exc_L2/3' })), gs[6:9, :], {}), 'Layer23Inh': (PlotTuningCurve( self.datastore, ParameterSet({ 'parameter_name': 'orientation', 'neurons': self.parameters.l23_inh_neurons, 'sheet_name': 'V1_Inh_L2/3' })), gs[9:12, :], {}), }
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 test(sim): params = ParameterSet({ 'system': { 'timestep': 0.1, 'min_delay': 0.1, 'max_delay': 10.0 }, 'input_spike_times': numpy.arange(5,105,10.0), 'cell_type': 'IF_curr_exp', 'cell_parameters': {}, 'plasticity': { 'short_term': None, 'long_term': None }, 'weights': 0.1, 'delays': 1.0, }) SimpleNetwork.check_parameters(params) net = SimpleNetwork(sim, params) sim.run(100.0) id = net.get_v()['post'].id_list()[0] print id print net.get_v()['post'][id]
def __init__(self,N=100): # simulator specific simulation_params = ParameterSet({'dt' : 0.1,# discretization step in simulations (ms) 'simtime' : 40000*0.1, # float; (ms) 'syn_delay' : 1.0, # float; (ms) 'kernelseed' : 4321097, # array with one element per thread 'connectseed' : 12345789 # seed for random generator(s) used during simulation }) # these may change self.params = ParameterSet({'simulation': simulation_params, 'N' : N, 'noise_std' : 6.0, # (nA??) standard deviation of the internal noise 'snr' : 1.0, # (nA??) size of the input signal 'weight' : 1.0 }, label="fiber_params") print self.params.pretty()
def subplot(self, subplotspec): gs = gridspec.GridSpecFromSubplotSpec(16, 1, subplot_spec=subplotspec) plots = {} dsv = param_filter_query(self.datastore, sheet_name=[ 'V1_Exc_L4', 'V1_Inh_L4', 'V1_Exc_L2/3', 'V1_Inh_L2/3' ]) print dsv.sheets() print['V1_Exc_L4', 'V1_Inh_L4', 'V1_Exc_L2/3', 'V1_Inh_L2/3'] for i, sheet in enumerate( ['V1_Exc_L4', 'V1_Inh_L4', 'V1_Exc_L2/3', 'V1_Inh_L2/3']): dsv1 = param_filter_query(data_store, value_name=['orientation HWHH'], sheet_name=sheet) plots[sheet] = (PerNeuronValueScatterPlot(dsv1, ParameterSet({})), gs[i * 4:i * 4 + 3, 0], {}) return plots
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})
class FiberChannel(object): """ Model class for the fiber of simple neurons. """ def __init__(self,N=100): # simulator specific simulation_params = ParameterSet({'dt' : 0.1,# discretization step in simulations (ms) 'simtime' : 40000*0.1, # float; (ms) 'syn_delay' : 1.0, # float; (ms) 'kernelseed' : 4321097, # array with one element per thread 'connectseed' : 12345789 # seed for random generator(s) used during simulation }) # these may change self.params = ParameterSet({'simulation': simulation_params, 'N' : N, 'noise_std' : 6.0, # (nA??) standard deviation of the internal noise 'snr' : 1.0, # (nA??) size of the input signal 'weight' : 1.0 }, label="fiber_params") print self.params.pretty() def run(self,params, verbose =True): tmpdir = tempfile.mkdtemp() timer = Timer() timer.start() # start timer on construction # === Build the network ======================================================== if verbose: print "Setting up simulation" sim.setup(timestep=params.simulation.dt,max_delay=params.simulation.syn_delay, debug=False) N = params.N #dc_generator current_source = sim.DCSource( amplitude= params.snr, start=params.simulation.simtime/4, stop=params.simulation.simtime/4*3) # internal noise model (NEST specific) noise = sim.Population(N,'noise_generator',{'mean':0.,'std':params.noise_std}) # target population output = sim.Population(N , sim.IF_cond_exp) # initialize membrane potential numpy.random.seed(params.simulation.kernelseed) V_rest, V_spike = -70., -53. output.tset('v_init',V_rest + numpy.random.rand(N,)* (V_spike -V_rest)) # Connecting the network conn = sim.OneToOneConnector(weights = params.weight) sim.Projection(noise, output, conn) for cell in output: cell.inject(current_source) output.record() # reads out time used for building buildCPUTime= timer.elapsedTime() # === Run simulation =========================================================== if verbose: print "Running simulation" timer.reset() # start timer on construction sim.run(params.simulation.simtime) simCPUTime = timer.elapsedTime() timer.reset() # start timer on construction output_filename = os.path.join(tmpdir,'output.gdf') #print output_filename output.printSpikes(output_filename)# output_DATA = load_spikelist(output_filename,N, t_start=0.0, t_stop=params.simulation.simtime) writeCPUTime = timer.elapsedTime() if verbose: print "\nFiber Network Simulation:" print "Number of Neurons : ", N print "Mean Output rate : ", output_DATA.mean_rate(), "Hz during ",params.simulation.simtime, "ms" print("Build time : %g s" % buildCPUTime) print("Simulation time : %g s" % simCPUTime) print("Writing time : %g s" % writeCPUTime) os.remove(output_filename) os.rmdir(tmpdir) return output_DATA
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('exportetd_model_parameters.tex',format='latex',**{'indent':1.5})
active = None uuid = None e = None sigma = None v_init = None section_syn = None simulated = None my = None electrode_r = None randomseed = None # Grab command line input parametersetfile = sys.argv[1] if not os.path.isfile(parametersetfile): raise Exception, 'provide parameterset filename on command line' PSet = ParameterSet(parametersetfile) #create some variables from parameter set for i in PSet.iterkeys(): vars()[i] = PSet[i] psetid = PSet['uuid'] print('Current simulation are using ParameterSet:') print PSet.pretty() #create folder to save data if it doesnt exist datafolder = os.path.join('savedata', psetid) if not os.path.isdir(datafolder): os.system('mkdir %s' % datafolder) print 'created folder %s!' % datafolder
#jens_model.connectors['V1L4InhL4ExcConnection'].store_connections(data_store) #jens_model.connectors['V1L4InhL4InhConnection'].store_connections(data_store) #jens_model.connectors['V1ExcL23ExcL23Connection'].store_connections(data_store) #jens_model.connectors['V1ExcL23InhL23Connection'].store_connections(data_store) #jens_model.connectors['V1InhL23ExcL23Connection'].store_connections(data_store) #jens_model.connectors['V1InhL23InhL23Connection'].store_connections(data_store) #jens_model.connectors['V1ExcL4ExcL23Connection'].store_connections(data_store) logger.info('Saving Datastore') if (not MPI) or (mpi_comm.rank == MPI_ROOT): data_store.save() else: setup_logging() #data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'/media/antolikjan/New Volume/DATA/mozaik/PushPullCCLISSOMModel/OR'}),replace=True) data_store = PickledDataStore(load=True, parameters=ParameterSet( {'root_directory': 'E'}), replace=True) logger.info('Loaded data store') import resource print "Current memory usage: %iMB" % ( resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / (1024)) pref_or = numpy.pi / 2 #find neuron with preference closet to pref_or l4_analog_ids = param_filter_query( data_store, sheet_name="V1_Exc_L4").get_segments()[0].get_stored_esyn_ids() l4_analog_ids_inh = param_filter_query(
parameters = ParameterSet({ 'system': { 'timestep': 0.01, 'min_delay': 0.1, 'max_delay': 10.0 }, 'input_spike_times': stgen.poisson_generator(rate=1000.0 / spike_interval, t_stop=sim_time, array=True), 'trigger_spike_times': stgen.poisson_generator(rate=1000.0 / spike_interval, t_stop=sim_time, array=True), 'cell_type': 'IF_curr_exp', 'cell_parameters': { 'tau_refrac': 10.0, 'tau_m': 2.0, 'tau_syn_E': 1.0 }, 'plasticity': { 'short_term': None, 'long_term': { 'timing_dependence': { 'model': 'SpikePairRule', 'params': { 'tau_plus': 20.0, 'tau_minus': 20.0 } }, 'weight_dependence': { 'model': 'AdditiveWeightDependence', 'params': { 'w_min': 0, 'w_max': 0.1, 'A_plus': 0.01, 'A_minus': 0.01 } }, 'ddf': 1.0, } }, 'weights': 0.01, 'delays': 1.0, })
from NeuroTools.parameters import ParameterSet from NeuroTools.parameters import ParameterRange import corr_SDNSD as st import pyNN.nest as sim from NeuroTools.sandbox import make_name from NeuroTools.sandbox import check_name import numpy p = ParameterSet({}) # Parameters for neuronal features p.vm = -65. p.th = -50. p.tau_synE = 0.3 p.tau_synI = 2. 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 = 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
from mozaik.controller import run_experiments, setup_experiments, setup_logging from mozaik.framework.population_selector import RCRandomPercentage from mozaik.visualization.plotting import * from mozaik.analysis.technical import NeuronAnnotationsToPerNeuronValues from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore from NeuroTools.parameters import ParameterSet from mozaik.storage.queries import * import mozaik logger = mozaik.getMozaikLogger("Mozaik") if True: params = setup_experiments('FFI', sim) jens_model = VogelsAbbott(sim, params) l4exc_kick = RCRandomPercentage(jens_model.sheets["V1_Exc_L4"], ParameterSet({'percentage': 20.0})) l4inh_kick = RCRandomPercentage(jens_model.sheets["V1_Inh_L4"], ParameterSet({'percentage': 20.0})) experiment_list = [ #Lets kick the network up into activation PoissonNetworkKick( jens_model, duration=10 * 10 * 7, sheet_list=["V1_Exc_L4", "V1_Inh_L4"], recording_configuration_list=[l4exc_kick, l4inh_kick], lambda_list=[100, 100]), #Spontaneous Activity NoStimulation(jens_model, duration=70 * 7), ] data_store = run_experiments(jens_model, experiment_list)
from model import VogelsAbbott from mozaik.controller import run_experiments, setup_experiments, setup_logging from mozaik.framework.population_selector import RCRandomPercentage from mozaik.visualization.plotting import * from mozaik.analysis.technical import NeuronAnnotationsToPerNeuronValues from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore from NeuroTools.parameters import ParameterSet from mozaik.storage.queries import * import mozaik logger = mozaik.getMozaikLogger("Mozaik") if True: params = setup_experiments('FFI',sim) jens_model = VogelsAbbott(sim,params) l4exc_kick = RCRandomPercentage(jens_model.sheets["V1_Exc_L4"],ParameterSet({'percentage': 20.0})) l4inh_kick = RCRandomPercentage(jens_model.sheets["V1_Inh_L4"],ParameterSet({'percentage': 20.0})) experiment_list = [ #Lets kick the network up into activation PoissonNetworkKick(jens_model,duration=70*7,sheet_list=["V1_Exc_L4","V1_Inh_L4"],recording_configuration_list=[l4exc_kick,l4inh_kick],lambda_list=[100,100]), #Spontaneous Activity NoStimulation(jens_model,duration=70*7), ] data_store = run_experiments(jens_model,experiment_list) #jens_model.connectors['V1L4ExcL4ExcConnection'].store_connections(data_store) #jens_model.connectors['V1L4ExcL4InhConnection'].store_connections(data_store) #jens_model.connectors['V1L4InhL4ExcConnection'].store_connections(data_store) #jens_model.connectors['V1L4InhL4InhConnection'].store_connections(data_store) logger.info('Saving Datastore') data_store.save()
def __init__(self, input=None): self.parameters = ParameterSet({'a': 1, 'b': 2}) self.parameters._url = "http://www.example.com/parameters" self.version = 0.1 self.input = input self.data = range(1000)
def __init__(self, N=1000): """ Default parameters for the retina of size NxN. Sets up parameters and the whole structure of the dictionary / HDF file in url. It contains all relevant parameters and stores them to a dictionary for clarity &future compatibility with XML exports. """ #try : # url = "https://neuralensemble.org/svn/NeuroTools/trunk/examples/retina/retina.param" # self.params = ParameterSet(url) # print "Loaded parameters from SVN" #except : params = {} # a dictionary containing all parameters # === Define parameters ======================================================== # LUP: get running file name and include script in HDF5? params = { 'description': 'default retina', 'N': N, # integer; square of total number of Ganglion Cells LUP: how do we include types and units in parameters? (or by default it is a float in ISO standards) TODO: go rectangular 'N_ret': .2, # float; diameter of Ganglion Cell's RF (max: 1) 'K_ret': 4.0, # float; ratio of center vs. surround in DOG 'dt': 0.1, # discretization step in simulations (ms) 'simtime': 40000 * 0.1, # float; (ms) 'syn_delay': 1.0, # float; (ms) 'noise_std': 5.0, # (nA) standard deviation of the internal noise 'snr': 2.0, # (nA) maximum signal 'weight': 1.0, # #'threads' : 2, 'kernelseeds' : [43210987, 394780234], # array with one element per thread #'threads' : 1, 'kernelseed': 4321097, # array with one element per thread # seed for random generator used when building connections 'connectseed': 12345789, # seed for random generator(s) used during simulation 'initialized': datetime.datetime.now().isoformat( ) # the date in ISO 8601 format to avoid overriding old simulations } # retinal neurons parameters params['parameters_gc'] = { 'Theta': -57.0, 'Vreset': -70.0, 'Vinit': -70.0, 'TauR': 0.5, 'gL': 28.95, 'C': 289.5, 'V_reversal_E': 0.0, 'V_reversal_I': -75.0, 'TauSyn_E': 1.5, 'TauSyn_I': 10.0, 'V_reversal_sfa': -70.0, 'q_sfa': 0., #14.48, 'Tau_sfa': 110.0, 'V_reversal_relref': -70.0, 'q_relref': 3214.0, 'Tau_relref': 1.97 } #,'python':True} ## default input image # TODO add start and stop time # define the center of every neuron in normalized visual angle / retinal space #X,Y = numpy.meshgrid(numpy.linspace(-N/2, N/2,N),numpy.linspace(-N/2,N/2,N)) X, Y = numpy.random.rand(N) * 2 - 1, numpy.random.rand(N) * 2 - 1 # Generate a DOG excitation on the input layer of the GC # Based on the assumptions of the DOG model (Enroth-Cugell and Robson, 1966) that ganglion cells linearly add signals from both center and surround mechanisms for all points in space # this is the impulse response to a discrete dirac in the center to some specific luminance / excentricity value # easy : extend to input images (simply by convoluting the image with this kernel) # hard : extend to time varrying movies (not only a step) params['position'] = [X, Y] R2 = X**2 + Y**2 N, N_ret, K_ret = params['N'], params['N_ret'], params['K_ret'] amplitude = (numpy.exp(-R2 / (2 * N_ret**2)) - 1 / K_ret**2 * numpy.exp(-R2 / (2 * N_ret**2 * K_ret**2))) / (1 - 1 / K_ret**2) #amplitude *= params['noise_std'] # scaled by the noise variance #file.setStructure({'amplitude' : amplitude }, "/build", createparents=True) params['amplitude'] = amplitude self.params = ParameterSet(params)
from NeuroTools.parameters import ParameterSet import sys from math import sqrt from pyNN.space import Space, Grid2D P = ParameterSet(sys.argv[1]) exec("import pyNN.%s as sim" % P.simulator) sim.setup() dx1 = dy1 = 500.0 / sqrt(P.n1) dx2 = dy2 = 500.0 / sqrt(P.n2) struct1 = Grid2D(dx=dx1, dy=dy1) struct2 = Grid2D(dx=dx2, dy=dy2) p1 = sim.Population(P.n1, sim.IF_cond_exp, structure=struct1) p2 = sim.Population(P.n2, sim.IF_cond_exp, structure=struct2) space = Space() DDPC = sim.DistanceDependentProbabilityConnector c = DDPC(P.d_expression, P.allow_self_connections, P.weights, P.delays, space, P.safe) prj = sim.Projection(p1, p2, c) sys.stdout.write(p1.describe().encode('utf-8')) sys.stdout.write(p2.describe().encode('utf-8')) sys.stdout.write(prj.describe().encode('utf-8')) sim.end()
def get_LFP_parameters(parameter_set_file, ps_id): ''' get parameter set for LFP sim corresponding to parameter set file Arguments --------- parameter_set_file : path full path to parameter set file ps_id : str unique identifier Returns ------- PS : ParameterSpace neurotools.parameters.ParameterSpace object PSET : ParameterSet neurotools.parameters.ParameterSet object ''' #get corresponding parameterSet dictionary #iterate over different parameterspaces in dict PSET = None for key, PS in list(psc.ParameterSpaces.items()): for paramset in PS.iter_inner(): #unique id for each parameter set, constructed from the parameset dict #converted to a sorted list of tuples id = helpers.get_unique_id(paramset) if ps_id == id: PSET = ParameterSet(os.path.join(psc.parameterset_dest, '{0}.pset'.format(ps_id))) #PSET = ParameterSet(paramset) if PSET is None: try: Warning('PSET is None, attempt loading .pset-file') PSET = ParameterSet(os.path.join(psc.parameterset_dest, '{0}.pset'.format(ps_id))) except NameError as ne: raise ne('parameterset id {} not in parameterspace.py or {}.pset file is not existing'.format(ps_id, ps_id)) #set up the analysis class instance analysis = dsa.get_network_analysis_object(parameter_set_file, ps_id) #Set up class object with layer specificity of connections from #hybrid scheme implementation. #It is a convoluted way of doing it, but calculations of layer specificity of #connectsion and such rely on a bunch of intermediate calculations, and it #is not nice to do so when creating the ParameterSet object below. We'll use #it here as a placeholder of different parameters PARAMS = general_params(PSET, analysis) ################################################################################ #Set up main parameters for hybrid scheme methods using the # #NeuroTools.parameters.ParameterSet class # ################################################################################ #set up file destinations differentiating between certain output PS = ParameterSet(dict( #Main folder of simulation output savefolder = os.path.join(psc.output_proc_prefix, ps_id), #make a local copy of main files used in simulations sim_scripts_path = os.path.join(psc.output_proc_prefix, ps_id, 'sim_scripts'), #destination of single-cell output during simulation cells_path = os.path.join(psc.output_proc_prefix, ps_id, 'cells'), #destination of cell- and population-specific signals, i.e., compund LFPs, #CSDs etc. populations_path = os.path.join(psc.output_proc_prefix, ps_id, 'populations'), #location of spike output from the network model spike_output_path = os.path.join(psc.output_proc_prefix, ps_id), #destination of figure file output generated during model execution figures_path = os.path.join(psc.output_proc_prefix, ps_id, 'figures') )) #parameters for class CachedTopoNetwork instance PS.update(dict(network_params = dict( simtime = PSET.t_sim, dt = PSET.dt, spike_output_path = PS.spike_output_path, label = PSET.spike_detector_label, ext = 'gdf', GIDs = PARAMS.GIDs, X = PARAMS.X, label_positions = PSET.position_filename_trunk, ))) #population (and cell type) specific parameters PS.update(dict( #list of presynaptic neuron populations (network populations) X = PARAMS.X, #list of postsynaptic neuron populations Y = PARAMS.Y, #list of cell types y in each postsynaptic population Y y = PARAMS.y, #population-specific LFPy.Cell parameters cellParams = PARAMS.yCellParams, #assuming excitatory cells are pyramidal rand_rot_axis = PARAMS.rand_rot_axis, #population sizes N_X = PARAMS.N_X, #kwargs passed to LFPy.Cell.simulate() simulationParams = dict(), #set up parameters corresponding to cylindrical model populations populationParams = PARAMS.populationParams, #set the boundaries between the "upper" and "lower" layer layerBoundaries = PARAMS.layerBoundaries, #set the geometry of the virtual recording device electrodeParams = dict( #contact locations: x = np.mgrid[-18:19:4, -18:19:4][1].flatten()*100, y = np.mgrid[-18:19:4, -18:19:4][0].flatten()*100, z = np.array([PARAMS.layerBoundaries.mean(axis=1)[1] for x in range(100)]), #center of layer 2/3 #extracellular conductivity: sigma = 0.3, #contact surface normals, radius, n-point averaging N = [[0, 0, 1]]*100, r = 5, n = 50, seedvalue = None, #dendrite line sources, soma as sphere source (Linden et al 2014), #and account for periodic boundary conditions also in the LFP to #the second order. Must use LFPy from github.com/espenhgn and #branch som_as_point_periodic (as the periodic boundaries are #just a hack) method = 'soma_as_point_periodic' if PSET.pbc else 'soma_as_point', periodic_order=2, periodic_side_length=PSET.extent_length*1000., ), #runtime, cell-specific attributes and output that will be stored savelist = [ 'somav', 'somapos', 'x', 'y', 'z', 'LFP', ], #flag for switching on calculation of CSD calculateCSD = False, #time resolution of saved signals #TODO: find nicer way to make sure we use same dt in analysis and #LFP simulation output dt_output = PSET.dt*5 )) #for each population, define layer- and population-specific connectivity #parameters PS.update(dict( #number of connections from each presynaptic population onto each #layer per postsynaptic population, preserving overall indegree k_yXL = PARAMS.k_yXL, #set up table of synapse weights onto postsynaptic cell type y from each #possible presynaptic population X J_yX = PARAMS.J_yX, #table of synapse time constants onto postsynaptic cell type y from each #possible presynaptic population X tau_yX = PARAMS.tau_yX, #unit synapse weights used for LFP proxy J_yX_unit = PARAMS.J_yX_unit, #set up synapse parameters as derived from the network synParams = PARAMS.synParams, #set up delays, here using fixed delays of network unless value is None synDelayLoc = {y : [None for X in PS.X] for y in PS.y}, #distribution of delays added on top of per connection delay using either #fixed or linear distance-dependent delays synDelayScale = {y : [PSET.sigma_delays['E' not in X] for X in PS.X] for y in PS.y}, #For topology-like connectivity. Only exponential and gaussian #connectivity and circular #masks are supported with fixed indegree given by k_yXL, #using information on extent and edge wrap (periodic boundaries). #At present, synapse delays are not distance-dependent. For speed, #multapses are always allowed. topology_connections = PARAMS.topology_connections, )) #mapping between population type and cell type specificity, PS.update(dict( mapping_Yy = PARAMS.mapping_Yy )) ###### MISC ATTRIBUTES NOT USED FOR SIMULATION #### PS.update(dict( depths = PARAMS.depths, PATH_m_y = PARAMS.PATH_m_y, m_y = PARAMS.m_y, N_y = PARAMS.N_y, full_scale_num_neurons = PARAMS.full_scale_num_neurons, )) #### Attributes for LFP proxy stuff#### PS.update(dict( #CachedFixedSpikesTopoNetwork params activationtimes=[200, 300, 400, 500, 600, 700, 800, 900, 1000], filelabel='population_spikes', mask=[-400, 0, -400, 0], #output files for TopoPopulation and Postprocess classes output_file = '{}_population_{}', compound_file='{}sum.h5', #parameters for LFP kernel extraction nlag = int(20 / PS.dt_output), #output files for calculating LFP proxies output_file_proxy = '{}_proxy_{}', compound_file_proxy='{}proxy.h5', #output files for estimates from firing rates output_file_approx = '{}_population_approx_{}', compound_file_approx='{}_approx.h5', extent = PSET.extent_length*1E3, pbc = PSET.pbc, #synapse strength in units of pA J = PARAMS.J )) return PS, PSET
class SimpleNetwork(object): required_parameters = ParameterSet({ 'system': dict, 'input_spike_times': numpy.ndarray, 'cell_type': str, 'cell_parameters': dict, 'plasticity': dict, 'weights': float, 'delays': float }) @classmethod def check_parameters(cls, parameters): assert isinstance(parameters, ParameterSet) for name, p_type in cls.required_parameters.flat(): assert isinstance( parameters[name], p_type), "%s: expecting %s, got %s" % (name, p_type, type(parameters[name])) return True def __init__(self, sim, parameters): self.sim = sim self.parameters = parameters sim.setup(**parameters.system) # Create cells self.pre = sim.Population( 1, sim.SpikeSourceArray, {'spike_times': parameters.input_spike_times}, label='pre') self.post = sim.Population(1, getattr(sim, parameters.cell_type), parameters.cell_parameters, label='post') self._source_populations = set([self.pre]) self._neuronal_populations = set([self.post]) # Create synapse model if parameters.plasticity.short_term: P = parameters.plasticity.short_term fast_mech = getattr(sim, P.model)(P.parameters) else: fast_mech = None if parameters.plasticity.long_term: P = parameters.plasticity.long_term print P.pretty() print P.timing_dependence print P.timing_dependence.model print P.timing_dependence.params slow_mech = sim.STDPMechanism( timing_dependence=getattr( sim, P.timing_dependence.model)(**P.timing_dependence.params), weight_dependence=getattr( sim, P.weight_dependence.model)(**P.weight_dependence.params), dendritic_delay_fraction=P.ddf) else: slow_mech = None if fast_mech or slow_mech: syn_dyn = sim.SynapseDynamics(fast=fast_mech, slow=slow_mech) else: syn_dyn = None # Create connections weights = parameters.weights # to give approximate parity in numerical values between if "_cond_" in parameters.cell_type: # current- and conductance-based synapses, we divide the weights /= 50.0 # weights by 50 (approx the distance in mV between threshold # and excitatory reversal potential) for conductance-based. connector = sim.AllToAllConnector(weights=weights, delays=parameters.delays) self.prj = [ sim.Projection(self.pre, self.post, method=connector, synapse_dynamics=syn_dyn) ] # Setup recording self.pre.record() self.post.record() self.post.record_v() def add_population(self, label, dim, cell_type, parameters={}): cell_type = getattr(self.sim, cell_type) pop = self.sim.Population(dim, cell_type, parameters, label=label) setattr(self, label, pop) pop.record() if cell_type.receptor_types: # don't record Vm for populations that don't have it pop.record_v() self._neuronal_populations.add(pop) else: self._source_populations.add(pop) def add_projection(self, src, tgt, connector_name, connector_parameters={}): connector = getattr(self.sim, connector_name)(**connector_parameters) assert hasattr(self, src) assert hasattr(self, tgt) prj = self.sim.Projection(getattr(self, src), getattr(self, tgt), connector) self.prj.append(prj) def save_weights(self): t = self.sim.get_current_time() for prj in self.prj: w = prj.getWeights() w.insert(0, t) prj.weights.append(w) def get_spikes(self): spikes = {} for pop in chain(self._neuronal_populations, self._source_populations): spike_arr = pop.getSpikes() spikes[pop.label] = signals.SpikeList(spike_arr, id_list=range(pop.size)) return spikes def get_v(self): vm = {} for pop in self._neuronal_populations: vm_arr = pop.get_v() vm[pop.label] = signals.VmList(vm_arr[:, (0, 2)], id_list=range(pop.size), dt=self.parameters.system.timestep, t_start=min(vm_arr[:, 1]), t_stop=max(vm_arr[:, 1]) + self.parameters.system.timestep) return vm def get_weights(self, at_input_spiketimes=False, recording_interval=1.0): w = {} if at_input_spiketimes: presynaptic_spike_times = self.pre.getSpikes()[:, 1] for prj in self.prj: w[prj.label] = numpy.array(prj.weights) if at_input_spiketimes: assert isinstance(prj._method.delays, float) post_synaptic_potentials = presynaptic_spike_times + prj._method.delays mask = numpy.ceil(post_synaptic_potentials / recording_interval).astype('int') w[prj.label] = w[prj.label][mask] return w
def load_parameters(url): return ParameterSet(url)
class FiberChannel(object): """ Model class for the fiber of simple neurons. """ def __init__(self, N=100): # simulator specific simulation_params = ParameterSet({ 'dt': 0.1, # discretization step in simulations (ms) 'simtime': 40000 * 0.1, # float; (ms) 'syn_delay': 1.0, # float; (ms) 'kernelseed': 4321097, # array with one element per thread 'connectseed': 12345789 # seed for random generator(s) used during simulation }) # these may change self.params = ParameterSet( { 'simulation': simulation_params, 'N': N, 'noise_std': 6.0, # (nA??) standard deviation of the internal noise 'snr': 1.0, # (nA??) size of the input signal 'weight': 1.0 }, label="fiber_params") print self.params.pretty() def run(self, params, verbose=True): tmpdir = tempfile.mkdtemp() timer = Timer() timer.start() # start timer on construction # === Build the network ======================================================== if verbose: print "Setting up simulation" sim.setup(timestep=params.simulation.dt, max_delay=params.simulation.syn_delay, debug=False) N = params.N #dc_generator current_source = sim.DCSource(amplitude=params.snr, start=params.simulation.simtime / 4, stop=params.simulation.simtime / 4 * 3) # internal noise model (NEST specific) noise = sim.Population(N, 'noise_generator', { 'mean': 0., 'std': params.noise_std }) # target population output = sim.Population(N, sim.IF_cond_exp) # initialize membrane potential numpy.random.seed(params.simulation.kernelseed) V_rest, V_spike = -70., -53. output.tset('v_init', V_rest + numpy.random.rand(N, ) * (V_spike - V_rest)) # Connecting the network conn = sim.OneToOneConnector(weights=params.weight) sim.Projection(noise, output, conn) for cell in output: cell.inject(current_source) output.record() # reads out time used for building buildCPUTime = timer.elapsedTime() # === Run simulation =========================================================== if verbose: print "Running simulation" timer.reset() # start timer on construction sim.run(params.simulation.simtime) simCPUTime = timer.elapsedTime() timer.reset() # start timer on construction output_filename = os.path.join(tmpdir, 'output.gdf') #print output_filename output.printSpikes(output_filename) # output_DATA = load_spikelist(output_filename, N, t_start=0.0, t_stop=params.simulation.simtime) writeCPUTime = timer.elapsedTime() if verbose: print "\nFiber Network Simulation:" print "Number of Neurons : ", N print "Mean Output rate : ", output_DATA.mean_rate( ), "Hz during ", params.simulation.simtime, "ms" print("Build time : %g s" % buildCPUTime) print("Simulation time : %g s" % simCPUTime) print("Writing time : %g s" % writeCPUTime) os.remove(output_filename) os.rmdir(tmpdir) return output_DATA
FT_lg = self.loggabor(u, v, sf_0, B_sf, theta, B_theta) fig, a1, a2 = self.im.show_FT(FT_lg * np.exp(-1j * phase)) return fig, a1, a2 def _test(): import doctest doctest.testmod() ##################################### # if __name__ == '__main__': _test() #### Main """ Some examples of use for the class """ from pylab import imread image = imread('database/lena512.png')[:, :, 0] from NeuroTools.parameters import ParameterSet pe = ParameterSet('default_param.py') pe.N_X, pe.N_Y = image.shape from SLIP import Image im = Image(pe) lg = LogGabor(im)
#not execute the network model, but see below. import brunel_alpha_nest as BN #set up file destinations differentiating between certain output PS = ParameterSet(dict( #Main folder of simulation output savefolder = 'simulation_output_example_brunel', #make a local copy of main files used in simulations sim_scripts_path = os.path.join('simulation_output_example_brunel', 'sim_scripts'), #destination of single-cell output during simulation cells_path = os.path.join('simulation_output_example_brunel', 'cells'), #destination of cell- and population-specific signals, i.e., compund LFPs, #CSDs etc. populations_path = os.path.join('simulation_output_example_brunel', 'populations'), #location of spike output from the network model spike_output_path = BN.spike_output_path, #destination of figure file output generated during model execution figures_path = os.path.join('simulation_output_example_brunel', 'figures') )) #population (and cell type) specific parameters PS.update(dict( #no cell type specificity within each E-I population
def show_loggabor(self, u, v, sf_0, B_sf, theta, B_theta, title='', phase=0.): FT_lg = self.loggabor(u, v, sf_0, B_sf, theta, B_theta) fig, a1, a2 = self.im.show_FT(FT_lg * np.exp(-1j*phase)) return fig, a1, a2 def _test(): import doctest doctest.testmod() ##################################### # if __name__ == '__main__': _test() #### Main """ Some examples of use for the class """ from pylab import imread image = imread('database/lena512.png')[:,:,0] from NeuroTools.parameters import ParameterSet pe = ParameterSet('default_param.py') pe.N_X, pe.N_Y = image.shape from SLIP import Image im = Image(pe) lg = LogGabor(im)
def verify_connectivity(data_store): l4_pos = data_store.get_neuron_postions()['V1_Exc_L4'] l4_inh_pos = data_store.get_neuron_postions()['V1_Inh_L4'] print find_neuron('center', l4_pos) print find_neuron('top_right', l4_pos) print find_neuron('top_left', l4_pos) print find_neuron('bottom_right', l4_pos) print find_neuron('bottom_left', l4_pos) ConnectivityPlot( data_store, ParameterSet({ 'neuron': data_store.get_sheet_ids('V1_Exc_L4', find_neuron('center', l4_pos)), 'sheet_name': 'V1_Exc_L4', 'reversed': True }), param_filter_query(data_store, identifier='PerNeuronValue', value_name='LGNAfferentOrientation')).plot() ConnectivityPlot( data_store, ParameterSet({ 'neuron': data_store.get_sheet_ids('V1_Exc_L4', find_neuron('top_right', l4_pos)), 'sheet_name': 'V1_Exc_L4', 'reversed': True }), param_filter_query(data_store, identifier='PerNeuronValue', value_name='LGNAfferentOrientation')).plot() ConnectivityPlot( data_store, ParameterSet({ 'neuron': data_store.get_sheet_ids('V1_Exc_L4', find_neuron('top_left', l4_pos)), 'sheet_name': 'V1_Exc_L4', 'reversed': True }), param_filter_query(data_store, identifier='PerNeuronValue', value_name='LGNAfferentOrientation')).plot() ConnectivityPlot( data_store, ParameterSet({ 'neuron': data_store.get_sheet_ids('V1_Exc_L4', find_neuron('bottom_right', l4_pos)), 'sheet_name': 'V1_Exc_L4', 'reversed': True }), param_filter_query(data_store, identifier='PerNeuronValue', value_name='LGNAfferentOrientation')).plot() ConnectivityPlot( data_store, ParameterSet({ 'neuron': data_store.get_sheet_ids('V1_Exc_L4', find_neuron('bottom_left', l4_pos)), 'sheet_name': 'V1_Exc_L4', 'reversed': True }), param_filter_query(data_store, identifier='PerNeuronValue', value_name='LGNAfferentOrientation')).plot() #ConnectivityPlot(data_store,ParameterSet({'neuron' : data_store.get_sheet_ids('V1_Exc_L4',find_neuron('center',l4_pos)),'sheet_name' : 'V1_Exc_L4','reversed' : True}),param_filter_query(data_store,identifier='PerNeuronValue',value_name='LGNAfferentPhase')).plot() #ConnectivityPlot(data_store,ParameterSet({'neuron' : data_store.get_sheet_ids('V1_Exc_L4',find_neuron('center',l4_inh_pos)),'sheet_name' : 'V1_Inh_L4','reversed' : True}),param_filter_query(data_store,identifier='PerNeuronValue',value_name='LGNAfferentOrientation')).plot() #ConnectivityPlot(data_store,ParameterSet({'neuron' : data_store.get_sheet_ids('V1_Exc_L4',find_neuron('center',l4_inh_pos)),'sheet_name' : 'V1_Inh_L4','reversed' : True}),param_filter_query(data_store,identifier='PerNeuronValue',value_name='LGNAfferentPhase')).plot() verify_push_pull(data_store, 'V1L4ExcL4ExcConnection') verify_push_pull(data_store, 'V1L4ExcL4InhConnection') verify_push_pull(data_store, 'V1L4InhL4ExcConnection') verify_push_pull(data_store, 'V1L4InhL4InhConnection')
from NeuroTools.parameters import ParameterSet from NeuroTools.parameters import ParameterRange import corr_poisson as st import pyNN.nest as sim from NeuroTools.sandbox import make_name from NeuroTools.sandbox import check_name import numpy p = ParameterSet({}) # Parameters for neuronal features p.vm = -65. p.th = -50. p.tau_synE = 0.3 p.tau_synI = 2. 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