Пример #1
0
def run_sim(ncell):

    print "Cells: ", ncell

    setup0 = time.time()

    sim.setup(timestep=0.1)

    hh_cell_type = sim.HH_cond_exp()

    hh = sim.Population(ncell, hh_cell_type)

    pulse = sim.DCSource(amplitude=0.5, start=20.0, stop=80.0)
    pulse.inject_into(hh)

    hh.record('v')

    setup1 = time.time()

    t0 = time.time()

    sim.run(100.0)

    v = hh.get_data()

    sim.end()

    t1 = time.time()

    setup_total = setup1 - setup0
    run_total = t1 - t0
    print "Setup: ", setup_total
    print "Run: ", run_total
    print "Total sim time: ", setup_total + run_total
    return run_total
def exercise1(v_rest = 65.0):
    ssp = p.Population(1, cellclass=p.SpikeSourcePoisson)
    ssp.set('rate', 30.)
    ssp.record()
    n = p.Population(1, cellclass=p.IF_cond_exp)

    n.record_v()
    n.record()
    n.record_gsyn()
    n.set('v_rest', v_rest) 
    prj = p.Projection(ssp, n, target="excitatory", method=p.AllToAllConnector())
    prj.setWeights(0.001)
    p.run(1000)
    gsyn = n.get_gsyn()
    pot = n.get_v()
    spikes = ssp.getSpikes()
    plot(pot[:,1], pot[:,2])
    plot(spikes[:,1], [max(pot[:,2])]*len(spikes), '|', color='r', markersize=20.0)

    xlabel('Time/ms')
    ylabel('Membrane potential/mV')
    title('EPSPs after excitatory postsynaptic signal')

    plot(gsyn[:,1], gsyn[:,2])
    plot(spikes[:,1], [0]*len(spikes), '|', color='r', markersize=20.0)

    xlabel('Time/ms')
    ylabel('Membrane potential/mV')
    title('Excitatory conductance')

    savefig('../output/day5figure2.png')

    return pot, gsyn, spikes
Пример #3
0
def exercise4_iandf():
    startTime = time.clock()
    hugs = p.Population(1, cellclass=p.IF_cond_exp)
    dcsource = p.DCSource(amplitude=0.9, start=100., stop=100000)
    dcsource.inject_into(hugs)
    p.run(100000.)
    print(time.clock() - startTime)
def run_simulation(parameters, plot_figure=False):
    """

    """
    import pyNN.neuron as sim

    timestamp = datetime.now()
    model = build_model(**parameters["network"])
    if "full_filename" in parameters["experiment"]:
        xml_file = os.path.splitext(parameters["experiment"]["full_filename"])[0] + ".xml"
    else:
        xml_file = "{}.xml".format(parameters["experiment"]["base_filename"])
    model.write(xml_file)
    print("Exported model to file {}".format(xml_file))

    sim.setup(timestep=parameters["experiment"]["timestep"])

    print("Building network")
    net = Network(sim, xml_file)

    if plot_figure:
        stim = net.populations["Ext"]
        stim[:100].record('spikes')
        exc = net.populations["Exc"]
        exc.sample(50).record("spikes")
        exc.sample(1).record(["nrn_v", "syn_a"])
        inh = net.populations["Inh"]
        inh.sample(50).record("spikes")
        inh.sample(1).record(["nrn_v", "syn_a"])
    else:
        ##all = net.assemblies["All"]
        ##all.sample(parameters["experiment"]["n_record"]).record("spikes")
        net.populations["Ext"].sample(parameters["experiment"]["n_record"]).record("spikes")  ## debugging

    print("Running simulation")
    t_stop = parameters["experiment"]["duration"]
    pb = SimulationProgressBar(t_stop/80, t_stop)
    sim.run(t_stop, callbacks=[pb])

    print("Handling data")
    data = {}
    if plot_figure:
        data["stim"] = stim.get_data().segments[0]
        data["exc"] = exc.get_data().segments[0]
        data["inh"] = inh.get_data().segments[0]
    else:
        if "full_filename" in parameters["experiment"]:
            filename = parameters["experiment"]["full_filename"]
        else:
            filename = "{}_nineml_{:%Y%m%d%H%M%S}.h5".format(parameters["experiment"]["base_filename"],
                                                             timestamp)
        print("Writing data to {}".format(filename))
        ##all.write_data(filename)  ## debugging
        net.populations["Ext"].write_data(filename)

    sim.end()
    return data
def model_network(param_dict):
    """
    This model network consists of a spike source and a neuron (IF_curr_alpha). 
    The spike rate of the source and the weight can be specified in the 
    param_dict. Returns the number of spikes fired during 1000 ms of simulation.
    
    Parameters:
    param_dict - dictionary with keys
                 rate - the rate of the spike source (spikes/second)
                 weight - weight of the connection source -> neuron
                 
    Returns:
    dictionary with keys:
        source_rate - the rate of the spike source
        weight - weight of the connection source -> neuron
        neuron_rate - spike rate of the neuron
    """
    #set up the network
    import pyNN.neuron as sim
    sim.setup(dt=0.01,
              min_delay=1.,
              max_delay=1.,
              debug=False,
              quit_on_end=False)

    weight = param_dict['weight']

    import NeuroTools.stgen as stgen
    stgen = stgen.StGen()
    spiketrain = stgen.poisson_generator(param_dict['rate'], t_stop=1000.)
    source = sim.Population(1, sim.SpikeSourceArray,
                            {'spike_times': spiketrain.spike_times})
    neuron = sim.Population(1, sim.IF_cond_alpha)
    sim.Projection(source,
                   neuron,
                   method=sim.OneToOneConnector(weights=param_dict['weight'],
                                                delays=1.))

    #set recorder
    neuron.record()
    neuron.record_v()

    #run the simulation
    sim.run(1001.)
    sim.end()

    # count the number of spikes
    spikes = neuron.getSpikes()
    numspikes = len(spikes)

    # return everything, including the input parameters
    return {
        'source_rate': param_dict['rate'],
        'weight': param_dict['weight'],
        'neuron_rate': numspikes
    }
def run_simulation(parameters, plot_figure=False):
    """

    """
    timestamp = datetime.now()
    model = build_model(**parameters["network"])
    if "full_filename" in parameters["experiment"]:
        xml_file = parameters["experiment"]["full_filename"].replace(
            ".h5", ".xml")
    else:
        xml_file = "{}.xml".format(parameters["experiment"]["base_filename"])
    model.write(xml_file)
    print("Exported model to file {}".format(xml_file))

    sim.setup()

    print("Building network")
    net = Network(sim, xml_file)

    if plot_figure:
        stim = net.populations["Ext"]
        stim[:100].record('spikes')
        exc = net.populations["Exc"]
        exc.sample(50).record("spikes")
        exc.sample(3).record(["nrn_v", "syn_a"])
        inh = net.populations["Inh"]
        inh.sample(50).record("spikes")
        inh.sample(3).record(["nrn_v", "syn_a"])
    else:
        all = net.assemblies["All"]
        all.sample(parameters["experiment"]["n_record"]).record("spikes")

    print("Running simulation")
    t_stop = parameters["experiment"]["duration"]
    pb = SimulationProgressBar(t_stop / 80, t_stop)
    sim.run(t_stop, callbacks=[pb])

    print("Handling data")
    data = {}
    if plot_figure:
        data["stim"] = stim.get_data().segments[0]
        data["exc"] = exc.get_data().segments[0]
        data["inh"] = inh.get_data().segments[0]
    else:
        if "full_filename" in parameters["experiment"]:
            filename = parameters["experiment"]["full_filename"]
        else:
            filename = "{}_nineml_{:%Y%m%d%H%M%S}.h5".format(
                parameters["experiment"]["base_filename"], timestamp)
        print("Writing data to {}".format(filename))
        all.write_data(filename)

    sim.end()
    return data
Пример #7
0
 def testSpikeRecording(self):
     # We test the mean spike count by checking if the rate of the poissonian sources are
     # close to 20 Hz. Then we also test how the spikes are saved
     self.pop1.record()
     self.pop3.record()
     simtime = 1000.0
     neuron.run(simtime)
     #self.pop1.printSpikes("temp_neuron.ras", gather=True)
     rate = self.pop1.meanSpikeCount()*1000/simtime
     if neuron.rank() == 0: # only on master node
         assert (20*0.8 < rate) and (rate < 20*1.2), "rate is %s" % rate
     rate = self.pop3.meanSpikeCount()*1000/simtime
     self.assertEqual(rate, 0.0)
Пример #8
0
 def testPotentialRecording(self):
     """Population.record_v() and Population.print_v(): not a full test, just checking 
     # there are no Exceptions raised."""
     rng = random.NumpyRNG(123)
     v_reset  = -65.0
     v_thresh = -50.0
     uniformDistr = random.RandomDistribution(rng=rng, distribution='uniform', parameters=[v_reset, v_thresh])
     self.pop2.randomInit(uniformDistr)
     self.pop2.record_v([self.pop2[0,0], self.pop2[1,1]])
     simtime = 10.0
     neuron.running = False
     neuron.run(simtime)
     self.pop2.print_v("temp_neuron.v", gather=True, compatible_output=True)
Пример #9
0
 def testRecordWithSpikeTimesGreaterThanSimTime(self):
     """
     If a `SpikeSourceArray` is initialized with spike times greater than the
     simulation time, only those spikes that actually occurred should be
     written to file or returned by getSpikes().
     """
     spike_times = numpy.arange(10.0, 200.0, 10.0)
     spike_source = neuron.Population(1, neuron.SpikeSourceArray, {'spike_times': spike_times})
     spike_source.record()
     neuron.run(100.0)
     spikes = spike_source.getSpikes()
     spikes = spikes[:,1]
     if neuron.rank() == 0:
         self.assert_( max(spikes) == 100.0, str(spikes) )
def model_network(param_dict):
    """
    This model network consists of a spike source and a neuron (IF_curr_alpha). 
    The spike rate of the source and the weight can be specified in the 
    param_dict. Returns the number of spikes fired during 1000 ms of simulation.
    
    Parameters:
    param_dict - dictionary with keys
                 rate - the rate of the spike source (spikes/second)
                 weight - weight of the connection source -> neuron
                 
    Returns:
    dictionary with keys:
        source_rate - the rate of the spike source
        weight - weight of the connection source -> neuron
        neuron_rate - spike rate of the neuron
    """ 
    #set up the network
    import pyNN.neuron as sim
    sim.setup(dt = 0.01,  min_delay = 1.,  max_delay = 1.,  debug = False,  
              quit_on_end = False)
    
    weight = param_dict['weight']
    
    import NeuroTools.stgen as stgen
    stgen = stgen.StGen()
    spiketrain = stgen.poisson_generator(param_dict['rate'], t_stop = 1000.)
    source = sim.Population(1, sim.SpikeSourceArray,  
                            {'spike_times':spiketrain.spike_times})
    neuron = sim.Population(1, sim.IF_cond_alpha)
    sim.Projection(source, neuron, 
                   method = sim.OneToOneConnector(weights = param_dict['weight'], 
                                                  delays = 1.))
    
    #set recorder
    neuron.record()
    neuron.record_v()
    
    #run the simulation
    sim.run(1001.)
    sim.end()
    
    # count the number of spikes
    spikes = neuron.getSpikes()
    numspikes = len(spikes)
    
    # return everything, including the input parameters
    return {'source_rate':param_dict['rate'], 
            'weight':param_dict['weight'], 
            'neuron_rate':numspikes }
