def test_evaluate_species(self): neat = NEAT() neat.species.append(Species(TestGenome1(), unimproved_life_time = 1)) neat.species.append(Species(TestGenome1(), unimproved_life_time = 2)) neat.species.append(Species(TestGenome1(), unimproved_life_time = 3)) self.assertEqual(len(neat.species), 3) neat.evaluate_species() self.assertEqual(len(neat.species), 2)
def __init__(self,
eval_env,
population_configuration: PopulationConfiguration,
mutation_rates: MutationRates = MutationRates()):
# CPPNs take 4 inputs, gotta move this somewhere else
nrOfLayers: int = 3
self.layers = np.linspace(-1.0, 1.0, num=nrOfLayers)
cppnInputs: int = 2
# cppnOutputs: int = nrOfLayers - 1
cppnOutputs = 1
self.n_inputs = population_configuration.n_inputs
self.n_outputs = population_configuration.n_outputs
# Substrate
hiddenLayersWidth: int = self.n_inputs
self.substrateNeurons: List[NeuronGene] = []
for y in self.layers:
if y == -1.0:
for x in np.linspace(-1.0, 1.0, num=self.n_inputs):
self.substrateNeurons.append(
NeuronGene(NeuronType.INPUT,
len(self.substrateNeurons), y, x))
elif y == 1.0:
for x in np.linspace(-1.0, 1.0, num=self.n_outputs):
self.substrateNeurons.append(
NeuronGene(NeuronType.OUTPUT,
len(self.substrateNeurons), y, x))
else:
for x in np.linspace(-1.0, 1.0, num=hiddenLayersWidth):
self.substrateNeurons.append(
NeuronGene(NeuronType.HIDDEN,
len(self.substrateNeurons), y, x))
print("Nodes in substrate: {}".format(len(self.substrateNeurons)))
population_configuration._data["n_inputs"] = cppnInputs
population_configuration._data["n_outputs"] = cppnOutputs
self.neat = NEAT(eval_env, population_configuration, mutation_rates)
def run():
print("Creating neat object")
pop_config = WeightAgnosticConfiguration(pop_size, inputs, outputs)
neat = NEAT(TestOrganism(), pop_config)
highest_fitness = -1000.0
last_best = neat.population.genomes[0]
start = time.time()
for _ in neat.epoch():
# if neat.epochs == 150:
# break
# print("Epoch Time: {}".format(time.time() - start))
# random_phenotype = random.choice(neat.phenotypes)
most_fit = max([(g.fitness, g) for g in neat.population.genomes], key=lambda e: e[0])
# most_novel = max([(g.novelty, g) for g in neat.population.genomes], key=lambda e: e[0])
# best_phenotype = max(neat.phenotypes, key=lambda e: e.fitness)
# if max_fitness[0] >= highest_fitness:
# run_env_once(max_fitness[1].createPhenotype(), env)
# highest_fitness = max_fitness[0]
# run_env_once(most_novel[1].createPhenotype(), env)
# run_env_once(most_fit[1].createPhenotype(), env)
# run_env_once(random_phenotype, env)
if most_fit[0] > highest_fitness:
print("New highescore: {:1.2f}".format(most_fit[0]))
# run_env_once(most_fit[1].createPhenotype(), env)
highest_fitness = most_fit[0]
# print("Highest fitness all-time: {}".format(highest_fitness))
print("Epoch {}/{}".format(neat.epochs, 150))
print("Time: {}".format(time.time() - start))
print("Highest fitness ({}): {:1.2f}/{:1.2f}".format(most_fit[1].ID, most_fit[0], highest_fitness))
# run_env_once(most_fit[1].createPhenotype(), env)
found_last = next((m for m in neat.population.genomes if m.ID == last_best.ID), None)
if found_last is not None:
print("Last best ({}): {:1.2f}/{:1.2f}".format(last_best.ID, found_last.fitness, highest_fitness))
# run_env_once(last_best.createPhenotype(), env)
else:
print("Last best genome is no longer in population.")
table = PrettyTable(["ID", "age", "members", "max fitness", "avg. distance", "stag", "neurons", "links", "avg. weight", "max. compat.", "to spawn"])
for s in neat.population.species:
table.add_row([
# Species ID
s.ID,
# Age
s.age,
# Nr. of members
len(s.members),
# Max fitness
"{:1.4f}".format(max([m.fitness for m in s.members])),
# Average distance
"{:1.4f}".format(max([m.distance for m in s.members])),
# Stagnation
s.generationsWithoutImprovement,
# Neurons
# "{:1.2f}".format(np.mean([len([n for n in p.graph.nodes.data() if n[1]['type'] == NeuronType.HIDDEN]) for p in neat.phenotypes])),
"{:1.2f}".format(np.mean(
[len([n for n in m.createPhenotype().graph.nodes.data() if n[1]['type'] == NeuronType.HIDDEN]) for m in
s.members])),
# Links
# "{:1.2f}".format(np.mean([len(p.graph.edges) for p in neat.phenotypes])),
"{:1.2f}".format(np.mean([len(m.createPhenotype().graph.edges) for m in s.members])),
# Avg. weight
"{:1.2f}".format(np.mean([l.weight for m in s.members for l in m.links])),
# Max. compatiblity
"{:1.2}".format(np.max([m.calculateCompatibilityDistance(s.leader) for m in s.members])),
# Nr. of members to spawn
s.numToSpawn])
print(table)
start = time.time()
# print("########## Epoch {} ##########".format(neat.epochs))
last_best = most_fit[1]
return highest_fitness
fitnesses_t = fitnesses.T
for i in range(fitnesses_t.shape[0]):
fitness = fitnesses_t[i]
mean = np.sum(fitness)/num_of_runs
final_fitnesses.append(mean)
return (np.array(final_fitnesses[:len(phenotypes)]), np.zeros((len(phenotypes), 0)))
env = gym.make(env_name)
pop_size = 100
envs_size = 100
inputs = 4
outputs = 2
pop_config = SpeciesConfiguration(pop_size, inputs, outputs)
neat = NEAT(TestOrganism(), pop_config)
highest_fitness = -1000.0
for _ in neat.epoch():
print("Epoch {}/{}".format(neat.epochs, 150))
most_fit = max([{"fitness": g.fitness, "genome": g} for g in neat.population.genomes], key=lambda e: e["fitness"])
if most_fit["fitness"] > highest_fitness:
print("New highescore: {:1.2f}".format(most_fit["fitness"]))
run_env_once(most_fit["genome"].createPhenotype(), env)
highest_fitness = most_fit["fitness"]
for s in neat.population.species:
i = np.argmax([m.fitness for m in s.members])
print("{}: {}".format(s.ID, s.members[i]))
env = gym.make('BipedalWalker-v2')
inputs = env.observation_space.shape[0]
outputs = env.action_space.shape[0]
neat = None
novelty_map = None
if (args.load):
print("Loading NEAT object from file")
with open("saves/" + args.load, "rb") as load:
neat, innovations, novelty_map = pickle.load(load)
neat.populationSize = 150
# neat.milestone = 157.0
else:
print("Creating NEAT object")
neat = NEAT(500, inputs, outputs, fullyConnected=False)
novelty_map = np.empty((0, 14), float)
# neat = None
# print("Loading NEAT object from file")
# with open("saves/lotsofspecies.ne", "rb") as load:
# with open("saves/bipedal/bipedal.178", "rb") as load:
# neat, innovations, novelty_map = pickle.load(load)
# General settings
IDToRender = None
highestReward = [-1000.0, 0]
# milestone: float = 1.0
# nrOfSteps: int = 600
# vis = Visualize()