def setup(timestep=0.1, min_delay=0.1, max_delay=10.0, **extra_params): """ Should be called at the very beginning of a script. extra_params contains any keyword arguments that are required by a given simulator but not by others. """ common.setup(timestep, min_delay, max_delay, **extra_params) simulator.state.clear() brian.set_global_preferences(**extra_params) simulator.state.dt = timestep # move to common.setup? simulator.state.min_delay = min_delay simulator.state.max_delay = max_delay simulator.state.mpi_rank = extra_params.get('rank', 0) simulator.state.num_processes = extra_params.get('num_processes', 1) simulator.state.network.add(update_currents) update_currents.clock = simulator.state.network.clock return rank()
locals()[var] = False else: raise Exception( 'Expecting True or False-valued command line argument "' + var + '".') num_examples = num_test data_size = 10000 # set brian global preferences b.set_global_preferences(defaultclock=b.Clock(dt=0.5 * b.ms), useweave=True, gcc_options=['-ffast-math -march=native'], usecodegen=True, usecodegenweave=True, usecodegenstateupdate=True, usecodegenthreshold=False, usenewpropagate=True, usecstdp=True, openmp=False, magic_useframes=False, useweave_linear_diffeq=True) # for reproducibility's sake np.random.seed(random_seed) start = timeit.default_timer() data = get_labeled_data(os.path.join(MNIST_data_path, 'testing'), False, False, xrange(10), 1000, normalize_inputs) print 'Time needed to load data:', timeit.default_timer() - start
from datetime import time import brian from perceptchoice.model.monitor import WTAMonitor brian.set_global_preferences(useweave=True,openmp=True,useweave_linear_diffeq =True, gcc_options = ['-ffast-math','-march=native'],usecodegenweave = True, usecodegenreset = True) from brian.library.IF import exp_IF from brian.library.synapses import exp_synapse, biexp_synapse from brian.membrane_equations import Current, InjectedCurrent from brian.network import Network, network_operation from brian.neurongroup import NeuronGroup from brian.stdunits import pF, nS, mV, ms, Hz, pA, nF from brian.tools.parameters import Parameters from brian.units import siemens, second from brian.clock import defaultclock, Clock from brian.directcontrol import PoissonGroup from brian.equations import Equations from brian.connections import DelayConnection, Connection import numpy as np from numpy.matlib import randn, rand pyr_params=Parameters( C=0.5*nF, gL=25*nS, refractory=2*ms, w_nmda = 0.165 * nS,
from brian.library.IF import exp_IF from brian.library.synapses import exp_synapse, biexp_synapse from brian.membrane_equations import Current, InjectedCurrent from brian.network import Network, network_operation from brian.neurongroup import NeuronGroup from brian.stdunits import pF, nS, mV, ms, Hz, pA, nF from brian.tools.parameters import Parameters from brian.units import siemens, second import argparse import numpy as np from pysbi.util.utils import init_connection from pysbi.voxel import Voxel, LFPSource, get_bold_signal from pysbi.wta.monitor import WTAMonitor brian.set_global_preferences(useweave=True, openmp=True, useweave_linear_diffeq=True, gcc_options=['-ffast-math', '-march=native'], usecodegenweave=True, usecodegenreset=True) pyr_params = Parameters( C=0.5 * nF, gL=25 * nS, refractory=2 * ms, w_nmda=0.165 * nS, w_ampa_ext_correct=2.1 * nS, w_ampa_ext_incorrect=0.0 * nS, w_ampa_bak=2.1 * nS, w_ampa_rec=0.05 * nS, w_gaba=1.3 * nS, )
#------------------------------------------------------------------------------ b.set_global_preferences( defaultclock=b.Clock( dt=0.5 * b.ms ), # The default clock to use if none is provided or defined in any enclosing scope. useweave= True, # Defines whether or not functions should use inlined compiled C code where defined. gcc_options=[ '-ffast-math -march=native' ], # Defines the compiler switches passed to the gcc compiler. #For gcc versions 4.2+ we recommend using -march=native. By default, the -ffast-math optimizations are turned on usecodegen= True, # Whether or not to use experimental code generation support. usecodegenweave= True, # Whether or not to use C with experimental code generation support. usecodegenstateupdate= True, # Whether or not to use experimental code generation support on state updaters. usecodegenthreshold= False, # Whether or not to use experimental code generation support on thresholds. usenewpropagate= True, # Whether or not to use experimental new C propagation functions. usecstdp=True, # Whether or not to use experimental new C STDP. openmp=True, # whether or not to use OpenMP pragmas in generated C code. magic_useframes= True, # defines whether or not the magic functions should serach for objects defined only in the calling frame, # or if they should find all objects defined in any frame. Set to "True" if not in an interactive shell. useweave_linear_diffeq= True, # Whether to use weave C++ acceleration for the solution of linear differential equations. ) np.random.seed(0)
testing = get_labeled_data(MNIST_data_path + 'testing', bTrain = False) end = time.time() print 'time needed to load test set:', end - start #------------------------------------------------------------------------------ # set parameters and equations #------------------------------------------------------------------------------ test_mode = True b.set_global_preferences( defaultclock = b.Clock(dt=0.5*b.ms), # The default clock to use if none is provided or defined in any enclosing scope. useweave = True, # Defines whether or not functions should use inlined compiled C code where defined. gcc_options = ['-march=native'], # Defines the compiler switches passed to the gcc compiler. #For gcc versions 4.2+ we recommend using -march=native. By default, the -ffast-math optimizations are turned on usecodegen = True, # Whether or not to use experimental code generation support. usecodegenweave = True, # Whether or not to use C with experimental code generation support. usecodegenstateupdate = True, # Whether or not to use experimental code generation support on state updaters. usecodegenthreshold = False, # Whether or not to use experimental code generation support on thresholds. usenewpropagate = True, # Whether or not to use experimental new C propagation functions. usecstdp = True, # Whether or not to use experimental new C STDP. ) np.random.seed(0) data_path = './' if test_mode: weight_path = data_path + 'weights/' num_examples = 10000 * 1 use_testing_set = True do_plot_performance = False record_spikes = True
def run_sim(ffExcInputMult=None, ffInhInputMult=None): """Run the cond-based LIF neuron simulation. Takes a few minutes to construct network and run Parameters ---------- ffExcInputMult: scalar: FF input magnitude to E cells. multiply ffInputV by this value and connect to E cells ffInhInputMult: scalar: FF input magnitude to I cells. Returns ------- outDict - spike times, records of continuous values from simulation """ # use helper to get input timecourses (ffInputV, condAddV) = create_input_vectors( doDebugPlot=False) # multiplied by scalars below # setup initial state stT = time.time() brian.set_global_preferences(usecodegen=True) brian.set_global_preferences(useweave=True) brian.set_global_preferences(usecodegenweave=True) brian.clear(erase=True, all=True) brian.reinit_default_clock() clk = brian.Clock(dt=0.05 * ms) ################ # create neurons, define connections neurNetwork = brian.NeuronGroup(nNet, model=eqs, threshold=vthresh, reset=vrest, refractory=absRefractoryMs * msecond, order=1, compile=True, freeze=False, clock=clk) # create neuron pools neurCE = neurNetwork.subgroup(nExc) neurCI = neurNetwork.subgroup(nInh) connCE = brian.Connection(neurCE, neurNetwork, 'ge') connCI = brian.Connection(neurCI, neurNetwork, 'gi') print('n cells: %d, nE,I %d,%d, %s, absRefractoryMs: %d' % (nNet, nExc, nInh, repr(clk), absRefractoryMs)) # connect the network to itself connCE.connect_random(neurCE, neurNetwork, internalSparseness, weight=connENetWeight) connCI.connect_random(neurCI, neurNetwork, internalSparseness, weight=connINetWeight) # connect inputs that change spont rate assert ( spontAddRate <= 0 ), 'Spont add rate should be negative - convention: neg, excite inhibitory cells' spontAddNInpSyn = 100 nTotalSpontNeurons = (spontAddNInpSyn * nInh * 0.02) neurSpont = brian.PoissonGroup(nTotalSpontNeurons, -1.0 * spontAddRate * Hz) connCSpont = brian.Connection(neurSpont, neurCI, 'ge') connCSpont.connect_random( p=spontAddNInpSyn * 1.0 / nTotalSpontNeurons, weight=connENetWeight, # match internal excitatory strengths fixed=True) # connect the feedforward visual (poisson) inputs to excitatory cells (ff E) ffExcInputNInpSyn = 100 nTotalFfNeurons = (ffExcInputNInpSyn * ffExcInputNTargs * 0.02 ) # one pop of input cells for both E and I FF _ffExcInputV = ffExcInputMult * np.abs(a_(ffInputV).copy()) assert (np.all( _ffExcInputV >= 0)), 'Negative FF rates are rectified to zero' neurFfExcInput = brian.PoissonGroup( nTotalFfNeurons, lambda t: _ffExcInputV[int(t * 1000)] * Hz) connCFfExcInput = brian.Connection(neurFfExcInput, neurNetwork, 'ge') connCFfExcInput.connect_random(neurFfExcInput, neurCE[0:ffExcInputNTargs], ffExcInputNInpSyn * 1.0 / nTotalFfNeurons, weight=connENetWeight, fixed=True) # connect the feedforward visual (poisson) inputs to inhibitory cells (ff I) ffInhInputNInpSyn = 100 _ffInhInputV = ffInhInputMult * np.abs(ffInputV.copy()) assert (np.all( _ffInhInputV >= 0)), 'Negative FF rates are rectified to zero' neurFfInhInput = brian.PoissonGroup( nTotalFfNeurons, lambda t: _ffInhInputV[int(t * 1000)] * Hz) connCFfInhInput = brian.Connection(neurFfInhInput, neurNetwork, 'ge') connCFfInhInput.connect_random( neurFfInhInput, neurCI[0:ffInhInputNTargs], ffInhInputNInpSyn * 1.0 / nTotalFfNeurons, # sparseness weight=connENetWeight, fixed=True) # connect added step (ChR2) conductance to excitatory cells condAddAmp = 4.0 gAdd = brian.TimedArray(condAddAmp * condAddV, dt=1 * ms) print('Adding conductance for %d cells (can be slow): ' % len(condAddNeurNs), end=' ') for (iN, tN) in enumerate(condAddNeurNs): neurCE[tN].gAdd = gAdd print('done') # Initialize using some randomness so all neurons don't start in same state. # Alternative: initialize with constant values, give net extra 100-300ms to evolve from initial state. neurNetwork.v = (brian.randn(1) * 5.0 - 65) * mvolt neurNetwork.ge = brian.randn(nNet) * 1.5 + 4 neurNetwork.gi = brian.randn(nNet) * 12 + 20 # Record continuous variables and spikes monSTarg = brian.SpikeMonitor(neurNetwork) if contRecNs is not None: contRecClock = brian.Clock(dt=contRecStepMs * ms) monVTarg = brian.StateMonitor(neurNetwork, 'v', record=contRecNs, clock=contRecClock) monGETarg = brian.StateMonitor(neurNetwork, 'ge', record=contRecNs, clock=contRecClock) monGAddTarg = brian.StateMonitor(neurNetwork, 'gAdd', record=contRecNs, clock=contRecClock) monGITarg = brian.StateMonitor(neurNetwork, 'gi', record=contRecNs, clock=contRecClock) # construct brian.Network before running (so brian explicitly knows what to update during run) netL = [ neurNetwork, connCE, connCI, monSTarg, neurFfExcInput, connCFfExcInput, neurFfInhInput, connCFfInhInput, neurSpont, connCSpont ] if contRecNs is not None: # noinspection PyUnboundLocalVariable netL.append([monVTarg, monGETarg, monGAddTarg, monGITarg]) # cont monitors net = brian.Network(netL) print("Network construction time: %3.1f seconds" % (time.time() - stT)) # run print("Simulation running...") sys.stdout.flush() start_time = time.time() net.run(simRunTimeS * second, report='text', report_period=30.0 * second) durationS = time.time() - start_time print("Simulation time: %3.1f seconds" % durationS) outNTC = collections.namedtuple( 'outNTC', 'vm ge gadd gi clockDtS clockStartS clockEndS spiketimes contRecNs') outNTC.__new__.__defaults__ = (None, ) * len( outNTC._fields) # default to None outNT = outNTC(clockDtS=float(monSTarg.clock.dt), clockStartS=float(monSTarg.clock.start), clockEndS=float(monSTarg.clock.end), spiketimes=a_(monSTarg.spiketimes.values(), dtype='O'), contRecNs=contRecNs) if contRecNs is not None: outNT = outNT._replace(vm=monVTarg.values, ge=monGETarg.values, gadd=monGAddTarg.values, gi=monGITarg.values) return outNT
testing = get_labeled_data(MNIST_data_path + 'testing', bTrain = False) end = time.time() print 'time needed to load test set:', end - start #------------------------------------------------------------------------------ # set parameters and equations #------------------------------------------------------------------------------ test_mode = True b.set_global_preferences( defaultclock = b.Clock(dt=0.5*b.ms), # The default clock to use if none is provided or defined in any enclosing scope. useweave = True, # Defines whether or not functions should use inlined compiled C code where defined. gcc_options = ['-ffast-math -march=native'], # Defines the compiler switches passed to the gcc compiler. #For gcc versions 4.2+ we recommend using -march=native. By default, the -ffast-math optimizations are turned on usecodegen = True, # Whether or not to use experimental code generation support. usecodegenweave = True, # Whether or not to use C with experimental code generation support. usecodegenstateupdate = True, # Whether or not to use experimental code generation support on state updaters. usecodegenthreshold = False, # Whether or not to use experimental code generation support on thresholds. usenewpropagate = True, # Whether or not to use experimental new C propagation functions. usecstdp = True, # Whether or not to use experimental new C STDP. ) np.random.seed(0) data_path = './' if test_mode: weight_path = data_path + 'weights/' num_examples = 10000 * 1 use_testing_set = True do_plot_performance = False record_spikes = True
import brian_no_units #import it to deactivate unit checking --> This should NOT be done for testing/debugging import brian as b from brian import * b.set_global_preferences( defaultclock = b.Clock(dt=0.25*b.ms), # The default clock to use if none is provided or defined in any enclosing scope. useweave = True, # Defines whether or not functions should use inlined compiled C code where defined. gcc_options = ['-ffast-math -march=native'], # Defines the compiler switches passed to the gcc compiler. #For gcc versions 4.2+ we recommend using -march=native. By default, the -ffast-math optimisations are turned on #- if you need IEEE guaranteed results, turn this switch off. useweave_linear_diffeq = True, # Whether to use weave C++ acceleration for the solution of linear differential #equations. Note that on some platforms, typically older ones, this is faster and on some platforms, #typically new ones, this is actually slower. usecodegen = True, # Whether or not to use experimental code generation support. usecodegenweave = True, # Whether or not to use C with experimental code generation support. usecodegenstateupdate = True, # Whether or not to use experimental code generation support on state updaters. usecodegenreset = False, # Whether or not to use experimental code generation support on resets. #Typically slower due to weave overheads, so usually leave this off. usecodegenthreshold = True, # Whether or not to use experimental code generation support on thresholds. usenewpropagate = True, # Whether or not to use experimental new C propagation functions. usecstdp = True, # Whether or not to use experimental new C STDP. openmp = False, # Whether or not to use OpenMP pragmas in generated C code. #If supported on your compiler (gcc 4.2+) it will use multiple CPUs and can run substantially faster. magic_useframes = True, # Defines whether or not the magic functions should search for objects #defined only in the calling frame or if they should find all objects defined in any frame. #This should be set to False if you are using Brian from an interactive shell like IDLE or IPython #where each command has its own frame, otherwise set it to True. ) # import brian.experimental.cuda.gpucodegen as gpu np.random.seed(0)
experiment_path = './results/' if len(sys.argv) == 2: experiment_number = int(sys.argv[1]) print 'EXPERIMENT', experiment_number b.set_global_preferences( defaultclock=b.Clock( dt=0.1 * b.ms), # The default clock to use if none is provided. useweave= True, # 301 Defines whether or not functions should use inlined compiled C code where defined. gcc_options=[ '-march=native' ], # Defines the compiler switches passed to the gcc compiler. usecodegen= True, # Whether or not to use experimental code generation support. usecodegenweave= True, # Whether or not to use C with experimental code generation support. usecodegenstateupdate= True, # Whether or not to use experimental code generation support on state updaters. usecodegenthreshold= False, # Whether or not to use experimental code generation support on thresholds. usenewpropagate= True, # Whether or not to use experimental new C propagation functions. usecstdp=True, # Whether or not to use experimental new C STDP. ) # SYSTEM PARAMETERS sensory_neurons = 784 spiking_neurons = 400 inhibitory_neurons = 400
b.ion() print u"\U0001F637" b.set_global_preferences( defaultclock = b.Clock(dt=timestep*b.second), # The default clock to use if none is provided or defined in any enclosing scope. useweave=True, # Defines whether or not functions should use inlined compiled C code where defined. gcc_options = ['-ffast-math -march=native'], # Defines the compiler switches passed to the gcc compiler. #For gcc versions 4.2+ we recommend using -march=native. By default, the -ffast-math optimisations are turned on #- if you need IEEE guaranteed results, turn this switch off. useweave_linear_diffeq = False, # Whether to use weave C++ acceleration for the solution of linear differential #equations. Note that on some platforms, typically older ones, this is faster and on some platforms, #typically new ones, this is actually slower. usecodegen = True, # Whether or not to use experimental code generation support. usecodegenweave = True, # Whether or not to use C with experimental code generation support. usecodegenstateupdate = True, # Whether or not to use experimental code generation support on state updaters. usecodegenreset = True, # Whether or not to use experimental code generation support on resets. #Typically slower due to weave overheads, so usually leave this off. usecodegenthreshold = True, # Whether or not to use experimental code generation support on thresholds. usenewpropagate = True, # Whether or not to use experimental new C propagation functions. usecstdp = True, # Whether or not to use experimental new C STDP. openmp = False, # Whether or not to use OpenMP pragmas in generated C code. #If supported on your compiler (gcc 4.2+) it will use multiple CPUs and can run substantially faster. magic_useframes = True, # Defines whether or not the magic functions should search for objects #defined only in the calling frame or if they should find all objects defined in any frame. #This should be set to False if you are using Brian from an interactive shell like IDLE or IPython #where each command has its own frame, otherwise set it to True. ) neuron_eqs = '''
testing = get_labeled_data(MNIST_data_path + 'testing', bTrain = False) end = time.time() print 'time needed to load test set:', end - start #------------------------------------------------------------------------------ # set parameters and equations #------------------------------------------------------------------------------ test_mode = False b.set_global_preferences( defaultclock = b.Clock(dt=0.5*b.ms), useweave = True, gcc_options = ['-ffast-math -march=native'], usecodegen = True, usecodegenweave = True, usecodegenstateupdate = True, usecodegenthreshold = False, usenewpropagate = True, usecstdp = True, ) np.random.seed(0) data_path = './' if test_mode: weight_path = data_path + 'weights/' num_examples = 10000 * 1 use_testing_set = True do_plot_performance = False record_spikes = True ee_STDP_on = False
""" NMDA synapses """ from brian import NeuronGroup, StateMonitor, set_global_preferences, run, Clock from brian.stdunits import ms import time from brian.experimental.synapses import * from brian import log_level_debug log_level_debug() set_global_preferences(useweave=True,usecodegen=True,usecodegenweave=True,usenewpropagate=True,usecstdp=True) from matplotlib.pyplot import plot, show, subplot params = {} params["t_Nr"] = 2*ms params["t_Nf"] = 80*ms params["t_AMPA"] = 5*ms simclock = Clock(dt=0.01*ms) input=NeuronGroup(2,model='dv/dt=1/(10*ms):1', threshold=1, reset=0,clock=simclock) neurons = NeuronGroup(1, model="""dv/dt=(NMDAo+AMPAo-v)/(10*ms) : 1 NMDAo : 1 AMPAo : 1""", freeze = True,clock=simclock) ampadyn = ''' dAMPAoS/dt = -AMPAoS/t_AMPA : 1 AMPAi = AMPAoS