if GA_settings["general"]["find"] not in GA_settings["general"][
"available_finds"]:
print("Not a valid problem type - check the avaible finds")
exit()
# Instantiate the GA with the settings set by user
genetic_algorithm = GA(GA_settings)
x = []
y = []
# Execute the Genetic Algorithm
for count in range(GA_settings["general"]["run_count"]):
x, y_highest, y_average, y_lowest = genetic_algorithm.execute()
highest_plot = plt.figure(0)
plt.plot(x, y_highest, label="Test {}".format(count + 1))
plt.legend()
plt.title("Highest Fitness per generation", fontsize=15)
plt.xlabel("Generation", fontsize=13)
plt.ylabel("Fitness", fontsize=13)
average_plot = plt.figure(1)
plt.plot(x, y_average, label="Test {}".format(count + 1))
plt.legend()
class LUNAR(Problem):
optimization = Optimization.min
def __init__(self, individual, args):
super().__init__()
self.individual = individual
self.derivation = str(individual.derivation)
self.env = gym.make('LunarLanderContinuous-v2')
#Aquí realizamos las transformaciones necesarias al individuo (derivation)
self.geneRange = []
auxder = self.derivation.split('FLOAT')
self.I = (len(auxder) - 1)
derivationChanges = [
f'{a}gene[{i}]' for i, a in enumerate(auxder[:-1])
]
derivationChanges.append(auxder[-1])
derivationChanges = "".join(derivationChanges)
auxder = derivationChanges.split('INDEX')
self.N = (len(auxder) - 1)
derivationChanges = [
f'{a}gene[{i+self.I}]' for i, a in enumerate(auxder[:-1])
]
derivationChanges.append(auxder[-1])
derivationChanges = "".join(derivationChanges)
derivationChanges = f'input = [max(min(i,1.0),-1.0) for i in {derivationChanges}]'
self.geneRange = ([[-100.0, 100.0]] * self.I) + ([[0, 7]] * self.N)
self.GA = GA(popSize=30,
geneRange=self.geneRange,
replacementDegree=0.5,
stepSize=50,
fitnessFunc=ft,
auxData=(derivationChanges, self.env),
minimize=True,
debug=False)
################################
def run(self):
self.individual.learn.acquire()
self.individual.no_learning.clear()
improvement = float("inf")
while self.individual.alive.is_set(
) and improvement > self.individual.learning_tolerance:
# Check maturity
if self.individual.async_learning:
if not self.individual.mature.is_set():
if improvement < self.individual.maturity_tolerance:
self.individual.mature.set()
elif not self.individual.converged.is_set():
# Wait until individuals release to learn
self.individual.no_learning.set()
self.individual.learn.acquire()
self.individual.no_learning.clear()
#Learn and obtain score
bestIndiv, fitness_hist, fitness_mean_hist = self.GA.execute(
self.individual.learning_tolerance_step)
self.individual._fitness = bestIndiv.fitness
self.individual.learning_iterations += self.individual.learning_tolerance_step
if math.isinf(improvement):
improvement = 1.0
else:
improvement = 1 - fitness_mean_hist[-1] / fitness_mean_hist[-(
self.individual.learning_tolerance_step + 1)]
self.env.close()
################################
self.individual.mature.set()
self.individual.no_learning.set()
################################
# phenotype = bestIndiv.phenotype(self.geneRange)
# derivation = self.derivation.split('FLOAT')
# derivationChanges = [f'{a}{str(phenotype[i])}' for i, a in enumerate(derivation[:-1])]
# derivationChanges.append(derivation[-1])
# derivation = "".join(derivationChanges)
# derivation = derivation.split('INDEX')
# derivationChanges = [f'{a}{str(phenotype[i+self.I])}' for i, a in enumerate(derivation[:-1])]
# derivationChanges.append(derivation[-1])
# derivation = "".join(derivationChanges)
# self.individual.finalDerivation = derivation
self.individual.finalDerivation = "EXP"
################################
#individual.raised.set()
return
class LUNAR(Problem):
optimization = Optimization.max
def __init__(self, individual, args):
super().__init__()
self.individual = individual
self.derivation = "".join(str(individual.derivation).split())
self.env = gym.make('LunarLander-v2')
self.env.seed(randomSeed)
self.game = Game(self.env)
self.geneRange = []
auxder = self.derivation.split('FLOAT')
derivationChanges = []
self.I = (len(auxder) - 1)
for i in range(self.I):
derivationChanges.append(f'{auxder[i]}gene[{i}]')
self.geneRange.append((-1.0,1.0))
derivationChanges.append(auxder[-1])
derivationChanges = "".join(derivationChanges)
# auxder = derivationChanges.split('INTEGER')
# derivationChanges = []
# self.N = (len(auxder) - 1)
# for i in range(self.N):
# derivationChanges.append(f'{auxder[i]}gene[{i+self.I}]')
# self.geneRange.append((0,23))
# derivationChanges.append(auxder[-1])
# derivationChanges = "".join(derivationChanges)
# #######################
# f = open('mariolike_simple.txt', "w")
# f.write(derivationChanges)
# f.close()
# #######################
self.bht = creation.string_bht_train(derivationChanges)
if len(self.geneRange) > 0:
self.GA = GA(popSize=50, geneRange=self.geneRange, replacementDegree=0.3, stepSize=20, fitnessFunc= ft, auxData=(self.bht, self.game), debug=False)
else:
self.GA = auxGA(bht=self.bht, game=self.game)
def run(self):
improvement = float("inf")
previous_score = float("-inf")
while self.individual.alive.is_set() and improvement > self.individual.learning_tolerance:
# Check maturity
if self.individual.async_learning:
if not self.individual.mature.is_set():
if improvement < self.individual.maturity_tolerance:
self.individual.mature.set()
elif not self.individual.converged.is_set():
# Wait until individuals realase to learn
self.individual.learn.acquire()
#Learn and obtain score
bestIndiv, fitness_hist, fitness_mean_hist = self.GA.execute(self.individual.learning_tolerance_step)
self.individual._fitness = bestIndiv.fitness
self.individual.learning_iterations += self.individual.learning_tolerance_step
if math.isinf(previous_score):
improvement = 1.0
else:
improvement = (self.individual._fitness - previous_score) / abs(previous_score)
previous_score = self.individual._fitness
self.env.close()
################################
derivation = self.derivation.split('FLOAT')
phenotype = bestIndiv.phenotype(self.geneRange)
derivationChanges = []
for i in range(self.I):
derivationChanges.append(derivation[i])
derivationChanges.append(str(phenotype[i]))
derivationChanges.append(derivation[-1])
derivation = "".join(derivationChanges)
# derivation = derivation.split('INTEGER')
# derivationChanges = []
# for i in range(self.N):
# derivationChanges.append(derivation[i])
# derivationChanges.append(str(phenotype[i+self.I]))
# derivationChanges.append(derivation[-1])
# derivation = "".join(derivationChanges)
self.individual.finalDerivation = derivation
################################
self.individual.mature.set()
return
