class ParallelizationConfiguration(IConfigurable):
num_java_threads = NodeThreadPool.getNumJavaThreads()
num_sim_GPU = NEFGPUInterface.getRequestedNumDevices()
use_GPU_for_creation = WeightedCostApproximator.getUseGPU()
p_num_java_threads = PInt('Number of Java Threads', num_java_threads, 1,
NodeThreadPool.getMaxNumJavaThreads())
p_num_sim_GPU = PGpuCount('Number of GPU\'s for Simulation')
p_use_GPU_for_creation = PGpuUse('Use GPU for Ensemble Creation')
properties = [p_num_java_threads, p_num_sim_GPU, p_use_GPU_for_creation]
def __init__(self):
self.button = make_button('parallelization', self.do_configure,
'Configure Parallelization')
self.button.enabled = True
def do_configure(self, event):
self.p_num_java_threads.setDefaultValue(
NodeThreadPool.getNumJavaThreads())
self.p_num_sim_GPU.setDefaultValue(
NEFGPUInterface.getRequestedNumDevices())
self.p_use_GPU_for_creation.setDefaultValue(
WeightedCostApproximator.getUseGPU())
uc = ca.nengo.ui.configurable.managers.UserTemplateConfigurer(self)
try:
uc.configureAndWait()
except ConfigException, e:
e.defaultHandleBehavior()
def completeConfiguration(self, props):
self.num_java_threads = props.getValue(self.p_num_java_threads)
self.num_sim_GPU = props.getValue(self.p_num_sim_GPU)
self.use_GPU_for_creation = props.getValue(self.p_use_GPU_for_creation)
NodeThreadPool.setNumJavaThreads(self.num_java_threads)
NEFGPUInterface.setRequestedNumDevices(self.num_sim_GPU)
WeightedCostApproximator.setUseGPU(self.use_GPU_for_creation)
def completeConfiguration(self,props):
self.num_java_threads=props.getValue(self.p_num_java_threads)
self.num_sim_GPU=props.getValue(self.p_num_sim_GPU)
self.use_GPU_for_creation=props.getValue(self.p_use_GPU_for_creation)
NodeThreadPool.setNumJavaThreads(self.num_java_threads)
NEFGPUInterface.setRequestedNumDevices(self.num_sim_GPU)
WeightedCostApproximator.setUseGPU(self.use_GPU_for_creation)
def __init__(self,network):
self.nodes=[]
self.projections=[]
self.tasks=[]
self.network=network
self.initialize(network)
if NodeThreadPool.getNumJavaThreads() > 0:
NEFGPUInterface.requireAllOutputsOnCPU(True);
self.thread_pool=NodeThreadPool(network,[]);
else:
self.thread_pool=None;
class Simulator:
def __init__(self,network):
self.nodes=[]
self.projections=[]
self.network=network
self.initialize(network)
if NEFGPUInterface.getUseGPU():
gpuNodes = LocalSimulator.collectNodes(self.nodes)
gpuNetworkArrays = LocalSimulator.collectNetworkArraysForGPU(self.nodes)
gpuProjections = LocalSimulator.collectProjections(self.nodes, self.projections)
self.thread_pool=NEFGPUInterface(gpuNodes, gpuProjections, gpuNetworkArrays)
elif NodeThreadPool.isMultithreading():
multithread_nodes = LocalSimulator.collectNodes(self.nodes)
multithread_projs = LocalSimulator.collectProjections(self.nodes, self.projections)
self.thread_pool=NodeThreadPool(multithread_nodes, multithread_projs)
else:
self.thread_pool=None
def initialize(self,network):
for p in network.projections:
self.projections.append(p);
for n in network.nodes:
if n.__class__.__name__=='NetworkArray':
self.nodes.append(n)
elif isinstance(n,Network) and not n.__class__.__name__ in ['CCMModelNetwork','PyramidalNetwork']:
self.initialize(n)
else:
self.nodes.append(n)
def reset(self,randomize=False):
for n in self.nodes: n.reset(randomize)
def step(self,start,end):
if self.thread_pool is not None:
# the thread pool should take care of the projections
self.thread_pool.step(start,end)
else:
for p in self.projections:
p.termination.setValues(p.origin.getValues())
for n in self.nodes:
n.run(start,end)
def kill(self):
if self.thread_pool is not None:
self.thread_pool.kill()
self.thread_pool = None
class Simulator:
def __init__(self,network):
self.nodes=[]
self.projections=[]
self.tasks=[]
self.network=network
self.initialize(network)
if NodeThreadPool.getNumJavaThreads() > 0:
NEFGPUInterface.requireAllOutputsOnCPU(True);
self.thread_pool=NodeThreadPool(network,[]);
else:
self.thread_pool=None;
def initialize(self,network):
for p in network.projections:
self.projections.append(p);
for n in network.nodes:
if isinstance(n,Network) and not n.__class__.__name__ in ['CCMModelNetwork','PyramidalNetwork']:
self.initialize(n)
else:
self.nodes.append(n)
def reset(self,randomize=False):
for n in self.nodes: n.reset(randomize)
# Force java garbage collection to free (hopefully) unused memory
System.gc()
def step(self,start,end):
self.network.fireStepListeners(start)
if self.thread_pool is not None:
self.thread_pool.step(start,end)
else:
for p in self.projections:
p.termination.setValues(p.origin.getValues())
for n in self.nodes:
n.run(start,end)
#for t in self.tasks:
# t.run(start,end)
def kill(self):
if self.thread_pool is not None:
NEFGPUInterface.requireAllOutputsOnCPU(False);
self.thread_pool.kill()
self.thread_pool = None
class Simulator:
def __init__(self, network):
self.nodes = []
self.projections = []
self.tasks = []
self.network = network
self.initialize(network)
if NodeThreadPool.getNumJavaThreads() > 0:
NEFGPUInterface.requireAllOutputsOnCPU(True)
self.thread_pool = NodeThreadPool(network, [])
else:
self.thread_pool = None
def initialize(self, network):
for p in network.projections:
self.projections.append(p)
for n in network.nodes:
if isinstance(n, Network) and not n.__class__.__name__ in [
'CCMModelNetwork', 'PyramidalNetwork'
]:
self.initialize(n)
else:
self.nodes.append(n)
def reset(self, randomize=False):
for n in self.nodes:
n.reset(randomize)
# Force java garbage collection to free (hopefully) unused memory
System.gc()
def step(self, start, end):
self.network.fireStepListeners(start)
if self.thread_pool is not None:
self.thread_pool.step(start, end)
else:
for p in self.projections:
p.termination.setValues(p.origin.getValues())
for n in self.nodes:
n.run(start, end)
#for t in self.tasks:
# t.run(start,end)
def kill(self):
if self.thread_pool is not None:
NEFGPUInterface.requireAllOutputsOnCPU(False)
self.thread_pool.kill()
self.thread_pool = None
def start():
(options, args) = parse_args()
logging.basicConfig(filename=options.logfile, filemode='w', level=logging.INFO)
logging.info("Parameters: " + str(options) + str(args))
command_line = 'cl' in args
if options.dry_run:
dry_run(options.results_file)
NodeThreadPool.setNumJavaThreads(options.threads)
if options.reduced_mode:
reduced_run(options)
else:
normal_run(options)
def start():
(options, args) = parse_args()
logging.basicConfig(filename=options.logfile,
filemode='w',
level=logging.INFO)
logging.info("Parameters: " + str(options) + str(args))
command_line = 'cl' in args
if options.dry_run:
dry_run(options.results_file)
NodeThreadPool.setNumJavaThreads(options.threads)
if options.reduced_mode:
reduced_run(options)
else:
normal_run(options)
def do_configure(self, event):
self.p_num_java_threads.setDefaultValue(NodeThreadPool.getNumJavaThreads())
self.p_num_sim_GPU.setDefaultValue(NEFGPUInterface.getRequestedNumDevices())
self.p_use_GPU_for_creation.setDefaultValue(WeightedCostApproximator.getUseGPU())
uc=ca.nengo.ui.configurable.managers.UserTemplateConfigurer(self)
try:
uc.configureAndWait()
except ConfigException, e:
e.defaultHandleBehavior()
def __init__(self,network):
self.nodes=[]
self.projections=[]
self.network=network
self.initialize(network)
if NEFGPUInterface.getUseGPU():
gpuNodes = LocalSimulator.collectNodes(self.nodes)
gpuNetworkArrays = LocalSimulator.collectNetworkArraysForGPU(self.nodes)
gpuProjections = LocalSimulator.collectProjections(self.nodes, self.projections)
self.thread_pool=NEFGPUInterface(gpuNodes, gpuProjections, gpuNetworkArrays)
elif NodeThreadPool.isMultithreading():
multithread_nodes = LocalSimulator.collectNodes(self.nodes)
multithread_projs = LocalSimulator.collectProjections(self.nodes, self.projections)
self.thread_pool=NodeThreadPool(multithread_nodes, multithread_projs)
else:
self.thread_pool=None
def do_configure(self, event):
self.p_num_java_threads.setDefaultValue(
NodeThreadPool.getNumJavaThreads())
self.p_num_sim_GPU.setDefaultValue(
NEFGPUInterface.getRequestedNumDevices())
self.p_use_GPU_for_creation.setDefaultValue(
WeightedCostApproximator.getUseGPU())
uc = ca.nengo.ui.configurable.managers.UserTemplateConfigurer(self)
try:
uc.configureAndWait()
except ConfigException, e:
e.defaultHandleBehavior()
def run(world, OS = "WIN", test_type = 7, test_option = None, num_test_run = 2, num_subjects = 1, \
multi_thread = False, en_logging = False, rand_type = 0, #rand_type = 110518233715, \
perfect_MB = True, perfect_cconv = True, CUthreshold = 0.4, CUNumsThreshold = 0.3, CUinScale = 1.0, \
tranf_scale = 0.451, learn_alpha = 1.0, auto_run = 2):
learn_actions = 2
if( test_option is None ):
if( test_type == 2 ):
# test_option = [[0.21,0.63,5],[0.63,0.21,5],[0.12,0.72,5],[0.72,0.12,5]]
test_option = [[100,0,20]]
learn_actions = 2
if( test_type == 3 ):
test_option = (4,0)
if( test_type == 4 ):
test_option = (None,None)
if( test_type == 5 ):
test_option = (5,'K')
if( test_type == 6 ):
test_option = (4,"AAxB","xB")
if( test_type == 7 ):
test_option = [3,2,1]
conf.OS = OS; conf.test_type = test_type; conf.test_option = test_option
conf.num_test_run = num_test_run; conf.num_subjects = num_subjects; conf.learn_alpha = learn_alpha
conf.CUthreshold = CUthreshold; conf.CUNumsThreshold = CUNumsThreshold; conf.CUinScale = CUinScale;
conf.tranf_scale = tranf_scale; conf.learn_actions = learn_actions
## ------------------------------------- DEFINE RULE SET ------------------------------------------
class SpaUNRules:
def task_init(vis = "A"):
set(ps_task = "X")
# def task_r_init(vis = "R"):
# set(ps_task = "R", ps_state = "TRANS1", ps_subtask = "MF")
# def task_r_store(ps_tasko = "R", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "TRANS1")
#
# def task_v_init(vis = "V"):
# set(ps_task = "V", ps_state = "SKIP", ps_subtask = "NON")
# def task_v_tr1_2_skp(ps_tasko = "V", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "SKIP")
#
# def task_f_init(vis = "F"):
# set(ps_task = "F", ps_state = "SKIP", ps_subtask = "NON")
# def task_f_tr1_2_tr2(ps_tasko = "F", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "TRANS2")
# def task_f_tr2_2_skp(ps_tasko = "F", ps_stateo = "TRANS2", scale = 0.5):
# set(ps_state = "SKIP")
#
# def task_m_init(vis = "M"):
# set(ps_task = "M", ps_state = "TRANS1", ps_subtask = "MF")
# def task_m_keep_tr1(ps_tasko = "M", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "TRANS1")
# def task_m_set_fwd(vis = "P", ps_tasko = "M", scale = 0.5):
# set(ps_subtask = "MF")
# def task_m_set_bck(vis = "K", ps_tasko = "M", scale = 0.5):
# set(ps_subtask = "MB")
#
# def task_r_init(vis = "R"):
# set(ps_task = "R", ps_state = "TRANS1", ps_subtask = "MF")
# def task_r_keep_tr1(ps_tasko = "R", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "TRANS1")
#
# def task_a_init(vis = "A"):
# set(ps_task = "A", ps_state = "SKIP", ps_subtask = "NON")
# def task_a_tr1_2_tr2(ps_tasko = "A", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "TRANS2")
# def task_a_keep_tr2(ps_tasko = "A", ps_stateo = "TRANS2", scale = 0.5):
# set(ps_state = "TRANS2")
# def task_a_set_k(ps_tasko = "A", vis = "K", scale = 0.5):
# set(ps_subtask = "AK")
# def task_a_set_p(ps_tasko = "A", vis = "P", scale = 0.5):
# set(ps_subtask = "AP")
#
# def task_c_init(vis = "C"):
# set(ps_task = "C", ps_state = "SKIP", ps_subtask = "NON")
# def task_c_set_cnt(ps_tasko = "C", ps_stateo = "TRANS1", scale = 0.5):
# set(ps_state = "CNT", ps_subtask = "CNT")
# def task_c_nomatch(ps_stateo = "CNT", scale = 1.0):
## match(mem_MB2 != mem_MBCnt)
# set(ps_subtask = "CNT")
# def task_c_match(ps_stateo = "CNT", scale = 0.5):
## match(mem_MB2 == mem_MBCnt)
# set(ps_subtask = "MF")
#
# def task_w_init(vis = "W"):
# set(ps_task = "W", ps_state = "VIS", ps_subtask = "MF")
#
def task_qm(vis = "QM"):
set(ps_task = "DEC")
def task_skp_2_tr1(ps_stateo = "SKIP"):
set(ps_state = "TRANS1")
def task_l_init(vis = "TWO", ps_tasko = "X", scale = 0.5):
set(ps_task = "L", ps_state = "LEARN", ps_subtask = "NON")
for i in range(conf.learn_actions):
code = """def task_l_a%d(ps_stateo = "LEARN-TRANS1-TRANS2-SKIP", scale = %f, rand_weights = rand_weights):
learn(ps_statea = rand_weights, pred_error = vstr_pred_error)
set(ps_subtask = "A%d")""" % (i+1,0.35,i+1)
exec(code)
## ------------------------------------- END DEFINE RULE SET ------------------------------------------
## ------------------------------------- DEFINE SPA NETWORK ------------------------------------------
class SpaUNLearn(spa.core.SPA):
dimensions = conf.num_dim
align_hrrs = True
stimulus = ControlModule()
vis = VisionModule()
ps = ProdSysBufferModule()
# mem = MemoryBufferModule()
# trans = TransformModule()
# enc = EncodingModule()
# dec = DecodingModule()
vstr = vStrModule()
motor = MotorModule()
BG = spa.bg.BasalGanglia(SpaUNRules(), pstc_input = 0.01)
thalamus = spa.thalamus.Thalamus(bg = BG, pstc_route_input = 0.01, pstc_gate = 0.001, route_scale = 1, \
pstc_inhibit = 0.01, pstc_output = 0.011, pstc_route_output = 0.01, \
mutual_inhibit = 2, quick = False)
## ------------------------------------- END DEFINE SPA NETWORK ------------------------------------------
if( perfect_MB ):
conf.MB_mode = "ideal"
if( perfect_cconv ):
conf.cconv_mode = "direct"
if( OS == "WIN" ):
conf.root_path = "D:\\fchoo\\Documents\\My Dropbox\\SPA\\Code\\Spaun\\"
conf.vis_filepath = "D:\\fchoo\\Documents\\My Dropbox\\SPA\\Code\\Digits\\Matlab\\"
elif( OS == "LIN_G" ):
conf.root_path = "/home/ctnuser/fchoo/code/"
conf.vis_filepath = "/home/ctnuser/fchoo/code/Digits/Matlab/"
elif( OS == "LIN" ):
conf.root_path = "/home/fchoo/Dropbox/SPA/Code/data/"
conf.vis_filepath = "/home/fchoo/Dropbox/SPA/Code/Digits/Matlab/"
rand_seed = rand_type
if( not rand_type == 0 ):
if( rand_type == 1 ):
rand_seed = eval(datetime.datetime.today().strftime("%y%m%d%H%M"))
else:
rand_seed = eval(datetime.datetime.today().strftime("%y%m%d%H%M%S"))
PDFTools.setSeed(rand_seed)
random.seed(rand_seed)
if( not multi_thread ):
NodeThreadPool.turnOffMultithreading()
else:
NodeThreadPool.setNumThreads(multi_thread)
datetime_str = datetime.datetime.today().strftime("%y%m%d%H%M%S")
filename = "task_" + vocabs.task_strs[test_type] + str(test_option) + "_" + datetime_str + ".txt"
logname = "log_" + vocabs.task_strs[test_type] + str(test_option) + "_" + datetime_str + ".csv"
if( not OS == "" ):
conf.out_file = conf.root_path + filename
else:
conf.out_file = ""
if( en_logging and not OS == "" ):
conf.log_file = conf.root_path + logname
else:
conf.log_file = ""
for i in range(learn_actions):
vocabs.subtask_strs.append("A" + str(i+1))
conf.vocab_data = vocabs.VocabData()
spaun = SpaUNLearn()
println(conf.est_runtime)
# Set default vocabularies (for interactive mode)
hrr.Vocabulary.defaults[conf.num_dim] = conf.vocab_data.vis_vocab
hrr.Vocabulary.defaults[conf.vocab_data.nums_dim] = conf.vocab_data.nums_vocab
hrr.Vocabulary.defaults[conf.vocab_data.state_dim] = conf.vocab_data.state_vocab
hrr.Vocabulary.defaults[conf.vocab_data.task_dim] = conf.vocab_data.task_vocab
hrr.Vocabulary.defaults[conf.vocab_data.subtask_dim] = conf.vocab_data.subtask_vocab
# Raw visual output vocab (for debug)
vis_raw_vocab = hrr.Vocabulary(conf.vis_dim, max_similarity = 0.05, include_pairs = False)
list_strs = read_csv(conf.vis_filepath + conf.sym_list_filename, True)
raw_vecs = read_csv(conf.vis_filepath + conf.mu_filename)
for i,list_str in enumerate(list_strs):
vis_raw_vocab.add(list_str[0], hrr.HRR(data = raw_vecs[i]))
hrr.Vocabulary.defaults[conf.vis_dim] = vis_raw_vocab
if( en_logging ):
wtfNode = nef.WriteToFileNode("wtf", conf.log_file, spaun.net, \
conf.vocab_data.vis_vocab, log_interval = 0.01, pstc = 0.01)
wtfNode.addValueTermination("dec", "motor_go")
wtfNode.addValueTermination("dec", "stimulus_cont")
if( auto_run > 0 ):
if( auto_run > 1 ):
spaun.net.view(play = conf.est_runtime)
else:
spaun.net.network.simulator.resetNetwork(False, False)
spaun.net.network.simulator.run(0, conf.est_runtime, 0.001, False)
data.record_sparsity(nav_agent.getNode("QNetwork").getNode("state_pop").getOrigin("AXON"), filter=filter)
data.record_avg(ctrl_agent.getNode("QNetwork").getNode("valdiff").getOrigin("X"), filter=filter)
data.record_avg(ctrl_agent.getNode("ErrorNetwork").getOrigin("error"), filter=filter)
data.record_avg(ctrl_agent.getNode("BGNetwork").getNode("weight_actions").getNode("0").getOrigin("AXON"), filter=filter)
data.record_avg(ctrl_agent.getNode("BGNetwork").getNode("weight_actions").getNode("1").getOrigin("AXON"), filter=filter)
net.add_to_nengo()
# net.view()
net.run(2000)
def run_workTermReport():
# run a bunch of configs
config = {"time": {"linear": "please"}}
# start at twice the normal scale and then let it degrade
NodeThreadPool.setNumJavaThreads(8) #Set it equal to the number of cores?
#run_deliveryenvironment({"learningrate": 9e-10, "discount": 0.1, "Qradius": 2.0,
# "load_weights": os.path.join("weights", "contextgrid_decoder", "SMDPAgent")},
# {"learningrate": 9e-10, "discount": 0.1, "load_weights": None},
# seed=1)
#run_contextenvironment({"learningrate":9e-10, "discount":0.1, "Qradius":2.0,
# "load_weights":None},
# seed=0)
#gen_evalpoints("contextbmp_evalpoints", seed=0)
#run_flat_delivery({"learningrate":9e-10, "discount":0.1, "Qradius":2.0,
# "load_weights":os.path.join("delivery", "flat", "NavAgent")},
# seed=2)
