def study_cem(params) -> None:
"""
Start a sum study of cem
:param params: the parameters of the study
:return: nothing
"""
assert params.policy_type in ['normal'], 'unsupported policy type'
# cuda = torch.device('cuda')
study = params.gradients
simu = make_simu_from_params(params)
simu.env.set_file_name(study[0] + '_' + simu.env_name)
reward_file = None
print("study : ", study)
# defixed layers
params.fix_layers = False
print("cem study") # cem study
chrono_cem = Chrono()
for j in range(params.nb_repet):
simu.env.reinit()
if params.policy_type=="normal":
policy = NormalPolicy(simu.obs_size, 24, 36, 1)
pw = PolicyWrapper(policy, params.policy_type, simu.env_name, j,params.team_name, params.max_episode_steps)
all_weights,all_rewards,all_pops,all_pops_scores,is_kept=simu.train(pw, params, policy, False, reward_file, "", study[0], 0, True)
cem_time = chrono_cem.stop()
return all_weights,all_rewards,all_pops,all_pops_scores,is_kept
def main(params) -> None:
env = make_env(params.env_name, params.policy_type, params.max_episode_steps, params.env_obs_space_name)
env.set_file_name("{}_{}".format(params.gradients[0], params.env_name))
simulation = Simulation(env, params.nb_trajs, params.update_threshold, params.nb_updates, params.batch_size,
params.print_interval)
simulation.rescale_reward = lambda reward: reward / 10
policy_loss_file, critic_loss_file = set_files(params.gradients[0], params.env_name)
chrono = Chrono()
for j in range(params.nb_repet):
env.reinit()
memory = ReplayBuffer()
# Initialise the policy/actor
policy = PolicyNet(params.lr_actor, params.init_alpha, params.lr_alpha, params.target_entropy_alpha)
pw = PolicyWrapper(policy, params.policy_type, params.env_name, params.team_name, params.max_episode_steps)
pw.duration_flag = False
# Initialise the critics
critic = DoubleQNet(params.lr_critic,params.gamma, params.tau)
plot_policy(policy, env, True, params.env_name, params.study_name, '_ante_', j, plot=False)
simulation.train(memory, pw, critic, policy_loss_file, critic_loss_file)
plot_policy(policy, env, True, params.env_name, params.study_name, '_post_', j, plot=False)
plot_critic(env, params.env_name, critic.q1, policy, params.study_name, '_q1_post_', j)
plot_critic(env, params.env_name, critic.q2, policy, params.study_name, '_q2_post_', j)
critic.q1.save_model('data/critics/{}#{}#SAC{}.pt'.format(params.env_name, params.team_name, str(j)))
critic.q2.save_model('data/critics/{}#{}#SAC{}.pt'.format(params.env_name, params.team_name, str(j)))
simulation.env.close()
chrono.stop()
def study_cem(params, starting_pol=None) -> None:
"""
Start a study of CEM algorithms
:param params: the parameters of the study
:param starting_pol: initial policy
:return: nothing
"""
assert params.policy_type in ['squashedGaussian', 'normal',
'beta'], 'unsupported policy type'
chrono = Chrono()
# cuda = torch.device('cuda')
study = params.gradients
if params.nb_trajs_cem is not None:
params.nb_trajs = params.nb_trajs_cem
simu = make_simu_from_params(params)
for i in range(1): # len(study) Only sum here
simu.env.set_file_name('cem' + study[i] + '_' + simu.env_name)
print("study : ", study[i])
for j in range(params.nb_repet):
simu.env.reinit()
if params.policy_type == "squashedGaussian":
policy = SquashedGaussianPolicy(simu.obs_size, 32, 64, 1)
elif params.policy_type == "normal":
policy = NormalPolicy(simu.obs_size, 32, 64, 1)
elif params.policy_type == "beta":
policy = BetaPolicy(simu.obs_size, 32, 64, 1)
if starting_pol is not None:
policy.set_weights(starting_pol[j])
pw = PolicyWrapper(policy, j, params.policy_type, simu.env_name,
params.team_name, params.max_episode_steps)
# plot_policy(policy, simu.env, True, simu.env_name, study[i], '_ante_', j, plot=False)
simu.train_cem(pw, params, policy)
# plot_policy(policy, simu.env, True, simu.env_name, study[i], '_post_', j, plot=False)
chrono.stop()
def study_regress(params) -> None:
assert params.policy_type in ['bernoulli', 'normal', 'squashedGaussian'
], 'unsupported policy type'
chrono = Chrono()
study = params.gradients
simu = make_simu_from_params(params)
for i in range(len(study)):
simu.env.set_file_name(study[i] + '_' + simu.env_name)
policy_loss_file, critic_loss_file = set_files(study[i], simu.env_name)
print("study : ", study[i])
for j in range(params.nb_repet):
simu.env.reinit()
if params.policy_type == "bernoulli":
policy = BernoulliPolicy(simu.obs_size, 24, 36, 1,
params.lr_actor)
elif params.policy_type == "normal":
policy = NormalPolicy(simu.obs_size, 24, 36, 1,
params.lr_actor)
elif params.policy_type == "squashedGaussian":
policy = SquashedGaussianPolicy(simu.obs_size, 24, 36, 1,
params.lr_actor)
pw = PolicyWrapper(policy, params.policy_type, simu.env_name,
params.team_name, params.max_episode_steps)
plot_policy(policy,
simu.env,
True,
simu.env_name,
study[i],
'_ante_',
j,
plot=False)
if not simu.discrete:
act_size = simu.env.action_space.shape[0]
critic = QNetworkContinuous(simu.obs_size + act_size, 24, 36,
1, params.lr_critic)
else:
critic = VNetwork(simu.obs_size, 24, 36, 1, params.lr_critic)
# plot_critic(simu, critic, policy, study[i], '_ante_', j)
regress(simu, policy, params.policy_type, 250, params.render)
simu.train(pw, params, policy, critic, policy_loss_file,
critic_loss_file, study[i])
plot_policy(policy,
simu.env,
True,
simu.env_name,
study[i],
'_post_',
j,
plot=False)
plot_critic(simu, critic, policy, study[i], '_post_', j)
critic.save_model('data/critics/' + params.env_name + '#' +
params.team_name + '#' + study[i] + str(j) +
'.pt')
chrono.stop()
def download(self,
site_id,
fields,
date_beg,
date_end,
filename,
show_chrono=True):
url = (
self.base_url + "?" + "UrlTemplate=" + "%26columns={" +
','.join(fields) + "}" + "%26sort={-" + fields[0] + "}"
#+ "%26segment=100068961" # Ce champ apparaissait pour les requêtes CA.fr
+ "%26space={s:" + str(site_id) + "}"
#+ "%26period={R:{D:'-1'}}" # La veille
+ "%26period={D:{start:'" + date_beg + "',end:'" + date_end +
"'}}" + "%26max-results=%23maxresult%23" +
"%26page-num=%23pagenum%23" + "%26sep=dot" +
"&UserId={}".format(self.cfg['user_id']) + "&UserLanguageId=1" +
"&Filename=mycsv" + "&Space={\"sites\":[\"" + str(site_id) +
"\"],\"group\":\"\"}")
headers = {
"Accept":
"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"Accept-Encoding":
"gzip, deflate, br",
"Accept-Language":
"fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7",
"Connection":
"keep-alive",
"Cookie":
("atuserid={}; ".format(self.fj(self.cfg['cookie']['atuserid'])) +
"AnalyticsSuiteVersion=2; " + "atidvisitor={}; ".format(
self.fj(self.cfg['cookie']['atidvisitor'])) +
"ATToken=Token=" + cookie.FIND_COOKIE() + ";"),
"Host":
"exportsproxy.atinternet-solutions.com",
"Referer":
"https://apps.atinternet-solutions.com/DataQuery/Designer/",
"Upgrade-Insecure-Requests":
"1",
"User-Agent":
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36" # Yes! on imite vraiment tout!
}
#print (cookie.FIND_COOKIE())
#print (headers)
if show_chrono:
chn = Chrono().start()
r = requests.get(url, headers=headers)
if show_chrono:
chn.stop() # Temps : 36s à 1min12
with open(filename, 'wt') as fout:
fout.write(r.text)
def run_dyna_prog():
# walls = [7, 8, 9, 10, 21,27,30,31,32,33,45, 46, 47]
# height = 6
# width = 9
#
m = build_maze(width, height, walls) # maze-like MDP definition
# m = create_maze(10, 10, 0.2)
m.render()
# plot_convergence_vi_pi(m, False)
#
print("value iteration V")
cpt = Chrono()
q, _, nbIter, nbUd = value_iteration_v(m, render=0)
print(nbIter, nbUd)
print(len(q))
cpt.stop()
def main():
debug = Debugger()
chrono = Chrono()
universe = Universe(debug)
source = Source(debug).get_source()
bucket_chain = BucketChain(debug, chrono, universe, source)
clusters = Clusters(debug, chrono, universe)
algorithm = OnlineClustering(debug, universe, bucket_chain, clusters)
while True:
operation_time = time.time()
if bucket_chain.is_updated():
universe.compute_log_n_df()
bucket_chain.compute_universal_counts()
bucket_chain.compute_universal_tfidf()
clusters.update_centroid_counts()
clusters.update_centroid_tfidf()
algorithm.pre_clustering_work()
algorithm.online_clustering()
clusters.remove_old_clusters()
universe.prune_terms(clusters)
debug.log("BUCKET FINISHED IN: " +
str(time.time() - operation_time))
clusters.debug_active_clusters()
clusters.save_active_clusters()
def __init__(self):
#Change the height and width values to change the window and the grid size.
self.width = 400
self.height = 600
self.map_size = Point(self.width, self.height)
self.frame_rate = 60
self.done = False
pygame.init()
size = (self.width, self.height)
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption("pyDeminer")
#This list will contain all the graphical components.
self.game_components = list()
chrono = Chrono(self, Point(self.width / 4, 50))
pui = Label(self, Point(self.width / 4 * 3, 50), "0%")
self.game_components.append(pui)
self.game_components.append(chrono)
self.game_components.append(
MineField(self, Point(0, 100),
Point(self.width, self.height - 100), pui, chrono))
self.game_loop()
print(policy_file)
env_name, algo, team_name = read_name(policy_file)
if env_name in self.score_dic:
scores = get_scores(args, folder, policy_file, env_name, algo, stats_path, hyperparams, n_evals)
self.score_dic[env_name][scores.mean()] = [team_name, algo, scores.std()]
else:
scores = get_scores(args, folder, policy_file, env_name, algo, stats_path, hyperparams, n_evals)
tmp_dic = {scores.mean(): [team_name, algo, scores.std()]}
self.score_dic[env_name] = tmp_dic
def display_hall_of_fame(self) -> None:
"""
Display the hall of fame of all the evaluated policies
:return: nothing
"""
print("Hall of fame")
for env, dico in self.score_dic.items():
print("Environment :", env)
for key, val in sorted(dico.items(),reverse=True):
print("team: ", val[0], " \t \t algo:", val[1], " \t \t mean score: ", key, "std: ", val[2])
if __name__ == '__main__':
directory = os.getcwd() + '/data/policies/'
ev = Evaluator()
c = Chrono()
ev.load_policies(directory)
ev.display_hall_of_fame()
c.stop()
def __init__(self, infopartie, lienreseau, monpseudo, mode, taille):
"""Initialise tous les paramètres pour le bon démarrage du jeu"""
self.lienreseau = lienreseau # conservation du lien avec le serveur
self.carte = infopartie['params'][0]
self.vitesse = infopartie['params'][1]
self.tempsbonus = infopartie['params'][2]
self.nombremonstres = infopartie['params'][3]
self.tortues = infopartie['tortues']
self.monpseudo = monpseudo
self.mode = mode
self.taille = taille
self.info = None
# initialisation des chronomètres
self.netchrono = Chrono() # empêche l'envoi trop rapide de paquets
self.joueurchrono = Chrono() # pour les mouvements
self.pilulechrono = Chrono() # pour le temps bonus
# initialisation de la fenêtre de jeu
self.window = tk.Tk()
self.window.title('Turtle-Men')
# mise en forme des scores
self.scores = OrderedDict() # dictionnaire ordonné des scores
self.scores[monpseudo] = [0] # score du joueur en premier
rang = 0
for joueurs in infopartie['tortues']:
self.scores[joueurs] = [0]
self.scores[joueurs].append(
tk.StringVar(value='{:<10}:{:>10}'.format(
joueurs, self.scores[joueurs][0])))
for index in range(len(self.scores)):
tk.Label(self.window,
textvariable=list(self.scores.items())[index][1][1]).grid(
row=index, column=0)
rang += 1
## ajouter des trucs de fenêtre içi ##
#détermine les dimensions de la carte
largeurcarte = max(len(i) for i in self.carte)
hauteurcarte = len(self.carte)
# taille de la fenêtre
self.canvas = tk.Canvas(self.window,
width=self.taille * largeurcarte,
height=self.taille * hauteurcarte)
self.canvas.grid(row=0, column=1, rowspan=rang)
self.fen = turtle.TurtleScreen(self.canvas) # "dessiner" içi
self.labyrinthe = Labyrinthe(self.fen, self.carte, self.taille)
# initialisation des monstres
self.monstres = dict()
posmonstres = self.labyrinthe.posDebut('M')
if self.nombremonstres > 0:
self.monstres['Blinky'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'red', 'B', self.taille)
]
if self.nombremonstres > 1:
self.monstres['Pinky'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'pink', 'P', self.taille)
]
if self.nombremonstres > 2:
self.monstres['Inky'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'cyan', 'I', self.taille)
]
if self.nombremonstres > 3:
self.monstres['Clyde'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'orange', 'C', self.taille)
]
# initialisation des autres joueurs
posjoueurs = self.labyrinthe.posDebut('T')
for nom in self.tortues:
if nom != self.monpseudo:
self.tortues[nom].append(
TMen(self.fen, 'red', nom, self.taille)) # instances
self.tortues[nom][0] = posjoueurs[:]
# initialisation du joueur principal
if self.mode == 'manuel':
self.joueur = JoueurHumain(self.fen, 'yellow', self.monpseudo,
self.taille)
self.fen.onkeypress(self.joueur.toucheLeft, 'Left')
self.fen.onkeypress(self.joueur.toucheRight, 'Right')
self.fen.onkeypress(self.joueur.toucheUp, 'Up')
self.fen.onkeypress(self.joueur.toucheDown, 'Down')
self.fen.listen()
else:
self.joueur = JoueurIA(self.fen, "yellow", self.monpseudo,
self.taille, self.monstres)
self.joueur.pos = posjoueurs[:]
self.joueur.pos = posjoueurs[:]
self.joueurchrono.reset() # démarrage du chrono joueur
self.mvtprec = 'est' # pour les virages
self.joueur.pencolor('white')
self.fen.ontimer(self.go, 1) # démarrage de la boucle principale
self.fen.mainloop()
class Jeu():
"""Constitue une partie du jeu"""
def __init__(self, infopartie, lienreseau, monpseudo, mode, taille):
"""Initialise tous les paramètres pour le bon démarrage du jeu"""
self.lienreseau = lienreseau # conservation du lien avec le serveur
self.carte = infopartie['params'][0]
self.vitesse = infopartie['params'][1]
self.tempsbonus = infopartie['params'][2]
self.nombremonstres = infopartie['params'][3]
self.tortues = infopartie['tortues']
self.monpseudo = monpseudo
self.mode = mode
self.taille = taille
self.info = None
# initialisation des chronomètres
self.netchrono = Chrono() # empêche l'envoi trop rapide de paquets
self.joueurchrono = Chrono() # pour les mouvements
self.pilulechrono = Chrono() # pour le temps bonus
# initialisation de la fenêtre de jeu
self.window = tk.Tk()
self.window.title('Turtle-Men')
# mise en forme des scores
self.scores = OrderedDict() # dictionnaire ordonné des scores
self.scores[monpseudo] = [0] # score du joueur en premier
rang = 0
for joueurs in infopartie['tortues']:
self.scores[joueurs] = [0]
self.scores[joueurs].append(
tk.StringVar(value='{:<10}:{:>10}'.format(
joueurs, self.scores[joueurs][0])))
for index in range(len(self.scores)):
tk.Label(self.window,
textvariable=list(self.scores.items())[index][1][1]).grid(
row=index, column=0)
rang += 1
## ajouter des trucs de fenêtre içi ##
#détermine les dimensions de la carte
largeurcarte = max(len(i) for i in self.carte)
hauteurcarte = len(self.carte)
# taille de la fenêtre
self.canvas = tk.Canvas(self.window,
width=self.taille * largeurcarte,
height=self.taille * hauteurcarte)
self.canvas.grid(row=0, column=1, rowspan=rang)
self.fen = turtle.TurtleScreen(self.canvas) # "dessiner" içi
self.labyrinthe = Labyrinthe(self.fen, self.carte, self.taille)
# initialisation des monstres
self.monstres = dict()
posmonstres = self.labyrinthe.posDebut('M')
if self.nombremonstres > 0:
self.monstres['Blinky'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'red', 'B', self.taille)
]
if self.nombremonstres > 1:
self.monstres['Pinky'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'pink', 'P', self.taille)
]
if self.nombremonstres > 2:
self.monstres['Inky'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'cyan', 'I', self.taille)
]
if self.nombremonstres > 3:
self.monstres['Clyde'] = [
posmonstres, 'nord', True, False,
Monstre(self.fen, 'orange', 'C', self.taille)
]
# initialisation des autres joueurs
posjoueurs = self.labyrinthe.posDebut('T')
for nom in self.tortues:
if nom != self.monpseudo:
self.tortues[nom].append(
TMen(self.fen, 'red', nom, self.taille)) # instances
self.tortues[nom][0] = posjoueurs[:]
# initialisation du joueur principal
if self.mode == 'manuel':
self.joueur = JoueurHumain(self.fen, 'yellow', self.monpseudo,
self.taille)
self.fen.onkeypress(self.joueur.toucheLeft, 'Left')
self.fen.onkeypress(self.joueur.toucheRight, 'Right')
self.fen.onkeypress(self.joueur.toucheUp, 'Up')
self.fen.onkeypress(self.joueur.toucheDown, 'Down')
self.fen.listen()
else:
self.joueur = JoueurIA(self.fen, "yellow", self.monpseudo,
self.taille, self.monstres)
self.joueur.pos = posjoueurs[:]
self.joueur.pos = posjoueurs[:]
self.joueurchrono.reset() # démarrage du chrono joueur
self.mvtprec = 'est' # pour les virages
self.joueur.pencolor('white')
self.fen.ontimer(self.go, 1) # démarrage de la boucle principale
self.fen.mainloop()
def go(self):
"""Fonction qui remplit la boucle principale, ne doit pas bloquer"""
# mise à jour des données
if self.netchrono.get() > 0.020: # on peut communiquer
self.info = self.lienreseau.rapporter(self.joueur.getStatus())
self.netchrono.reset()
if self.info is not None:
# données des monstres
for monstre in self.info['monstres'].keys():
self.monstres[monstre][0] =\
self.info['monstres'][monstre][0]
self.monstres[monstre][1] =\
self.info['monstres'][monstre][1]
self.monstres[monstre][2] =\
self.info['monstres'][monstre][2]
self.monstres[monstre][3] =\
self.info['monstres'][monstre][3]
# données des tortues
for tortue in self.info['tortues'].keys():
if tortue != self.monpseudo:
self.tortues[tortue][0] =\
self.info['tortues'][tortue][0]
self.tortues[tortue][1] =\
self.info['tortues'][tortue][1]
self.tortues[tortue][2] =\
self.info['tortues'][tortue][2]
self.tortues[tortue][3] =\
self.info['tortues'][tortue][3]
# mise à jour des scores
if not self.info['gagnant']:
for joueur in self.info['scores'].keys():
self.scores[joueur][0] = self.info['scores'][joueur]
self.scores[joueur][1].set('{:<10}:{:>10}'.format(
joueur, self.scores[joueur][0]))
else:
for joueur in self.info['scores'].keys():
if joueur == self.info['gagnant']:
self.scores[joueur][1].set('{:<10}:{:>10}'.format(
joueur, 'gagnant'))
else:
self.scores[joueur][1].set('{:<10}:{:>10}'.format(
joueur, 'perdant'))
# mise à jour des monstres
for monstre in self.monstres.keys():
self.monstres[monstre][-1].deplacer(self.monstres[monstre][0])
self.monstres[monstre][-1].orienter(self.monstres[monstre][1])
# mise à jour des autres tortues
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
self.tortues[joueur][-1].deplacer(self.tortues[joueur][0])
self.tortues[joueur][-1].orienter(self.tortues[joueur][1])
# mouvement du joueur
deltat = self.joueurchrono.get()
self.joueurchrono.reset()
case = tuple(math.floor(i) for i in self.joueur.pos)
diffcase = tuple(i - j for i, j in zip(case, self.joueur.pos))
normediffcase = (diffcase[0]**2 + diffcase[1]**2)**(0.5)
distance = self.vitesse * deltat
if not self.joueur.vie:
distance = 0
if self.mvtprec == 'est':
mvtactuel = (1, 0)
elif self.mvtprec == 'ouest':
mvtactuel = (-1, 0)
elif self.mvtprec == 'nord':
mvtactuel = (0, -1)
elif self.mvtprec == 'sud':
mvtactuel = (0, 1)
else:
mvtactuel = (0, 0)
if self.mode != 'manuel':
self.joueur.deterDirection()
self.joueur.posprec = self.joueur.pos
if self.joueur.bougervers == 'est':
mvtvoulu = (1, 0)
elif self.joueur.bougervers == 'ouest':
mvtvoulu = (-1, 0)
elif self.joueur.bougervers == 'nord':
mvtvoulu = (0, -1)
elif self.joueur.bougervers == 'sud':
mvtvoulu = (0, 1)
else:
mvtvoulu = (0, 0)
if mvtactuel == mvtvoulu: # même direction
pass
elif mvtactuel == tuple(-i for i in mvtvoulu): # direction inverse
self.mvtprec = self.joueur.bougervers
mvtactuel = mvtvoulu
else: # virage
produitscalaire = abs(
sum(i * j for i, j in zip(diffcase, mvtactuel)))
if produitscalaire <= distance and not\
self.labyrinthe.blocExiste(math.floor(self.joueur.pos[1] +
mvtvoulu[1]),
math.floor(self.joueur.pos[0] +
mvtvoulu[0])):
distance -= normediffcase # perte de distance partielle
self.mvtprec = self.joueur.bougervers
mvtactuel = mvtvoulu
else:
pass # on continue dans la même direction
posvoulue = (self.joueur.pos[0] + distance * mvtactuel[0],
self.joueur.pos[1] + distance * mvtactuel[1])
if not self.labyrinthe.blocExiste(
math.floor(posvoulue[1] + mvtactuel[1] / 2 + 0.5),
math.floor(posvoulue[0] + mvtactuel[0] / 2 + 0.5)):
self.joueur.pos = posvoulue
else:
if self.mvtprec == 'est':
posx = math.floor(posvoulue[0])
elif self.mvtprec == 'ouest':
posx = math.ceil(posvoulue[0])
else:
posx = posvoulue[0]
if self.mvtprec == 'nord':
posy = math.ceil(posvoulue[1])
elif self.mvtprec == 'sud':
posy = math.floor(posvoulue[1])
else:
posy = posvoulue[1]
self.joueur.pos = (posx, posy)
self.joueur.deplacer(self.joueur.pos)
self.joueur.orienter(self.mvtprec)
# gestion des nourritures
casesoccupe = list()
macase = tuple(math.floor(i + 0.5) for i in self.joueur.pos)
casesoccupe.append(macase)
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
casesoccupe.append(
tuple(
math.floor(i + 0.5)
for i in self.tortues[joueur][-1].pos))
for posjoueur in casesoccupe:
if self.labyrinthe.bouffeExiste(posjoueur):
self.labyrinthe.detruireBouffe(posjoueur)
# gestion des pilules
for posjoueur in casesoccupe:
if self.labyrinthe.piluleExiste(posjoueur):
self.labyrinthe.detruirePilule(posjoueur)
if posjoueur == macase: # c'est nous, avec la pilule
self.joueur.energie = True
self.joueur.color('lightgreen')
self.pilulechrono.reset()
# autres tortues
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
if self.tortues[joueur][3]:
self.tortues[joueur][-1].color('green')
else:
self.tortues[joueur][-1].color('red')
# collisions avec les monstres
caseoccupe = [] # on réinitialise
for monstre in self.monstres.keys():
posmonstre = self.monstres[monstre][-1].pos
if self.monstres[monstre][2]: # monstre en vie
caseoccupe.append(
tuple(
math.floor(i + 0.5)
for i in self.monstres[monstre][-1].pos))
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
if not self.tortues[joueur][2]:
self.tortues[joueur][-1].hideturtle()
# si les monstres meurent
for monstre in self.monstres.keys():
if self.monstres[monstre][2]:
self.monstres[monstre][-1].showturtle()
else:
self.monstres[monstre][-1].hideturtle()
if macase in caseoccupe and not self.joueur.energie:
self.joueur.vie = False
self.joueur.hideturtle()
if self.pilulechrono.get() >= self.tempsbonus: # temps bonus dépassé
self.joueur.energie = False
self.joueur.color('yellow')
self.fen.update()
self.fen.ontimer(self.go, 0)
def study_pg(params) -> None:
"""
Start a study of the policy gradient algorithms
:param params: the parameters of the study
:return: nothing
"""
#### MODIF : added discrete
assert params.policy_type in [
'bernoulli', 'normal', 'squashedGaussian', 'discrete'
], 'unsupported policy type'
####
chrono = Chrono()
# cuda = torch.device('cuda')
study = params.gradients
simu = make_simu_from_params(params)
for i in range(len(study)):
simu.env.set_file_name(study[i] + '_' + simu.env_name)
policy_loss_file, critic_loss_file = set_files(study[i], simu.env_name)
print("study : ", study[i])
for j in range(params.nb_repet):
simu.env.reinit()
if params.policy_type == "bernoulli":
policy = BernoulliPolicy(simu.obs_size, 100, 200, 1,
params.lr_actor)
#### MODIF : added the discrete policy
elif params.policy_type == "discrete":
if isinstance(simu.env.action_space, gym.spaces.box.Box):
nb_actions = int(simu.env.action_space.high[0] -
simu.env.action_space.low[0] + 1)
print(
"Error : environment action space is not discrete :" +
str(simu.env.action_space))
else:
nb_actions = simu.env.action_space.n
policy = DiscretePolicy(simu.obs_size, 24, 36, nb_actions,
params.lr_actor)
####
elif params.policy_type == "normal":
policy = NormalPolicy(simu.obs_size, 100, 200, 1,
params.lr_actor)
elif params.policy_type == "squashedGaussian":
policy = SquashedGaussianPolicy(simu.obs_size, 100, 200, 1,
params.lr_actor)
elif params.policy_type == "DDPG":
policy = DDPG(simu.obs_size, 24, 36, 1, params.lr_actor)
# policy = policy.cuda()
pw = PolicyWrapper(policy, params.policy_type, simu.env_name,
params.team_name, params.max_episode_steps)
plot_policy(policy,
simu.env,
True,
simu.env_name,
study[i],
'_ante_',
j,
plot=False)
if not simu.discrete:
act_size = simu.env.action_space.shape[0]
critic = QNetworkContinuous(simu.obs_size + act_size, 24, 36,
1, params.lr_critic)
else:
critic = VNetwork(simu.obs_size, 24, 36, 1, params.lr_critic)
# plot_critic(simu, critic, policy, study[i], '_ante_', j)
simu.train(pw, params, policy, critic, policy_loss_file,
critic_loss_file, study[i])
plot_policy(policy,
simu.env,
True,
simu.env_name,
study[i],
'_post_',
j,
plot=False)
if False:
if params.policy_type == "normal":
plot_normal_histograms(policy, j, simu.env_name)
else:
plot_weight_histograms(policy, j, simu.env_name)
plot_critic(simu, critic, policy, study[i], '_post_', j)
critic.save_model('data/critics/' + params.env_name + '#' +
params.team_name + '#' + study[i] + str(j) + '.pt')
chrono.stop()
from flask import Flask, render_template
from datetime import date, time, datetime
from unicorn_helpers import test_flash
from chrono import Chrono
app = Flask(__name__)
# @app.route('/')
# def index():
# return "Hello World"
time = Chrono()
time.tick()
@app.route('/')
def index():
return render_template('index.html')
@app.route('/flash')
def flash():
test_flash()
return render_template('flash.html')
@app.route('/time')
def get_time(time=datetime.now().strftime("%b-%d-%Y, %H-%M")):
return render_template('time.html', time=time)
HIDDEN_RATE = 0.1
def prepare_prng(nb_students, nb_questions):
nb_hidden = round(HIDDEN_RATE * nb_questions)
u0 = 0
a = 4685763
b = 47831
n = 47564875
u = [u0]
for i in range(nb_hidden * nb_students):
u.append(((a * u[-1] + b) % n) % nb_questions)
return u
chrono = Chrono()
files = IO()
for dataset_name in ['fraction']:
dataset = Dataset(dataset_name, files)
q = QMatrix()
q.load('qmatrix-%s' % dataset_name)
models = [Zero(), IRT(), MIRT(dim=2), MIRT(dim=3), MIRT(q=q)] # [IRT()]#, MIRT(dim=2), MIRT(dim=3), MIRT(q=q)] # , MHRM(dim=2), , MHRM(dim=2)
dataset.load_subset()
print(dataset)
for i_exp in range(STUDENT_FOLD):
# train_subset = dataset.train_subsets[i_exp]
# test_subset = dataset.test_subsets[i_exp]
for j_exp in range(QUESTION_FOLD):
# validation_index = set(dataset.validation_question_sets[j_exp])
files.update(i_exp, j_exp)
for model in models:
if cw['rainfall'] != 0.0 and self.prev[n]['rainfall'] == 0.0:
self.fire(name=n, weather=cw)
if cw['rainfall'] == 0.0 and self.prev[n]['rainfall'] != 0.0:
self.fire(name=n, weather=cw)
self.prev[n] = cw
def load_handler(module_name, class_name, cons_args=[], cons_kwargs={}):
import importlib
module = importlib.import_module(module_name)
klazz = module.__getattribute__(class_name)
return klazz(*cons_args, **cons_kwargs)
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
with open('config.json') as fp:
conf = json.load(fp)
appid = conf['appid']
def map_to_venue(obj):
return obj['name'], Coordinate(**obj['coordinate'])
venues = list(map(map_to_venue, conf['venues']))
ac = ApiClapper(appid)
t = Tefnut(ac, venues)
for h in conf['handlers']:
hdlr = load_handler(**h)
t.add_handler(hdlr)
ch = Chrono(t.trigger, timedelta(minutes=5), first_fire=True)
dile.createNetCDF4(path,matrix[a:b+1,c:d+1]) z += 1 printProgress(x*(len(ind)*len(diles))+(y*len(diles)+z), iter_len, basename, fname) y += 1 x += 1 return iter_len if __name__ == '__main__': timer = Chrono() ncg = NetcdfGeometry() lpw = LukePathWalker() mydir = "/sdiles/ubuntu/sdiles" myext = ["nc"] paths = [] for file in lpw.getDirectoryContent(mydir): if lpw.checkExtention(myext, file): paths.append(file) for i in range(50,len(paths)):