def _initialize_hidden_layers(self, neural_network):
"""Initializes hidden layers, based on defined number of layers."""
number_of_layers = randint(self.init_minimum_layers, self.layers)
""" -1 here (two lines) """
neurons_per_layer = [
randint(1, self.init_maximum_neurons_per_layer)
for _ in range(number_of_layers - 1)
]
hidden_layers = [[
create_neuron(None,
neural_network.bias,
maximum_bias_connection_weight=self.
maximum_bias_connection_weight)
for _ in range(neurons_per_layer[layer])
] for layer in range(number_of_layers - 1)]
# From Jan: Create hidden layers with one neuron with random activation function each.
# hidden_layers = [[create_neuron(None, neural_network.bias)] for i in range(self.layers - 1)]
# Add final hidden layer with one neuron
activation_function = choice(
list(_NON_LINEAR_ACTIVATION_FUNCTIONS.keys()))
hidden_layers.append([
create_neuron(activation_function,
neural_network.bias,
maximum_bias_connection_weight=self.
maximum_bias_connection_weight)
])
# Returns hidden layers.
return hidden_layers
def _initialize_hidden_layers(self, neural_network):
"""Initializes hidden layers, based on defined number of layers."""
# Create hidden layers with one neuron with random activation function each.
hidden_layers = [[create_neuron(None, neural_network.bias)]
for i in range(self.layers - 1)]
# Add final hidden layer with one neuron with tanh activation function.
hidden_layers.append([create_neuron('tanh', neural_network.bias)])
# Returns hidden layers.
return hidden_layers
def mutate_network(self, algorithm):
neural_network = algorithm.champion.neural_network
bias = neural_network.bias
hidden_layers = [[create_neuron(activation_function=None, bias=bias)]
for i in range(len(neural_network.hidden_layers) - 1)]
hidden_layers.append([self._create_final_hidden_neuron(bias)])
return hidden_layers
def mutate_network(self, algorithm):
neural_network = algorithm.champion.neural_network
bias = neural_network.bias
number_layers = len(neural_network.hidden_layers)
""" -1 here """
new_neurons = [
randint(1, self.maximum_new_neurons_per_layer)
for _ in range(number_layers - 1)
]
# neurons = self.maximum_new_neurons_per_layer if self.maximum_new_neurons_per_layer >= number_layers else number_layers
# neurons = sample(range(1, neurons), number_layers - 1)
hidden_layers = [[
create_neuron(activation_function=None,
bias=bias,
maximum_bias_connection_weight=self.
maximum_bias_connection_weight)
for _ in range(neuron)
] for neuron in new_neurons]
hidden_layers.append([
self._create_final_hidden_neuron(
bias,
maximum_bias_connection_weight=self.
maximum_bias_connection_weight)
])
return hidden_layers
def mutate_network(self, algorithm):
neural_network = algorithm.champion.neural_network
bias = neural_network.bias
number_cnn_layers = len(neural_network.cnn_layers)
number_hidden_layers = len(neural_network.hidden_layers)
""" -1 here """
new_neurons = [
randint(1, self.maximum_new_neurons_per_layer)
for _ in range(number_hidden_layers - 1)
]
new_cnn_neurons = [
randint(1, self.maximum_new_cnn_neurons_per_layer)
for _ in range(number_cnn_layers)
]
# new_hidden_neurons = [randint(1, self.maximum_new_cnn_neurons_per_layer) for i in range(number_hidden_layers - 1)]
cnn_layers = [[
create_cnn_neuron(activation_function=None) for _ in range(neuron)
] for neuron in new_cnn_neurons]
# hidden_layers = [[create_neuron(activation_function=None) for i in range(neuron)] for neuron in new_hidden_neurons]
hidden_layers = [[
create_neuron(activation_function=None,
bias=bias,
maximum_bias_connection_weight=self.
maximum_bias_connection_weight)
for _ in range(neuron)
] for neuron in new_neurons]
return cnn_layers, hidden_layers
def _initialize_neural_network(self, topology):
"""Creates neural network from initial topology."""
# Create shallow copy of topology.
neural_network = copy(topology)
# Create output neuron.
neural_network.output_neuron = create_neuron('identity', None)
# Create hidden layer.
neural_network.hidden_layers = self._initialize_hidden_layers(
neural_network)
# Establish connections
self._connect_nodes(neural_network.sensors,
neural_network.hidden_layers[0],
random=True)
previous_neurons = neural_network.hidden_layers[0]
for hidden_layer in neural_network.hidden_layers[1:]:
self._connect_nodes(previous_neurons, hidden_layer, random=False)
previous_neurons = hidden_layer
# Calculate hidden neurons.
for layer in neural_network.hidden_layers:
for neuron in layer:
neuron.calculate()
# Connect last neuron to output neuron with learning step.
self._connect_learning_step(neural_network)
# Calculate output semantics.
neural_network.output_neuron.calculate()
# Return neural network.
return neural_network
def mutate_network(self, algorithm):
neural_network = algorithm.champion.neural_network
bias = neural_network.bias
neurons = randint(1, self.max_neurons)
hidden_layers = [[create_neuron() for i in range(neurons)]
for j in range(len(neural_network.hidden_layers) - 1)]
hidden_layers.append([self._create_final_hidden_neuron(bias)])
return hidden_layers
def mutate_network(self, algorithm):
neural_network = algorithm.champion.neural_network
bias = neural_network.bias
number_layers = len(neural_network.hidden_layers)
neurons = self.max_neurons if self.max_neurons >= number_layers else number_layers
neurons = sample(range(1, neurons), number_layers - 1)
hidden_layers = [[create_neuron() for i in range(neuron)]
for neuron in neurons]
hidden_layers.append([self._create_final_hidden_neuron(bias)])
return hidden_layers
def _create_final_hidden_neuron(self,
bias,
maximum_bias_connection_weight=None):
""" Creates the final hidden neuron """
activation_function = choice(
list(_NON_LINEAR_ACTIVATION_FUNCTIONS.keys()))
return create_neuron(
activation_function,
bias,
maximum_bias_connection_weight=maximum_bias_connection_weight)
def mutate_network(self,
algorithm,
last_hidden_layer_neurons=50,
conv_prob=0.9):
neural_network = algorithm.champion.neural_network
bias = neural_network.bias
number_cnn_layers = len(neural_network.cnn_layers)
number_hidden_layers = len(neural_network.hidden_layers)
new_cnn_neurons = [
randint(1, self.maximum_new_cnn_neurons_per_layer)
for _ in range(number_cnn_layers)
]
#=======================================================================
# isAllEmpty = False
# while isAllEmpty == False:
# lower_range = 0
# new_cnn_neurons = []
# for i in range(number_cnn_layers):
# neurons = randint(lower_range, self.maximum_new_cnn_neurons_per_layer)
# if neurons > 0:
# lower_range = 1
# new_cnn_neurons.append(neurons)
# isAllEmpty = any(i > 0 for i in new_cnn_neurons)
#=======================================================================
new_neurons = [
randint(1, self.maximum_new_neurons_per_layer)
for _ in range(number_hidden_layers - 1)
]
new_neurons.append(last_hidden_layer_neurons)
# new_cnn_neurons = [randint(1, self.maximum_new_cnn_neurons_per_layer) for i in range(number_cnn_layers)]
# new_hidden_neurons = [randint(1, self.maximum_new_cnn_neurons_per_layer) for i in range(number_hidden_layers - 1)]
cnn_layers = [[
create_cnn_neuron(activation_function=None, conv_prob=conv_prob)
for _ in range(neuron)
] for neuron in new_cnn_neurons]
# hidden_layers = [[create_neuron(activation_function=None) for i in range(neuron)] for neuron in new_hidden_neurons]
hidden_layers = [[
create_neuron(activation_function=None,
bias=bias,
maximum_bias_connection_weight=self.
maximum_bias_connection_weight)
for _ in range(neuron)
] for neuron in new_neurons]
return cnn_layers, hidden_layers
def _create_final_hidden_neuron(self, bias):
"""Creates the final hidden neuron, which must have a hyperbolic tangent activation function."""
return create_neuron('tanh', bias)