def run_simulation(parameters, plot_figure=False):
    """

    """
    import pyNN.neuron as sim

    timestamp = datetime.now()
    model = build_model(**parameters["network"])
    if "full_filename" in parameters["experiment"]:
        xml_file = parameters["experiment"]["full_filename"].replace(
            ".h5", ".xml")
    else:
        xml_file = "{}.xml".format(parameters["experiment"]["base_filename"])
    model.write(xml_file)
    print("Exported model to file {}".format(xml_file))

    sim.setup()

    print("Building network")
    net = Network(sim, xml_file)

    stim = net.populations["Ext"]
    stim.record('spikes')
    exc = net.populations["Exc"]
    exc.record("spikes")
    exc[:3].record(["nrn_v", "syn_a"])

    print("Running simulation")
    t_stop = parameters["experiment"]["duration"]
    pb = SimulationProgressBar(t_stop / 80, t_stop)
    sim.run(t_stop, callbacks=[pb])

    print("Handling data")
    data = {}
    if plot_figure:
        data["stim"] = stim.get_data().segments[0]
        data["exc"] = exc.get_data().segments[0]
        data["exc"].annotate(simulator="lib9ML with pyNN.neuron")
    else:
        if "full_filename" in parameters["experiment"]:
            filename = parameters["experiment"]["full_filename"]
        else:
            filename = "{}_nineml_{:%Y%m%d%H%M%S}.pkl".format(
                parameters["experiment"]["base_filename"], timestamp)
        print("Writing data to {}".format(filename))
        exc.write_data(filename)

    sim.end()
    return data
Пример #12
0
def run_simulation(parameters, plot_figure=False):
    """

    """
    import pyNN.neuron as sim

    timestamp = datetime.now()
    model = build_model(**parameters["network"])
    if "full_filename" in parameters["experiment"]:
        xml_file = parameters["experiment"]["full_filename"].replace(".h5", ".xml")
    else:
        xml_file = "{}.xml".format(parameters["experiment"]["base_filename"])
    model.write(xml_file)
    print("Exported model to file {}".format(xml_file))

    sim.setup()

    print("Building network")
    net = Network(sim, xml_file)

    stim = net.populations["Ext"]
    stim.record('spikes')
    exc = net.populations["Exc"]
    exc.record("spikes")
    n_record = int(parameters["experiment"]["n_record"])
    exc[:n_record].record(["nrn_v", "syn_a"])

    print("Running simulation")
    t_stop = parameters["experiment"]["duration"]
    pb = SimulationProgressBar(t_stop/80, t_stop)
    sim.run(t_stop, callbacks=[pb])

    print("Handling data")
    data = {}
    if plot_figure:
        data["stim"] = stim.get_data().segments[0]
        data["exc"] = exc.get_data().segments[0]
        data["exc"].annotate(simulator="lib9ML with pyNN.neuron")
    else:
        if "full_filename" in parameters["experiment"]:
            filename = parameters["experiment"]["full_filename"]
        else:
            filename = "{}_nineml_{:%Y%m%d%H%M%S}.pkl".format(parameters["experiment"]["base_filename"],
                                                              timestamp)
        print("Writing data to {}".format(filename))
        exc.write_data(filename)

    sim.end()
    return data
def exercise3():
    p.setup(quit_on_end=False, timestep=0.01)
    iandf = p.Population(1, cellclass=p.IF_cond_exp)
    dcsource = p.DCSource(amplitude=1.0, start=100.0, stop=1000.0)
    dcsource.inject_into(iandf)
    iandf.record()
    iandf.record_v()
    p.run(1200.0)
    pot = iandf.get_v()
    spikes = iandf.getSpikes()
    plot(pot[:, 1], pot[:, 2], color="b")
    plot(spikes[:, 1], [-60] * len(spikes), ".", color="r")
    line = axhline(y=-60, xmin=0, xmax=len(pot[:, 1]), color="r")
    xlabel("Time/ms")
    ylabel("Current/mV")
    savefig("../output/day4_figure3.png")
    show()
Пример #14
0
def run_simulation(parameters, plot_figure=False):
    """

    """
    timestamp = datetime.now()
    dt = 0.1

    seed = parameters["experiment"]["seed"]
    sim.setup(timestep=dt)

    print("Building network")
    stim, exc, inh = build_network(sim, seed=seed, **parameters["network"])

    if plot_figure:
        stim[:100].record('spikes')
        exc.sample(50).record("spikes")
        exc.sample(3).record("nrn_v")
        inh.sample(50).record("spikes")
        inh.sample(3).record("nrn_v")
    else:
        all = exc + inh
        all.sample(parameters["experiment"]["n_record"]).record("spikes")

    print("Running simulation")
    t_stop = parameters["experiment"]["duration"]
    pb = SimulationProgressBar(t_stop/80, t_stop)
    sim.run(t_stop, callbacks=[pb])

    print("Handling data")
    data = {}
    if plot_figure:
        data["stim"] = stim.get_data().segments[0]
        data["exc"] = exc.get_data().segments[0]
        data["inh"] = inh.get_data().segments[0]
    else:
        if "full_filename" in parameters["experiment"]:
            filename = parameters["experiment"]["full_filename"]
        else:
            filename = "{}_ninemlpartial_{:%Y%m%d%H%M%S}.h5".format(parameters["experiment"]["base_filename"],
                                                                              timestamp)
        print("Writing data to {}".format(filename))
        all.write_data(filename)

    sim.end()
    return data
Пример #15
0
def exercise4_curve(tau_refrac):
  hugs = p.Population(1, cellclass=p.IF_cond_exp)
  hugs.set("tau_refrac", tau_refrac)
  start = 100.
  stop = 1100.
  frequency = []
  currentSpace = linspace(0.1,5.0,50)
  for current in currentSpace:
    hugs.record()
    hugs.record_v()
    dcsource = p.DCSource(amplitude=current, start=start, stop=stop)
    dcsource.inject_into(hugs)
    p.run(1100.)
    spikes = hugs.getSpikes()
    frequency.append(len(spikes) / (stop - start))
    print(current, frequency[-1])
    p.reset() 
  return currentSpace, frequency
Пример #16
0
def sim(trial):
    global direction
    global inspikes
    global outspikes
    global outspikes2
    global outvolts
    direction=0
    #print direction
    p.reset()
    #for direction in dirs:
    for n in range(len(neuron)):
      neuron[n].set('spike_times',DATA[direction][n][trial])

    p.run(2000)

    outspikes=[0,0]
    outspikes2=[]
    outvolts=[]
    for i,o in enumerate(out):
        outspikes[i]=o.get_spike_counts().values()[0]
        outspikes2.append(o.getSpikes())
        outvolts.append(o.get_v())
    inspikes=[0,0,0,0,0]

    for i,n in enumerate(neuron):
        inspikes[i]=n.get_spike_counts().values()[0]
        
    """  
    fig = figure()
    ax = fig.add_subplot(1,1,1)
    hold(True)
    for i in range(nout):
        ax.plot(outspikes2[i][:,1],i*ones_like(outspikes2[i][:,1]),'b|')
    ax.set_ylim(-6,5)
    for i in range(nneurons):
   
#    ax.plot(DATA[direction][i][trial],-1-i*ones_like(DATA[direction][i][trial]),'r|')
        inspikes2=neuron[i].getSpikes()
        ax.plot(inspikes2,-1-i*ones_like(inspikes2),'r|')
    #ax2=fig.add_subplot(2,1,2)
    #ax2.plot(outvolts[0][:,1],outvolts[0][:,2])
    """
    return inspikes,outspikes
Пример #17
0
def exercise3():
  figure(figsize=(10,6))
  p.setup(quit_on_end=False, timestep=0.01)
  iandf = p.Population(1, cellclass=p.IF_cond_exp)
  dcsource = p.DCSource(amplitude=1., start=100., stop=1000.)
  dcsource.inject_into(iandf)
  iandf.record()
  iandf.record_v()
  p.run(1200.)
  pot = iandf.get_v()
  spikes = iandf.getSpikes()
  plt = plot(pot[:,1], pot[:,2], color='b')
  spks = plot(spikes[:,1], [-49]*len(spikes), '.', color='r')
  legend((plt, spks), ('Membrane potential', 'Spike times'))
  xlabel('Time/ms')
  ylabel('Current/mV')
  title('Integrate and fire model neuron')
  savefig('../output/day4_figure3.png')
  show()
def exercise2():
    hugs = p.Population(1, cellclass=p.HH_cond_exp)
    start = 100.0
    stop = 1100.0
    frequency = []
    currentSpace = linspace(0.1, 10, 100)
    for current in currentSpace:
        hugs.record()
        hugs.record_v()
        dcsource = p.DCSource(amplitude=current, start=start, stop=stop)
        dcsource.inject_into(hugs)
        p.run(1100.0)
        spikes = hugs.getSpikes()
        frequency.append(len(spikes) / (stop - start))
        p.reset()
    plot(currentSpace, frequency)
    xlabel("Current/nA")
    ylabel("Frequency/kHz")
    savefig("../output/day4_figure2.png")
    show()
def exercise1():
    hugs = p.Population(1, cellclass=p.HH_cond_exp)
    dcsource = p.DCSource(amplitude=1.0, start=100.0, stop=600)
    dcsource.inject_into(hugs)

    hugs.record()
    hugs.record_v()

    p.run(1000.0)

    pot = hugs.get_v()
    spikes = hugs.getSpikes()

    plot(pot[:, 1], pot[:, 2])
    plot(spikes[:, 1], [-40] * len(spikes), ".", color="r")
    line = axhline(y=-40, xmin=0, xmax=len(pot[:, 1]), color="r")
    xlabel("Time/ms")
    ylabel("Current/mV")
    savefig("../output/day4_figure1.png")
    show()
Пример #20
0
def exercise1():
    figure(figsize=(10,6))

    hugs = p.Population(1, cellclass=p.HH_cond_exp)
    dcsource = p.DCSource(amplitude=1., start=100., stop=600)
    dcsource.inject_into(hugs)

    hugs.record()
    hugs.record_v()

    p.run(1000.)

    pot = hugs.get_v()
    spikes = hugs.getSpikes()

    plt = plot(pot[:,1], pot[:,2])
    spks = plot(spikes[:,1], [52]*len(spikes), 'D', color='r')
    xlabel('Time/ms')
    ylabel('Current/mV')
    legend((plt, spks), ('Membrane potential', 'Spike times'))
    title('Hodgkin-Huxley model neuron')
    savefig('../output/day4_figure1.png')
    show()
def exercise5(tau_m, v_thresh=-55.0):
    hugs = p.Population(1, cellclass=p.IF_cond_exp)
    hugs.set("tau_refrac", 2.0)
    hugs.set("tau_m", tau_m)
    hugs.set("v_thresh", v_thresh)

    start = 100.0
    stop = 400.0

    dcsource = p.DCSource(amplitude=0.95, start=start, stop=stop)
    dcsource.inject_into(hugs)

    hugs.record()
    hugs.record_v()

    p.run(500.0)

    pot = hugs.get_v()
    spikes = hugs.getSpikes()

    p.reset()

    return pot, spikes, (stop - start)
Пример #22
0
def exercise2():
  figure(figsize=(10,6))

  hugs = p.Population(1, cellclass=p.HH_cond_exp)
  start = 100.
  stop = 1100.
  frequency = []
  currentSpace = linspace(0.1,10,100)
  for current in currentSpace:
    hugs.record()
    hugs.record_v()
    dcsource = p.DCSource(amplitude=current, start=start, stop=stop)
    dcsource.inject_into(hugs)
    p.run(1100.)
    spikes = hugs.getSpikes()
    frequency.append(len(spikes) / (stop - start))
    p.reset() 
  plot(currentSpace, frequency)
  title('Current-frequency diagram for a HH model neuron')
  xlabel('Current/nA')
  ylabel('Frequency/kHz')
  savefig('../output/day4_figure2.png')
  show()
