def fit_cartpole():
global _env
hist = []
_env = gym.make('CartPole-v1')
_env._max_episode_steps = 500
nn = SimpleNeuralControllerNumpy(4, 1, 2, 5)
nn.init_random_params()
es = cma.CMAEvolutionStrategy(nn.get_parameters(), 0.2)
for _ in range(800):
solutions = es.ask()
es.tell(solutions, [eval_nn(x) for x in solutions])
hist.append(-es.result.fbest)
_env.close()
return hist, -es.result.fbest, es.result.xbest
def eval_nn(genotype, render=False):
total_reward = 0
nn = SimpleNeuralControllerNumpy(4, 1, 2, 5)
print(len(nn.get_parameters()))
nn.set_parameters(genotype)
observation = env.reset()
for t in range(1000):
if render:
env.render()
action = nn.predict(observation)
if action > 0:
action = 1
else:
action = 0
observation, reward, done, info = env.step(action)
total_reward += reward
if done:
print("Episode finished after %d timesteps" % (t + 1))
break
return total_reward
if(dump):
f.write(" ".join(map(str,pos))+"\n")
if (old_pos is not None):
d=math.sqrt((pos[0]-old_pos[0])**2+(pos[1]-old_pos[1])**2)
total_dist+=d
old_pos=list(pos)
if(done):
break
if (dump):
f.close()
dist_obj=info["dist_obj"]
#print("End of eval, total_dist=%f"%(total_dist))
return ## A completer: une evaluation devra renvoyer la fitness utilisée, mais aussi le descripteur comportemental résultant de cette évaluation
nn=SimpleNeuralControllerNumpy(5,2,2,10)
center=nn.get_parameters()
## Il vous est recommandé de gérer les différentes variantes avec cette variable. Les 3 valeurs possibles seront:
## "FIT+NS": expérience multiobjectif avec la fitness et la nouveauté (NSGA-2)
## "NS": nouveauté seule
## "FIT": fitness seule
## pour les variantes avec un seul objectif, vous pourrez, au choix, utiliser CMA-ES ou NSGA-2 avec un seul objectif,
## il vous est cependant recommandé d'utiliser NSGA-2 car cela limitera la différence entre les variantes et cela
##vvous fera gagner du temps pour la suite.
variant="FIT+NS"
# votre code contiendra donc des tests comme suit pour gérer la différence entre ces variantes:
if (variant=="FIT+NS"):
pass ## A remplacer par les instructions appropriées
elif (variant=="FIT"):
pass ## A remplacer par les instructions appropriées
from deap import tools
import array
import random
import math
from ea_simple import ea_simple
# La ligne suivante permet de lancer des calculs en parallèle, ce qui peut considérablement accélérer les calculs sur une machine multi-coeur. Pour cela, il vous faut charger le module scoop: python -m scoop gym_cartpole.py
#from scoop import futures
# pour que DEAP utilise la parallélisation, il suffit alors d'ajouter toolbox.register("map", futures.map) dans la paramétrisation de l'algorithme évolutionniste. Si vous souhaitez explorer cette possibilité, nous vous conseillons de ne pas mettre l'algorithme évolutionniste dans un fichier séparé, cela peut créer des problèmes avec DEAP.
# Pour récupérer le nombre de paramètre. voir fixed_structure_nn_numpy pour la signification des paramètres. Le TME fonctionne avec ces paramètres là, mais vous pouvez explorer des valeurs différentes si vous le souhaitez.
nn = SimpleNeuralControllerNumpy(4, 1, 2, 5)
IND_SIZE = len(nn.get_parameters())
env = gym.make('CartPole-v1')
def eval_nn(genotype, render=False, nbstep=500):
total_reward = 0
nn = SimpleNeuralControllerNumpy(4, 1, 2, 5)
nn.set_parameters(genotype)
## à completer
# utilisez render pour activer ou inhiber l'affichage (il est pratique de l'inhiber pendant les calculs et de ne l'activer que pour visualiser les résultats.
# nbstep est le nombre de pas de temps. Plus il est grand, plus votre pendule sera stable, mais par contre, plus vos calculs seront longs. Vous pouvez donc ajuster cette
# valeur pour accélérer ou ralentir vos calculs. Utilisez la valeur par défaut pour indiquer ce qui doit se passer pendant l'apprentissage, vous pourrez indiquer une
# valeur plus importante pour visualiser le comportement du résultat obtenu.
else:
action = 0
observation, reward, done, info = env.step(action)
total_reward += reward
if done:
print("Episode finished after %d timesteps" % (t + 1))
break
return -total_reward
sigma = 1
### A completer pour optimiser les parametres du reseau de neurones avec CMA-ES ###
nn = SimpleNeuralControllerNumpy(4, 1, 2, 5)
nn.init_random_params()
res = launch_cmaes_full_genotype(nn.get_parameters(),
sigma,
nbeval=1000,
display=True,
ma_func=eval_nn)
nn.set_parameters(res)
env.reset()
r = env.step(env.action_space.sample()) # take a random action
observations = r[0]
reward = r[1]
done = r[2]
print(nn.predict(observations))
for _ in range(1000):
env.render()
