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 range_mode(self, loop_in_node):
if loop_in_node.iterations == 0:
for inp, outp in zip(loop_in_node.inputs[1:-1], self.outputs):
outp.sv_set(inp.sv_get(deepcopy=False, default=[]))
elif loop_in_node.iterations == 1:
for inp, outp in zip(self.inputs[2:], self.outputs):
outp.sv_set(inp.sv_get(deepcopy=False, default=[]))
else:
intersection, related_nodes = self.get_affected_nodes(loop_in_node)
if self.bad_inner_loops(intersection):
raise Exception("Loops inside not well connected")
iterations = min(int(loop_in_node.inputs['Iterations'].sv_get()[0][0]), loop_in_node.max_iterations)
tree_nodes = self.id_data.nodes
do_update(intersection[:-1], tree_nodes)
for i in range(iterations-1):
if self.break_loop():
break
for j, socket in enumerate(self.inputs[2:]):
data = socket.sv_get(deepcopy=False, default=[])
loop_in_node.outputs[j+3].sv_set(data)
loop_in_node.outputs['Loop Number'].sv_set([[i+1]])
process_looped_nodes(intersection[1:-1], tree_nodes, 'Iteration', i+1)
for inp, outp in zip(self.inputs[2:], self.outputs):
outp.sv_set(inp.sv_get(deepcopy=False, default=[]))
do_update(related_nodes, self.id_data.nodes)
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):
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_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 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_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 set_fittest(tree, genes, agent, update_list):
'''sets the nodetree with the best value'''
try:
tree.sv_process = False
for gen_data, agent_gene in zip(genes, agent):
gen_data.set_node_with_gene(tree, agent_gene)
tree.sv_process = True
do_update(update_list, tree.nodes)
finally:
tree.sv_process = True
def evaluate_fitness(self, tree, update_list, node):
try:
tree.sv_process = False
for gen_data, agent_gene in zip(self.genes_def, self.genes):
gen_data.set_node_with_gene(tree, agent_gene)
tree.sv_process = True
do_update(update_list, tree.nodes)
agent_fitness = node.inputs[0].sv_get(deepcopy=False)[0]
if isinstance(agent_fitness, list):
agent_fitness = agent_fitness[0]
self.fitness = agent_fitness
finally:
tree.sv_process = True
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 set_fittest(tree, genes, agent, update_list):
'''sets the nodetree with the best value'''
try:
tree.sv_process = False
for gene_o, gene_agent in zip(genes, agent):
if isinstance(gene_o, GeneList):
set_list_node(gene_o, gene_agent, tree)
else:
if gene_o.g_type == 'int':
tree.nodes[gene_o.name].int_ = gene_agent
else:
tree.nodes[gene_o.name].float_ = gene_agent
tree.sv_process = True
do_update(update_list, tree.nodes)
finally:
tree.sv_process = True
def for_each_mode(self, loop_in_node):
list_match = list_match_func[loop_in_node.list_match]
params = list_match([
inp.sv_get(deepcopy=False, default=[])
for inp in loop_in_node.inputs[1:-1]
])
if len(params[0]) == 1:
if not self.break_loop():
for inp, outp in zip(self.inputs[2:], self.outputs):
outp.sv_set(inp.sv_get(deepcopy=False, default=[]))
else:
for outp in self.outputs:
outp.sv_set([])
else:
intersection, related_nodes = self.get_affected_nodes(loop_in_node)
if self.bad_inner_loops(intersection):
raise Exception("Loops inside not well connected")
tree_nodes = self.id_data.nodes
do_print = loop_in_node.print_to_console
idx = 0
out_data = [[] for inp in self.inputs[2:]]
do_update(intersection[:-1], tree_nodes)
self.append_data(out_data)
for item_params in zip(*params):
if idx == 0:
idx += 1
continue
for j, data in enumerate(item_params):
loop_in_node.outputs[j + 3].sv_set([data])
loop_in_node.outputs['Loop Number'].sv_set([[idx]])
idx += 1
if do_print:
print(f"Looping Object Number {idx}")
process_looped_nodes(intersection[1:-1], tree_nodes, 'Element',
idx)
self.append_data(out_data)
for inp, outp in zip(out_data, self.outputs):
outp.sv_set(inp)
do_update(related_nodes, self.id_data.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 evaluate_fitness(self, tree, update_list, node):
try:
tree.sv_process = False
for gen_data, agent_gene in zip(self.genes_def, self.genes):
if isinstance(gen_data, GeneList):
set_list_node(gen_data, agent_gene, tree)
else:
if gen_data.g_type == 'float':
tree.nodes[gen_data.name].float_ = agent_gene
else:
tree.nodes[gen_data.name].int_ = agent_gene
tree.sv_process = True
do_update(update_list, tree.nodes)
agent_fitness = node.inputs[0].sv_get(deepcopy=False)[0]
if isinstance(agent_fitness, list):
agent_fitness = agent_fitness[0]
self.fitness = agent_fitness
finally:
tree.sv_process = True
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")
