-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathneural_network_lab.py
183 lines (161 loc) · 7.02 KB
/
neural_network_lab.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
import random
global_activate_id = 1
class Node:
def __init__(self, node_id, activate_id, specialty):
self.state = 0
self.id = node_id
self.specialty = specialty
self.fired = False
self.from_synapses_id = []
# self.const = random.random()
# if random.random() > 0.5:
# self.const = -self.const
if activate_id == 0:
self.activate = self.relu
elif activate_id == 1:
self.activate = self.default
def __str__(self):
return str(self.__class__) + ": " + str(self.__dict__)
def relu(self, x):
if x < 0:
return 0
else:
return x
def default(self, x):
return x
class Synapse:
def __init__(self, synapse_id, from_node_id, to_node_id, weight, enabled=True):
self.id = synapse_id
self.weight = weight
self.from_node_id = from_node_id
self.to_node_id = to_node_id
self.enabled = enabled
def __str__(self):
return str(self.__class__) + ": " + str(self.__dict__)
class Network:
def __init__(self, network_id, num_sensory, num_effector):
self.id = network_id
self.species = 0
self.num_sensory = num_sensory
self.num_effector = num_effector
self.node_genes = {}
self.effector_nodes_id = []
self.sensory_nodes_id = []
# self.control_nodes_id = []
self.synapse_genes = {}
self.next_node_id = 0
self.ranking = -1
self.mutation_history = []
# add control nodes
# for x in range(0, 2):
# activate_id = 0
# node = Node(self.next_node_id, activate_id, "control")
# self.node_genes[node.id] = node
# self.control_nodes_id.append(node.id)
# self.next_node_id += 1
# add sensory nodes
for x in range(0, num_sensory):
activate_id = global_activate_id
node = Node(self.next_node_id, activate_id, "sensory")
self.node_genes[node.id] = node
self.sensory_nodes_id.append(node.id)
self.next_node_id += 1
# add effector nodes
for x in range(0, num_effector):
activate_id = global_activate_id
node = Node(self.next_node_id, activate_id, "effector")
self.node_genes[node.id] = node
self.effector_nodes_id.append(node.id)
self.next_node_id += 1
def __str__(self):
return str(self.__class__) + ": " + str(self.__dict__)
@staticmethod
def generate_weight():
weight = round(random.random(), 2)
if random.random() > 0.5:
weight = -weight
return weight
def mutate(self, innov_num):
node_add_chance = 0.1
synapse_build_chance = 0.3
synapse_remove_chance = 0.01
synapse_edit_chance = 0.3
if random.random() <= node_add_chance and self.synapse_genes:
self.add_node(innov_num)
innov_num += 2
self.mutation_history.append("add_node")
if random.random() <= synapse_build_chance:
from_node_id = random.choice(list(self.node_genes.keys()))
to_node_id = random.choice(list(self.node_genes.keys()))
if from_node_id != to_node_id and \
self.node_genes[from_node_id].specialty != "effector" and \
self.node_genes[to_node_id].specialty != "sensory":
self.build_synapse(innov_num, from_node_id, to_node_id, self.generate_weight())
self.mutation_history.append("build_synapse")
innov_num += 1
if random.random() <= synapse_edit_chance and self.synapse_genes:
synapse_id = random.choice(list(self.synapse_genes.keys()))
self.edit_synapse(synapse_id)
self.mutation_history.append("edit_synapse")
if random.random() <= synapse_remove_chance and self.synapse_genes:
synapse_id = random.choice(list(self.synapse_genes.keys()))
self.disable_synapse(synapse_id)
self.mutation_history.append("disable_synapse")
return innov_num
def build_synapse(self, innov_num, from_node_id, to_node_id, weight, enabled=True):
new_synapse = Synapse(innov_num, from_node_id, to_node_id, weight, enabled)
self.synapse_genes[new_synapse.id] = new_synapse
self.node_genes[to_node_id].from_synapses_id.append(new_synapse.id)
return 0
def edit_synapse(self, synapse_id):
self.synapse_genes[synapse_id].weight = self.generate_weight()
return 0
def disable_synapse(self, synapse_id):
self.synapse_genes[synapse_id].enabled = False
def build_node(self, node_id):
activate_id = global_activate_id
node = Node(node_id, activate_id, "inter")
self.node_genes[node_id] = node
return node
def add_node(self, innov_num):
synapse_id = random.choice(list(self.synapse_genes.keys()))
synapse = self.synapse_genes[synapse_id]
node = self.build_node(self.next_node_id)
self.build_synapse(innov_num, synapse.from_node_id, node.id, synapse.weight)
self.build_synapse(innov_num+1, node.id, synapse.to_node_id, synapse.weight)
self.disable_synapse(synapse_id)
self.next_node_id += 1
return 0
def update_node(self, node_id):
# if loops back to this node, return old state, acting as a memory
if (len(self.node_genes[node_id].from_synapses_id) == 0
# or self.node_genes[node_id].specialty == "control"
or self.node_genes[node_id].fired):
return self.node_genes[node_id].state
new_state = 0
self.node_genes[node_id].fired = True
for synapse_id in self.node_genes[node_id].from_synapses_id:
if self.synapse_genes[synapse_id].enabled:
synapse = self.synapse_genes[synapse_id]
new_state += synapse.weight * self.update_node(synapse.from_node_id)
self.node_genes[node_id].state = self.node_genes[node_id].activate(new_state)
return self.node_genes[node_id].state
def think(self, sense):
for node_id, node in self.node_genes.items():
node.fired = False
# if len(self.control_nodes_id) > 0:
# self.node_genes[0].state = 0
# if len(self.control_nodes_id) > 1:
# self.node_genes[1].state = 1
sense_counter = 0
for x in self.sensory_nodes_id:
self.node_genes[x].fired = True
self.node_genes[x].state = sense[sense_counter]
sense_counter += 1
response = [0] * self.num_effector
response_counter = 0
for effector_id in self.effector_nodes_id:
self.update_node(effector_id)
response[response_counter] = self.node_genes[effector_id].state
response_counter += 1
return response