def __init__(self, size, step, name):
pygame.init()
pygame.display.set_caption(name)
screen = pygame.display.set_mode((size, size))
screen.fill((235, 235, 235))
gril = grille.Grille(size, step)
gril.createTab("0")
self.use = balle.Balle(screen, gril, 3, 2, int(step / 2))
gril.draw(pygame, screen)
def resolution_nbr_cases(nbLignes = default_nbLignes,
nbCol = default_nbCol,
p = default_p,
gamma = default_gamma,
epsilon = default_epsilon):
size = nbLignes * nbCol
couts = [0, 1, size ** 1, size ** 2, size ** 3]
reward = 1000
grid = grille.Grille(nbLignes,nbCol,2,0.2,0.2,0.2,0.2,0.2,couts,reward)
d,v,t,time = p2.iteration_de_la_valeur(grid.g,p,gamma,epsilon)
print(ot.from_action_to_dir(d,grid.g))
def __init__(self, taille, saison):
"""
:param taille: taille de la grille
:type taille: tuple
:param saison: saison
:type saison:string
:return:
"""
self.taille = taille
self.saison = saison
self.grille = g.Grille(self.taille, self.saison)
self.grille.remplir_case()
def __init__(self, size, step, name):
pygame.init()
pygame.display.set_caption(name)
screen = pygame.display.set_mode((size, size))
screen.fill((235, 235, 235))
gril = grille.Grille(size, step)
gril.createTab("0") # cré une table rempli de 0
self.finish = arrive.Arrive(screen, gril, 2,
2) # instancie une arrivé en position 2,2
self.use = balle.Balle(
screen, gril, 3, 2, int(step / 2)
) # instancie une balle en position 3,2 avec un rayon qui vaut la moitié de la taille d'une case
gril.draw(pygame, screen)
def impact_q(variation_q,
nbLignes = default_nbLignes,
nbCol = default_nbCol,
p = default_p,
gamma = default_gamma,
epsilon = default_epsilon):
couts = [0,1,2,3,4]
for q in variation_q:
random.seed(1)
np.random.seed(1)
print(q)
new_couts = [x**q for x in couts]
g = grille.Grille(nbLignes,nbCol,2,0.2,0.2,0.2,0.2,0.2,new_couts,1000).g
d,v,t,time = p2.iteration_de_la_valeur(g,p,gamma,epsilon)
print(ot.from_action_to_dir(d,g))
def main():
pygame.init()
size=[dim,dim]
screen=pygame.display.set_mode(size)
g=grille.Grille()
while 1:
event = pygame.event.poll()
if event.type == pygame.QUIT: break
g.deplacements()
affichage(screen,g)
pygame.quit()
def fond(screen,g):
#on récupère les coordonnées des obstacles,portes,des voyageurs(mobiles)
#Grille.getVoyageurs.keys (on récupère les tuples)
#Grille.getObstacles.keys (on récupère les bstacles)
g = grille.Grille()
#on récupère les coordonnées des obstacles
OBSTACLES=g.getObstacles()
#on récupère les coordonnées des portes
PORTES=g.getPortes()
dessiner_grille(screen)
case = pygame.Surface((taille,taille)) # une surface grise
#on place les obstacles
for obstacle in OBSTACLES:
obst=OBSTACLES[obstacle]
case.fill(obst.couleur)
screen.blit(case,obstacle)
#on place les portes
for porte in PORTES:
p=PORTES[porte]
case.fill(p.couleur)
screen.blit(case,porte)
pygame.display.flip()
def resolution_nbr_cases(nbLignes=default_nbLignes,
nbCol=default_nbCol,
p=default_p,
gamma=default_gamma,
epsilon=default_epsilon):
size = nbLignes * nbCol
couts = [0, 1, size**1, size**2, size**3]
reward = 1000
grid = grille.Grille(nbLignes, nbCol, 2, 0.2, 0.2, 0.2, 0.2, 0.2, couts,
reward)
d, v, t, time = algos.iteration_de_la_valeur(grid.g, p, gamma, epsilon)
print(ot.from_action_to_dir(d, grid.g))
#affichage dans la GUI
grid.resultat.config(state=tk.NORMAL)
grid.resultat.delete(1.0, tk.END)
grid.resultat.insert(tk.INSERT, ot.from_action_to_dir(d, grid.g))
grid.resultat.insert(tk.INSERT, '\nnumber of iteration :' + str(t))
grid.resultat.insert(tk.INSERT, '\ntime :' + str(time))
grid.resultat.config(state=tk.DISABLED)
grid.Mafenetre.mainloop()
# resolution_nbr_cases()
def impact_size(sizes,
nbr_tests = default_tests,
p = default_p,
gamma = default_gamma,
epsilon = default_epsilon):
df = pd.DataFrame(columns = ["dimensions",
"taille",
"iter_val",
"iter_pol",
#"iter_pl",
"time_val",
"time_pol",
#"time_pl",
])
for i, taille in enumerate(sizes) :
print(taille)
somme1_it = 0
somme1_t = 0
somme2_it =0
somme2_t =0
# TODO : à decommenter pour le PL
#somme3_it = 0
#somme3_t=0
for k in range(nbr_tests):
g = grille.Grille(taille[0],taille[1],2,0.2,0.2,0.2,0.2,0.2,[0,1,2,3,4],1000).g
#print(g)
#print("run "+str(k+1)+" out of "+str(nbr_tests))
# iteration de la valeur
d,v,t, time = p2.iteration_de_la_valeur(g,p,gamma,epsilon)
somme1_it += t
somme1_t += time
# iteration de la politique
d,v,t, time = p2.iteration_de_la_politique(g,p,gamma,epsilon)
somme2_it += t
somme2_t += time
# TODO : à decommenter avec le PL
#d,v,t,time = p2.pl(g,p,gamma,epsilon)
#somme3_it += t
#somme3_t += time
# ajouter le pl
line = pd.Series({'dimensions' : taille,
'taille' : taille[0]*taille[1],
'iter_val' : somme1_it/nbr_tests,
'iter_pol': somme2_it/nbr_tests,
#'iter_pl' : somme3_it/nbr_tests,
'time_val': somme1_t/nbr_tests,
'time_pol': somme2_t/nbr_tests,
#'time_pl': somme3_t/nbr_tests,
})
df = df.append(line, ignore_index=True)
# Affichage des résultats
print(df)
plt.figure(1)
ax1 = plt.subplot(211)
plt.scatter(df.taille, df.iter_val, label = "Iteration de la valeur")
plt.scatter(df.taille, df.iter_pol, label = "Iteration de la politique")
# plt.scatter(df.taille, df.iter_pl, label = "Programmation mathématique")
#plt.xlabel("Taille de l'instance")
plt.ylabel("Nombre d'itérations")
plt.setp(ax1.get_xticklabels(), visible=False)
plt.legend(bbox_to_anchor=(1.05, 1), loc = 0, borderaxespad = 0.)
plt.subplot(212, sharex = ax1)
plt.scatter(df.taille, df.time_val, label = "Iteration de la valeur")
plt.scatter(df.taille, df.time_pol, label = "Iteration de la politique")
# plt.scatter(df.taille, df.time_pl, label = "Programmation mathématique")
plt.xlabel("Taille de l'instance")
plt.ylabel("Durée d'execution")
plt.show()
def impact_p(interval_p,
nbr_tests = default_tests,
nbLignes = default_nbLignes,
nbCol = default_nbCol,
gamma = default_gamma,
epsilon = default_epsilon):
df = pd.DataFrame(columns = ["p",
"iter_val",
"iter_pol",
#"iter_pl",
"time_val",
"time_pol",
#"time_pl",
])
for p in interval_p:
print("p = "+ str(p))
somme1_it = 0
somme1_t = 0
somme2_it =0
somme2_t =0
for k in range(nbr_tests):
g = grille.Grille(nbLignes,nbCol,2,0.2,0.2,0.2,0.2,0.2,[0,1,2,3,4],1000).g
#print(g)
#print("run "+str(k+1)+" out of "+str(nbr_tests))
d,v,t, time = p2.iteration_de_la_valeur(g,p,gamma,epsilon)
somme1_it += t
somme1_t += time
d,v,t,time = p2.iteration_de_la_politique(g,p,gamma,epsilon)
somme2_it += t
somme2_t += time
#TODO : à decommenter avec le PL
#d,v,t,time = p2.pl(g,p,gamma,epsilon)
#somme3_it += t
#somme3_t += time
# ajouter le pl
line = pd.Series({'p' : p,
'iter_val' : somme1_it/nbr_tests,
'iter_pol': somme2_it/nbr_tests,
#'iter_pl' : somme3_it/nbr_tests,
'time_val': somme1_t/nbr_tests,
'time_pol': somme2_t/nbr_tests,
#'time_pl': somme3_t/nbr_tests,
})
df = df.append(line, ignore_index=True)
print(df)
plt.figure(1)
ax1 = plt.subplot(211)
plt.scatter(df.p, df.iter_val, label = "Iteration de la valeur")
plt.scatter(df.p, df.iter_pol, label = "Iteration de la politique")
# plt.scatter(df.p, df.iter_pl, label = "Programmation mathématique")
plt.ylabel("Nombre d'itérations")
plt.setp(ax1.get_xticklabels(), visible=False)
plt.legend(bbox_to_anchor=(1.05, 1), loc = 0, borderaxespad = 0.)
plt.subplot(212, sharex = ax1)
plt.scatter(df.p, df.time_val, label = "Iteration de la valeur")
plt.scatter(df.p, df.time_pol, label = "Iteration de la politique")
# plt.scatter(df.p, df.time_pl, label = "Programmation mathématique")
plt.xlabel("Valeur de p")
plt.ylabel("Durée d'execution")
plt.show()
import environnement
import grille
"""
Petit programme de test de la classe Grille
"""
if __name__ == '__main__':
noir = (0, 0, 0)
rouge = (255, 0, 0)
vert = (0, 255, 0)
g = grille.Grille()
p1 = environnement.Porte(vert, g)
voy1 = environnement.Voyageur(rouge, [p1], g)
obs1 = environnement.Obstacle(noir, g)
g.addObstacle([(0, 0), (5, 4), (5, 5), (6, 5), (9, 9)], obs1)
g.addVoyageur((1, 1), voy1)
g.addPorte([(7, 8), (7, 9)], p1)
print(g)
print(g.getContenuCase((0, 0)), g.getContenuCase((1, 1)))
print(g.getDirection(voy1, p1))
g.deplacements()
print(g)
g.deplacements()
print(g)
g.deleteVoyageur(voy1)
print(g)
print("fini !")
def impact_size(sizes,
nbr_tests=default_tests,
p=default_p,
gamma=default_gamma,
epsilon=default_epsilon):
df = pd.DataFrame(columns=[
"dimensions",
"taille",
"iter_val",
"iter_pol",
"iter_pl",
"time_val",
"time_pol",
"time_pl",
])
for i, taille in enumerate(sizes):
print(taille)
somme1_it = 0
somme1_t = 0
somme2_it = 0
somme2_t = 0
somme3_it = 0
somme3_t = 0
for k in range(nbr_tests):
fenetre = grille.Grille(taille[0], taille[1], 2, 0.2, 0.2, 0.2,
0.2, 0.2, [0, 1, 2, 3, 4], 1000)
g = fenetre.g
# iteration de la valeur
d, v, t, time = algos.iteration_de_la_valeur(g, p, gamma, epsilon)
somme1_it += t
somme1_t += time
# iteration de la politique
d, v, t, time = algos.iteration_de_la_politique(
g, p, gamma, epsilon)
somme2_it += t
somme2_t += time
#pl
d, v, t, time = algos.pl(g, p, gamma)
somme3_it += t
somme3_t += time
# ajouter le pl
line = pd.Series({
'dimensions': taille,
'taille': taille[0] * taille[1],
'iter_val': somme1_it / nbr_tests,
'iter_pol': somme2_it / nbr_tests,
'iter_pl': somme3_it / nbr_tests,
'time_val': somme1_t / nbr_tests,
'time_pol': somme2_t / nbr_tests,
'time_pl': somme3_t / nbr_tests,
})
df = df.append(line, ignore_index=True)
# Affichage des résultats
print(df)
#stocke dans un fichier csv
df.to_csv("./impact_size.csv", ';')
plt.figure(1)
ax1 = plt.subplot(211)
plt.scatter(df.taille, df.iter_val, label="Iteration de la valeur")
plt.scatter(df.taille, df.iter_pol, label="Iteration de la politique")
plt.scatter(df.taille, df.iter_pl, label="Programmation mathématique")
plt.xlabel("Taille de l'instance")
plt.ylabel("Nombre d'itérations")
plt.setp(ax1.get_xticklabels(), visible=False)
plt.legend(bbox_to_anchor=(1, 1), loc=0, borderaxespad=0.)
plt.subplot(212, sharex=ax1)
plt.scatter(df.taille, df.time_val, label="Iteration de la valeur")
plt.scatter(df.taille, df.time_pol, label="Iteration de la politique")
plt.scatter(df.taille, df.time_pl, label="Programmation mathématique")
plt.xlabel("Taille de l'instance")
plt.ylabel("Durée d'execution")
plt.show()
def impact_gamma(interval_gamma,
nbr_tests=default_tests,
nbLignes=default_nbLignes,
nbCol=default_nbCol,
p=default_p,
epsilon=default_epsilon):
df = pd.DataFrame(columns=[
"gamma",
"iter_val",
"iter_pol",
"iter_pl",
"time_val",
"time_pol",
"time_pl",
])
for gamma in interval_gamma:
print("gamma = " + str(gamma))
somme1_it = 0
somme1_t = 0
somme2_it = 0
somme2_t = 0
somme3_it = 0
somme3_t = 0
for k in range(nbr_tests):
g = grille.Grille(nbLignes, nbCol, 2, 0.2, 0.2, 0.2, 0.2, 0.2,
[0, 1, 2, 3, 4], 1000).g
#iteration de la valeur
d, v, t, time = algos.iteration_de_la_valeur(g, p, gamma, epsilon)
somme1_it += t
somme1_t += time
#iteration de la politique
d, v, t, time = algos.iteration_de_la_politique(
g, p, gamma, epsilon)
somme2_it += t
somme2_t += time
#PL
d, v, t, time = algos.pl(g, p, gamma)
somme3_it += t
somme3_t += time
# ajouter le pl
line = pd.Series({
'gamma': gamma,
'iter_val': somme1_it / nbr_tests,
'iter_pol': somme2_it / nbr_tests,
'iter_pl': somme3_it / nbr_tests,
'time_val': somme1_t / nbr_tests,
'time_pol': somme2_t / nbr_tests,
'time_pl': somme3_t / nbr_tests,
})
df = df.append(line, ignore_index=True)
print(df)
df.to_csv("./impact_gamma.csv", ';')
plt.figure(1)
ax1 = plt.subplot(211)
plt.scatter(df.gamma, df.iter_val, label="Iteration de la valeur")
plt.scatter(df.gamma, df.iter_pol, label="Iteration de la politique")
plt.scatter(df.gamma, df.iter_pl, label="Programmation mathématique")
plt.ylabel("Nombre d'itérations")
plt.setp(ax1.get_xticklabels(), visible=False)
plt.legend(bbox_to_anchor=(1.05, 1), loc=0, borderaxespad=0.)
plt.subplot(212, sharex=ax1)
plt.scatter(df.gamma, df.time_val, label="Iteration de la valeur")
plt.scatter(df.gamma, df.time_pol, label="Iteration de la valeur")
plt.scatter(df.gamma, df.time_pl, label="Programmation mathématique")
plt.xlabel("Valeur de Gamma")
plt.ylabel("Durée d'execution")
plt.show()
