def no_con_last_layer(DNA, max=None):
if DNA:
g = Fun.DNA2graph(DNA)
node = g.key2node.get(Fun.num_layers(DNA) - 1)
if len(node.parents) == 1:
return DNA
else:
return False
def node2obs(self, space, node):
creator = self.observation_creator
weight = Funct.node2num_particles(node)
path = list(Funct.node2direction(node))
path[0] = path[0] - self.center
num_conv_layers = len(
[0 for layer in space.node2key(node) if layer[0] == 0])
return creator(num_layer=num_conv_layers, path=path, weight=weight)
def update_from_select_nm(self):
phase_space = self.phase_space
creator = self.Creator
selector = self.Selector
version = self.version
phase_space.time = phase_space.time + 1
list_particles = [
phase_space.node2particles(node) for node in phase_space.objects
]
print("particles: ", list_particles)
node_max = node_max_particles(phase_space)
p_m = Funct.node2num_particles(node_max)
node_c = phase_space.key2node(phase_space.DNA_graph.center)
p_c = Funct.node2num_particles(node_c)
print(f'The value of p_m is : {p_m} and pc is : {p_c} ')
if (p_m > p_c * 2):
phase_space.time = 0
num_particles = phase_space.num_particles
old_graph = phase_space.DNA_graph
old_center = old_graph.center
condition = old_graph.condition
typos = old_graph.typos
#node_max = phase_space.node_max_particles
node_max = node_max_particles(phase_space)
print("node_max particles:", Funct.node2num_particles(node_max))
center = phase_space.node2key(node_max)
status = phase_space.status
Alai = status.Alai
stream = phase_space.stream
delta = stream.key2len_hist(center)
Alai.update(delta)
stream.signals_off()
stream.key2signal_on(center)
stream.clear()
selector.update(center)
actions = selector.get_predicted_actions()
x = old_graph.x_dim
y = old_graph.y_dim
space = DNA_Graph(center,
1, (x, y),
condition,
actions,
version,
creator,
selector=selector,
num_morphisms=5)
phase_space.DNA_graph = space
phase_space.objects = space.objects
phase_space.support = []
phase_space.create_particles(num_particles + 1)
phase_space.attach_balls()
phase_space.max_changed = False
phase_space.node_max_particles = None
self.space = space
self.phase_space = phase_space
self.objects = phase_space.objects
self.support = phase_space.support
self.Graph = phase_space.DNA_graph
def update_current_path(self,space, new_center):
if not isinstance(space, tuple) and new_center is not None:
node_nc = space.key2node(new_center)
absolute_direction = Funct.node2direction(node_nc)
relative_direction = Funct.absolute2relative(direction=absolute_direction, last_layer=self.last_mutated_layer,
max_layers=self.max_layers_condition)
self.current_path.path.append(relative_direction)
self.current_path.absolute_path.append(absolute_direction)
if len(self.current_path.path)>self.max_path_size:
self.current_path.path.pop(0)
self.current_path.absolute_path.pop(0)
def __run_predict(self):
if self.observations is not None and len(self.observations) > 0:
input_predict = self.converter.generate_LSTM_predict(observation=self.current_path)
print("path to predict: ", self.current_path.path)
print(input_predict.size())
top_directions = len(self.observations) // 2
predicted_tensor = self.net.predict(x=input_predict)
predicted_relative_directions = self.converter.topK_predicted_directions(predicted_tensor=predicted_tensor, k=len(self.observations))
print("relative predicted: ", predicted_relative_directions)
predicted_absolute_directions = []
for relative_direction in predicted_relative_directions:
absolute_direction = Funct.relative2absolute(direction=relative_direction, last_layer=self.last_mutated_layer,
max_layers=self.max_layers_condition)
predicted_absolute_directions.append(absolute_direction)
for direction in predicted_absolute_directions:
layer = direction[0]
mutation = direction[1]
direction_accepted = self.verify_direction(layer=layer, mutation=mutation)
if direction_accepted == True:
self.predicted_actions.append( (layer,mutation) )
if len(self.predicted_actions) >= top_directions:
break
print("predicted by lstm: ", self.predicted_actions)
def __addLayer_convex(self, mutation):
graph_dna = Funct.DNA2graph(self.center_key)
parent_layers = []
acum_parents = 0
acum_history = []
for layer_index in range(self.current_num_layer):
node = graph_dna.key2node.get(layer_index)
parents = len(node.parents)
parent_layers.append(parents)
acum_parents += parents
acum_history.append(acum_parents)
factor = random.randint(0, sum(parent_layers))
selected_index = -1
for i in range(len(acum_history)):
if factor <= acum_history[i]:
selected_index = i
break
direction_accepted = self.verify_direction(layer=selected_index, mutation=self.mutations[mutation])
if direction_accepted == True:
self.predicted_actions.append( (selected_index, self.mutations[mutation]) )
def update_current_center(self, space=None, new_center=None):
if not (type(space)) is tuple:
node_nc = space.key2node(new_center)
if not (new_center == space.center):
direction = Funct.node2direction(node_nc)
if direction[1] == (1, 0, 0, 0):
self.center = self.center + 1
elif direction[1] == (-1, 0, 0, 0):
self.center = self.center - 1
if self.observations:
node_new_c = space.graph.node2key
lef_weight = sum([
observation.weight for observation in self.observations
if observation.path[0] < 0
])
right_weight = sum([
observation.weight for observation in self.observations
if observation.path[0] > 0
])
center_weight = sum([
observation.weight for observation in self.observations
if observation.path[0] == 0
])
if center_weight > max(lef_weight, center_weight):
pass
elif right_weight > lef_weight:
self.center = self.center + 1
elif right_weight < lef_weight:
self.center = self.center - 1
def update_from_select_Alai(self):
phase_space = self.phase_space
creator = self.Creator
selector = self.Selector
version = self.version
phase_space.time = phase_space.time + 1
node_max = node_max_particles(phase_space)
node_c = phase_space.key2node(phase_space.DNA_graph.center)
p_c = Funct.node2num_particles(node_c)
p_m = Funct.node2num_particles(node_max)
print(f'The value of p_m is : {p_m} and p_c is : {p_c} ')
if (p_m > p_c * 2) or (phase_space.time > 4000):
phase_space.time = 0
num_particles = phase_space.num_particles
old_graph = phase_space.DNA_graph
old_center = old_graph.center
condition = old_graph.condition
typos = old_graph.typos
node_max = phase_space.node_max_particles
center = phase_space.node2key(node_max)
selector.update(old_graph, new_center=center)
actions = selector.get_predicted_actions()
x = old_graph.x_dim
y = old_graph.y_dim
space = DNA_Graph(center, 1, (x, y), condition, actions, version,
creator)
phase_space.DNA_graph = space
phase_space.objects = space.objects
phase_space.support = []
phase_space.create_particles(num_particles + 1)
phase_space.stream.signals_off()
phase_space.attach_balls()
phase_space.max_changed = False
phase_space.node_max_particles = None
self.space = space
self.phase_space = phase_space
self.objects = phase_space.objects
self.support = phase_space.support
self.Graph = phase_space.DNA_graph
elif False:
#elif phase_space.time>self.clear_period:
phase_space.time = 0
node2remove = phase_space2node2remove(phase_space)
node_c = phase_space.key2node(phase_space.DNA_graph.center)
if node2remove and not (node2remove == node_c):
remove_node(phase_space, node2remove)
new_DNA = add_node(phase_space, selector)
def no_con_image(DNA, max=None):
if DNA:
g = Fun.DNA2graph(DNA)
node = g.key2node.get(-1)
if len(node.kids) == 1:
return DNA
else:
return False
def con_image(DNA, max=None):
if DNA:
g = Fun.DNA2graph(DNA)
condition = all(
[node_con_image(g, node) for node in list(g.key2node.values())])
if condition:
return DNA
else:
return None
def add_node(phase_space, Selector, particles=0):
center = phase_space.center()
DNA_graph = phase_space.DNA_graph
graph = DNA_graph.graph
keys = list(graph.node2key.values())
new_DNA = None
while (new_DNA in keys) or new_DNA == None:
new_DNA = Selector.DNA2new_DNA(center)
actions = Selector.get_predicted_actions()
direction = tuple(actions[0])
Funct.add_node(graph, new_DNA)
graph.add_edges(center, [new_DNA])
new_node = phase_space.key2node(new_DNA)
DNA_graph.objects.append(new_node)
p = Funct.node2plane(new_node)
p.direction = direction
return new_DNA
def max_parents(DNA, max):
if DNA:
g = Fun.DNA2graph(DNA)
if all([
len(node.parents) < max + 1
for node in list(g.key2node.values())
]):
return DNA
else:
return False
def update_from_select_stochastic(self):
phase_space = self.phase_space
creator = self.Creator
selector = self.Selector
version = self.version
phase_space.time = phase_space.time + 1
p = randint(0, 300)
if phase_space.node_max_particles:
node_max = phase_space.node_max_particles
node_c = phase_space.key2node(phase_space.DNA_graph.center)
p_c = Funct.node2num_particles(node_c)
p_m = Funct.node2num_particles(node_max)
if (phase_space.max_changed
and p_m * 0.9 > p_c) or (phase_space.time > 4000):
phase_space.time = 0
num_particles = phase_space.num_particles
old_graph = phase_space.DNA_graph
old_center = old_graph.center
condition = old_graph.condition
typos = old_graph.typos
node_max = phase_space.node_max_particles
center = phase_space.node2key(node_max)
selector.update(old_graph, new_center=center)
actions = selector.get_predicted_actions()
x = old_graph.x_dim
y = old_graph.y_dim
space = DNA_Graph(center, 1, (x, y), condition, actions, version,
creator)
phase_space.DNA_graph = space
phase_space.objects = space.objects
phase_space.support = []
phase_space.create_particles(num_particles + 1)
phase_space.stream.signals_off()
phase_space.attach_balls()
phase_space.max_changed = False
phase_space.node_max_particles = None
self.space = space
self.phase_space = phase_space
self.objects = phase_space.objects
self.support = phase_space.support
self.Graph = phase_space.DNA_graph
def register_observations(self,space,new_center=None):
creator=self.observation_creator
if type(space) is tuple:
num_conv_layers = len([0 for layer in space if
layer[0] == 0])
self.current_num_layer=num_conv_layers
if new_center:
self.center_key=new_center
else:
self.center_key=space
else:
if new_center:
self.center_key=new_center
else:
self.center_key=space.center
center=space.center
self.current_num_layer=len([0 for layer in new_center if
layer[0] == 0])
node_c=space.key2node(center)
self.observations = []
weight_array = []
i = 0
for node in node_c.kids:
if Funct.node2energy(node) > 0:
weight_array.append(Funct.node2energy(node)*10)
weight_array = Funct.normalize(dataset=weight_array)
for node in node_c.kids:
if Funct.node2energy(node) > 0:
observation_path = []
for direction in self.current_path.path:
observation_path.append(direction)
absolute_direction = Funct.node2direction(node)
relative_direction = Funct.absolute2relative(direction=absolute_direction, last_layer=self.last_mutated_layer,
max_layers=self.max_layers_condition)
observation_path.append(relative_direction)
if len(observation_path) > self.max_observation_size:
observation_path.pop(0)
observation = self.observation_creator(path=observation_path, weight=weight_array[i])
self.observations.append(observation)
i += 1
def register_observations(self, space, new_center=None):
creator = self.observation_creator
if type(space) is tuple:
num_conv_layers = len([0 for layer in space if layer[0] == 0])
self.current_num_layer = num_conv_layers
if new_center:
self.center_key = new_center
else:
self.center_key = space
else:
if new_center:
self.center_key = new_center
else:
self.center_key = space.center
center = space.center
self.current_num_layer = len(
[0 for layer in new_center if layer[0] == 0])
node_c = space.key2node(center)
self.observations = (self.observations + [
self.node2obs(space, node)
for node in node_c.kids if Funct.node2num_particles(node) > 0
])
def test():
observation_size = 3
max_layers_lstm = 5 * 2
num_actions = 4
mutations = ((0, 1, 0, 0), (0, -1, 0, 0), (0, 0, 1, 1), (0, 0, -1, -1))
directions_per_observations = [[(1, (0, 1, 0, 0)), (2, (0, -1, 0, 0)),
(0, (0, 1, 0, 0))],
[(1, (0, 1, 0, 0)), (2, (0, -1, 0, 0)),
(0, (0, 0, 1, 1))],
[(1, (0, 1, 0, 0)), (2, (0, -1, 0, 0)),
(0, (0, -1, 0, 0))],
[(1, (0, 1, 0, 0)), (2, (0, -1, 0, 0)),
(0, (0, 0, -1, -1))]]
#observations_weight = [getLoss(0.4525), getLoss(0.4520), getLoss(0.4145), getLoss(0.4220)]
observations_weight = [0.5142 * 10, 0.4821 * 10, 0.4680 * 10, 0.4734 * 10]
observations_weight = Funct.normalize(dataset=observations_weight)
print("weight: ", observations_weight)
lstmConverter = LSTMConverter.LSTMConverter(
cuda=True,
max_layers=max_layers_lstm,
mutation_list=mutations,
limit_directions=observation_size)
observations = []
for i in range(num_actions):
observation = Observation.Observation(
path=directions_per_observations[i],
weight=observations_weight[i],
time=0)
print("observation: ", i)
print("path: ", observation.path)
print("weight: ", observation.weight)
observations.append(observation)
input_lstm = lstmConverter.generate_LSTM_input(observations=observations)
print("input size: ", input_lstm.size())
current_path = Observation.Observation(path=[(1, (0, 1, 0, 0)),
(2, (0, -1, 0, 0))],
weight=1,
time=0)
network = nw_lstm.NetworkLSTM(observation_size=observation_size,
in_channels=max_layers_lstm,
out_channels=max_layers_lstm *
lstmConverter.mutations,
kernel_size=lstmConverter.mutations,
cuda_flag=True)
print("empezando entrenamiento")
network.Training(data=input_lstm,
dt=0.001,
p=5000,
observations=observations)
print("entrenamiento finalizado")
predict = lstmConverter.generate_LSTM_predict(observation=current_path)
predicted = network.predict(predict)
print("ht: ")
print(predicted)
predicted_directions = lstmConverter.topK_predicted_directions(
predicted_tensor=predicted, k=num_actions // 2)
print(predicted_directions)
i += 1
def is_convex(DNA, index):
g = Fun.DNA2graph(DNA)
node = g.key2node.get(index)
output = node.objects[0][1] == max(
[node.objects[0][2] for node in node.parents])
return output