Пример #23
0
def t4():
    print 'Loading Forth XML File (iaf-2coba-Model)'
    print '----------------------------------------'
    component = readers.XMLReader.read_component(
        Join(tenml_dir, 'iaf_2coba.10ml'), component_name='iaf')
    writers.XMLWriter.write(component, '/tmp/nineml_toxml4.xml', )
    model = readers.XMLReader.read_component(Join(tenml_dir, 'iaf_2coba.10ml'))

    from nineml.abstraction_layer.flattening import flatten
    from nineml.abstraction_layer.component_modifiers import ComponentModifier

    flatcomponent = flatten(model, componentname='iaf_2coba')
    ComponentModifier.close_analog_port(component=flatcomponent, port_name='iaf_iSyn', value='0')

    writers.XMLWriter.write(flatcomponent, '/tmp/nineml_out_iaf_2coba.9ml')

    import pyNN.neuron as sim
    from pyNN.utility import init_logging

    init_logging(None, debug=True)
    sim.setup(timestep=0.1, min_delay=0.1)
    print 'Attempting to simulate From Model:'
    print '----------------------------------'
    celltype_cls = pyNNml.nineml_celltype_from_model(
        name="iaf_2coba",
        nineml_model=flatcomponent,
        synapse_components=[
            pyNNml.CoBaSyn(namespace='cobaExcit',  weight_connector='q'),
            pyNNml.CoBaSyn(namespace='cobaInhib',  weight_connector='q'),
        ]
    )

    parameters = {
        'iaf.cm': 1.0,
        'iaf.gl': 50.0,
        'iaf.taurefrac': 5.0,
        'iaf.vrest': -65.0,
        'iaf.vreset': -65.0,
        'iaf.vthresh': -50.0,
        'cobaExcit.tau': 2.0,
        'cobaInhib.tau': 5.0,
        'cobaExcit.vrev': 0.0,
        'cobaInhib.vrev': -70.0,
    }

    parameters = ComponentFlattener.flatten_namespace_dict(parameters)

    cells = sim.Population(1, celltype_cls, parameters)
    cells.initialize('iaf_V', parameters['iaf_vrest'])
    cells.initialize('tspike', -1e99)  # neuron not refractory at start
    cells.initialize('regime', 1002)  # temporary hack

    input = sim.Population(2, sim.SpikeSourcePoisson, {'rate': 100})

    connector = sim.OneToOneConnector(weights=1.0, delays=0.5)

    conn = [sim.Projection(input[0:1], cells, connector, target='cobaExcit'),
            sim.Projection(input[1:2], cells, connector, target='cobaInhib')]

    cells._record('iaf_V')
    cells._record('cobaExcit_g')
    cells._record('cobaInhib_g')
    cells._record('cobaExcit_I')
    cells._record('cobaInhib_I')
    cells.record()

    sim.run(100.0)

    cells.recorders['iaf_V'].write("Results/nineml_neuron.V", filter=[cells[0]])
    cells.recorders['cobaExcit_g'].write("Results/nineml_neuron.g_exc", filter=[cells[0]])
    cells.recorders['cobaInhib_g'].write("Results/nineml_neuron.g_inh", filter=[cells[0]])
    cells.recorders['cobaExcit_I'].write("Results/nineml_neuron.g_exc", filter=[cells[0]])
    cells.recorders['cobaInhib_I'].write("Results/nineml_neuron.g_inh", filter=[cells[0]])

    t = cells.recorders['iaf_V'].get()[:, 1]
    v = cells.recorders['iaf_V'].get()[:, 2]
    gInh = cells.recorders['cobaInhib_g'].get()[:, 2]
    gExc = cells.recorders['cobaExcit_g'].get()[:, 2]
    IInh = cells.recorders['cobaInhib_I'].get()[:, 2]
    IExc = cells.recorders['cobaExcit_I'].get()[:, 2]

    import pylab
    pylab.subplot(311)
    pylab.ylabel('Voltage')
    pylab.plot(t, v)

    pylab.subplot(312)
    pylab.ylabel('Conductance')
    pylab.plot(t, gInh)
    pylab.plot(t, gExc)

    pylab.subplot(313)
    pylab.ylabel('Current')
    pylab.plot(t, IInh)
    pylab.plot(t, IExc)

    pylab.suptitle("From Tree-Model Pathway")
    pylab.show()

    sim.end()
Пример #24
0
prjE_E = sim.Projection(poissonE_E, popE, method=myconn, target='excitatory')
prjE_I = sim.Projection(poissonE_I, popI, method=myconn, target='excitatory')

prjI_E = sim.Projection(poissonI_E, popE, method=myconn, target='inhibitory')
prjI_I = sim.Projection(poissonI_I, popI, method=myconn, target='inhibitory')

## Record the spikes ##
popE.record(to_file=False)
popI.record(to_file=False)
printTimer("Time for setup part")


###################### RUN PART ###########################
## Run the simulation without inter-connection ##
printMessage("Now running without inter-lattice connections.")
sim.run(int(tinit))
printTimer("Time for first half of run")



# Lower the external network "ghost" processes according to how many connections of that
# type were added.
poissonI_E.rate = rateI_E * (connectionsI_E - NumOfConI_E)
poissonI_I.rate = rateI_I * (connectionsI_I - NumOfConI_I)
poissonE_E.rate = rateE_E * (connectionsE_E - NumOfConE_E)
poissonE_I.rate = rateE_I * (connectionsE_I - NumOfConE_I)


# Prepare the connectors #
myConnectorE_E = LatticeConnector(weights=globalWeight, dist_factor=distanceFactor,
                                  noise_factor=noiseFactor, n=NumOfConE_E)
Пример #25
0
prjE_E = sim.Projection(poissonE_E, popE, method=myconn, target='excitatory')
prjE_I = sim.Projection(poissonE_I, popI, method=myconn, target='excitatory')

prjI_E = sim.Projection(poissonI_E, popE, method=myconn, target='inhibitory')
prjI_I = sim.Projection(poissonI_I, popI, method=myconn, target='inhibitory')

## Record the spikes ##
popE.record(to_file=False)
popI.record(to_file=False)
printTimer("Time for setup part")


###################### RUN PART ###########################
## Run the simulation without inter-connection ##
printMessage("Now running without inter-lattice connections.")
sim.run(int(tinit))
printTimer("Time for first half of run")


# Lower the external network "ghost" processes according to how many connections of that
# type were added.
poissonI_E.rate = rateI_E * (connectionsI_E - NumOfConI_E)
poissonI_I.rate = rateI_I * (connectionsI_I - NumOfConI_I)
poissonE_E.rate = rateE_E * (connectionsE_E - NumOfConE_E)
poissonE_I.rate = rateE_I * (connectionsE_I - NumOfConE_I)


# Prepare the connectors #
myConnectorE_E = LatticeConnector(weights=globalWeight, dist_factor=distanceFactor,
                                  noise_factor=noiseFactor, n=NumOfConE_E)
myConnectorE_I = LatticeConnector(weights=globalWeight, dist_factor=distanceFactor,
                                                         A_plus=0.003,
                                                         A_minus=0.005)))
prj1 = p.Projection(ss1,tn, 
                    method=p.AllToAllConnector(),
                    synapse_dynamics=syndyn)
prj2 = p.Projection(ss2,tn,  
                    method=p.AllToAllConnector(),
                    synapse_dynamics=syndyn)
weight = 0.04
prj1.setWeights(weight)
prj2.setWeights(weight)
times = numpy.ones(2000)*10. # 2000 * 10 ms = 20000 ms
prj1_weights = numpy.zeros_like(times)
prj2_weights = numpy.zeros_like(times)
for i,t in enumerate(times):
        p.run(t)
        prj1_weights[i] = prj1.getWeights()[0]
        prj2_weights[i] = prj2.getWeights()[0]

spikes = tn.getSpikes()

figure()
plot(numpy.cumsum(times), prj1_weights, label='prj1', color='blue')
plot(numpy.cumsum(times), prj2_weights, label='prj2', color='red')
plot(spikes, [0.04]*len(spikes), '|', color='black', markersize=10.0)
plot(st1, [0.042]*len(st1), '|', color='blue', markersize=10.0)
plot(st2, [0.042]*len(st2), '|', color='red', markersize=10.0)
ax = gca()
ax.set_ylabel('weight [nA]')
ax.set_xlabel('time [ms]')
legend()
Пример #27
0
    n, sim.SpikeSourceArray(spike_times=generate_spike_times))

spike_source.record('spikes')
cells.record('spikes')
cells[0:2].record('m')

syn = sim.StaticSynapse(weight=w, delay=syn_delay)
input_conns = sim.Projection(spike_source,
                             cells,
                             sim.FixedProbabilityConnector(0.5),
                             syn,
                             receptor_type="default")

# === Run simulation ===========================================================

sim.run(simtime)

filename = normalized_filename("Results", "nrn_artificial_cell", "pkl",
                               "neuron", sim.num_processes())
cells.write_data(filename, annotations={'script_name': __file__})

print("Mean firing rate: ", cells.mean_spike_count() * 1000.0 / simtime, "Hz")

