def fitness(pop):
"""
Recieves a list of pop. Modify ONLY their
fitness values
"""
for g in pop:
g['fitness'] = 0
# nw_activate = neat.generate_network(g)
# for xi, xo in zip(xor_inputs, xor_outputs):
# output = nw_activate(xi)
# g['fitness'] -= (output[0] - xo[0]) ** 2
print(type(g))
pickle.dump(g, open('network.p', 'wb'))
main(MyDriver(logdata=False))
# predictions = []
# for input in inputs:
# output_pred = nw_activate(input)
# predictions.append(output_pred)
# # genome.fitness += ( abs(output_real[0] - output_pred[0]) )
# fitness = 0 - sklearn.metrics.mean_squared_error(outputs, predictions)
# f = open('fitness.txt', 'w')
# f.write(str(fitness) + "\n")
# f.close()
#
fitness_file = open('fitness.txt', 'r')
for f in fitness_file:
g['fitness'] = float(f)
def eval_genomes(genomes, config):
# start torcs serever
# start torcs client
# wait until finished
# fitness = results
for genome_id, genome in genomes:
genome.fitness = 0
net = neat.nn.RecurrentNetwork.create(genome, config)
with open('network.p', 'wb') as handle:
pickle.dump(net, handle, protocol=pickle.HIGHEST_PROTOCOL)
main(MyDriver(logdata=False))
# predictions = []
# for input, output_real in zip((inputs), (outputs)):
# output_pred = te.activate(input)
# predictions.append(output_pred)
# # genome.fitness += ( abs(output_real[0] - output_pred[0]) )
# fitness = 0 - sklearn.metrics.mean_squared_error(outputs,predictions)
# f = open('fitness.txt', 'w')
# f.write(str(fitness) + "\n")
# f.close()
fitness_file = open('fitness.txt', 'r')
for f in fitness_file:
fitness = f
genome.fitness = float(f)
def run(driver, config_path):
command = "torcs -r {}".format(os.path.abspath(config_path))
sys.argv = sys.argv[:1]
try:
proc = subprocess.Popen(command.split())
time.sleep(3)
return_code = proc.poll()
if return_code is not None:
raise ValueError(
"Some error occurred. Either torcs isn't installed or the config file is not present"
)
print("Driver is in slowbro")
main(driver)
os.wait()
list_of_files = glob.glob(
'drivelogs/*') # * means all if need specific format then *.csv
latest_file = max(list_of_files, key=os.path.getctime)
print(latest_file)
end_state, end_command = pickle.load(open(latest_file, "rb"))
finally:
if proc:
try:
proc.kill()
except:
# ignore errors
...
def eval_fitness(genomes, config):
# start torcs serever
# start torcs client
# wait until finished
# fitness = results
for genome_id, genome in genomes:
genome.fitness = 0
net = neat.nn.RecurrentNetwork.create(genome, config)
pickle.dump(net,open('network.p','wb'))
print("Starting simulation...")
# run_torcs from yaml
# last_path = (os.getcwd())
# os.chdir("../")
# # print(os.getcwd())
# os.system('./torcs_tournament.py quickrace.yml') # forza
# os.chdir(last_path)
main(MyDriver(logdata=False))
# genome.fitness =
# print(genome.fitness)
fitness_file = open('fitness.txt', 'r')
for f in fitness_file:
genome.fitness = float(f)
print("Fitness: ",genome.fitness)
def eval_genome(genome, config):
net = neat.nn.FeedForwardNetwork.create(genome, config)
subprocess.call('myneat/autostart.sh', shell=True)
main(MyDriver(net))
with open('myneat/fitnessFile', 'r') as fitnessFile:
fitness = float(fitnessFile.read())
subprocess.call('myneat/autostop.sh', shell=True)
print('fitness: {}'.format(fitness))
return fitness
def eval_genome(genome, config):
global net
net = neat.nn.FeedForwardNetwork.create(genome, config)
driver = main(TestNeatDriver(logdata=False, net=net))
global fitness
return fitness
def run():
pop = Checkpointer.restore_checkpoint('neat-checkpoint-3')
winner = Checkpointer.
stats = neat.StatisticsReporter()
pe = neat.ParallelEvaluator(1, eval_genome)
winner = pop.run(pe.evaluate)
print(winner)
#print(pop.statistics.best_genome())
net = neat.nn.FeedForwardNetwork.create(genome, config)
driver = main(TestNeatDriver(logdata=False, net=net))
visualize.plot_stats(stats, ylog=True, view=True, filename="feedforward-fitness.svg")
visualize.plot_species(stats, view=True, filename="feedforward-speciation.svg")
node_names = {-1: 'x', -2: 'dx', -3: 'theta', -4: 'dtheta', 0: 'control'}
visualize.draw_net(config, winner, True, node_names=node_names)
visualize.draw_net(config, winner, view=True, node_names=node_names,
filename="winner-feedforward.gv")
visualize.draw_net(config, winner, view=True, node_names=node_names,
filename="winner-feedforward-enabled.gv", show_disabled=False)
visualize.draw_net(config, winner, view=True, node_names=node_names,
filename="winner-feedforward-enabled-pruned.gv", show_disabled=False, prune_unused=True)
def train_agent():
NUMBER_OF_EPISODES = 1000
if os.path.isfile("trained_model.h5") == True:
model = torch.load("trained_model.h5")
target = torch.load("trained_model.h5")
else:
model = DQN(26, 15)
save_model(model)
target = torch.load(
"trained_model.h5") # Make sure target is with the same weight
models = (model, target)
exploration_rate = 0.9 # Exploratiore states in the enviroment
# Optimizer
optim = Adam(model.parameters(), lr=0.000025)
#Loss function
criterion = torch.nn.MSELoss()
for episode in range(NUMBER_OF_EPISODES):
print("THE GAME NUMBER IS: ", episode)
agent = main(
MyDriver(logdata=False, models=models, explore=exploration_rate))
average_loss = 0
train_counter = 0
for n in range(20):
loss = train_policy(optim, criterion, model, target)
average_loss += loss
train_counter += 1
print(average_loss / train_counter)
if episode % 2 == 0 and episode > 0:
save_model(model)
exploration_rate = exploration_rate - 0.05
if episode % 10 == 0:
target = torch.load(
"trained_model.h5") # Update target network
print("TARGET NETWORK IS UPDATED")
models = (model, target)
agent = main(
MyDriver(logdata=False,
models=models,
explore=0,
optimizer=optim)
) # Test drive to see how well agent is behaving
if exploration_rate < 0.1: # Update exploration rate
exploration_rate = 0.1
print("EXPLORATION IS: ", exploration_rate)
def evaluate_xor(genome):
net = NEAT.NeuralNetwork()
try:
subprocess.call('./autostart.sh', shell=True)
# print("b")
# time.sleep(1)
# print("c")
main(MyDriver(net=net))
# print("d")
with open("mydata.txt", 'r') as f:
fitt = f.read()
# os.system('pkill torcs')
subprocess.call('./autostop.sh', shell=True)
print("fitness ******************* ", fitt)
return float(fitt)
except Exception as ex:
print('Exception:', ex)
return 0.0
def eval_genome(genome, config):
# net = neat.nn.FeedForwardNetwork.create(genome, config)
net = neat.nn.FeedForwardNetwork.create(genome, config)
# print("meh")
# os.system('pkill torcs')
# time.sleep(5)
# subprocess.call('torcs',shell=True)
# os.system('torcs')
# print("a")
# time.sleep(1)
# cwd=os.getcwd()
subprocess.call('./autostart.sh', shell=True)
# print("b")
# time.sleep(1)
# print("c")
main(MyDriver(net=net))
# print("d")
with open("mydata.txt", 'r') as f:
fitt = f.read()
# os.system('pkill torcs')
subprocess.call('./autostop.sh', shell=True)
print("fitness ******************* ", fitt)
return float(fitt)
def evaluate_xor(genome):
net = NEAT.NeuralNetwork()
genome.BuildHyperNEATPhenotype(net, substrate)
# nn=genome.BuildHyperNEATPhenotype(net, substrate)
# error = 0
# depth = 5
# do stuff and return the fitness
# net.Flush()
net = NEAT.NeuralNetwork()
genome.BuildPhenotype(net)
img = np.zeros((400, 400, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 400, 400), net)
cv2.imshow("CPPN", img)
# Visualize best network's Pheotype
net = NEAT.NeuralNetwork()
genome.BuildESHyperNEATPhenotype(net, substrate, params)
img = np.zeros((800, 800, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 800, 800), net, substrate=True)
cv2.imshow("NN", img)
cv2.waitKey(33)
subprocess.call('./autostart.sh',shell=True)
# print("b")
# time.sleep(1)
# print("c")
main(MyDriver(net=net))
# print("d")
with open("mydata.txt",'r') as f:
fitt=f.read()
# os.system('pkill torcs')
subprocess.call('./autostop.sh',shell=True)
# print("fitness ******************* ",fitt)
return float(fitt)
def eval_genome(genome, config):
"""
evaluate the genome by giving it a fitness
param: genome
param: config file
return: fitness
"""
global net
global counter
global fitness
# create network
net = neat.nn.FeedForwardNetwork.create(genome, config)
# initialize the driver with the network
driver = main(NeatDriver(logdata=False, net=net))
print("ID number of genome: ", counter)
print("The fitness is: ", fitness + eta)
print("----------------------------------------")
counter += 1
# fitness is + eta so it will always be a real number
return fitness + eta
#! /usr/bin/env python3
from pytocl.main import main
#from pytocl.driver import Driver
#from my_driver import MyDriver
#from my_driver_mlp2 import MyDriverMLP
from Swarm_MyDriver import MyDriverMLP
import os
import pickle
if __name__ == '__main__':
main(MyDriverMLP())
#! /usr/bin/env python3 from pytocl.main import main #from pytocl.driver import Driver #from my_driver import MyDriver #from my_driver_mlp2 import MyDriverMLP from Swarm_MyDriver import MyDriverMLP import os import pickle if __name__ == '__main__': main(MyDriverMLP())
#! /usr/bin/env python3
import sys, os, argparse
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from pytocl.main import main
from drivers.elm import ELMDriver
MODEL_PATH = 'resources/models/elm/'
if __name__ == '__main__':
main(ELMDriver(MODEL_PATH))
#! /usr/bin/env python3
import sys, os, argparse
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from pytocl.main import main
from drivers.recmode import rec_mode_driver
MODEL_PATH = 'resources/models/Link to BEST ONE/'
if __name__ == '__main__':
main(rec_mode_driver(MODEL_PATH))
#! /usr/bin/env python3
from pytocl.main import main
from my_driver import MyDriver
import os
for root, dirs, files in os.walk('team_communication/positions'):
for f in files:
os.unlink(os.path.join(root, f))
if __name__ == '__main__':
main(MyDriver())
for i in range(0,le):
networks2.append(networks[i])
#networks2.append(networks[len(networks)-1])
return networks2
if __name__ == '__main__':
print("started")
MyDriver.networks=[]
temp_networks=[]
for i in range(0,62):
temp_networks.append(read_networks(i))
#MyDriver.add_network(read_networks(i))
#MyDriver.add_network(read_networks(35))
temp_networks=sort(temp_networks)
print(len(temp_networks))
for i in range(0,len(temp_networks)):
temp_networks[i].fitness=0
MyDriver.add_network(temp_networks[i])
MyDriver.index=-1
MyDriver.network=MyDriver.get_best_network()
my_driver=MyDriver(logdata=False)
my_driver.msg='dd'
my_driver.distance=0.0
my_driver.speed_x=0.0
my_driver.brake=0.0
my_driver.count=0
my_driver.net_score={}
MyDriver.num_childs=50
main(my_driver,3001)
#! /usr/bin/env python3
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from pytocl.main import main
from drivers.manual import ManualDriver
if __name__ == '__main__':
# get going
main(ManualDriver())
#! /usr/bin/env python3
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from pytocl.main import main
from drivers.judas import Judas
if __name__ == '__main__':
main(Judas())
#! /usr/bin/env python3
from pytocl.main import main
from my_driver import MyDriver
from nn_driver import FFNNDriver
if __name__ == '__main__':
main(FFNNDriver())
if up and rpm > 7000:
gear += 1
if not up and rpm < 3000:
gear -= 1
speed = carstate.speed_x
accel = 1 if self.prev_accel is None else self.prev_accel
if speed < self.max_speed:
accel += 0.1
if accel > 1:
accel = 1.0
else:
accel -= 0.1
if accel < 0:
accel = 0.0
command = Command()
command.accelerator = accel
command.steering = steer
command.gear = gear
self.prev_accel = command.accelerator
return command
if __name__ == '__main__':
main(LanqDriver())
# help='Model name.',
# type=str
# )
parser.add_argument('-o',
'--output_file',
help='File where to print results.',
type=str)
args, _ = parser.parse_known_args()
print(args.parameters_file)
print(args.output_file)
#print(args.name)
if args.parameters_file is not None:
print('NN driver!!!!!!')
main(MyDriver(args.parameters_file,
out_file=args.output_file)) #, name=args.name))
else:
main(Driver())
except Exception as exc:
traceback.print_exc()
sys.stdout = orig_stdout
sys.stderr = orig_stderr
file_out.close()
file_err.close()
copyfile('../debug/out.log', '../debug/out_{}.log'.format(tm.time()))
copyfile('../debug/err.log', '../debug/err_{}.log'.format(tm.time()))
raise
sys.stdout = orig_stdout
default='Driver1')
parser.add_argument('-u',
'--unstuck',
help='Make the drivers automatically try to unstuck',
action='store_true')
args, _ = parser.parse_known_args()
print(args.parameters_file)
print(args.output_file)
print(args.driver)
if args.parameters_file is not None:
driver = registry[args.driver](args.parameters_file,
out_file=args.output_file,
unstuck=args.unstuck)
else:
driver = Driver()
try:
main(driver)
except Exception as exc:
traceback.print_exc()
if args.parameters_file is not None:
driver.saveResults()
raise
#! /usr/bin/env python3
# 11 12 22:55
from pytocl.main import main
from my_driver import MyDriver
if __name__ == '__main__':
main(MyDriver(logdata=False))
#! /usr/bin/env python3
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from pytocl.main import main
from drivers.cheesus import Cheesus
if __name__ == '__main__':
# get going
main(Cheesus())
#! /usr/bin/env python3
import sys, os, argparse
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from pytocl.main import main
from drivers.rnn import RNNDriver
MODEL_PATH = 'resources/models/rnn/'
if __name__ == '__main__':
main(RNNDriver(MODEL_PATH))
#! /usr/bin/env python3
from pytocl.main import main
from combined_driver import Final_Driver
steering = [REPLACE_STEERING]
max_speed = REPLACE_MAX_SPEED
if __name__ == '__main__':
main(Final_Driver(steering, max_speed))
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
print("Socket successfully created")
port = 52230
s.bind(('', port))
print("socket binded to %s" %(port))
s.listen(5)
print("socket is listening")
_thread.start_new_thread(socket_thread, ('socket_thread', s))
except OSError as e:
print('socket has some OS problems.')
print(e)
s.close()
except e:
print('socket has some problems.')
print(e)
s.close()
time.sleep(1)
import my_driver_clean
main(my_driver_clean.MyDriver(logdata=False))
if SOCKET:
try:
s.close()
except:
pass
if __name__ == '__main__':
local_dir = os.path.dirname(__file__)
config_path = os.path.join(local_dir, 'config-ctrnn')
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_path)
with open('winner-feedforward', 'rb') as f:
c = pickle.load(f)
print('Loaded genome:')
net=neat.ctrnn.CTRNN.create(c, config, 10)
# subprocess.call('./start.sh',shell=True)
main(MyDriver(net=net))
with open("mydata.txt",'r') as f:
fitt=f.read()
# subprocess.call('./autostop.sh',shell=True)
print("fitness ******************* ",fitt)
from __future__ import print_function
import sys, os, argparse
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
import numpy as np
from pytocl.main import main
from drivers.gear import GearDriver
if __name__ == '__main__':
population = np.array([6350, 9050, 9200, 9350, 9400])
downshift = np.array([5775, 6775, 7200, 7500, 7900])
np.save("../resources/gear/active", population)
main(GearDriver())
