def update(self, orig_geom=None, inputs=None):
if orig_geom is not None:
self.orig_geom = orig_geom
if inputs is not None:
self.inputs = inputs
for name in self.graph.nodes():
self.graph.node[name]["evaluated"] = False # flag all nodes as unevaluated
self.set_input_node_states(self.inputs) # reset the inputs
for name in self.output_node_names:
self.graph.node[name]["state"] = 0.0 # clear old outputs
self.graph.node[name]["state"] = self.calc_node_state(name) # calculate new outputs
loc = [0, 0, 0]
for n, name in enumerate(self.output_node_names[:3]):
loc[n] = self.size[n] * (0.5*self.graph.node[name]["state"] + 0.5)
# print self.size
# print "loc: ", loc
# new geometry: just a single patch different from original geometry
self.values, _ = add_patch(self.orig_geom, loc=loc, mat=self.patch_mat)
def mutate(self, rate=None):
if self.patch_mode:
self.values, sub_vox_dict = add_patch(self.values)
for parent, child in sub_vox_dict.items():
self.sub_vox_dict[parent] = [child]
return "patched", 1
else:
if rate is None:
rate = self.p
scale = self.scale
if self.scale is None:
scale = np.abs(1 / self.values)
# scale = np.clip(self.values**0.5, self.start_value**0.5, self.upper_bound)
# this was for meta mutations
selection = np.random.random(self.size) < rate
selection = np.logical_and(selection, self.mutable_vox)
if self.vox_options is not None:
change = np.random.choice(self.vox_options, self.size)
self.values[selection] = change[selection]
else:
change = np.random.normal(scale=scale, size=self.size)
self.values[selection] += change[selection]
self.values = np.clip(self.values, self.lower_bound,
self.upper_bound)
self.enforce_symmetry()
self.regulate_sub_voxels()
if self.func is not None:
self.values = self.func(self.values)
return "gaussian", self.scale
def update(self, orig_geom=None, inputs=None, loc=None):
if loc is not None:
self.values, _ = add_patch(orig_geom, loc=loc, mat=self.patch_mat)
return
if orig_geom is not None:
self.orig_geom = orig_geom
if self.already_patched or self.freeze:
self.values = self.orig_geom
return
if inputs is not None:
self.input_layer = inputs + [1.0]*self.has_input_bias
# track weight index
w = 0
if len(self.hidden_layer) > 0:
# hidden layer
new_hidden_layer = [0]*(len(self.hidden_layer) - self.has_hidden_bias)
for h in range(len(new_hidden_layer)):
for i in range(len(self.input_layer)):
new_hidden_layer[h] += self.input_layer[i] * self.weights[w]
w += 1
self.hidden_layer = list(np.tanh(new_hidden_layer)) + [1.0]*self.has_hidden_bias
# output layer
new_output_layer = [0]*len(self.output_layer)
for o in range(len(new_output_layer)):
for h in range(len(self.hidden_layer)):
new_output_layer[o] += self.hidden_layer[h] * self.weights[w]
w += 1
self.output_layer = np.tanh(new_output_layer)
elif self.evo_strategies:
self.output_layer = self.weights
else: # no hidden layer input goes straight to output
# output layer
new_output_layer = [0]*len(self.output_layer)
for o in range(len(new_output_layer)):
for i in range(len(self.input_layer)):
new_output_layer[o] += self.input_layer[i] * self.weights[w]
w += 1
self.output_layer = np.tanh(new_output_layer)
shifted_output = 0.5*self.output_layer+0.5
# if self.evo_strategies:
# w = 3
# shifted_output = 0.5*shifted_output+0.2
#
# if self.input_layer[0] == 0:
# shifted_output[0] = 1-(shifted_output[0]+0.1)
# shifted_output[1] = 1-(shifted_output[1]+0.1)
#
# if self.input_layer[0] == 1:
# shifted_output[0] = 1-(shifted_output[0]+0.1)
#
# if self.input_layer[0] == 2:
# shifted_output[1] = 1-(shifted_output[1]+0.1)
loc = [0, 0, 0]
for i in range(3):
loc[i] = self.size[i]*shifted_output[i]
# new geometry: just a single patch different from original geometry
self.values, _ = add_patch(self.orig_geom, loc=loc, mat=self.patch_mat)
if w < len(self.weights):
n = len(self.weights) - w
print "only need the first {0} weights (deleting the extra {1})".format(w, n)
self.weights = self.weights[:w]