def annBreeding(self, mom, dad):
child = Ann()
momScore = mom.highScore
dadScore = dad.highScore
total = momScore + dadScore
parents = [mom, dad] #parents in array for easier indexing
#choosing fittest parents, so they pass their genes more often
if momScore > dadScore:
percent = momScore/total
fittest = 0
notFit = 1
else:
percent = dadScore/total
fittest = 1
notFit = 0
for i in range(0, len(mom.data) - 1): #iterate through layers
for j in range(0, len(mom.data[i])): #iterate through neurons
chance = random.uniform(0, 1); #which parent to get genne from
if chance < percent:
child.data[i][j] = parents[fittest].data[i][j]
else:
child.data[i][j] = parents[notFit].data[i][j]
return child
def annBreeding(self, mom, dad):
child = Ann()
momScore = mom.highScore
dadScore = dad.highScore
#print "momScore: ", momScore, " and dadScore: ", dadScore
momScore += 651 #avoid dbz error
dadScore += 651
total = momScore + dadScore
parents = [mom, dad] #parents in array for easier indexing
#choosing fittest parents, so they pass their genes more often
if momScore > dadScore:
percent = momScore / total
fittest = 0
notFit = 1
else:
percent = dadScore / total
fittest = 1
notFit = 0
#TODO try swapping weights instead of entire neurons
for i in range(0, len(mom.data) - 1): #iterate through layers
for j in range(0, len(mom.data[i])): #iterate through neurons
chance = random.uniform(0, 1)
#which parent to get genne from
if chance < percent:
child.data[i][j] = parents[fittest].data[i][j]
else:
child.data[i][j] = parents[notFit].data[i][j]
return child
def run_simulation(self, environments_copy):
weights = self.prepare_weights_for_ann()
ann = Ann(weights=weights,
hidden_layers=self.hidden_layers,
activation_functions=self.activation_functions)
for j in range(len(environments_copy)):
environment = environments_copy[j]
agent = environments_copy[j].agent
for k in range(60):
agent_sensor_output = agent.sense_front_left_right(environment)
ann_inputs = [
1 if agent_sensor_output[0] == CellItem.food else 0,
1 if agent_sensor_output[1] == CellItem.food else 0,
1 if agent_sensor_output[2] == CellItem.food else 0,
1 if agent_sensor_output[0] == CellItem.poison else 0,
1 if agent_sensor_output[1] == CellItem.poison else 0,
1 if agent_sensor_output[2] == CellItem.poison else 0
]
prediction = ann.predict(inputs=ann_inputs)
best_index = prediction.argmax()
if best_index == 1:
agent.move_left()
elif best_index == 2:
agent.move_right()
agent.move_forward(environment)
def main():
test_data_set_path = '../../../Dataset/TestData/'
test_files = os.listdir(test_data_set_path)
test_files = random.sample(test_files, 10)
network = Ann()
print "=" * 20, "Test Results", "=" * 20
for each_file in test_files:
print each_file.ljust(10) + ": " + network.get_emotion(test_data_set_path + each_file)
print "=" * 54
print "Now recorded: ", network.get_emotion("/home/venkatesh/Desktop/recorded.wav")
print "Now recorded: ", network.get_emotion("/home/venkatesh/Desktop/recorded_sad.wav")
def initialize(self):
chrisMartinez = Ann()
#chrisMartinez.print()
#chrisMartinez.printLayer(3)
"""
for i in range(0, 9):
chrisMartinez.trainShit()
"""
self.data[0] = chrisMartinez
for i in range(1, ANN_COUNT):
#temp = copy.copy(chrisMartinez)
#self.mutateAnn(temp)
temp = Ann()
#temp.printAnn()
self.data[i] = temp
def __init__(self, delay, environments, ann_weights, layers_list, activation_functions,
fitness_log_average, fitness_log_best, standard_deviation_log):
tk.Tk.__init__(self)
self.delay = delay
self.flatlands = environments
self.ann = Ann(weights=ann_weights, hidden_layers=layers_list, activation_functions=activation_functions)
self.current_timestep = 0
self.max_timestep = 60
self.standard_deviation_log = standard_deviation_log
self.fitness_log_best = fitness_log_best
self.fitness_log_average = fitness_log_average
self.title("Flatland")
self.grid = {}
self.food_texts = []
self.poison_texts = []
self.step_text = None
self.cell_components = {}
self.agent_component = [[] for _ in range(len(self.flatlands))]
self.cell_size = (SCREEN_WIDTH - (max(2, len(environments) + 1)) * GRID_OFFSET) / \
(FLATLAND_WIDTH*max(2, len(environments)))
self.canvas = tk.Canvas(self, width=SCREEN_WIDTH, height=(self.cell_size + 4)*self.flatlands[0].height, background='white', borderwidth=0)
self.canvas.pack(side="top", fill="both", expand="true")
self.pause = True
self.bind('<space>', self.toggle_pause)
self.bind('<n>', self.decrease_simulation_speed)
self.bind('<m>', self.increase_simulation_speed)
self.reset_button = tk.Button(self, text="Reset board", command=self.reset_gui_with_new_environment).pack()
self.draw_text()
self.draw_board()
self.update_text()
self.draw_agents()
self.run_simulation()
def perceptron(size, weights):
"""Creates a perceptron network
"""
inputLayer = Layer(LayerType.INPUT, size[0], activation=None)
outputLayer = Layer(LayerType.OUTPUT, size[1], activation=Neuron.HEAVISIDE)
pp.pprint(weights)
inputLayer.connect(outputLayer, weights)
return Ann({'input': inputLayer, 'hidden': [], 'output': outputLayer})
def create_ann(self):
self.extract_layers()
self.extract_modules()
self.extract_links()
return Ann(self.layers, self.links, self.parse_execution_order())
def calculate_phenotype(self):
self.phenotype = Ann(FlatLandGenotype.num_inputs,
FlatLandGenotype.num_outputs)
for i in range(self.phenotype.num_edges):
j = i * FlatLandGenotype.bits_per_weight
weight = sum(self.genotype.dna[j:j +
FlatLandGenotype.bits_per_weight])
weight = 4 * float(weight) / FlatLandGenotype.bits_per_weight - 2
self.phenotype.weights[i] = weight
def initialize_agents():
agents = []
ann = Ann(name='Ann', args=('Ann', routes, routing_table, graph))
ann.daemon = True
ann.start()
agents.append(ann)
time.sleep(1)
chan = Chan(name='Chan', args=('Chan', routes, routing_table, graph))
chan.daemon = True
chan.start()
agents.append(chan)
time.sleep(1)
jan = Jan(name='Jan', args=('Jan', routes, routing_table, graph))
jan.daemon = True
jan.start()
agents.append(jan)
return agents
def multi_layer_network(size, weights):
"""Creates a 3 layer network (1 hidden)
"""
inputLayer = Layer(LayerType.INPUT, size[0], activation=None)
hiddenLayer = Layer(LayerType.HIDDEN, size[1], activation=Neuron.LOGISTIC)
outputLayer = Layer(LayerType.OUTPUT, size[2], activation=Neuron.LOGISTIC)
inputLayer.connect(hiddenLayer, weights[1])
hiddenLayer.connect(outputLayer, weights[0])
return Ann({
'input': inputLayer,
'hidden': [hiddenLayer],
'output': outputLayer
})
def run_simulation(self, environments_copy):
weights = self.prepare_weights_for_ann()
ann = Ann(weights=weights, hidden_layers=self.hidden_layers, activation_functions=self.activation_functions)
for j in range(len(environments_copy)):
environment = environments_copy[j]
agent = environments_copy[j].agent
for k in range(60):
agent_sensor_output = agent.sense_front_left_right(environment)
ann_inputs = [
1 if agent_sensor_output[0] == CellItem.food else 0,
1 if agent_sensor_output[1] == CellItem.food else 0,
1 if agent_sensor_output[2] == CellItem.food else 0,
1 if agent_sensor_output[0] == CellItem.poison else 0,
1 if agent_sensor_output[1] == CellItem.poison else 0,
1 if agent_sensor_output[2] == CellItem.poison else 0,
]
prediction = ann.predict(inputs=ann_inputs)
best_index = prediction.argmax()
if best_index == 1:
agent.move_left()
elif best_index == 2:
agent.move_right()
agent.move_forward(environment)
def deep_network(size, weights):
"""Creates a 5 layer network (3 hidden)
"""
inputLayer = Layer(LayerType.INPUT, size[0], activation=None)
hiddenLayer1 = Layer(LayerType.HIDDEN, size[1], activation=Neuron.LOGISTIC)
hiddenLayer2 = Layer(LayerType.HIDDEN, size[2], activation=Neuron.LOGISTIC)
hiddenLayer3 = Layer(LayerType.HIDDEN, size[3], activation=Neuron.LOGISTIC)
outputLayer = Layer(LayerType.OUTPUT, size[4], activation=Neuron.LOGISTIC)
inputLayer.connect(hiddenLayer1, weights[3])
hiddenLayer1.connect(hiddenLayer2, weights[2])
hiddenLayer2.connect(hiddenLayer3, weights[1])
hiddenLayer3.connect(outputLayer, weights[0])
return Ann({
'input': inputLayer,
'hidden': [hiddenLayer1, hiddenLayer2, hiddenLayer3],
'output': outputLayer
})
def mains():
# for ann - load the path weights ..
file_r = open('data/min_error_weights.pkl', 'r')
ann_weights = pickle.load(file_r)
file_r.close()
hidden_weights = ann_weights[0]
output_weights = ann_weights[1]
ann_obj = Ann(1, parameters.no_of_hidden, 4)
i = 0
for hnode in ann_obj.hidden_nodes:
j = 0
for w in hnode.weights:
hnode.weights[j] = hidden_weights[i]
i += 1
j += 1
i = 0
for onode in ann_obj.output_nodes:
j = 0
for w in onode.weights:
onode.weights[j] = output_weights[i]
i += 1
j += 1
# prediction model starts ..
obj = pmodel()
obj_p = p_clustering(parameters.no_of_clusters, parameters.dimensionality)
time = 3
train_status = obj.initial_model()
print "\n..Clusters trained. Real Time handling of data started"
obj_p.prepare_fclusters(obj.cluster_info, time)
ch = 'y'
while ch == 'y':
obj.real_time_handle(obj_p, time, ann_obj, train_status)
ch = raw_input("\n..Want to continue ? (y/n) : ")
time += 1
train_status = False
print '\n..Exiting'
arg_parser.add_argument(
'-g',
'--generation',
dest='generation',
help=
'If dynamic mode, this specifies which generation to pick board(s) from',
type=int,
required=False,
default=0)
args = arg_parser.parse_args()
with open('best_individual.json') as best_agent_weights:
weights = json.load(best_agent_weights)
a = Ann(num_inputs=6, num_outputs=3)
a.weights = weights
g = gfx.Gfx()
g.fps = 8
for i in range(args.num_scenarios):
grid_seed = i + (
(997 * args.generation) if args.mode == 'dynamic' else 0)
print 'grid_seed', grid_seed
f = Flatland(ann=a, grid_seed=grid_seed, should_visualize=True)
f.gfx = g
f.run()
print '{0} food items, {1} poison items'.format(
f.agent.num_food_consumed, f.agent.num_poison_consumed)
#!/usr/bin/python
from __future__ import print_function
from ann import Ann
flines = []
with open('optdigits_train.txt', 'r') as f:
flines = f.readlines()
data = [
[float(x) for x in line.strip().split(',')[:-1]]
for line in flines
]
answers = [line.strip().split(',')[-1] for line in flines]
nn = Ann()
for i in range(100):
print(nn.train(data, answers))
def __init__(self):
self.data = [Ann()] * ANN_COUNT
self.highScores = []
self.avgScores = []
from ann import ATOMModel, Ann
from ase.io import read
p1 = read('au55.xyz', index=0, format='xyz')
model = ATOMModel(restore='atom_model', n=55)
p1.set_calculator(Ann(atoms=p1, ann_model=model))
print p1.get_potential_energy()
print p1.get_forces()
'type': 'output'
}, {
'id': 'o2',
'x': 6,
'y': 3,
'size': 1,
'label': 'motor_right',
'type': 'output'
}]
with open('best_individual.json') as best_agent_weights:
weights = json.load(best_agent_weights)
num_inputs = 6
num_outputs = 3
a = Ann(num_inputs, num_outputs)
a.weights = weights
edges = []
i = 0
for output_index in range(num_outputs):
for input_index in range(num_inputs + 1):
idx = a.convert_2d_to_1d(input_index, output_index)
weight = a.weights[idx]
edges.append({
'id': 'e{}'.format(i),
'source': 'i{}'.format(input_index),
'target': 'o{}'.format(output_index),
'weight': weight
from ann import Ann
import operator
import random
from breeding import Breeding
loveShack = Breeding()
lovers = []
for i in range(0, 4):
lovers.append(Ann())
lovers[i].giveName("John")
score = random.uniform(0, 100)
lovers[i].setScore(score)
lovers[i].Print()
print
print "Lets Make Love!!!"
print
loveShack.getGen(lovers)
loveShack.getNextGeneration()
'_ann' + str(i))) #create new filename
currAnn.saveFile()
#currAnn.printScore()
i += 1
# stuff b/w generations
breeder.getNextGeneration()
"""
if WE_HAVE_ANN_AGENT:
poolOfAnns = breeder.data
#for NUMBER_OF_GENERATIONS
#for ann in ANN_POOL_SIZE
score = runGames( **args )
print score
else:
runGames
"""
elif sys.argv[2:3] == ['LoaderAgent']:
print 'Using file: ' + FILE_TO_BE_LOADED
temp = Ann()
temp.loadFile(FILE_TO_BE_LOADED)
args['pacman'].setAnn(temp) #set ann to the one gotten from .txt file
runGames(**args)
else:
print 'Continue as normal'
runGames(**args)
# import cProfile
# cProfile.run("runGames( **args )")
pass
class FlatlandGui(tk.Tk):
def __init__(self, delay, environments, ann_weights, layers_list, activation_functions,
fitness_log_average, fitness_log_best, standard_deviation_log):
tk.Tk.__init__(self)
self.delay = delay
self.flatlands = environments
self.ann = Ann(weights=ann_weights, hidden_layers=layers_list, activation_functions=activation_functions)
self.current_timestep = 0
self.max_timestep = 60
self.standard_deviation_log = standard_deviation_log
self.fitness_log_best = fitness_log_best
self.fitness_log_average = fitness_log_average
self.title("Flatland")
self.grid = {}
self.food_texts = []
self.poison_texts = []
self.step_text = None
self.cell_components = {}
self.agent_component = [[] for _ in range(len(self.flatlands))]
self.cell_size = (SCREEN_WIDTH - (max(2, len(environments) + 1)) * GRID_OFFSET) / \
(FLATLAND_WIDTH*max(2, len(environments)))
self.canvas = tk.Canvas(self, width=SCREEN_WIDTH, height=(self.cell_size + 4)*self.flatlands[0].height, background='white', borderwidth=0)
self.canvas.pack(side="top", fill="both", expand="true")
self.pause = True
self.bind('<space>', self.toggle_pause)
self.bind('<n>', self.decrease_simulation_speed)
self.bind('<m>', self.increase_simulation_speed)
self.reset_button = tk.Button(self, text="Reset board", command=self.reset_gui_with_new_environment).pack()
self.draw_text()
self.draw_board()
self.update_text()
self.draw_agents()
self.run_simulation()
def toggle_pause(self, event=None):
self.pause = not self.pause
def increase_simulation_speed(self, event=None):
self.delay = max(self.delay - 10, 1)
def decrease_simulation_speed(self, event=None):
self.delay += 10
def draw_board(self):
for i in range(len(self.flatlands)):
offset = (i * (FLATLAND_WIDTH * self.cell_size + GRID_OFFSET))
for y in range(FLATLAND_HEIGHT):
for x in range(FLATLAND_WIDTH):
self.grid[i, x, y] = self.canvas.create_rectangle(
x * self.cell_size + GRID_OFFSET + offset,
y * self.cell_size + GRID_OFFSET,
(x + 1) * self.cell_size + GRID_OFFSET + offset,
(y + 1) * self.cell_size + GRID_OFFSET)
if self.flatlands[i].board[y][x] == CellItem.food:
self.cell_components[i, x, y] = self.canvas.create_oval(
x * self.cell_size + GRID_OFFSET + offset,
y * self.cell_size + GRID_OFFSET,
(x + 1) * self.cell_size + GRID_OFFSET + offset,
(y + 1) * self.cell_size + GRID_OFFSET,
fill="green")
elif self.flatlands[i].board[y][x] == CellItem.poison:
self.cell_components[i, x, y] = self.canvas.create_oval(
x * self.cell_size + GRID_OFFSET + offset,
y * self.cell_size + GRID_OFFSET,
(x + 1) * self.cell_size + GRID_OFFSET + offset,
(y + 1) * self.cell_size + GRID_OFFSET,
fill="red")
def draw_text(self):
for i in range(len(self.flatlands)):
self.food_texts.append(self.canvas.create_text(
GRID_OFFSET + (i * (FLATLAND_WIDTH * self.cell_size + GRID_OFFSET)),
GRID_OFFSET + FLATLAND_HEIGHT * self.cell_size,
anchor=tk.NW))
self.poison_texts.append(self.canvas.create_text(
GRID_OFFSET + (i * (FLATLAND_WIDTH * self.cell_size + GRID_OFFSET)),
GRID_OFFSET*1.5 + FLATLAND_HEIGHT * self.cell_size,
anchor=tk.NW))
self.step_text = self.canvas.create_text(GRID_OFFSET, GRID_OFFSET/2)
def update_text(self):
for i in range(len(self.flatlands)):
self.canvas.itemconfig(self.food_texts[i], text="Food eaten:" +
str(self.flatlands[i].agent.food_eaten) + "/" +
str(self.flatlands[i].food_count))
self.canvas.itemconfig(self.poison_texts[i], text="Poison eaten:" +
str(self.flatlands[i].agent.poison_eaten) + "/" +
str(self.flatlands[i].poison_count))
self.canvas.itemconfig(self.step_text, text="Step: " + str(self.current_timestep + 1))
def draw_agents(self):
for i in range(len(self.flatlands)):
agent = self.flatlands[i].agent
for j in range(len(self.agent_component[i])):
self.canvas.delete(self.agent_component[i][j])
offset = (i * (FLATLAND_WIDTH * self.cell_size + GRID_OFFSET))
self.agent_component[i] = []
self.agent_component[i].append(self.canvas.create_polygon(
agent.x * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET,
outline='red', fill='blue', width=1))
if agent.direction == Direction.north or agent.direction == Direction.east:
self.agent_component[i].append(self.canvas.create_oval(
agent.x * self.cell_size + (self.cell_size * 12/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 6/20) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 14/20) - 1 + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 8/20) + GRID_OFFSET,
fill="yellow"
))
if agent.direction == Direction.east or agent.direction == Direction.south:
self.agent_component[i].append(self.canvas.create_oval(
agent.x * self.cell_size + (self.cell_size * 12/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 12/20) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 14/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 14/20) + GRID_OFFSET,
fill="yellow"
))
if agent.direction == Direction.south or agent.direction == Direction.west:
self.agent_component[i].append(self.canvas.create_oval(
agent.x * self.cell_size + (self.cell_size * 6/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 12/20) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 8/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 14/20) + GRID_OFFSET,
fill="yellow"
))
if agent.direction == Direction.west or agent.direction == Direction.north:
self.agent_component[i].append(self.canvas.create_oval(
agent.x * self.cell_size + (self.cell_size * 6/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 6/20) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 8/20) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 8/20) + GRID_OFFSET,
fill="yellow"
))
if agent.direction == Direction.north or \
agent.direction == Direction.east or \
agent.direction == Direction.west:
self.agent_component[i].append(self.canvas.create_line(
agent.x * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 1/2) + GRID_OFFSET + offset,
agent.y * self.cell_size - (self.cell_size * 1/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET
))
if agent.direction == Direction.south or \
agent.direction == Direction.east or \
agent.direction == Direction.west:
self.agent_component[i].append(self.canvas.create_line(
agent.x * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 1/2) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 6/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET
))
if agent.direction == Direction.west or \
agent.direction == Direction.north or \
agent.direction == Direction.south:
self.agent_component[i].append(self.canvas.create_line(
agent.x * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET,
agent.x * self.cell_size - (self.cell_size * 1/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 1/2) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 1/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET
))
if agent.direction == Direction.east or \
agent.direction == Direction.north or \
agent.direction == Direction.south:
self.agent_component[i].append(self.canvas.create_line(
agent.x * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 2/5) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 6/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 1/2) + GRID_OFFSET,
agent.x * self.cell_size + (self.cell_size * 4/5) + GRID_OFFSET + offset,
agent.y * self.cell_size + (self.cell_size * 3/5) + GRID_OFFSET
))
def start_simulation(self):
self.current_timestep = 0
self.run_simulation()
def run_simulation(self):
if not self.pause:
if self.current_timestep < self.max_timestep:
for i in range(len(self.flatlands)):
agent_sensor_output = self.flatlands[i].agent.sense_front_left_right(self.flatlands[i])
ann_inputs = [1 if agent_sensor_output[0] == CellItem.food else 0,
1 if agent_sensor_output[1] == CellItem.food else 0,
1 if agent_sensor_output[2] == CellItem.food else 0,
1 if agent_sensor_output[0] == CellItem.poison else 0,
1 if agent_sensor_output[1] == CellItem.poison else 0,
1 if agent_sensor_output[2] == CellItem.poison else 0]
prediction = self.ann.predict(inputs=ann_inputs)
best_index = prediction.argmax()
if best_index == 1:
self.flatlands[i].agent.move_left()
elif best_index == 2:
self.flatlands[i].agent.move_right()
self.flatlands[i].agent.move_forward(self.flatlands[i])
# Remove cell component
if (i, self.flatlands[i].agent.x, self.flatlands[i].agent.y) in self.cell_components:
self.canvas.delete(self.cell_components[i, self.flatlands[i].agent.x, self.flatlands[i].agent.y])
self.draw_agents()
self.update_text()
self.current_timestep += 1
else:
print "Simulation over"
self.plot_data(self.fitness_log_average, self.fitness_log_best, self.standard_deviation_log)
return
self.after(self.delay, lambda: self.run_simulation())
def reset_gui_with_new_environment(self, event=None):
self.flatlands = [Flatland(width=self.flatlands[0].width,
height=self.flatlands[0].height,
food_probability=self.flatlands[0].food_probability,
poison_probability=self.flatlands[0].poison_probability)
for _ in range(len(self.flatlands))]
self.pause = True
for key, val in self.grid.items():
self.canvas.delete(val)
for key, val in self.cell_components.items():
self.canvas.delete(val)
self.draw_board()
self.draw_agents()
self.start_simulation()
@staticmethod
def plot_data(fitness_log_average, fitness_log_best, standard_deviation_log):
plt.figure(1)
plt.subplot(211)
plt.plot(fitness_log_average[-1], label="Average fitness")
plt.plot(fitness_log_best[-1], label="Best fitness")
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0.)
plt.subplot(212)
plt.plot(standard_deviation_log[-1], label="Standard deviation")
#plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0.)
plt.show()
window.update_view( board.generateState(board.grid) )
#Feedback about how the game went
print "Your best tile is: " + str(int(2 ** board.bestTile))
return int(2 ** board.bestTile)
root = Tk()
window = GameWindow(root)
EPOCHS_PER_GAME = 10
NEURONS_IN_HIDDEN_LAYERS = [17,500,500,4]
LIST_OF_FUNCTIONS = ["rectify","rectify","softmax"]
LEARNING_RATE = 0.003
MOMENTUM_RATE = 0.9
a = Ann(neuronsInHiddenLayers=NEURONS_IN_HIDDEN_LAYERS, listOfFunctions=LIST_OF_FUNCTIONS, learningRate=LEARNING_RATE, momentumRate=MOMENTUM_RATE, errorFunc=10)
for i in range (50):
trX, trY = get_data.get_training_data('training/train_data_'+str(i+1))
print "Training on data "+str(i+1)
a.training(trX, trY,len(trX)-1,EPOCHS_PER_GAME)
random_res = []
#random_res = [128, 128, 256, 64, 256, 128, 64, 64, 32, 64, 128, 128, 128, 128, 128, 128, 64, 128, 64, 128, 128, 64, 64, 64, 64, 128, 128, 128, 64, 128, 128, 128, 128, 128, 128, 128, 32, 128, 256, 64, 64, 128, 64, 64, 64, 128, 128, 64, 128, 64]
for i in range(50):
print "Random game: "+str(i+1)
board = Board()
window.update_view( board.generateState(board.grid) )
solver = Solver(board, window, root)
solver.startSolver("random")
random_res.append(int(2**board.bestTile))
def __init__(self):
self.avgScoreOfAnns = 0
self.highScoreOfAnns = -999
self.data = [Ann()] * ANN_COUNT
from ann import Ann from breeding import Breeding net = Ann() net.Print() #net.PrintLayer(3) #net.PrintNeuron(3, 1)
