def __init__(self, config):
Configurable.__init__(self, config)
self._add_config_value('tau', quantity) # membrane time constant
self._add_config_value('V_rest', quantity) # resting membrane potential
self._add_config_value('threshold', quantity) # spiking threshold
self._add_config_value('g_leak', quantity) # leak conductance
self._add_config_value('refractory_period', quantity)
self._add_config_value('V_exc', quantity) # excitatory reversal potential
self._add_config_value('V_inh', quantity) # inhibitory reversal potential
self._add_config_value('I_b', quantity) # additional current
self._add_config_value('g_exc_bar', quantity)
self._add_config_value('g_inh_bar', quantity)
self._add_config_value('init_inh_w', quantity)
self._add_config_value('tau_exc', quantity) # excitat. syn. time constant
self._add_config_value('tau_inh', quantity) # inhibit. syn. time constant
self._add_config_value('tau_stdp', quantity)
self._add_config_value('tau_w', quantity)
self._add_config_value('eta', float)
self._add_config_value('rho', quantity)
self.alpha = 2 * self.rho * self.tau_stdp
self.eqs = b.Equations('''
dg_exc/dt = -g_exc / self.tau_exc : siemens
I_exc = g_exc * (self.V_exc - V) : amp
dg_inh/dt = -g_inh / self.tau_inh : siemens
I_inh = g_inh * (self.V_inh - V) : amp
dV/dt = ((self.V_rest - V) + (I_exc + I_inh + self.I_b) / \
self.g_leak) / self.tau : volt
dx/dt = -x / self.tau_stdp : 1
''')
def __init__(self):
Interface.__init__(self, "TC")
Configurable.__init__(self)
self.__lastStatus = None
self.__lastElement = None
self.__useConfig = {}
LOG("Created")
def __init__(self, input_data, model):
config = input_data.getNodeAttr('/', 'config')
Configurable.__init__(self, config['recording'])
self._add_config_value('recording_duration', quantity)
self._add_config_value('rate_bin_size', quantity)
self._add_config_value('store_times', quantity_list)
self._add_config_value('current_timestep', int)
self._add_config_value('weights_timestep', int)
self.input_data = input_data
self.dt = quantity(config['dt'])
self.model = model
self.m_spikes = b.SpikeMonitor(model.neuron)
self.m_rates = b.PopulationRateMonitor(model.neuron, self.rate_bin_size)
self.m_exc_syn_currents = b.RecentStateMonitor(
model.neuron, 'I_exc', self.recording_duration,
timestep=self.current_timestep)
self.m_inh_syn_currents = b.RecentStateMonitor(
model.neuron, 'I_inh', self.recording_duration,
timestep=self.current_timestep)
self.m_exc_weights = b.StateMonitor(
model.exc_synapses, 'w', record=True,
timestep=self.weights_timestep)
self.m_inh_weights = b.StateMonitor(
model.inh_synapses, 'w', record=True,
timestep=self.weights_timestep)
self.model.add(
self.m_spikes, self.m_rates, self.m_exc_syn_currents,
self.m_inh_syn_currents, self.m_exc_weights, self.m_inh_weights)
def __init__(self):
Interface.__init__(self, "RSC")
Configurable.__init__(self)
LOG("Created")
self.toCheck = [ 'TM', 'TC' ]
self.rscStatus = {}
self.rscCallbacks = []
def __init__(self):
Interface.__init__(self, "TC")
Configurable.__init__(self)
self.__lastStatus = None
self.__lastElement = None
self.__useConfig = {}
LOG("Created")
def __init__(self, config, model):
Configurable.__init__(self, config)
self._add_config_value('stimulus_duration', quantity)
self._add_config_value('num_trials', int)
self.model = model
self.m_spikes = b.SpikeMonitor(model.neuron)
self.model.add(self.m_spikes)
def __init__(self):
Interface.__init__(self, "TM")
Configurable.__init__(self)
self.__tmParameters = {}
self.__verifiers = []
self.__verifTable = []
self.__verifMutex = thread.allocate_lock()
self.__ctxName = None
LOG("Created")
def __init__(self, tcClass, cmd, description = ""):
Configurable.__init__(self)
self.__tcClass = tcClass
self.__cmdName = cmd
self.__cmdDescription = description
self.__parameters= []
self.__completed = [False]
self.__success = [False]
self.__elements = [ self.__cmdName ]
self.__executionStage = ['UKN']
self.__executionStatus = ['UKN']
self.__comment = [" "]
self.__updateTime = [" "]
def __init__(self, config, duration=None):
Configurable.__init__(self, config)
self._add_config_value('peak_firing_rate', quantity)
self._add_config_value('background_activity', quantity)
self._add_config_value('sparseness', int)
self._add_config_value('approximate_normalization', float)
self._add_config_value('filter_time_constant', quantity)
self._add_config_value('dt', quantity)
self.current_raw_value = 0.0
self.current_time = 0.0 * brian.second
self.sparsification_start = 1
self.signal = None
self.duration = duration
def __init__(self, tcClass, cmd, description=""):
Configurable.__init__(self)
self.__tcClass = tcClass
self.__cmdName = cmd
self.__cmdDescription = description
self.__parameters = []
self.__completed = [False]
self.__success = [False]
self.__elements = [self.__cmdName]
self.__executionStage = ['UKN']
self.__executionStatus = ['UKN']
self.__comment = [" "]
self.__updateTime = [" "]
def __init__(self, tmClass, name, description = None):
# Super constructor
Configurable.__init__(self)
# Initialize basics
self._tmClass = tmClass
self._name = name
self._description = description
self._rawValue = None
self._engValue = None
self._status = None
# Default item configuration is given by the TM interface
# TM interface shall be a Configurable as well
self.setConfig( tmClass )
def __init__(self, tmClass, name, description=None):
# Super constructor
Configurable.__init__(self)
# Initialize basics
self._tmClass = tmClass
self._name = name
self._description = description
self._rawValue = None
self._engValue = None
self._status = None
# Default item configuration is given by the TM interface
# TM interface shall be a Configurable as well
self.setConfig(tmClass)
def __init__(self, config, outfile):
Configurable.__init__(self, config)
self._add_config_value('epoch_duration', quantity)
self._add_config_value('num_tunings', int)
self._add_config_value('num_epochs', int)
self._add_config_value('eta', float)
self._add_config_value('rho', quantity)
self.outfile = outfile
self.exc_weights = 0.5 * (0.35 + 1.1 / (
1.0 + (np.arange(self.num_tunings) - 4) ** 4))
self.inh_weights = np.empty(self.num_tunings)
self.inh_weights.fill(0.05)
self.signal_gens = [InputSignalGenerator(
self._config['raw_signals'], self.epoch_duration)
for i in xrange(self.num_tunings)]
def main():
argparser = argparse.ArgumentParser()
argparser.add_argument('--config_file', default='../configs/default.cfg')
args, extra_args = argparser.parse_known_args()
config = Configurable(args.config_file, extra_args, logger)
tokenizer, train_loader, dev_loader, test_loader, num_train_steps, label_list = load_data(
config)
model, optimizer, device, n_gpu = load_model(config, num_train_steps,
label_list)
train(tokenizer, model, optimizer, train_loader, dev_loader, test_loader,
config, device, n_gpu, label_list, num_train_steps)
def __init__(self, config, duration=None):
Configurable.__init__(self, config)
self._add_config_value('num_tunings', int)
self._add_config_value('num_trains', int)
self._add_config_value('fraction_inhibitory', float)
self._add_config_value('refractory_period', quantity)
self.num_trains_per_tuning = self.num_trains // self.num_tunings
self.num_inhibitory = int(self.fraction_inhibitory * self.num_trains)
self.num_excitatory = self.num_trains - self.num_inhibitory
self.num_inhib_per_tuning = self.num_inhibitory / self.num_tunings
self.num_excit_per_tuning = self.num_excitatory / self.num_tunings
self.signal_gens = [
InputSignalGenerator(self._config['raw_signals'], duration)
for i in xrange(self.num_tunings)]
time_gens = [PoissonSpikeTimesGenerator(
gen, self.neuron_indices_of_group(i), self.refractory_period)
for i, gen in enumerate(self.signal_gens)]
self.merged_times = heapq.merge(*time_gens)
def __init__(self, config, exc_weights, inh_weights):
b.Network.__init__(self)
Configurable.__init__(self, config)
self._add_config_value('stimulus_duration', quantity)
builder = TrainedLearningModelBuilder(config['model'])
self.input_gen = inputs.GroupedSpikeTimesGenerator(
config['inputs'], self.stimulus_duration)
self.indexing_scheme = self.input_gen.get_indexing_scheme()
self.neuron = builder.build_neuron_group()
self.input_neurons = b.SpikeGeneratorGroup(
self.input_gen.num_trains, inputs.swap_tuple_values(self.input_gen))
self.input_groups = ModelInputGroups(
self.indexing_scheme, self.input_neurons)
self.exc_synapses = builder.build_exc_synapses(
self.input_groups.excitatory, self.neuron, exc_weights)
self.inh_synapses = builder.build_inh_synapses(
self.input_groups.inhibitory, self.neuron, inh_weights)
self.add(
self.neuron, self.input_neurons, self.inh_synapses,
self.exc_synapses)
from parser import Parser
from config import Configurable
import torch
import numpy as np
import os
if __name__ == '__main__':
default_seed = int(time.time())
argparser = argparse.ArgumentParser()
argparser.add_argument(
'--exp_des', default='description-of-this-experiment-no-whitespace')
argparser.add_argument('--config_file', default='config.txt')
argparser.add_argument('--random_seed', type=int, default=default_seed)
# argparser.add_argument('--thread', default=4, type=int, help='thread num')
args, extra_args = argparser.parse_known_args()
conf = Configurable(args.config_file, extra_args)
# cudaNo = conf.cudaNo
# os.environ["CUDA_VISIBLE_DEVICES"] = cudaNo
all_seeds = [args.random_seed]
random.seed(all_seeds[0])
for i in range(3):
all_seeds.append(random.randint(1, 987654321))
np.random.seed(all_seeds[1])
torch.cuda.manual_seed(all_seeds[2])
torch.manual_seed(all_seeds[3])
print('random_seeds = ', all_seeds, flush=True)
torch.set_num_threads(
4) # run with CPU, then use multi-thread? What does this mean?
def __init__(self, d):
self.type = self.parse_string(d, "type")
self._filter_cls, config_cls = Configurable.parse(__name__, self.type)
self.config = self.parse_object(d, "config", config_cls)
def __init__(self):
Interface.__init__(self, "USR")
Configurable.__init__(self)
LOG("Created")
def __init__(self):
Interface.__init__(self, "RNG")
Configurable.__init__(self)
self.__ctxName = None
LOG("Created")
def __init__(self):
Interface.__init__(self, "MEM")
Configurable.__init__(self)
self.__ctxName = None
LOG("Created")
def __init__(self, config, model):
Configurable.__init__(self, config)
self._add_config_value('store_times', quantity_list)
self.model = model
self.m_spike_count = b.PopulationSpikeCounter(model.neuron)
def __init__(self):
Interface.__init__(self, "USR")
Configurable.__init__(self)
LOG("Created")
def __init__(self, config):
Configurable.__init__(self, config)
self._add_config_value('equations', EquationString('\n'))
self._add_config_value('pre', EquationString('; '))
self._add_config_value('post', EquationString('; '))
