def get_affected_nodes(self, loop_in_node):
tree = self.id_data
nodes_to_loop_out = make_tree_from_nodes([self.name], tree, down=False)
nodes_from_loop_in = make_tree_from_nodes([loop_in_node.name], tree, down=True)
nodes_from_loop_out = make_tree_from_nodes([self.name], tree, down=True)
set_nodes_from_loop_in = frozenset(nodes_from_loop_in)
set_nodes_from_loop_out = frozenset(nodes_from_loop_out)
intersection = [x for x in nodes_to_loop_out if x in set_nodes_from_loop_in and tree.nodes[x].bl_idname != 'NodeReroute']
related_nodes = [x for x in nodes_from_loop_in if x not in set_nodes_from_loop_out and x not in intersection]
return intersection, related_nodes
def process_vectorize(self):
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
node_names = self.get_nodes_to_process(out_node.name)
ul = make_tree_from_nodes(node_names, monad, down=False)
data_out = [[] for s in self.outputs]
data_in = match_long_repeat([s.sv_get(deepcopy=False) for s in self.inputs])
if self.split:
for idx, data in enumerate(data_in):
new_data = unwrap(split_list(d) for d in data)
data_in[idx] = new_data
data_in = match_long_repeat(data_in)
monad["current_total"] = len(data_in[0])
for master_idx, data in enumerate(zip(*data_in)):
for idx, d in enumerate(data):
socket = in_node.outputs[idx]
if socket.is_linked:
socket.sv_set([d])
monad["current_index"] = master_idx
do_update(ul, monad.nodes)
for idx, s in enumerate(out_node.inputs[:-1]):
data_out[idx].extend(s.sv_get(deepcopy=False))
for idx, socket in enumerate(self.outputs):
if socket.is_linked:
socket.sv_set(data_out[idx])
def process(self):
if not any(s.is_linked for s in self.outputs):
return
if not self.monad:
return
if self.vectorize:
self.process_vectorize()
return
elif self.loop_me:
self.process_looped(self.loops)
return
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
monad['current_index'] = 0
monad['current_total'] = 0
for index, socket in enumerate(self.inputs):
data = socket.sv_get(deepcopy=False)
in_node.outputs[index].sv_set(data)
node_names = self.get_nodes_to_process(out_node.name)
ul = make_tree_from_nodes(node_names, monad, down=False)
do_update(ul, monad.nodes)
# set output sockets correctly
for index, socket in enumerate(self.outputs):
if socket.is_linked:
data = out_node.inputs[index].sv_get(deepcopy=False)
socket.sv_set(data)
def process(self):
if not self.monad:
return
if self.vectorize:
self.process_vectorize()
return
elif self.loop_me:
self.process_looped(self.loops)
return
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
for index, socket in enumerate(self.inputs):
data = socket.sv_get(deepcopy=False)
in_node.outputs[index].sv_set(data)
# get update list
# could be cached
ul = make_tree_from_nodes([out_node.name], monad, down=False)
do_update(ul, monad.nodes)
# set output sockets correctly
for index, socket in enumerate(self.outputs):
if socket.is_linked:
data = out_node.inputs[index].sv_get(deepcopy=False)
socket.sv_set(data)
def process_vectorize(self):
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
ul = make_tree_from_nodes([out_node.name], monad, down=False)
data_out = [[] for s in self.outputs]
data_in = match_long_repeat([s.sv_get(deepcopy=False) for s in self.inputs])
if self.split:
for idx, data in enumerate(data_in):
new_data = unwrap(split_list(d) for d in data)
data_in[idx] = new_data
data_in = match_long_repeat(data_in)
monad["current_total"] = len(data_in[0])
for master_idx, data in enumerate(zip(*data_in)):
for idx, d in enumerate(data):
socket = in_node.outputs[idx]
if socket.is_linked:
socket.sv_set([d])
monad["current_index"] = master_idx
do_update(ul, monad.nodes)
for idx, s in enumerate(out_node.inputs[:-1]):
data_out[idx].extend(s.sv_get(deepcopy=False))
for idx, socket in enumerate(self.outputs):
if socket.is_linked:
socket.sv_set(data_out[idx])
def process(self):
if not self.monad:
return
if self.vectorize:
self.process_vectorize()
return
elif self.loop_me:
self.process_looped(self.loops)
return
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
for index, socket in enumerate(self.inputs):
data = socket.sv_get(deepcopy=False)
in_node.outputs[index].sv_set(data)
# get update list
# could be cached
ul = make_tree_from_nodes([out_node.name], monad, down=False)
do_update(ul, monad.nodes)
# set output sockets correctly
for index, socket in enumerate(self.outputs):
if socket.is_linked:
data = out_node.inputs[index].sv_get(deepcopy=False)
socket.sv_set(data)
def process(self):
group_ng = bpy.data.node_groups[self.group_name]
in_node = find_node("SvGroupInputsNode", group_ng)
out_node = find_node('SvGroupOutputsNode', group_ng)
ul = make_tree_from_nodes([out_node.name], group_ng, down=False)
for socket in self.inputs:
if socket.is_linked:
data = socket.sv_get(deepcopy=False)
in_node.outputs[socket.name].sv_set(data)
# get update list
# could be cached
for i in range(self.iter_count):
do_update(ul, group_ng.nodes)
for socket in out_node.inputs:
if socket.is_linked:
data = out_node.inputs[socket.name].sv_get(deepcopy=False)
socket.sv_set(data)
in_node.outputs[socket.name].sv_set(data)
# set output sockets correctly
for socket in self.outputs:
if socket.is_linked:
data = out_node.inputs[socket.name].sv_get(deepcopy=False)
socket.sv_set(data)
def process(self):
group_ng = bpy.data.node_groups[self.group_name]
in_node = find_node("SvGroupInputsNode", group_ng)
out_node = find_node('SvGroupOutputsNode', group_ng)
ul = make_tree_from_nodes([out_node.name], group_ng, down=False)
for socket in self.inputs:
if socket.is_linked:
data = socket.sv_get(deepcopy=False)
in_node.outputs[socket.name].sv_set(data)
# get update list
# could be cached
for i in range(self.iter_count):
do_update(ul, group_ng.nodes)
for socket in out_node.inputs:
if socket.is_linked:
data = out_node.inputs[socket.name].sv_get(deepcopy=False)
socket.sv_set(data)
in_node.outputs[socket.name].sv_set(data)
# set output sockets correctly
for socket in self.outputs:
if socket.is_linked:
data = out_node.inputs[socket.name].sv_get(deepcopy=False)
socket.sv_set(data)
def sv_execute(self, context, node):
tree = node.id_data
data = evolver_mem[node.node_id]
genes = data["genes"]
population = data["population"]
update_list = make_tree_from_nodes([g.name for g in genes], tree)
set_fittest(tree, genes, population[0], update_list)
def execute(self, context):
tree = bpy.data.node_groups[self.idtree]
node = bpy.data.node_groups[self.idtree].nodes[self.idname]
data = evolver_mem[node.node_id]
genes = data["genes"]
population = data["population"]
update_list = make_tree_from_nodes([g.name for g in genes], tree)
set_fittest(tree, genes, population[0], update_list)
return {'FINISHED'}
def __init__(self, genotype_frame, node, tree):
self.node = node
self.tree = tree
self.time_start = time.time()
self.genes = get_genes(tree, genotype_frame)
self.update_list = make_tree_from_nodes([g.name for g in self.genes],
tree)
self.population_g = []
self.init_population(node.population_n)
def execute(self, context):
node = self.get_node(context)
if not node: return {'CANCELLED'}
data = evolver_mem[node.node_id]
genes = data["genes"]
population = data["population"]
update_list = make_tree_from_nodes([g.name for g in genes], tree)
set_fittest(tree, genes, population[0], update_list)
return {'FINISHED'}
def sv_execute(self, context, node):
if not node.inputs[0].is_linked:
node.info_label = "Stopped - Fitness not linked"
return
genotype_frame = node.genotype
evolver_mem[node.node_id] = {}
seed_set(node.r_seed)
np.random.seed(node.r_seed)
population = Population(genotype_frame, node, tree)
population.evolve()
update_list = make_tree_from_nodes([node.name], tree)
do_update(update_list, tree.nodes)
def execute(self, context):
tree = bpy.data.node_groups[self.idtree]
node = bpy.data.node_groups[self.idtree].nodes[self.idname]
if not node.inputs[0].is_linked:
node.info_label = "Stopped - Fitness not linked"
return {'FINISHED'}
genotype_frame = node.genotype
evolver_mem[node.node_id] = {}
seed_set(node.r_seed)
np.random.seed(node.r_seed)
population = Population(genotype_frame, node, tree)
population.evolve()
update_list = make_tree_from_nodes([node.name], tree)
do_update(update_list, tree.nodes)
return {'FINISHED'}
def do_process(self, sockets_data_in):
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
for index, data in enumerate(sockets_data_in):
in_node.outputs[index].sv_set(data)
ul = make_tree_from_nodes([out_node.name], monad, down=False)
do_update(ul, monad.nodes)
# set output sockets correctly
socket_data_out = []
for index, socket in enumerate(self.outputs):
if socket.is_linked:
data = out_node.inputs[index].sv_get(deepcopy=False)
socket_data_out.append(data)
return socket_data_out
def do_process(self, sockets_data_in):
monad = self.monad
in_node = monad.input_node
out_node = monad.output_node
for index, data in enumerate(sockets_data_in):
in_node.outputs[index].sv_set(data)
ul = make_tree_from_nodes([out_node.name], monad, down=False)
do_update(ul, monad.nodes)
# set output sockets correctly
socket_data_out = []
for index, socket in enumerate(self.outputs):
if socket.is_linked:
data = out_node.inputs[index].sv_get(deepcopy=False)
socket_data_out.append(data)
return socket_data_out
def sv_execute(node):
start = time.time()
hyperparametersList = node.inputs['Hyperparameters'].sv_get(deepcopy=True)
datasetList = node.inputs['Dataset'].sv_get(deepcopy=True)
hyperparametersList = Replication.flatten(hyperparametersList)
datasetList = Replication.flatten(datasetList)
inputs = [hyperparametersList, datasetList]
if ((node.Replication) == "Trim"):
inputs = Replication.trim(inputs)
inputs = Replication.transposeList(inputs)
elif ((node.Replication) == "Default") or ((node.Replication)
== "Iterate"):
inputs = Replication.iterate(inputs)
inputs = Replication.transposeList(inputs)
elif ((node.Replication) == "Repeat"):
inputs = Replication.repeat(inputs)
inputs = Replication.transposeList(inputs)
elif ((node.Replication) == "Interlace"):
inputs = list(Replication.interlace(inputs))
outputs = []
timestampList = []
classifierList = []
optimizerList = []
training_testing_splitList = []
hidden_layersList = []
conv_layer_typeList = []
poolingList = []
learning_rateList = []
batch_sizeList = []
durationList = []
epochsList = []
training_accuracyList = []
testing_accuracyList = []
training_lossList = []
testing_lossList = []
for i, anInput in enumerate(inputs):
output = runItem(i, anInput)
timestamp, duration, classifier, optimizer_str, training_testing_split, hidden_layers, conv_layer_type, pooling, learning_rate, batch_size, epochs, training_accuracy, testing_accuracy, training_loss, testing_loss = output
timestampList.append(timestamp)
durationList.append(duration)
classifierList.append(classifier)
optimizerList.append(optimizer_str)
training_testing_splitList.append(training_testing_split)
hidden_layersList.append(hidden_layers)
conv_layer_typeList.append(conv_layer_type)
poolingList.append(pooling)
learning_rateList.append(learning_rate)
batch_sizeList.append(batch_size)
epochsList.append(epochs)
training_accuracyList.append(training_accuracy)
testing_accuracyList.append(testing_accuracy)
training_lossList.append(training_loss)
testing_lossList.append(testing_loss)
node.outputs['Timestamp'].sv_set(timestampList)
node.outputs['Duration'].sv_set(durationList)
node.outputs['Classifier'].sv_set(classifierList)
node.outputs['Optimizer'].sv_set(optimizerList)
node.outputs['Training Testing Split'].sv_set(training_testing_splitList)
node.outputs['Hidden Layers'].sv_set(hidden_layersList)
node.outputs['Conv Layer Type'].sv_set(conv_layer_typeList)
node.outputs['Pooling'].sv_set(poolingList)
node.outputs['Learning Rate'].sv_set(learning_rateList)
node.outputs['Batch Size'].sv_set(batch_sizeList)
node.outputs['Epochs'].sv_set(epochsList)
node.outputs['Training Accuracy'].sv_set(training_accuracyList)
node.outputs['Testing Accuracy'].sv_set(testing_accuracyList)
node.outputs['Training Loss'].sv_set(training_lossList)
node.outputs['Testing Loss'].sv_set(testing_lossList)
tree = node.id_data
update_list = make_tree_from_nodes([node.name], tree)
update_list = update_list[1:]
do_update(update_list, tree.nodes)
end = time.time()
print("DGL.TrainClassifier Operation consumed " +
str(round(end - start, 2) * 1000) + " ms")
