def main():
# generer un environnement:
# 1. definir les dims du plateau
plateau = Environnement.ClassePlateau(50, 50)
# 2. définir le nombre d obstacles
nbObstacles = 200
env = Environnement.ClasseEnvironnement(plateau, nbObstacles)
# 3. générer les obstacles
env.genererListeObstacles()
#print(len(env.listeDesObstacles))
# 4. tirer un sommet d arrivee
env.genererArrivee()
#pdb.set_trace()
# 5. tirer un sommet de départ
env.genererDepart()
# validation ok:
#print(env.depart.x)
# 6. ajouter le necessaire pour que depart puisse etre ajoute dans la
# pile de priorite
env.depart.initDepart(env.arrivee)
env.depart.mettreAJourClassement()
# 7. marque le point d arrivee comme etant l arrivee (distance arrivee nulle)
env.arrivee.initArrivee()
print(dir(env.depart))
# 8. creer une pilie de prio
liste_priorite_noeuds_en_traitement = PileDePriorite.ClassePileDePriorite()
env.pile = liste_priorite_noeuds_en_traitement
# validation ok:
#print(liste_priorite_noeuds_en_traitement)
# 9. la liste de noeuds traités, une bete liste
liste_de_noeuds_traites = ListeAssociativeDeSommetsVisites.ListeAssociativeDeSommets(
)
env.traite = liste_de_noeuds_traites
# 10. il nous faut une structure qui represente le graphe en fournissant les voisins
# d un noeud donné
G = graphe.Graphe(env)
resultat = astar.astar(G, env.depart, env.arrivee, liste_de_noeuds_traites,
liste_priorite_noeuds_en_traitement)
def inputIfDuree(msg_lever, msg_coucher, msg_erreur=msg_erreur):
"""
Fonction qui récupère une duree d'ensoleillement à partir d'une heure de lever et d'une heure de coucher.
:return: (float) duree d'ensoleillement
"""
Temps = 0
cond = "True"
while cond:
try:
# On récupère les heures de coucher et lever
lever = input(msg_lever)
coucher = input(msg_coucher)
# On essaye de les convertir en une duree
Temps = env.duree_journee(lever, coucher)
# On arrête la boucle en mettant la condition à False
cond = False
except:
print(format("Erreur : " + msg_erreur, "erreur"))
return Temps
def donnees(mode=1):
"""Fonction qui permet d'appeler des valeurs de test"""
Tfluide = 65 + 273.15
a = .30
b = .2
Tamb = 20 + 273.15
Esol = 19.6
Temps_sol = 12
HRamb = 45
Masse_aliment = .5
Masse_epmsi = 3
Masse_epmsf = .1
Temps_sec = 5
HRmax = 20
if mode == 1:
Fd = 900
Fi = 100
else:
# Calcul des flux solaires
Fd, Fi = env.flux_solaires(Tamb, Esol, Temps_sol, HRamb)
return Tfluide, a, b, Tamb, Fd, Fi, HRamb, Masse_aliment, Masse_epmsi, Masse_epmsf, Temps_sec, HRmax
def main(mode="labo"):
"""
Fonction principale qui exécute tout le code.
"""
# INPUTS
if "test" in mode:
if mode == "test":
Tfluide, a, b, Tamb, Fd, Fi, HRamb, Masse_aliment, Masse_epmsi, Masse_epmsf, Temps_sec, HRmax = donnees(
0)
elif mode == "test1":
Tfluide, a, b, Tamb, Fd, Fi, HRamb, Masse_aliment, Masse_epmsi, Masse_epmsf, Temps_sec, HRmax = donnees(
1)
else:
Tfluide, a, b, Tamb, Fd, Fi, HRamb, Masse_aliment, Masse_epmsi, Masse_epmsf, Temps_sec, HRmax = userInputs(
mode)
# OUPUTS
Yamb = env.HRversY(HRamb, Tamb)
Ymax = env.HRversY(HRmax, Tfluide)
Q, J = vent.Bloc_ventilation(Masse_aliment, Masse_epmsi, Masse_epmsf, Yamb,
Ymax, Temps_sec)
P, succes = eds.Bloc_effet_de_serre(Tfluide, Fd, Fi, a, b)
D = Q / rho
L = dimensionnement(P[0], a, Q, Tfluide, Tamb, J)
# PRINT
printline()
print(format("► Résultats :", "gras"))
if succes is True:
print(format("Le logiciel a trouvé une solution", "vert"))
print(
"\u001b[1;32m" + "\nLongueur =",
round(L, 2),
"m" + "\u001b[0m",
"\nJ =\t",
round(J, 6),
"kg/s",
"\nQ =\t",
round(Q, 6),
"kg/s",
"\u001b[1;32m" + "\nDébit =\t",
round(D, 6),
"m³/s",
"\nDébit =\t",
round(D * 60, 6),
"m³/min",
"\nDébit =\t",
round(D * 3600, 3),
"m³/h",
"\nDébit =\t",
round(D / (0.04**2 * 3.1416), 3),
"m/s (pour 4cm de dimaètre)" + "\u001b[0m",
"\nYamb =\t",
round(Yamb, 6),
"kg d'eau par kg d'air sec",
"\nYmax =\t",
round(Ymax, 6),
"kg d'eau par kg d'air sec",
"\nFd =\t",
round(Fd, 1),
"W/m²",
"\nFi =\t",
round(Fi, 1),
"W/m²",
"\nP =\t",
round(P[0], 1),
"W/m²",
"\nPuissance théorique totale =",
round(L * a * P[0], 2),
"W",
"\nTs =\t",
round(P[1], 1),
"K\t=",
round(P[1] - 273.15, 1),
"°C",
"\nTp =\t",
round(P[2], 1),
"K\t=",
round(P[2] - 273.15, 1),
"°C",
"\nFs =\t",
round(P[3], 1),
"W/m²",
"\nFp =\t",
round(P[4], 1),
"W/m²",
"\nRa =\t",
int(P[5]),
"\nRa / 10^7 =",
round(P[5] / 10**7, 2),
"\u001b[1;35m" + "\nValidité des corrélations :",
10**7 < P[5] < (2 * 10**11),
"\u001b[0m", # détermine si la nombre de Rayleigh est valable par rapport au nombre de Nusselt
"\nNu =\t",
round(P[6], 3),
"\u001b[1;35m" + "\nh =\t",
round(P[7], 2)), "\u001b[0m"
else:
print(
format(
"Le logiciel n'a pas trouvé de solution. \nVeuillez vérifier que vos valeurs rentrent dans le domaine de validité du programme.",
"erreur"))
return None
def userInputs(mode=mode_par_defaut):
"""
Fonction qui traite les inputs.
:return: toutes le valeurs des inputs dans l'odre suivant :
Tfluide, a, b, Tamb, Fd, Fi, HRamb, Masse_aliment, Masse_epmsi, Masse_epmsf, Temps_sec, HRmax
"""
# Effet de serre
printline()
print(format("► Partie Effet de serre :\n", "gras"))
Tfluide = inputIfDeci("T que l'on veut atteindre [C°] = ") + 273.15
a = inputIfDeci("Longueur de la section de la boîte [m] = ")
b = inputIfDeci("Hauteur de la section de la boîte [m] = ")
# Environnement : température et humidité ambiante, temps d'ensoleillement et énergie totale captée en une journée
printline()
print(format("► Partie Environnement :\n", "gras"))
Tamb = inputIfDeci("Température ambiante [C°] = ") + 273.15
HRamb = inputIfDeci("Humidité relative ambiante en pourcents = ")
# Calcul des flux solaires
if mode == "énergie":
Esol = inputIfDeci(
"Energie solaire reçue au sol au cours d'une journée [MJ/m²] = ")
Temps_sol = inputIfDuree(
"Heure de lever du soleil (exemple : 18h30)= ",
"Heure de coucher du soleil (exemple : 18h30)= ",
format(
"Echec de la conversion en duree. Veillez à bien formatter les heures. Veuillez réessayer.",
"erreur"))
Fd, Fi = env.flux_solaires(Tamb, Esol, Temps_sol, HRamb)
elif mode == "flux moyen":
Fd = inputIfDeci("Flux solaire direct [W/m²] = ")
Fi = env.flux_indirect(Tamb, HRamb)
elif mode == "labo":
Fd = inputIfDeci("Flux solaire direct [W/m²] = ")
Fi = inputIfDeci("Flux solaire indirect [W/m²] = ")
# Ventilation
printline()
print(format("► Partie Ventilation :\n", "gras"))
Masse_aliment = inputIfDeci(
"Masse de l'aliment que vous souhaitez sécher [kg] = ")
Masse_epmsi = inputIfDeci(
"Masse d'eau par kg de matière sèche initiale [kg] = ")
Masse_epmsf = inputIfDeci(
"Masse d'eau par kg de matière sèche que l'on souhaite atteindre au final [kg] = "
)
assert Masse_epmsi > Masse_epmsf, "Erreur : vous avez entré une masse d'eau finale dans l'aliment supérieure à la masse d'eau initiale !"
Temps_sec = inputIfDeci("Temps de séchage souhaité [heures] = ")
HRmax = inputIfDeci(
"Humidité relative maximale dans le séchoir en pourcents = ")
return Tfluide, a, b, Tamb, Fd, Fi, HRamb, Masse_aliment, Masse_epmsi, Masse_epmsf, Temps_sec, HRmax
)
# ------------ Defining several parameters - others will be chosen by grid search --------------
N_items = 10
N_recommended = 2
memory = 1
choiceMethod = 'QlearningActionsTuples'
rewardType = 'Trust'
behaviour = 'random'
rewardParameters = [1, 1]
steps = 10
epochs = 5
train_list = [True for u in range(3)] + [False, False]
#------------- Defining the environnement -----------
environnement = Environnement(N_items, N_recommended, behaviour, rewardType,
rewardParameters)
#>>> let's test the efficiency of our algorithm by testing with this simplified set:
for item in environnement.items.items:
item.cost = 1
environnement.items.items[2].cost = 0
environnement.items.items[4].cost = 0
#<<<
environnement.items.display(True)
# >>> Grid search over the parameters to get the best parameters
gridSearch = GridSearch()
num_avg = 3
_, params = gridSearch(num_avg,
environnement,
from AvailableMoves import *
from Environnement import *
if __name__ == '__main__':
env = Environnement()
env.init_pos((3, 5))
movs = MovesChecker(env)
env.visit('north')
m = movs.availableMoves((3, 3), True)
for x in m:
print(x)
def results_on_same_environnement():
# ______ Environment creation _________
environnement = Environnement(N_items,
N_recommended,
behaviour,
rewardType,
rewardParameters,
proba_p=min_similarities_sum)
environnement.items.items[0].cost = 0 # To remove later
# ______ RL agents ____________________
# a) DeepQlearning
# --params --
choiceMethod = 'DeepQlearning'
model = nn.Sequential(nn.Linear(memory + 2 * N_recommended, 10), nn.SELU(),
nn.Linear(10, 1))
trainable_layers = [0, 2]
deepQModel = {'model': model, 'trainable_layers': trainable_layers}
# -- Grid search the best parameters --
gridSearch = GridSearch()
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps,
more_params=None,
deepQModel=deepQModel)
# -- Results with the best hyper parameters --
avgSeries_DL = AverageSeries(num_avg, environnement, memory, choiceMethod,
params, epochs_test, train_list, steps,
deepQModel)
Rewards_DeepQLearning = avgSeries_DL.avgRewards
# b) Tabular Q Learning
# --params --
choiceMethod = 'QlearningActionsTuples'
# -- Grid search the best parameters --
gridSearch = GridSearch()
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps)
# -- Results with the best hyper parameters --
avgSeries_Tabular = AverageSeries(num_avg, environnement, memory,
choiceMethod, params, epochs_test,
train_list, steps)
Rewards_Tabular = avgSeries_Tabular.avgRewards
# c) Linear Q Learning
# --params --
choiceMethod = 'LinearQlearning'
# -- Grid search the best parameters --
gridSearch = GridSearch()
_, params = gridSearch(num_avg,
environnement,
memory,
choiceMethod,
epochs,
train_list,
steps=steps)
# -- Results with the best hyper parameters --
avgSeries_Linear = AverageSeries(num_avg, environnement, memory,
choiceMethod, params, epochs_test,
train_list, steps)
Rewards_Linear = avgSeries_Linear.avgRewards
return np.array(Rewards_Tabular), np.array(
Rewards_DeepQLearning), np.array(Rewards_Linear)
N_recommended = 3
memory = 2
choiceMethod = 'DeepQlearningFaster'
rewardType = 'Trust'
behaviour = 'similarWithSubset'
rewardParameters = [1, 1]
steps = 10
epochs = 3
train_list = [True for u in range(3)] + [False, False]
more_params = {'debug': False, 'subset_size': 30}
min_similarities_sum = N_recommended / 3 #TODO : explore / change this user behaviour accordingly
#------------- Defining the environnement -----------
print("--> creating environnement")
environnement = Environnement(N_items,
N_recommended,
behaviour,
rewardType,
rewardParameters,
proba_p=min_similarities_sum)
#environnement.items.display(True)
#Create model
# model = nn.Sequential(
# nn.Linear(memory+2*N_recommended, 20),
# nn.SELU(),
# nn.Linear(20, 5),
# nn.SELU(),
# nn.Linear(5, 1),
# nn.Sigmoid()
#
# )
dt = duree_stim/float(nb_pts-1) #position agent xA = 0 yA = 0 #position cible xS = -5 yS = 0 #constante raideur k = 3.0 '''-------------------''' #debut de la simulation env = Environnement(nb_pts, duree_stim, xA, yA, xS, yS) agent = Controleur(k) #boucle de simulation for i in range(nb_pts-1): agent.update(env.y[i,0], env.theta_etoile()) #en parametres, respectivement : theta, theta etoile(deplacement angulaire desire) env.update(agent.output_u1, agent.output_u2, i) #affichage somme = 0 for i in range(nb_pts): somme += env.y[i,1] moyV = somme / float(nb_pts) xdata = [env.y[i,0] for i in range(nb_pts)]
listeDeSommetsVisites: 'List[Sommet.ClassSommet]'
) -> 'List[Sommet.ClassSommet]':
listeResultante = copy.deepcopy(listeSuccesseurs)
for un_sommet in listeResultante:
if un_sommet in listeDeSommetsVisites:
listeResultante.remove(un_sommet)
return listeResultante
if __name__ == '__main__':
# validé pour la verif du type de environnement
#env = "qdfqdsf"
#g = Graphe(env)
# generer un environnement:
# 1. definir les dims du plateau
plateau = Environnement.ClassePlateau(50, 50)
# 2. définir le nombre d obstacles
nbObstacles = 200
env = Environnement.ClasseEnvironnement(plateau, nbObstacles)
# 3. générer les obstacles
env.genererListeObstacles()
#print(len(env.listeDesObstacles))
# 4. tirer un sommet d arrivee
env.genererArrivee()
# 5. tirer un sommet de départ
env.genererDepart()
# validation ok:
#print(env.depart.x)
# 6. ajouter le necessaire pour que depart puisse etre ajoute dans la
# pile de priorite
rewardType = 'Trust'
behaviour = 'similarWithSubset'
rewardParameters = [1, 1]
steps = 10
epochs = 3
train_list = [True for u in range(3)] + [False, False]
more_params = {
'debug': True,
'subset_size': 4
} #Here, the subset will exactly be the number of available actions
min_similarities_sum = 1
#------------- Defining the environnement -----------
environnement = Environnement(
N_items,
N_recommended,
behaviour,
rewardType,
rewardParameters,
proba_p=min_similarities_sum
) #Here the proba_p parameter is not necessarly a probability
#>>> let's test the efficiency of our algorithm by testing with this simplified set:
for item in environnement.items.items:
item.cost = 1
environnement.items.items[1].cost = 0
environnement.items.similarities = np.array([[-np.inf, 0.1, 0.1, 0.8],
[0.1, -np.inf, 0.1, 0.8],
[0.1, 0.1, -np.inf, 0.8],
[0.8, 0.8, 0.8, -np.inf]])
#<<<
