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_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 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")