plot_figure = True
if plot_figure:
    from pyNN.utility.plotting import Figure, Panel
    figure_filename = filename.replace("pkl", "png")
    data = cells.get_data().segments[0]
    m = data.filter(name="m")[0]
    Figure(Panel(m,
                 ylabel="Membrane potential (dimensionless)",
def run(plot_and_show=True):

    import sys
    from os.path import abspath, realpath, join
    import nineml

    root = abspath(join(realpath(nineml.__path__[0]), "../../.."))
    sys.path.append(join(root, "lib9ml/python/examples/AL"))
    sys.path.append(join(root, "code_generation/nmodl"))

    from nineml.abstraction_layer.example_models import get_hierachical_iaf_2coba
    from nineml.abstraction_layer.flattening import ComponentFlattener

    import pyNN.neuron as sim
    import pyNN.neuron.nineml as pyNNml

    from pyNN.utility import init_logging

    init_logging(None, debug=True)
    sim.setup(timestep=0.1, min_delay=0.1)

    testModel = get_hierachical_iaf_2coba()

    celltype_cls = pyNNml.nineml_celltype_from_model(
        name="iaf_2coba",
        nineml_model=testModel,
        synapse_components=[
            pyNNml.CoBaSyn(
                namespace='cobaExcit',  weight_connector='q'),
            pyNNml.CoBaSyn(
                namespace='cobaInhib',  weight_connector='q'),
        ]
    )

    parameters = {
        'iaf.cm': 1.0,
        'iaf.gl': 50.0,
        'iaf.taurefrac': 5.0,
        'iaf.vrest': -65.0,
        'iaf.vreset': -65.0,
        'iaf.vthresh': -50.0,
        'cobaExcit.tau': 2.0,
        'cobaInhib.tau': 5.0,
        'cobaExcit.vrev': 0.0,
        'cobaInhib.vrev': -70.0,
    }

    parameters = ComponentFlattener.flatten_namespace_dict(parameters)

    cells = sim.Population(1, celltype_cls, parameters)
    cells.initialize('iaf_V', parameters['iaf_vrest'])
    cells.initialize('tspike', -1e99)  # neuron not refractory at start
    cells.initialize('regime', 1002)  # temporary hack

    input = sim.Population(2, sim.SpikeSourcePoisson, {'rate': 100})

    connector = sim.OneToOneConnector(weights=1.0, delays=0.5)
    # connector = sim.OneToOneConnector(weights=20.0, delays=0.5)

    conn = [sim.Projection(input[0:1], cells, connector, target='cobaExcit'),
            sim.Projection(input[1:2], cells, connector, target='cobaInhib')]

    cells._record('iaf_V')
    cells._record('cobaExcit_g')
    cells._record('cobaInhib_g')
    cells._record('regime')
    cells.record()

    sim.run(100.0)

    cells.recorders['iaf_V'].write("Results/nineml_neuron.V", filter=[cells[0]])
    cells.recorders['regime'].write("Results/nineml_neuron.regime", filter=[cells[0]])
    cells.recorders['cobaExcit_g'].write("Results/nineml_neuron.g_exc", filter=[cells[0]])
    cells.recorders['cobaInhib_g'].write("Results/nineml_neuron.g_inh", filter=[cells[0]])

    t = cells.recorders['iaf_V'].get()[:, 1]
    v = cells.recorders['iaf_V'].get()[:, 2]
    regime = cells.recorders['regime'].get()[:, 2]
    gInh = cells.recorders['cobaInhib_g'].get()[:, 2]
    gExc = cells.recorders['cobaExcit_g'].get()[:, 2]

    if plot_and_show:
        import pylab
        pylab.subplot(311)
        pylab.plot(t, v)
        pylab.subplot(312)
        pylab.plot(t, gInh)
        pylab.plot(t, gExc)
        pylab.subplot(313)
        pylab.plot(t, regime)
        pylab.ylim((999, 1005))
        pylab.suptitle("From Tree-Model Pathway")
        pylab.show()

    sim.end()
Пример #29
0
"""

from plot_helper import plot_current_source
import pyNN.neuron as sim

sim.setup()

population = sim.Population(30, sim.IF_cond_exp(tau_m=10.0))
population[27:28].record_v()

steps = sim.StepCurrentSource(times=[50.0, 110.0, 150.0, 210.0],
                              amplitudes=[0.4, 0.6, -0.2, 0.2])
steps.inject_into(population[(6, 11, 27)])
steps._record()

sim.run(250.0)

t, i_inj = steps._get_data()
v = population.get_data().segments[0].analogsignals[0]

plot_current_source(
    t,
    i_inj,
    v,
    #v_range=(-66, -49),
    v_ticks=(-66, -64, -62, -60),
    i_range=(-0.3, 0.7),
    i_ticks=(-0.2, 0.0, 0.2, 0.4, 0.6),
    t_range=(0, 250))
Пример #30
0
fpc 	= sim.FixedProbabilityConnector(0.02, rng=NumpyRNG(seed=854))



connections = sim.Projection(input, output, fpc,
                             synapse_type=stdp,
                             receptor_type='excitatory')


connections.set(eta=0.0003)


output.record(['spikes', 'v'])

sim.run(simTimeFin - simTimeIni)


print("\n\nETA: input to output:")
print connections.get('eta', format='list')


print("\n\ninput to output:")
print connections.get('weight', format='list')




data = output.get_data().segments[0]

popSpikes = output.get_data('spikes')
Пример #31
0
"""
import pyNN.neuron as sim
import pylab as pl
from quantities import nA

sim.setup(timestep=0.01)

cell = sim.Population(1, sim.HH_cond_exp())
step_current = sim.DCSource(start=20.0, stop=150.0)
step_current.inject_into(cell)

cell.record('v')

for amp in [-0.2, 0.1]:
    step_current.amplitude = amp
    sim.run(200.0)
    sim.reset(annotations={"amplitude": amp*nA})

data = cell.get_data()

sim.end()

for segment in data.segments:
    vm = segment.analogsignalarrays[0]
    pl.plot(vm.times, vm, linewidth=2,
            label=str(segment.annotations["amplitude"]))
pl.legend(loc=0, fontsize=16)
pl.xlabel("Time (%s)" % vm.times.units._dimensionality, fontsize=16)
pl.ylabel("Membrane potential (%s)" % vm.units._dimensionality,
          fontsize=16)
pl.tick_params(labelsize=16)
Пример #32
0
"""

"""

from plot_helper import plot_current_source
import pyNN.neuron as sim

sim.setup()

population = sim.Population(30, sim.IF_cond_exp(tau_m=10.0))
population[27:28].record_v()

steps = sim.StepCurrentSource(times=[50.0, 110.0, 150.0, 210.0],
                              amplitudes=[0.4, 0.6, -0.2, 0.2])
steps.inject_into(population[(6, 11, 27)])
steps._record()

sim.run(250.0)

t, i_inj = steps._get_data()
v = population.get_data().segments[0].analogsignalarrays[0]

plot_current_source(t, i_inj, v,
                    #v_range=(-66, -49),
                    v_ticks=(-66, -64, -62, -60),
                    i_range=(-0.3, 0.7),
                    i_ticks=(-0.2, 0.0, 0.2, 0.4, 0.6),
                    t_range=(0, 250))
Пример #33
0
##
# Setup and run a simulation. Note there is no current injection into the neuron.
# All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes
##

neurons = all_cells
sim = pyNN.neuron
arange = np.arange
import re

neurons.record(['v', 'spikes'])  # , 'u'])
neurons.initialize(v=-65.0, u=-14.0)

# === Run the simulation =====================================================

sim.run(15509.0)

data = neurons.get_data().segments[0]
with open('pickles/qi.p', 'wb') as f:
    pickle.dump(data, f)
'''
from pyNN.utility.plotting import Figure, Panel, comparison_plot, plot_spiketrains
data = neurons.get_data().segments[0]
v = data.filter(name="v")
for i in v:
  Figure(
    Panel(i, ylabel="Membrane potential (mV)", xticks=True,
          xlabel="Time (ms)", yticks=True),
    #Panel(u, ylabel="u variable (units?)"),
    annotations="Simulated with"
  )
Пример #34
0
connector = sim.OneToOneConnector(weights=1.0, delays=0.5)


conn = [
    sim.Projection(input[0:1], cells, connector, target='nmda'),
    sim.Projection(input[0:1], cells, connector, target='cobaExcit'),
]


cells._record('iaf_V')
cells._record('nmda_g')
cells._record('cobaExcit_g')
cells.record()

sim.run(100.0)

cells.recorders['iaf_V'].write("Results/nineml_neuron.V", filter=[cells[0]])
cells.recorders['nmda_g'].write("Results/nineml_neuron.g_nmda", filter=[cells[0]])
cells.recorders['cobaExcit_g'].write("Results/nineml_neuron.g_cobaExcit", filter=[cells[0]])


t = cells.recorders['iaf_V'].get()[:, 1]
v = cells.recorders['iaf_V'].get()[:, 2]
gNMDA = cells.recorders['nmda_g'].get()[:, 2]
gExcit = cells.recorders['cobaExcit_g'].get()[:, 2]

import pylab

pylab.subplot(211)
pylab.plot(t, v)
Пример #35
0
def run(argv):
    """
    Runs the simulation script from the provided arguments
    """
    import nineml
    from pype9.exceptions import Pype9UsageError
    import neo.io
    import time
    import logging

    logger = logging.getLogger('PyPe9')

    args = parser.parse_args(argv)

    seed = time.time() if args.seed is None else args.seed

    if args.simulator == 'neuron':
        from pype9.neuron import Network, CellMetaClass, simulation_controller  # @UnusedImport @IgnorePep8
    elif args.simulator == 'nest':
        from pype9.nest import Network, CellMetaClass, simulation_controller  # @Reimport @IgnorePep8
    else:
        raise Pype9UsageError(
            "Unrecognised simulator '{}', (available 'neuron' or 'nest')"
            .format(args.simulator))

    if isinstance(args.model, nineml.Document):
        min_delay = 0.1  # FIXME: Should add as method to Network class
        max_delay = 10.0
    else:
        min_delay = args.timestep
        max_delay = args.timestep * 2

    if isinstance(args.model, nineml.Network):
        if args.simulator == 'neuron':
            from pyNN.neuron import run, setup  # @UnusedImport
        else:
            from pyNN.nest import run, setup  # @Reimport

        # Reset the simulator
        setup(min_delay=min_delay, max_delay=max_delay,
              timestep=args.timestep, rng_seeds_seed=seed)
        # Construct the network
        print "Constructing '{}' network".format(args.model.name)
        network = Network(args.model, build_mode=args.build_mode)
        print "Finished constructing the '{}' network".format(args.model.name)
        for record_name, _, _ in args.record:
            pop_name, port_name = record_name.split('.')
            network[pop_name].record(port_name)
        print "Running the simulation".format()
        run(args.simtime)
        for record_name, filename, name in args.record:
            pop_name, port_name = record_name.split('.')
            seg = network[pop_name].get_data().segments[0]
            data[filename] = seg  # FIXME: not implemented
    else:
        assert isinstance(args.model, (nineml.DynamicsProperties,
                                       nineml.Dynamics))
        model = args.model
        # Override properties passed as options
        if args.prop:
            props_dict = dict((parm, float(val) * parse_units(unts))
                              for parm, val, unts in args.prop)
            props = nineml.DynamicsProperties(
                model.name + '_props', model, props_dict)
            component_class = model
        elif isinstance(model, nineml.DynamicsProperties):
            props = model
            component_class = model.component_class
        else:
            raise Pype9UsageError(
                "Specified model {} is not a dynamics properties object and "
                "no properties supplied to simulate command via --prop option"
                .format(model))
        # Get the init_regime
        init_regime = args.init_regime
        if init_regime is None:
            if component_class.num_regimes == 1:
                init_regime = next(component_class.regimes).name
            else:
                raise Pype9UsageError(
                    "Need to specify initial regime as dynamics has more than "
                    "one '{}'".format("', '".join(
                        r.name for r in component_class.regimes)))
        # Build cell class
        Cell = CellMetaClass(component_class, name=model.name,
                             init_regime=init_regime,
                             build_mode=args.build_mode,
                             default_properties=props)
        # Create cell
        cell = Cell()
        init_state = dict((sv, float(val) * parse_units(units))
                          for sv, val, units in args.init_value)
        if set(cell.state_variable_names) != set(init_state.iterkeys()):
            raise Pype9UsageError(
                "Need to specify an initial value for each state in the model,"
                " missing '{}'".format(
                    "', '".join(set(cell.state_variable_names) -
                                set(init_state.iterkeys()))))
        cell.set_state(init_state)
        # Play inputs
        for port_name, fname, _ in args.play:
            port = component_class.receive_port(port_name)
            seg = neo.io.PickleIO(filename=fname).read()[0]
            if port.communicates == 'event':
                signal = seg.spiketrains[0]
            else:
                signal = seg.analogsignals[0]
            # Input is an event train or analog signal
            cell.play(port_name, signal)
        # Set up recorders
        for port_name, _, _ in args.record:
            cell.record(port_name)
        # Run simulation
        simulation_controller.run(args.time)
        # Collect data into Neo Segments
        fnames = set(r[1] for r in args.record)
        data_segs = {}
        for fname in fnames:
            data_segs[fname] = neo.Segment(
                description="Simulation of '{}' cell".format(model.name))
        for port_name, fname, _ in args.record:
            data = cell.recording(port_name)
            if isinstance(data, neo.AnalogSignal):
                data_segs[fname].analogsignals.append(data)
            else:
                data_segs[fname].spiketrains.append(data)
        # Write data to file
        for fname, data_seg in data_segs.iteritems():
            neo.io.PickleIO(fname).write(data_seg)
    logger.info("Simulated '{}' for {} ms".format(model.name, args.time))
Пример #36
0

sim.setup()
pyr_parameters= {'cm': 0.25, 'tau_m': 20.0, 'v_rest': -60, 'v_thresh': -50, 'tau_refrac': refractory_period, 'v_reset': -60, 'v_spike': -50.0, 'a': 1.0, 'b': 0.005, 'tau_w': 600, 'delta_T': 2.5,  'tau_syn_E': 5.0, 'e_rev_E': 0.0, 'tau_syn_I': 10.0, 'e_rev_I': -80 }

pyrcell = sim.Population(1, sim.EIF_cond_exp_isfa_ista(**pyr_parameters))

step_current = sim.DCSource(start=20.0, stop=80.0)
step_current.inject_into(pyrcell)

pyrcell.record('v')
print(pyrcell.celltype.recordable)

for amp in (-0.2, -0.1, 0.0, 0.1, 0.2,0.3,0.4,0.5):
    step_current.amplitude = amp
    sim.run(150.0)
    sim.reset(annotations={"amplitude": amp * nA})

data = pyrcell.get_data()

sim.end()

for segment in data.segments:
    vm = segment.analogsignals[0]
    plt.plot(vm.times, vm,
             label=str(segment.annotations["amplitude"]))
plt.legend(loc="upper left")
plt.xlabel("Time (%s)" % vm.times.units._dimensionality)
plt.ylabel("Membrane potential (%s)" % vm.units._dimensionality)

plt.show()
    nineml_cell_type('Poisson',
                     read("../sources/Poisson.xml")['Poisson'], {})(rate=rate))
stim.initialize(t_next=numpy.random.exponential(1000 / rate))

weight = 0.1
delay = 0.5
prj = sim.Projection(stim,
                     p,
                     sim.AllToAllConnector(),
                     sim.StaticSynapse(weight=weight, delay=delay),
                     receptor_type='excitatory')

stim.record('spikes')
p.record('v')

sim.run(t_stop)

nrn_data = p.get_data().segments[0]
stim_data = stim.get_data().segments[0]

print("Expected spike count: {}".format(t_stop * rate / 1000))
print("Actual spike count: {}".format(stim.mean_spike_count()))

Figure(
    Panel(stim_data.spiketrains, markersize=0.5, xlim=(0, t_stop)),
    Panel(nrn_data.filter(name='v')[0],
          yticks=True,
          xlim=(0, t_stop),
          xticks=True,
          xlabel="Time (ms)"),
).save("test_poisson_generator.png")
Пример #38
0
def run(plot_and_show=True):
    import sys
    from os.path import abspath, realpath, join
    import numpy
    import nineml

    root = abspath(join(realpath(nineml.__path__[0]), "../../.."))
    sys.path.append(join(root, "lib9ml/python/examples/AL"))
    sys.path.append(join(root, "code_generation/nmodl"))
    sys.path.append(join(root, "code_generation/nest2"))

    #from nineml.abstraction_layer.example_models import  get_hierachical_iaf_3coba
    from nineml.abstraction_layer.testing_utils import TestableComponent
    from nineml.abstraction_layer.flattening import ComponentFlattener

    import pyNN.neuron as sim
    import pyNN.neuron.nineml as pyNNml

    from pyNN.utility import init_logging

    init_logging(None, debug=True)
    sim.setup(timestep=0.1, min_delay=0.1)

    #test_component = get_hierachical_iaf_3coba()
    test_component = TestableComponent('hierachical_iaf_3coba')()

    from nineml.abstraction_layer.writers import DotWriter
    DotWriter.write(test_component, 'test1.dot')

    from nineml.abstraction_layer.writers import XMLWriter
    XMLWriter.write(test_component, 'iaf_3coba.xml')

    celltype_cls = pyNNml.nineml_celltype_from_model(
        name="iaf_3coba",
        nineml_model=test_component,
        synapse_components=[
            pyNNml.CoBaSyn(namespace='AMPA', weight_connector='q'),
            pyNNml.CoBaSyn(namespace='GABAa', weight_connector='q'),
            pyNNml.CoBaSyn(namespace='GABAb', weight_connector='q'),
        ])

    parameters = {
        'iaf.cm': 1.0,
        'iaf.gl': 50.0,
        'iaf.taurefrac': 5.0,
        'iaf.vrest': -65.0,
        'iaf.vreset': -65.0,
        'iaf.vthresh': -50.0,
        'AMPA.tau': 2.0,
        'GABAa.tau': 5.0,
        'GABAb.tau': 50.0,
        'AMPA.vrev': 0.0,
        'GABAa.vrev': -70.0,
        'GABAb.vrev': -95.0,
    }

    parameters = ComponentFlattener.flatten_namespace_dict(parameters)

    cells = sim.Population(1, celltype_cls, parameters)
    cells.initialize('iaf_V', parameters['iaf_vrest'])
    cells.initialize('tspike', -1e99)  # neuron not refractory at start
    cells.initialize('regime', 1002)  # temporary hack

    input = sim.Population(3, sim.SpikeSourceArray)

    numpy.random.seed(12345)
    input[0].spike_times = numpy.add.accumulate(
        numpy.random.exponential(1000.0 / 100.0, size=1000))
    input[1].spike_times = numpy.add.accumulate(
        numpy.random.exponential(1000.0 / 20.0, size=1000))
    input[2].spike_times = numpy.add.accumulate(
        numpy.random.exponential(1000.0 / 50.0, size=1000))

    connector = sim.OneToOneConnector(weights=1.0, delays=0.5)

    conn = [
        sim.Projection(input[0:1], cells, connector, target='AMPA'),
        sim.Projection(input[1:2], cells, connector, target='GABAa'),
        sim.Projection(input[2:3], cells, connector, target='GABAb')
    ]

    cells._record('iaf_V')
    cells._record('AMPA_g')
    cells._record('GABAa_g')
    cells._record('GABAb_g')
    cells.record()

    sim.run(100.0)

    cells.recorders['iaf_V'].write("Results/nineml_neuron.V",
                                   filter=[cells[0]])
    cells.recorders['AMPA_g'].write("Results/nineml_neuron.g_exc",
                                    filter=[cells[0]])
    cells.recorders['GABAa_g'].write("Results/nineml_neuron.g_gabaA",
                                     filter=[cells[0]])
    cells.recorders['GABAb_g'].write("Results/nineml_neuron.g_gagaB",
                                     filter=[cells[0]])

    t = cells.recorders['iaf_V'].get()[:, 1]
    v = cells.recorders['iaf_V'].get()[:, 2]
    gInhA = cells.recorders['GABAa_g'].get()[:, 2]
    gInhB = cells.recorders['GABAb_g'].get()[:, 2]
    gExc = cells.recorders['AMPA_g'].get()[:, 2]

    if plot_and_show:
        import pylab
        pylab.subplot(211)
        pylab.plot(t, v)
        pylab.ylabel('voltage [mV]')
        pylab.suptitle("AMPA, GABA_A, GABA_B")
        pylab.subplot(212)
        pylab.plot(t, gInhA, label='GABA_A')
        pylab.plot(t, gInhB, label='GABA_B')
        pylab.plot(t, gExc, label='AMPA')
        pylab.ylabel('conductance [nS]')
        pylab.xlabel('t [ms]')
        pylab.legend()

        pylab.show()

    sim.end()
def t4():
    print 'Loading Forth XML File (iaf-2coba-Model)'
    print '----------------------------------------'
    component = readers.XMLReader.read_component(Join(tenml_dir,
                                                      'iaf_2coba.10ml'),
                                                 component_name='iaf')
    writers.XMLWriter.write(
        component,
        '/tmp/nineml_toxml4.xml',
    )
    model = readers.XMLReader.read_component(Join(tenml_dir, 'iaf_2coba.10ml'))

    from nineml.abstraction_layer.flattening import flatten
    from nineml.abstraction_layer.dynamics.utils.modifiers import (
        DynamicsModifier)

    flatcomponent = flatten(model, componentname='iaf_2coba')
    DynamicsModifier.close_analog_port(component=flatcomponent,
                                       port_name='iaf_iSyn',
                                       value='0')

    writers.XMLWriter.write(flatcomponent, '/tmp/nineml_out_iaf_2coba.9ml')

    import pyNN.neuron as sim
    from pyNN.utility import init_logging

    init_logging(None, debug=True)
    sim.setup(timestep=0.1, min_delay=0.1)
    print 'Attempting to simulate From Model:'
    print '----------------------------------'
    celltype_cls = pyNNml.nineml_celltype_from_model(
        name="iaf_2coba",
        nineml_model=flatcomponent,
        synapse_components=[
            pyNNml.CoBaSyn(namespace='cobaExcit', weight_connector='q'),
            pyNNml.CoBaSyn(namespace='cobaInhib', weight_connector='q'),
        ])

    parameters = {
        'iaf.cm': 1.0,
        'iaf.gl': 50.0,
        'iaf.taurefrac': 5.0,
        'iaf.vrest': -65.0,
        'iaf.vreset': -65.0,
        'iaf.vthresh': -50.0,
        'cobaExcit.tau': 2.0,
        'cobaInhib.tau': 5.0,
        'cobaExcit.vrev': 0.0,
        'cobaInhib.vrev': -70.0,
    }

    parameters = ComponentFlattener.flatten_namespace_dict(parameters)

    cells = sim.Population(1, celltype_cls, parameters)
    cells.initialize('iaf_V', parameters['iaf_vrest'])
    cells.initialize('tspike', -1e99)  # neuron not refractory at start
    cells.initialize('regime', 1002)  # temporary hack

    input = sim.Population(2, sim.SpikeSourcePoisson, {'rate': 100})

    connector = sim.OneToOneConnector(weights=1.0, delays=0.5)

    conn = [
        sim.Projection(input[0:1], cells, connector, target='cobaExcit'),
        sim.Projection(input[1:2], cells, connector, target='cobaInhib')
    ]

    cells._record('iaf_V')
    cells._record('cobaExcit_g')
    cells._record('cobaInhib_g')
    cells._record('cobaExcit_I')
    cells._record('cobaInhib_I')
    cells.record()

    sim.run(100.0)

    cells.recorders['iaf_V'].write("Results/nineml_neuron.V",
                                   filter=[cells[0]])
    cells.recorders['cobaExcit_g'].write("Results/nineml_neuron.g_exc",
                                         filter=[cells[0]])
    cells.recorders['cobaInhib_g'].write("Results/nineml_neuron.g_inh",
                                         filter=[cells[0]])
    cells.recorders['cobaExcit_I'].write("Results/nineml_neuron.g_exc",
                                         filter=[cells[0]])
    cells.recorders['cobaInhib_I'].write("Results/nineml_neuron.g_inh",
                                         filter=[cells[0]])

    t = cells.recorders['iaf_V'].get()[:, 1]
    v = cells.recorders['iaf_V'].get()[:, 2]
    gInh = cells.recorders['cobaInhib_g'].get()[:, 2]
    gExc = cells.recorders['cobaExcit_g'].get()[:, 2]
    IInh = cells.recorders['cobaInhib_I'].get()[:, 2]
    IExc = cells.recorders['cobaExcit_I'].get()[:, 2]

    import pylab
    pylab.subplot(311)
    pylab.ylabel('Voltage')
    pylab.plot(t, v)

    pylab.subplot(312)
    pylab.ylabel('Conductance')
    pylab.plot(t, gInh)
    pylab.plot(t, gExc)

    pylab.subplot(313)
    pylab.ylabel('Current')
    pylab.plot(t, IInh)
    pylab.plot(t, IExc)

    pylab.suptitle("From Tree-Model Pathway")
    pylab.show()

    sim.end()
def validate():
    global direction
    global inspikes
    global outspikes
    global outspikes2
    global outvolts
    global prj
    
    prj = []
    for i in range(nneurons):
	for j in range(nout):
	    prj.append(p.Projection(neurons[i], out[j], target="excitatory",method=p.AllToAllConnector()))
	    prj[-1].setWeights(initweight)
    goodWeights = pickle.load(open("goodWeightsFile.pkl"))
    for i, pr in enumerate(prj):
	print goodWeights[i], pr
	pr.setWeights(goodWeights[i])
    print "Validating..."
    # set inputs
    for ntrial in range(ntrials, ntrials+nindependents):
	for direction in dirs:
	    print "Checking direction:", direction, ", trial:", ntrial+1
	    print "Reading data:"
	    trainingset = [DATA[direction][nneuron][ntrial] for nneuron in range(nneurons)]
	    trainingset = [trainingset[i][startstimulus < trainingset[i]] for i in range(nneurons)]
	    trainingset = [trainingset[i][trainingset[i] < endstimulus] for i in range(nneurons)]
	    #import pdb; pdb.set_trace()

	    # run simulation
	    p.reset()
	    for o in out:
		o.record()
		o.record_v()
	    for i, neuron in enumerate(neurons):
		neuron.set('spike_times', trainingset[i])
		#neuron[nneuron].set('spike_times',arange(1,1901,100))
		neuron.record()

	    p.run(2000)

	    outSpikeTimes = [[] for i in range(nout)]
	    outvolts = [[] for i in range(nout)]
	    ## plot spike trains
	    #fig = figure()
	    #hold(True)
	    #ax = fig.add_subplot(1,1,1)
	    #title("Direction "+str(direction)+", Trial "+str(ntrial+1))
	    for j, o in enumerate(out):
		spikes = list(o.getSpikes()[:,1])
		#print j, spikes, len(spikes), type(spikes)
		outSpikeTimes[j] = spikes
		outvolts[j] = o.get_v()
		#print j, outSpikeTimes[j], len(outSpikeTimes[j])
		
		#ax.plot(outSpikeTimes[j], [j]*len(outSpikeTimes[j]), 'b|', markersize = 20.)

	    inspikes=[0 for i in range(nneurons)]
	    outspikes=[0 for i in range(nout)]
	    outspikes2=[]
	    outvolts=[]
	    for i,o in enumerate(out):
		outspikes[i] = o.get_spike_counts().values()[0]
		#outspikes2.append(o.getSpikes())
		outvolts.append(o.get_v())
	    print "outspikes:", outspikes

	    for i,neuron in enumerate(neurons):
		inspikes[i] = neurons[i].get_spike_counts().values()[0]
		#print inspikes[i]

	    def check():
		global direction
		global inspikes
		global outspikes
		global outspikes2
		global outvolts
		print "Learning..."
		#-----------------------------------------------------
		def printWeights():
		    global direction
		    global inspikes
		    global outspikes
		    global outspikes2
		    global outvolts
		    global prj
		    print "outspikes:", outspikes
		    adjust=0.02
		    negadjust=0.02
		    nmax=inspikes.index(max(inspikes))
		    if (outspikes[0]<outspikes[1]) and (direction==dirs[1]):
			print 'correct 0'
		    elif (outspikes[0]>outspikes[1]) and (direction==dirs[0]): 
			print 'correct 3'
		    elif (outspikes[0]>=outspikes[1]) and (direction==dirs[1]):
			print 'wrong 0'
		    elif (outspikes[0]<=outspikes[1]) and (direction==dirs[0]):
			print 'wrong 3' 
		    else:
			print 'no 5'
		    print
		printWeights()
		#-----------------------------------------------------
		for p in prj:
		    currentWeight = p.getWeights()[0]
		    print direction, ntrial, p, currentWeight

	    check()
	print "Reading data:"
	trainingset = [DATA[direction][nneuron][ntrial] for nneuron in range(nneurons)]
	trainingset = [trainingset[i][startstimulus < trainingset[i]] for i in range(nneurons)]
	trainingset = [trainingset[i][trainingset[i] < endstimulus] for i in range(nneurons)]

	# run simulation
	p.reset()
	for o in out:
	    o.record()
	    o.record_v()
	for i, neuron in enumerate(neurons):
	    neuron.set('spike_times', trainingset[i])
	    #neuron[nneuron].set('spike_times',arange(1,1901,100))
	    neuron.record()

	p.run(2000)

	outSpikeTimes = [[] for i in range(nout)]
	outvolts = [[] for i in range(nout)]
	## plot spike trains
	#fig = figure()
	#hold(True)
	#ax = fig.add_subplot(1,1,1)
	#title("Direction "+str(direction)+", Trial "+str(ntrial+1))
	for j, o in enumerate(out):
	    spikes = list(o.getSpikes()[:,1])
	    #print j, spikes, len(spikes), type(spikes)
	    outSpikeTimes[j] = spikes
	    outvolts[j] = o.get_v()
	    print "--------------------------------"
	    #print j, outSpikeTimes[j], len(outSpikeTimes[j])
def simulate():
    global direction
    global inspikes
    global outspikes
    global outspikes2
    global outvolts
    global prj
    print "Simulating..."
    # set inputs
    for ntrial in range(ntrials):
	for direction in dirs:
	    print "Training direction:", direction, ", trial:", ntrial+1
	    print "Reading data:"
	    trainingset = [DATA[direction][nneuron][ntrial] for nneuron in range(nneurons)]
	    trainingset = [trainingset[i][startstimulus < trainingset[i]] for i in range(nneurons)]
	    trainingset = [trainingset[i][trainingset[i] < endstimulus] for i in range(nneurons)]

	    # run simulation
	    p.reset()
	    for o in out:
		o.record()
		o.record_v()
	    for i, neuron in enumerate(neurons):
		neuron.set('spike_times', trainingset[i])
		#neuron[nneuron].set('spike_times',arange(1,1901,100))
		neuron.record()

	    p.run(2000)

	    outSpikeTimes = [[] for i in range(nout)]
	    outvolts = [[] for i in range(nout)]
	    ## plot spike trains
	    #fig = figure()
	    #hold(True)
	    #ax = fig.add_subplot(1,1,1)
	    #title("Direction "+str(direction)+", Trial "+str(ntrial+1))
	    for j, o in enumerate(out):
		spikes = list(o.getSpikes()[:,1])
		#print j, spikes, len(spikes), type(spikes)
		outSpikeTimes[j] = spikes
		outvolts[j] = o.get_v()
		print "--------------------------------"
		#print j, outSpikeTimes[j], len(outSpikeTimes[j])
		
		#ax.plot(outSpikeTimes[j], [j]*len(outSpikeTimes[j]), 'b|', markersize = 20.)

	    inspikes=[0 for i in range(nneurons)]
	    outspikes=[0 for i in range(nout)]
	    outspikes2=[]
	    outvolts=[]
	    for i,o in enumerate(out):
		outspikes[i] = o.get_spike_counts().values()[0]
		#outspikes2.append(o.getSpikes())
		outvolts.append(o.get_v())

	    for i,neuron in enumerate(neurons):
		inspikes[i] = neurons[i].get_spike_counts().values()[0]
		#print inspikes[i]

	    def learn():
		global direction
		global inspikes
		global outspikes
		global outspikes2
		global outvolts
		print "Learning..."
		#-----------------------------------------------------
		def updateWeights():
		    global direction
		    global inspikes
		    global outspikes
		    global outspikes2
		    global outvolts
		    global prj
		    print "outspikes:", outspikes
		    print "Updating..."
		    adjust=0.02
		    negadjust=0.02
		    nmax=inspikes.index(max(inspikes))
		    if (outspikes[0]<outspikes[1]) and (direction==dirs[1]):
			prj[2*nmax+1].setWeights(prj[2*nmax+1].getWeights()[0]+adjust)
			print 'correct 0'
			print "Updated to:", prj[2*nmax+1].getWeights()
		    elif (outspikes[0]>outspikes[1]) and (direction==dirs[0]): 
			prj[2*nmax+0].setWeights(prj[2*nmax+0].getWeights()[0]+adjust)
			print 'correct 3'
			print "Updated to:", prj[2*nmax+0].getWeights()
		    elif (outspikes[0]>=outspikes[1]) and (direction==dirs[1]):
			print 'wrong 0'
			prj[2*nmax+0].setWeights(max(0,prj[2*nmax+0].getWeights()[0]-negadjust))
			print "Updated to:", prj[2*nmax+0].getWeights()
		    elif (outspikes[0]<=outspikes[1]) and (direction==dirs[0]):
			prj[2*nmax+1].setWeights(max(0,prj[2*nmax+1].getWeights()[0]-negadjust))
			print 'wrong 3' 
			print "Updated to:", prj[2*nmax+1].getWeights()
		    else:
			print 'no 5'
		    print
		updateWeights()
		#-----------------------------------------------------
		for p in prj:
		    currentWeight = p.getWeights()[0]
		    print direction, ntrial, p, currentWeight

	    learn()
    goodWeights = [pr.getWeights() for i, pr in enumerate(prj)]
    print "goodWeights:", goodWeights 
    pickle.dump(goodWeights, open("goodWeightsFile.pkl", "wb"))
Пример #43
0
        return gen()
assert generate_spike_times(0).max() > simtime

spike_source = sim.Population(n, sim.SpikeSourceArray(spike_times=generate_spike_times))

spike_source.record('spikes')
cells.record('spikes')
cells[0:2].record('m')

syn = sim.StaticSynapse(weight=w, delay=syn_delay)
input_conns = sim.Projection(spike_source, cells, sim.FixedProbabilityConnector(0.5), syn,
                             receptor_type="default")

# === Run simulation ===========================================================

sim.run(simtime)

filename = normalized_filename("Results", "small_network", "pkl",
                               "neuron", sim.num_processes())
cells.write_data(filename, annotations={'script_name': __file__})

print("Mean firing rate: ", cells.mean_spike_count() * 1000.0 / simtime, "Hz")

plot_figure = True
if plot_figure:
    from pyNN.utility.plotting import Figure, Panel
    figure_filename = filename.replace("pkl", "png")
    data = cells.get_data().segments[0]
    m = data.filter(name="m")[0]
    Figure(
        Panel(m, ylabel="Membrane potential (dimensionless)", yticks=True, ylim=(0,1)),
Пример #44
0
from pyNN import neuron as p
#p.setup(1.0)
p.setup(timestep=1.0, min_delay=1.0)

#cell_params = {'cm': 0.25, 'tau_m': 10.0, 'tau_refrac': 2.0, 'tau_syn_E': 2.5, 'tau_syn_I': 2.5, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -55.0 }
#cell_params = {'a':0.1779222, 'b':-5e-09, 'c':-59.52801, 'd':0.1531787, v_init=-'73.32355','i_offset':0}#, u_init, i_offset}

#pop = p.Population(NETSIZE, p.IF_curr_exp(i_offset=0))
neuron_type = p.Izhikevich()  #cell_params)
pop = p.Population(NETSIZE, neuron_type)
#for ind in pop:
print(p.connect)

pop.record("spikes")
p.run(100)
pop.set(i_offset=1.0)
p.run(100)
pop.set(i_offset=0.0)
p.run(100)
spikes = pop.get_data("spikes")
p.end()

#p.setup(1.0)
#pop = sim.Population(100, sim.IZKCurrExp(cell_params))

print(spikes)

# In[ ]:

#nldf['From']
Пример #45
0
def sim_runner(wgf):
    wg = wgf

    import pyNN.neuron as sim
    nproc = sim.num_processes()
    node = sim.rank()
    print(nproc)
    import matplotlib
    matplotlib.use('Agg')

    import matplotlib.pyplot as plt
    import matplotlib as mpl
    mpl.rcParams.update({'font.size':16})

    #import mpi4py
    #threads  = sim.rank()
    threads = 1
    rngseed  = 98765
    parallel_safe = False
    #extra = {'threads' : threads}
    import os
    import pandas as pd
    import sys
    import numpy as np
    from pyNN.neuron import STDPMechanism
    import copy
    from pyNN.random import RandomDistribution, NumpyRNG
    import pyNN.neuron as neuron
    from pyNN.neuron import h
    from pyNN.neuron import StandardCellType, ParameterSpace
    from pyNN.random import RandomDistribution, NumpyRNG
    from pyNN.neuron import STDPMechanism, SpikePairRule, AdditiveWeightDependence, FromListConnector, TsodyksMarkramSynapse
    from pyNN.neuron import Projection, OneToOneConnector
    from numpy import arange
    import pyNN
    from pyNN.utility import get_simulator, init_logging, normalized_filename
    import random
    import socket
    #from neuronunit.optimization import get_neab
    import networkx as nx
    sim = pyNN.neuron

    # Get some hippocampus connectivity data, based on a conversation with
    # academic researchers on GH:
    # https://github.com/Hippocampome-Org/GraphTheory/issues?q=is%3Aissue+is%3Aclosed
    # scrape hippocamome connectivity data, that I intend to use to program neuromorphic hardware.
    # conditionally get files if they don't exist.


    path_xl = '_hybrid_connectivity_matrix_20171103_092033.xlsx'
    if not os.path.exists(path_xl):
        os.system('wget https://github.com/Hippocampome-Org/GraphTheory/files/1657258/_hybrid_connectivity_matrix_20171103_092033.xlsx')

    xl = pd.ExcelFile(path_xl)
    dfEE = xl.parse()
    dfEE.loc[0].keys()
    dfm = dfEE.as_matrix()

    rcls = dfm[:,:1] # real cell labels.
    rcls = rcls[1:]
    rcls = { k:v for k,v in enumerate(rcls) } # real cell labels, cast to dictionary
    import pickle
    with open('cell_names.p','wb') as f:
        pickle.dump(rcls,f)
    import pandas as pd
    pd.DataFrame(rcls).to_csv('cell_names.csv', index=False)

    filtered = dfm[:,3:]
    filtered = filtered[1:]
    rng = NumpyRNG(seed=64754)
    delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
    weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng)


    sanity_e = []
    sanity_i = []

    EElist = []
    IIlist = []
    EIlist = []
    IElist = []

    for i,j in enumerate(filtered):
      for k,xaxis in enumerate(j):
        if xaxis == 1 or xaxis == 2:
          source = i
          sanity_e.append(i)
          target = k

        if xaxis ==-1 or xaxis == -2:
          sanity_i.append(i)
          source = i
          target = k

    index_exc = list(set(sanity_e))
    index_inh = list(set(sanity_i))
    import pickle
    with open('cell_indexs.p','wb') as f:
        returned_list = [index_exc, index_inh]
        pickle.dump(returned_list,f)

    import numpy
    a = numpy.asarray(index_exc)
    numpy.savetxt('pickles/'+str(k)+'excitatory_nunber_labels.csv', a, delimiter=",")
    import numpy
    a = numpy.asarray(index_inh)
    numpy.savetxt('pickles/'+str(k)+'inhibitory_nunber_labels.csv', a, delimiter=",")

    for i,j in enumerate(filtered):
      for k,xaxis in enumerate(j):
        if xaxis==1 or xaxis == 2:
          source = i
          sanity_e.append(i)
          target = k
          delay = delay_distr.next()
          weight = 1.0
          if target in index_inh:
             EIlist.append((source,target,delay,weight))
          else:
             EElist.append((source,target,delay,weight))

        if xaxis==-1 or xaxis == -2:
          sanity_i.append(i)

          source = i
          target = k
          delay = delay_distr.next()
          weight = 1.0
          if target in index_exc:
              IElist.append((source,target,delay,weight))
          else:
              IIlist.append((source,target,delay,weight))


    internal_conn_ee = sim.FromListConnector(EElist)
    ee = internal_conn_ee.conn_list

    ee_srcs = ee[:,0]
    ee_tgs = ee[:,1]

    internal_conn_ie = sim.FromListConnector(IElist)
    ie = internal_conn_ie.conn_list
    ie_srcs = set([ int(e[0]) for e in ie ])
    ie_tgs = set([ int(e[1]) for e in ie ])

    internal_conn_ei = sim.FromListConnector(EIlist)
    ei = internal_conn_ei.conn_list
    ei_srcs = set([ int(e[0]) for e in ei ])
    ei_tgs = set([ int(e[1]) for e in ei ])

    internal_conn_ii = sim.FromListConnector(IIlist)
    ii = internal_conn_ii.conn_list
    ii_srcs = set([ int(e[0]) for e in ii ])
    ii_tgs = set([ int(e[1]) for e in ii ])

    for e in internal_conn_ee.conn_list:
        assert e[0] in ee_srcs
        assert e[1] in ee_tgs

    for i in internal_conn_ii.conn_list:
        assert i[0] in ii_srcs
        assert i[1] in ii_tgs


    ml = len(filtered[1])+1
    pre_exc = []
    post_exc = []
    pre_inh = []
    post_inh = []


    rng = NumpyRNG(seed=64754)
    delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)

    plot_EE = np.zeros(shape=(ml,ml), dtype=bool)
    plot_II = np.zeros(shape=(ml,ml), dtype=bool)
    plot_EI = np.zeros(shape=(ml,ml), dtype=bool)
    plot_IE = np.zeros(shape=(ml,ml), dtype=bool)

    for i in EElist:
        plot_EE[i[0],i[1]] = int(0)
        #plot_ss[i[0],i[1]] = int(1)

        if i[0]!=i[1]: # exclude self connections
            plot_EE[i[0],i[1]] = int(1)

            pre_exc.append(i[0])
            post_exc.append(i[1])



    assert len(pre_exc) == len(post_exc)
    for i in IIlist:
        plot_II[i[0],i[1]] = int(0)
        if i[0]!=i[1]:
            plot_II[i[0],i[1]] = int(1)
            pre_inh.append(i[0])
            post_inh.append(i[1])

    for i in IElist:
        plot_IE[i[0],i[1]] = int(0)
        if i[0]!=i[1]: # exclude self connections
            plot_IE[i[0],i[1]] = int(1)
            pre_inh.append(i[0])
            post_inh.append(i[1])

    for i in EIlist:
        plot_EI[i[0],i[1]] = int(0)
        if i[0]!=i[1]:
            plot_EI[i[0],i[1]] = int(1)
            pre_exc.append(i[0])
            post_exc.append(i[1])

    plot_excit = plot_EI + plot_EE
    plot_inhib = plot_IE + plot_II

    assert len(pre_inh) == len(post_inh)

    num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ]
    num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ]

    # the network is dominated by inhibitory neurons, which is unusual for modellers.
    assert num_inh > num_exc
    assert np.sum(plot_inhib) > np.sum(plot_excit)
    assert len(num_exc) < ml
    assert len(num_inh) < ml
    # # Plot all the Projection pairs as a connection matrix (Excitatory and Inhibitory Connections)

    import pickle
    with open('graph_inhib.p','wb') as f:
       pickle.dump(plot_inhib,f, protocol=2)


    import pickle
    with open('graph_excit.p','wb') as f:
       pickle.dump(plot_excit,f, protocol=2)


    #with open('cell_names.p','wb') as f:
    #    pickle.dump(rcls,f)
    import pandas as pd
    pd.DataFrame(plot_EE).to_csv('ee.csv', index=False)

    import pandas as pd
    pd.DataFrame(plot_IE).to_csv('ie.csv', index=False)

    import pandas as pd
    pd.DataFrame(plot_II).to_csv('ii.csv', index=False)

    import pandas as pd
    pd.DataFrame(plot_EI).to_csv('ei.csv', index=False)


    from scipy.sparse import coo_matrix
    m = np.matrix(filtered[1:])

    bool_matrix = np.add(plot_excit,plot_inhib)
    with open('bool_matrix.p','wb') as f:
       pickle.dump(bool_matrix,f, protocol=2)

    if not isinstance(m, coo_matrix):
        m = coo_matrix(m)

    Gexc_ud = nx.Graph(plot_excit)
    avg_clustering = nx.average_clustering(Gexc_ud)#, nodes=None, weight=None, count_zeros=True)[source]

    rc = nx.rich_club_coefficient(Gexc_ud,normalized=False)
    print('This graph structure as rich as: ',rc[0])
    gexc = nx.DiGraph(plot_excit)

    gexcc = nx.betweenness_centrality(gexc)
    top_exc = sorted(([ (v,k) for k, v in dict(gexcc).items() ]), reverse=True)

    in_degree = gexc.in_degree()
    top_in = sorted(([ (v,k) for k, v in in_degree.items() ]))
    in_hub = top_in[-1][1]
    out_degree = gexc.out_degree()
    top_out = sorted(([ (v,k) for k, v in out_degree.items() ]))
    out_hub = top_out[-1][1]
    mean_out = np.mean(list(out_degree.values()))
    mean_in = np.mean(list(in_degree.values()))

    mean_conns = int(mean_in + mean_out/2)

    k = 2 # number of neighbouig nodes to wire.
    p = 0.25 # probability of instead wiring to a random long range destination.
    ne = len(plot_excit)# size of small world network
    small_world_ring_excit = nx.watts_strogatz_graph(ne,mean_conns,0.25)



    k = 2 # number of neighbouring nodes to wire.
    p = 0.25 # probability of instead wiring to a random long range destination.
    ni = len(plot_inhib)# size of small world network
    small_world_ring_inhib   = nx.watts_strogatz_graph(ni,mean_conns,0.25)


    nproc = sim.num_processes()
    nproc = 8
    host_name = socket.gethostname()
    node_id = sim.setup(timestep=0.01, min_delay=1.0)#, **extra)
    print("Host #%d is on %s" % (node_id + 1, host_name))
    rng = NumpyRNG(seed=64754)

    #pop_size = len(num_exc)+len(num_inh)
    #num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ]
    #num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ]
    #pop_exc =  sim.Population(len(num_exc), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
    #pop_inh = sim.Population(len(num_inh), sim.Izhikevich(a=0.02, b=0.25, c=-65, d=2, i_offset=0))


    #index_exc = list(set(sanity_e))
    #index_inh = list(set(sanity_i))
    all_cells = sim.Population(len(index_exc)+len(index_inh), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
    #all_cells = None
    #all_cells = pop_exc + pop_inh
    pop_exc = sim.PopulationView(all_cells,index_exc)
    pop_inh = sim.PopulationView(all_cells,index_inh)
    #print(pop_exc)
    #print(dir(pop_exc))
    for pe in pop_exc:
        print(pe)
        #import pdb
        pe = all_cells[pe]
        #pdb.set_trace()
        #pe = all_cells[i]
        r = random.uniform(0.0, 1.0)
        pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0)
        #pop_exc.append(pe)

    #pop_exc = sim.Population(pop_exc)
    for pi in index_inh:
        pi = all_cells[pi]
        #print(pi)
        #pi = all_cells[i]
        r = random.uniform(0.0, 1.0)
        pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0)
        #pop_inh.append(pi)
    #pop_inh = sim.Population(pop_inh)

    '''
    for pe in pop_exc:
        r = random.uniform(0.0, 1.0)
        pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0)

    for pi in pop_inh:
        r = random.uniform(0.0, 1.0)
        pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0)
    '''
    NEXC = len(num_exc)
    NINH = len(num_inh)

    exc_syn = sim.StaticSynapse(weight = wg, delay=delay_distr)
    assert np.any(internal_conn_ee.conn_list[:,0]) < ee_srcs.size
    prj_exc_exc = sim.Projection(all_cells, all_cells, internal_conn_ee, exc_syn, receptor_type='excitatory')
    prj_exc_inh = sim.Projection(all_cells, all_cells, internal_conn_ei, exc_syn, receptor_type='excitatory')
    inh_syn = sim.StaticSynapse(weight = wg, delay=delay_distr)
    delay_distr = RandomDistribution('normal', [1, 100e-3], rng=rng)
    prj_inh_inh = sim.Projection(all_cells, all_cells, internal_conn_ii, inh_syn, receptor_type='inhibitory')
    prj_inh_exc = sim.Projection(all_cells, all_cells, internal_conn_ie, inh_syn, receptor_type='inhibitory')
    inh_distr = RandomDistribution('normal', [1, 2.1e-3], rng=rng)


    def prj_change(prj,wg):
        prj.setWeights(wg)
    prj_change(prj_exc_exc,wg)
    prj_change(prj_exc_inh,wg)
    prj_change(prj_inh_exc,wg)
    prj_change(prj_inh_inh,wg)

    def prj_check(prj):
        for w in prj.weightHistogram():
            for i in w:
                print(i)
    prj_check(prj_exc_exc)
    prj_check(prj_exc_inh)
    prj_check(prj_inh_exc)
    prj_check(prj_inh_inh)

    #print(rheobase['value'])
    #print(float(rheobase['value']),1.25/1000.0)
    '''Old values that worked
    noise = sim.NoisyCurrentSource(mean=0.85/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
    pop_exc.inject(noise)
    #1000.0 pA


    noise = sim.NoisyCurrentSource(mean=1.740/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
    pop_inh.inject(noise)
    #1750.0 pA
    '''

    noise = sim.NoisyCurrentSource(mean=0.74/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
    pop_exc.inject(noise)
    #1000.0 pA


    noise = sim.NoisyCurrentSource(mean=1.440/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
    pop_inh.inject(noise)

    ##
    # Setup and run a simulation. Note there is no current injection into the neuron.
    # All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes
    ##

    sim = pyNN.neuron
    arange = np.arange
    import re
    all_cells.record(['v','spikes'])  # , 'u'])
    all_cells.initialize(v=-65.0, u=-14.0)
    # === Run the simulation =====================================================
    tstop = 2000.0
    sim.run(tstop)
    data = None
    data = all_cells.get_data().segments[0]

    #print(len(data.analogsignals[0].times))
    with open('pickles/qi'+str(wg)+'.p', 'wb') as f:
        pickle.dump(data,f)
    # make data none or else it will grow in a loop
    all_cells = None
    data = None
    noise = None
Пример #46
0
    exc = net.populations["Exc"]
    exc.sample(50).record("spikes")
    exc.sample(3).record(["nrn_v", "syn_a"])
    inh = net.populations["Inh"]
    inh.sample(50).record("spikes")
    inh.sample(3).record(["nrn_v", "syn_a"])
else:
    all_neurons = net.assemblies["All"]
    # all.sample(50).record("spikes")
    all_neurons.record("spikes")

print("Running simulation")
t_stop = args.limits[1]
pb = SimulationProgressBar(t_stop / 80, t_stop)

sim.run(t_stop, callbacks=[pb])

print("Handling data")
if args.plot:
    stim_data = stim.get_data().segments[0]
    exc_data = exc.get_data().segments[0]
    inh_data = inh.get_data().segments[0]
else:
    all_neurons.write_data("brunel_network_alpha_%s.h5" % args.case)

sim.end()


def instantaneous_firing_rate(segment, begin, end):
    """Computed in bins of 0.1 ms """
    bins = np.arange(begin, end, 0.1)
Пример #47
0
                      nineml_cell_type('Poisson', read("../sources/Poisson.xml")['Poisson'], {})(
                          rate=[0.5*nu_thresh, nu_thresh, 2*nu_thresh, 0.0]))

prj1 = sim.Projection(stim, p1,
                      sim.OneToOneConnector(),
                      sim.StaticSynapse(weight=w_eff, delay=delay),
                      receptor_type='syn')
prj2 = sim.Projection(stim, p2,
                      sim.OneToOneConnector(),
                      sim.StaticSynapse(weight=w_eff, delay=delay),
                      receptor_type='syn')

p1.record(['nrn_v', 'syn_a', 'syn_b'])
p2.record(['nrn_v', 'syn_a', 'syn_b'])

sim.run(t_stop)

v_m1 = p1.get_data().segments[0].filter(name='nrn_v')[0]
v_m2 = p2.get_data().segments[0].filter(name='nrn_v')[0]


# NEST simulation

nest.ResetKernel()
nest.SetKernelStatus({"resolution": dt, "print_time": True, 'local_num_threads': 1})


neuron_params = {"C_m":        1000*cell_parameters["nrn_tau"]/cell_parameters["nrn_R"],
                 "tau_m":      cell_parameters["nrn_tau"],
                 "tau_syn_ex": cell_parameters["syn_tau"],
                 "tau_syn_in": cell_parameters["syn_tau"],
def run(plot_and_show=True):
    import sys
    from os.path import abspath, realpath, join
    import numpy
    import nineml

    root = abspath(join(realpath(nineml.__path__[0]), "../../.."))
    sys.path.append(join(root, "lib9ml/python/examples/AL"))
    sys.path.append(join(root, "code_generation/nmodl"))     
    sys.path.append(join(root, "code_generation/nest2"))       
               

    #from nineml.abstraction_layer.example_models import  get_hierachical_iaf_3coba
    from nineml.abstraction_layer.testing_utils import TestableComponent
    from nineml.abstraction_layer.flattening import  ComponentFlattener

    import pyNN.neuron as sim
    import pyNN.neuron.nineml as pyNNml

    from pyNN.utility import init_logging


    init_logging(None, debug=True)
    sim.setup(timestep=0.1, min_delay=0.1)


    #test_component = get_hierachical_iaf_3coba()
    test_component = TestableComponent('hierachical_iaf_3coba')()

    from nineml.abstraction_layer.writers import DotWriter
    DotWriter.write(test_component, 'test1.dot')
    

    from nineml.abstraction_layer.writers import XMLWriter
    XMLWriter.write(test_component, 'iaf_3coba.xml')


    celltype_cls = pyNNml.nineml_celltype_from_model(
                                            name = "iaf_3coba",
                                            nineml_model = test_component,
                                            synapse_components = [
                                                pyNNml.CoBaSyn( namespace='AMPA',  weight_connector='q' ),
                                                pyNNml.CoBaSyn( namespace='GABAa',  weight_connector='q' ),
                                                pyNNml.CoBaSyn( namespace='GABAb',  weight_connector='q' ),
                                                       ]
                                            )

    parameters = {
        'iaf.cm': 1.0,
        'iaf.gl': 50.0,
        'iaf.taurefrac': 5.0,
        'iaf.vrest': -65.0,
        'iaf.vreset': -65.0,
        'iaf.vthresh': -50.0,
        'AMPA.tau': 2.0,
        'GABAa.tau': 5.0,
        'GABAb.tau': 50.0,
        'AMPA.vrev': 0.0,
        'GABAa.vrev': -70.0,
        'GABAb.vrev': -95.0,

    }


    parameters = ComponentFlattener.flatten_namespace_dict( parameters )


    cells = sim.Population(1, celltype_cls, parameters)
    cells.initialize('iaf_V', parameters['iaf_vrest'])
    cells.initialize('tspike', -1e99) # neuron not refractory at start
    cells.initialize('regime', 1002) # temporary hack

    input = sim.Population(3, sim.SpikeSourceArray)

    numpy.random.seed(12345)
    input[0].spike_times = numpy.add.accumulate(numpy.random.exponential(1000.0/100.0, size=1000))
    input[1].spike_times = numpy.add.accumulate(numpy.random.exponential(1000.0/20.0, size=1000))
    input[2].spike_times = numpy.add.accumulate(numpy.random.exponential(1000.0/50.0, size=1000))

    connector = sim.OneToOneConnector(weights=1.0, delays=0.5)


    conn = [sim.Projection(input[0:1], cells, connector, target='AMPA'),
            sim.Projection(input[1:2], cells, connector, target='GABAa'),
            sim.Projection(input[2:3], cells, connector, target='GABAb')]


    cells._record('iaf_V')
    cells._record('AMPA_g')
    cells._record('GABAa_g')
    cells._record('GABAb_g')
    cells.record()

    sim.run(100.0)

    cells.recorders['iaf_V'].write("Results/nineml_neuron.V", filter=[cells[0]])
    cells.recorders['AMPA_g'].write("Results/nineml_neuron.g_exc", filter=[cells[0]])
    cells.recorders['GABAa_g'].write("Results/nineml_neuron.g_gabaA", filter=[cells[0]])
    cells.recorders['GABAb_g'].write("Results/nineml_neuron.g_gagaB", filter=[cells[0]])


    t = cells.recorders['iaf_V'].get()[:,1]
    v = cells.recorders['iaf_V'].get()[:,2]
    gInhA = cells.recorders['GABAa_g'].get()[:,2]
    gInhB = cells.recorders['GABAb_g'].get()[:,2]
    gExc = cells.recorders['AMPA_g'].get()[:,2]

    if plot_and_show:
        import pylab
        pylab.subplot(211)
        pylab.plot(t,v)
        pylab.ylabel('voltage [mV]')
        pylab.suptitle("AMPA, GABA_A, GABA_B")
        pylab.subplot(212)
        pylab.plot(t,gInhA,label='GABA_A')
        pylab.plot(t,gInhB, label='GABA_B')
        pylab.plot(t,gExc, label='AMPA')
        pylab.ylabel('conductance [nS]')
        pylab.xlabel('t [ms]')
        pylab.legend()

        pylab.show()

    sim.end()
Пример #49
0
"""

"""

from plot_helper import plot_current_source
import pyNN.neuron as sim

sim.setup()

population = sim.Population(30, sim.IF_cond_exp(tau_m=10.0))
population[0:1].record_v()

noise = sim.NoisyCurrentSource(mean=1.5, stdev=1.0, start=50.0, stop=450.0,
                               dt=1.0)
population.inject(noise)
noise._record()

sim.run(500.0)

t, i_inj = noise._get_data()
v = population.get_data().segments[0].analogsignals[0]

plot_current_source(t, i_inj, v,
                    v_range=(-66, -48),
                    v_ticks=(-65, -60, -55, -50),
                    i_range=(-3, 5),
                    i_ticks=range(-2, 6, 2),
                    t_range=(0, 500))
Пример #50
0
def std_pynn_simulation(test_component, parameters, initial_values,
                        synapse_components, records, plot=True, sim_time=100.,
                        synapse_weights=1.0, syn_input_rate=100):

    from nineml.abstraction_layer.flattening import ComponentFlattener

    import pyNN.neuron as sim
    import pyNN.neuron.nineml as pyNNml
    from pyNN.neuron.nineml import CoBaSyn

    from pyNN.utility import init_logging

    init_logging(None, debug=True)
    sim.setup(timestep=0.01, min_delay=0.1)

    synapse_components_ML = [CoBaSyn(namespace=ns,  weight_connector=wc)
                             for (ns, wc) in synapse_components]

    celltype_cls = pyNNml.nineml_celltype_from_model(
        name=test_component.name,
        nineml_model=test_component,
        synapse_components=synapse_components_ML,
    )

    parameters = ComponentFlattener.flatten_namespace_dict(parameters)
    initial_values = ComponentFlattener.flatten_namespace_dict(initial_values)

    cells = sim.Population(1, celltype_cls, parameters)

    # Set Initial Values:
    for state, state_initial_value in initial_values.iteritems():
        cells.initialize(state, state_initial_value)

    # For each synapse type, create a spike source:
    if synapse_components:
        input = sim.Population(
            len(synapse_components), sim.SpikeSourcePoisson,
            {'rate': syn_input_rate})
        connector = sim.OneToOneConnector(weights=synapse_weights, delays=0.5)

        conn = []
        for i, (ns, weight_connector) in enumerate(synapse_components):
            proj = sim.Projection(input[i:i + 1], cells, connector, target=ns),
            conn.append(proj)

    # Setup the Records:
    for record in records:
        cells.record(record.what)

    cells.record('spikes')

    # Run the simulation:
    sim.run(sim_time)

    if len(records) == 0:
        assert False

    # Write the Results to a file:
    cells.write_data("Results/nineml.pkl")

    # Plot the values:

    results = cells.get_data().segments[0]

    # Create a list of the tags:
    tags = []
    for record in records:
        if not record.tag in tags:
            tags.append(record.tag)

    # Plot the graphs:
    if plot:
        import pylab
        nGraphs = len(tags)

        # Plot the Records:
        for graphIndex, tag in enumerate(tags):
            pylab.subplot(nGraphs, 1, graphIndex + 1)

            for r in records:
                if r.tag != tag:
                    continue
                trace = results.filter(name=r.what)[0]
                pylab.plot(trace.times, trace, label=r.label)

            pylab.ylabel(tag)
            pylab.legend()

        # Plot the spikes:
        # pylab.subplot(nGraphs,1, len(tags)+1)
        # t_spikes = cells[0:1].getSpikes()[:1]
        # pylab.plot( [1,3],[1,3],'x'  )
        # print t_spikes
        # if t_spikes:
        #    pylab.scatter( t_spikes, t_spikes )

        # Add the X axis to the last plot:
        pylab.xlabel('t [ms]')

        # pylab.suptitle("From Tree-Model Pathway")
        pylab.show()

    sim.end()

    return results
Пример #51
0
import pyNN.neuron as sim  # can of course replace `nest` with `neuron`, `brian`, etc.
import matplotlib.pyplot as plt
from quantities import nA

sim.setup()

cell = sim.Population(1, sim.HH_cond_exp())
step_current = sim.DCSource(start=20.0, stop=80.0)
step_current.inject_into(cell)

cell.record('v')

for amp in (-0.2, -0.1, 0.0, 0.1, 0.2):
    step_current.amplitude = amp
    sim.run(100.0)
    sim.reset(annotations={"amplitude": amp * nA})

data = cell.get_data()

sim.end()

for segment in data.segments:
    vm = segment.analogsignals[0]
    plt.plot(vm.times, vm,
             label=str(segment.annotations["amplitude"]))
plt.legend(loc="upper left")
plt.xlabel("Time (%s)" % vm.times.units._dimensionality)
plt.ylabel("Membrane potential (%s)" % vm.units._dimensionality)

plt.show()
Пример #52
0
    exc = net.populations["Exc"]
    exc.sample(50).record("spikes")
    exc.sample(3).record(["nrn_V", "syn_A"])
    inh = net.populations["Inh"]
    inh.sample(50).record("spikes")
    inh.sample(3).record(["nrn_V", "syn_A"])
else:
    all = net.assemblies["All neurons"]
    #all.sample(50).record("spikes")
    all.record("spikes")

print("Running simulation")
t_stop = plot_limits[1]
pb = SimulationProgressBar(t_stop / 80, t_stop)

sim.run(t_stop, callbacks=[pb])

print("Handling data")
if plot_figure:
    stim_data = stim.get_data().segments[0]
    exc_data = exc.get_data().segments[0]
    inh_data = inh.get_data().segments[0]
else:
    all.write_data("brunel_network_alpha_%s.h5" % case)

sim.end()


def instantaneous_firing_rate(segment, begin, end):
    """Computed in bins of 0.1 ms """
    bins = np.arange(begin, end, 0.1)