def in_ports(self, idx=None):
"""
Get InPorts of an Arrow.
Returns:
List of InPorts
"""
return [port for port in self._ports if pa.is_in_port(port)]
def supervised_train(arrow: Arrow,
train_input_data: List[Generator],
train_output_data: List[Generator],
test_input_data: List[Generator],
test_output_data: List[Generator],
callbacks=None,
options=None) -> CompositeArrow:
callbacks = [] if callbacks is None else callbacks
options = {} if options is None else options
grabs = ({'input': lambda p: is_in_port(p) and not is_param_port(p) and not has_port_label(p, 'train_output'),
'train_output': lambda p: has_port_label(p, 'train_output'),
'supervised_error': lambda p: has_port_label(p, 'supervised_error'),
'sub_arrow_error': lambda p: has_port_label(p, 'sub_arrow_error'),
'inv_fwd_error': lambda p: has_port_label(p, 'inv_fwd_error')})
# Not all arrows will have these ports
optional = ['sub_arrow_error', 'inv_fwd_error', 'param']
tensors = extract_tensors(arrow, grabs=grabs, optional=optional)
train_feed_gens = [okok(options['batch_size'], train_input_data, train_output_data,
tensors['input'], tensors['train_output'])]
test_feed_gens = [okok(options['batch_size'], test_input_data, test_output_data,
tensors['input'], tensors['train_output'])]
# All losses
loss_dict = {}
for loss in ['error', 'sub_arrow_error', 'inv_fwd_error', 'supervised_error']:
if loss in tensors:
loss_dict[loss] = accumulate_losses(tensors[loss])
# error to minimize
error = options['error'] if 'error' in options else 'error'
loss_to_min = accumulate_losses(tensors[error])
losses = [loss_to_min]
loss_updates = [gen_update_step(loss) for loss in losses]
loss_ratios = [1]
sess = tf.Session()
fetch = gen_fetch(sess, **options)
fetch['input_tensors'] = tensors['input']
fetch['output_tensors'] = tensors['output']
fetch['loss'] = loss_dict
train_load_save(sess,
loss_updates,
fetch,
train_feed_gens,
test_feed_gens,
loss_ratios=loss_ratios,
callbacks=callbacks,
**options)
def side(port, i=0):
if is_in_port(port):
ins = port.arrow.in_ports()
if len(ins) > i:
return ins[i]
else:
return None
else:
outs = port.arrow.out_ports()
if len(outs) > i:
return outs[i]
else:
return None
def down(port, i=0):
if is_in_port(port):
neighs = port.arrow.parent.neigh_ports(port)
if len(neighs) > i:
return neighs[i]
else:
return None
else:
ins = port.arrow.in_ports()
if len(ins) > i:
return ins[i]
else:
return None
def up(port, i=0):
if is_in_port(port):
outs = port.arrow.out_ports()
if len(outs) > i:
return outs[i]
else:
return None
else:
neighs = port.arrow.parent.neigh_ports(port)
if len(neighs) > i:
return neighs[i]
else:
return None
def attachNN(comp_arrow: CompositeArrow) -> CompositeArrow:
"""
Returns a composite arrow with the neural networks already
attached to each layer of sub_arrows
"""
new_arrow = deepcopy(comp_arrow)
partition_arrows = partition(new_arrow)
for (i, layer) in enumerate(partition_arrows):
in_ports = []
param_ports = []
# input ports of new_arrow are inputs of the first neural network to
# provide information to the sub_arrows with only parametric inputs
if i == 0:
for in_port in new_arrow.in_ports():
if is_param_port(in_port) == False:
in_ports.extend(new_arrow.neigh_in_ports(in_port))
for sub_arrow in layer:
for port in sub_arrow.in_ports():
for neigh_port in new_arrow.neigh_out_ports(port):
if is_param_port(neigh_port):
if port not in param_ports:
param_ports.append(port)
elif neigh_port.arrow == new_arrow and is_in_port(
neigh_port):
if port not in in_ports:
in_ports.append(port)
elif neigh_port.arrow != new_arrow and is_out_port(
neigh_port):
if port not in in_ports:
in_ports.append(port)
if len(in_ports) == 0 or len(param_ports) == 0:
continue
neural_net_arrow = TfArrow(n_in_ports=len(in_ports),
n_out_ports=len(param_ports),
graph=tf.Graph(),
name="nn_for_params_" + str(i))
nn_in_ports = neural_net_arrow.in_ports()
nn_out_ports = neural_net_arrow.out_ports()
for (j, in_port) in enumerate(in_ports):
new_arrow.add_edge(in_port, nn_in_ports[j])
for (j, param_port) in enumerate(param_ports):
new_arrow.add_edge(nn_out_ports[j], param_port)
return new_arrow