def test_learning_output_shape(self, mode, minibatch_size):
'''
Tests for correct output from composition.learn
Expected: All results from last epoch
'''
xor_in = pnl.TransferMechanism(name='xor_in',
default_variable=np.zeros(2))
xor_hid = pnl.TransferMechanism(name='xor_hid',
default_variable=np.zeros(10),
function=pnl.Logistic())
xor_out = pnl.TransferMechanism(name='xor_out',
default_variable=np.zeros(1),
function=pnl.Logistic())
hid_map = pnl.MappingProjection(matrix=np.random.rand(2, 10),
sender=xor_in,
receiver=xor_hid)
out_map = pnl.MappingProjection(matrix=np.random.rand(10, 1))
xor = pnl.AutodiffComposition()
xor.add_node(xor_in)
xor.add_node(xor_hid)
xor.add_node(xor_out)
xor.add_projection(sender=xor_in, projection=hid_map, receiver=xor_hid)
xor.add_projection(sender=xor_hid,
projection=out_map,
receiver=xor_out)
xor_inputs = np.array( # the inputs we will provide to the model
[[0, 0], [0, 1], [1, 0], [1, 1]])
xor_targets = np.array( # the outputs we wish to see from the model
[[0], [1], [1], [0]])
results = xor.learn(inputs={
"inputs": {
xor_in: xor_inputs
},
"targets": {
xor_out: xor_targets
},
"epochs": 10
},
minibatch_size=minibatch_size,
bin_execute=mode)
assert len(results) == 4 // minibatch_size
def get_trained_network(bipartite_graph, num_features=3, num_hidden=200, epochs=10, learning_rate=20, attach_LCA=True, competition=0.2, self_excitation=0.2, leak=0.4, threshold=1e-4):
# Get all tasks from bipartite graph (edges) and strip 'i/o' suffix
all_tasks = get_all_tasks(bipartite_graph)
# Analyze bipartite graph for network properties
onodes = [ n for n, d in bipartite_graph.nodes(data=True) if d['bipartite'] == 0 ]
inodes = [ n for n, d in bipartite_graph.nodes(data=True) if d['bipartite'] == 1 ]
input_dims = len(inodes)
output_dims = len(onodes)
num_tasks = len(all_tasks)
# Start building network as PsyNeuLink object
# Layer parameters
nh = num_hidden
D_i = num_features * input_dims
D_c = num_tasks
D_h = nh
D_o = num_features * output_dims
# Weight matrices (defaults provided by Dillon)
wih = np.random.rand(D_i, D_h) * 0.02 - 0.01
wch = np.random.rand(D_c, D_h) * 0.02 - 0.01
wco = np.random.rand(D_c, D_o) * 0.02 - 0.01
who = np.random.rand(D_h, D_o) * 0.02 - 0.01
# Training params (defaults provided by Dillon)
patience = 10
min_delt = 0.00001
lr = learning_rate
# Instantiate layers and projections
il = pnl.TransferMechanism(size=D_i, name='input')
cl = pnl.TransferMechanism(size=D_c, name='control')
hl = pnl.TransferMechanism(size=D_h, name='hidden',
function=pnl.Logistic(bias=-2))
ol = pnl.TransferMechanism(size=D_o, name='output',
function=pnl.Logistic(bias=-2))
pih = pnl.MappingProjection(matrix=wih)
pch = pnl.MappingProjection(matrix=wch)
pco = pnl.MappingProjection(matrix=wco)
pho = pnl.MappingProjection(matrix=who)
# Create training data for network
# We train across all possible inputs, one task at a time
input_examples, output_examples, control_examples = generate_training_data(all_tasks, num_features, input_dims, output_dims)
# Training parameter set
input_set = {
'inputs': {
il: input_examples.tolist(),
cl: control_examples.tolist()
},
'targets': {
ol: output_examples.tolist()
},
'epochs': epochs
}
mnet = pnl.AutodiffComposition(learning_rate=learning_rate,
name='mnet')
mnet.output_CIM.parameters.value._set_history_max_length(100000)
mnet.add_node(il)
mnet.add_node(cl)
mnet.add_node(hl)
mnet.add_node(ol)
mnet.add_projection(projection=pih, sender=il, receiver=hl)
mnet.add_projection(projection=pch, sender=cl, receiver=hl)
mnet.add_projection(projection=pco, sender=cl, receiver=ol)
mnet.add_projection(projection=pho, sender=hl, receiver=ol)
# Train network
print("training 1")
t1 = time.time()
mnet.learn(
inputs=input_set,
minibatch_size=1,
bin_execute=MNET_BIN_EXECUTE,
patience=patience,
min_delta=min_delt,
)
t2 = time.time()
print("training 1:", MNET_BIN_EXECUTE, t2-t1)
# Apply LCA transform (values from Sebastian's code -- supposedly taken from the original LCA paper from Marius & Jay)
if attach_LCA:
lca = pnl.LCAMechanism(size=D_o,
leak=leak,
competition=competition,
self_excitation=self_excitation,
time_step_size=0.01,
threshold=threshold,
threshold_criterion=pnl.CONVERGENCE,
reset_stateful_function_when=pnl.AtTrialStart(),
name='lca')
# Wrapper composition used to pass values between mnet (AutodiffComposition) and lca (LCAMechanism)
wrapper_composition = pnl.Composition()
# Add mnet and lca to outer_composition
wrapper_composition.add_linear_processing_pathway([mnet, lca])
return wrapper_composition
return mnet
def get_trained_network_multLCA(bipartite_graph, num_features=3, num_hidden=200, epochs=10, learning_rate=20, attach_LCA=True, competition=0.2, self_excitation=0.2, leak=0.4, threshold=1e-4, exec_limit=EXEC_LIMIT):
# Get all tasks from bipartite graph (edges) and strip 'i/o' suffix
all_tasks = get_all_tasks(bipartite_graph)
# Analyze bipartite graph for network properties
onodes = [ n for n, d in bipartite_graph.nodes(data=True) if d['bipartite'] == 0 ]
inodes = [ n for n, d in bipartite_graph.nodes(data=True) if d['bipartite'] == 1 ]
input_dims = len(inodes)
output_dims = len(onodes)
num_tasks = len(all_tasks)
# Start building network as PsyNeuLink object
# Layer parameters
nh = num_hidden
D_i = num_features * input_dims
D_c = num_tasks
D_h = nh
D_o = num_features * output_dims
# Weight matrices (defaults provided by Dillon)
wih = np.random.rand(D_i, D_h) * 0.02 - 0.01
wch = np.random.rand(D_c, D_h) * 0.02 - 0.01
wco = np.random.rand(D_c, D_o) * 0.02 - 0.01
who = np.random.rand(D_h, D_o) * 0.02 - 0.01
# Training params (defaults provided by Dillon)
patience = 10
min_delt = 0.00001
lr = learning_rate
# Instantiate layers and projections
il = pnl.TransferMechanism(size=D_i, name='input')
cl = pnl.TransferMechanism(size=D_c, name='control')
hl = pnl.TransferMechanism(size=D_h,
name='hidden',
function=pnl.Logistic(bias=-2))
ol = pnl.TransferMechanism(size=D_o,
name='output',
function=pnl.Logistic(bias=-2))
pih = pnl.MappingProjection(matrix=wih)
pch = pnl.MappingProjection(matrix=wch)
pco = pnl.MappingProjection(matrix=wco)
pho = pnl.MappingProjection(matrix=who)
# Create training data for network
# We train across all possible inputs, one task at a time
input_examples, output_examples, control_examples = generate_training_data(all_tasks, num_features, input_dims, output_dims)
# Training parameter set
input_set = {
'inputs': {
il: input_examples.tolist(),
cl: control_examples.tolist()
},
'targets': {
ol: output_examples.tolist()
},
'epochs': 10 #epochs # LCA doesn't settle for 1000 epochs
}
# Build network
mnet = pnl.AutodiffComposition(learning_rate=learning_rate,
name='mnet')
mnet.output_CIM.parameters.value._set_history_max_length(1000)
mnet.add_node(il)
mnet.add_node(cl)
mnet.add_node(hl)
mnet.add_node(ol)
mnet.add_projection(projection=pih, sender=il, receiver=hl)
mnet.add_projection(projection=pch, sender=cl, receiver=hl)
mnet.add_projection(projection=pco, sender=cl, receiver=ol)
mnet.add_projection(projection=pho, sender=hl, receiver=ol)
# Train network
print("training 2:", MNET_BIN_EXECUTE)
t1 = time.time()
mnet.learn(
inputs=input_set,
minibatch_size=input_set['epochs'],
bin_execute=MNET_BIN_EXECUTE,
patience=patience,
min_delta=min_delt,
)
t2 = time.time()
print("training 2:", MNET_BIN_EXECUTE, t2-t1)
for projection in mnet.projections:
if hasattr(projection.parameters, 'matrix'):
weights = projection.parameters.matrix.get(mnet)
projection.parameters.matrix.set(weights, None)
# Apply LCA transform (values from Sebastian's code -- supposedly taken from the original LCA paper from Marius & Jay)
if attach_LCA:
lci = pnl.LeakyCompetingIntegrator(rate=leak,
time_step_size=0.01)
lca_matrix = get_LCA_matrix(output_dims, num_features, self_excitation, competition)
lca = pnl.RecurrentTransferMechanism(size=D_o,
matrix=lca_matrix,
integrator_mode=True,
integrator_function=lci,
name='lca',
termination_threshold=threshold,
reset_stateful_function_when=pnl.AtTrialStart())
# Wrapper composition used to pass values between mnet (AutodiffComposition) and lca (LCAMechanism)
wrapper_composition = pnl.Composition()
# Add mnet and lca to outer_composition
wrapper_composition.add_linear_processing_pathway([mnet, lca])
# Dummy to save mnet results
if str(LCA_BIN_EXECUTE).startswith("LLVM"):
dummy = pnl.TransferMechanism(size=D_o,
name="MNET_OUT")
wrapper_composition.add_linear_processing_pathway([mnet, dummy])
# Set execution limit
lca.parameters.max_executions_before_finished.set(exec_limit, wrapper_composition)
# # Logging/Debugging
# lca.set_log_conditions('value', pnl.LogCondition.EXECUTION)
return wrapper_composition
return mnet
n_units, len(has_list)),
name="map_hm_has",
sender=hm,
receiver=out_sig_has)
map_hm_can = pnl.MappingProjection(matrix=np.random.rand(
n_units, len(can_list)),
name="map_hm_can",
sender=hm,
receiver=out_sig_can)
#This block of code constructs the network
RumelNet = pnl.AutodiffComposition(param_init_from_pnl=True,
patience=10,
min_delta=0.00001,
learning_rate=1,
randomize=False)
RumelNet.add_node(nouns_in)
RumelNet.add_node(rels_in)
RumelNet.add_node(hn)
RumelNet.add_node(hm)
RumelNet.add_node(out_sig_I)
RumelNet.add_node(out_sig_is)
RumelNet.add_node(out_sig_has)
RumelNet.add_node(out_sig_can)
RumelNet.add_projection(sender=nouns_in, projection=map_nouns_hn, receiver=hn)
RumelNet.add_projection(sender=rels_in, projection=map_rels_hm, receiver=hm)
RumelNet.add_projection(sender=hn, projection=map_hn_hm, receiver=hm)
sender=hm,
receiver=out_sig_has
)
map_hm_can = pnl.MappingProjection(
matrix=np.random.rand(n_units,len(can_list)),
name="map_hm_can",
sender=hm,
receiver=out_sig_can
)
#This block of code constructs the network
RumelNet = pnl.AutodiffComposition(
patience=10,
min_delta=0.00001,
learning_rate=1,
randomize=False
)
RumelNet.add_node(nouns_in)
RumelNet.add_node(rels_in)
RumelNet.add_node(hn)
RumelNet.add_node(hm)
RumelNet.add_node(out_sig_I)
RumelNet.add_node(out_sig_is)
RumelNet.add_node(out_sig_has)
RumelNet.add_node(out_sig_can)
RumelNet.add_projection(sender=nouns_in, projection=map_nouns_hn, receiver=hn)
RumelNet.add_projection(sender=rels_in, projection=map_rels_hm, receiver=hm)