def __init__(self,prog=None,gp=None,lCap=[]):
# gestion du GeneratePercept choisir la variable de stockage
if gp is not None: generatep = gp
elif lCap == []: generatep = None
else: generatep = GeneratePercept(lCap,objetsStatiques)
#Création du programme génétique
if prog is None:
# choisir le nom de votre variable, remplacez les ...
dicaction={"A":"Aspirer","G":"Gauche","D":"Droite","R":"Repos"}
if lCap==[]:
programme = ProgramGenetic(1,8,['A','G','D','R'],dicaction)
else:
programme = ProgramGenetic(1,generatep.howMany,['A','G','D','R'],dicaction)
elif isinstance(prog,ProgramGenetic):
if lCap!=[]:
if gp.howMany!=len(prog):
raise AssertionError("the generatepercept don't match the program")
programme = prog
else:
raise AssertionError("{} expected got {}"
.format(ProgramGenetic,type(prog)))
# récupération des actions depuis votre variable
# attention ce n'est pas une 'list' c'est un 'set'
lAct = list(programme.actions)
super().__init__(lCap,lAct)
self._dicAspi["gp"]=generatep
self._dicAspi["programme"]=programme
# choisir la variable pour energie
self._dicAspi["energie"]= 100
self._dicAspi["cpt"]=0
self.reset()
def __init__(self, prog = None, gp = None, lCap = []):
if gp is not None:
self.__stock = gp
elif lCap == []:
self.__stock = None
else:
self.__stock = GeneratePercept(lCap, objetsStatiques)
if prog is None:
if lCap == []:
self.__chromosome = ProgramGenetic(1, 8, "A G D R".split(), plagiatUnaire)
else:
self.__chromosome = ProgramGenetic(1, self.__stock.howMany, "A G D R".split(), plagiatUnaire)
elif isinstance(prog, ProgramGenetic):
if lCap != []:
assert (len(prog) == self.__stock.howMany), "pas compatible"
self.__chromosome = prog
else:
raise AssertionError("{} expected got {}"
.format(ProgramGenetic, type(prog)))
lAct = list(self.__chromosome.actions)
super().__init__(lCap, lAct)
self.__energy = 100
self.__cpt = 0
self.reset()
def __init__(self,
nbIteration,
fichier,
capteurs,
envt,
nbIndiv,
szGene,
alphabet,
decodeur,
panne=False):
self.__sim = Simulateur(nbIteration, fichier, capteurs, panne)
if capteurs == []:
self.__nbG = 20
self.__gp = None
else:
self.__gp = GeneratePercept(capteurs, envt)
self.__nbG = self.__gp.howMany
self.__prog = ProgramGenetic(szGene, self.__nbG, alphabet, decodeur)
super().__init__(nbIndiv, self.__nbG, szGene, alphabet)
for x in self.popAG:
x.fitness = lambda _: self.simEval(_)
def __init__(self,prog=None,gp=None,lCap=[]):
if gp is not None: self.__gp = gp
elif lCap == []: self.__gp = None
else: self.__gp = GeneratePercept(lCap,objetsStatiques)
if prog is None:
if lCap == []:
self.__prog = ProgramGenetic(1,8,"AGDR",mmcUnaire)
else:
self.__prog = ProgramGenetic(1,self.__gp.howMany,
"AGDR",mmcUnaire)
elif isinstance(prog,ProgramGenetic):
if self.__gp is not None:
assert len(prog)==self.__gp.howMany,\
("expected: {} found: {} 'prog' is not suitable"
.format(self.__gp.howMany,len(prog)))
self.__prog = prog
else:
raise AssertionError("{} expected got {}"
.format(ProgramGenetic,type(prog)))
lAct = list(self.__prog.actions)
super().__init__(lCap,lAct)
self.__energy = 100
self.reset()
class Aspirateur_PG(Aspirateur):
"""
prog: un programme genetique, par défaut None
gp: un GeneratePercept, par défaut None
lCap: valeur par défaut []
"""
def __init__(self,prog=None,gp=None,lCap=[]):
if gp is not None: self.__gp = gp
elif lCap == []: self.__gp = None
else: self.__gp = GeneratePercept(lCap,objetsStatiques)
if prog is None:
if lCap == []:
self.__prog = ProgramGenetic(1,8,"AGDR",mmcUnaire)
else:
self.__prog = ProgramGenetic(1,self.__gp.howMany,
"AGDR",mmcUnaire)
elif isinstance(prog,ProgramGenetic):
if self.__gp is not None:
assert len(prog)==self.__gp.howMany,\
("expected: {} found: {} 'prog' is not suitable"
.format(self.__gp.howMany,len(prog)))
self.__prog = prog
else:
raise AssertionError("{} expected got {}"
.format(ProgramGenetic,type(prog)))
lAct = list(self.__prog.actions)
super().__init__(lCap,lAct)
self.__energy = 100
self.reset()
def reset(self):
self.vivant = True
self.cpt = 0
self.__tour = 0
@property
def nbTours(self):
""" permet de savoir combien de temps l'agent est resté vivant """
return self.__tour
@property
def energie(self): return self.__energy
@energie.setter
def energie(self,v):
#print("avt: {}, aprs: {}".format(self.energie,v))
assert isinstance(v,int), "int expected found {}".format(type(v))
self.__energy = max(0,min(100,v))
if self.__energy == 0: self.vivant = False
@property
def vivant(self): return self.__alive
@vivant.setter
def vivant(self,v):
if isinstance(v,bool): self.__alive = v
@property
def cpt(self): return self.__cpt
@cpt.setter
def cpt(self,v):
assert isinstance(v,int)
self.__cpt = v % len(self.__prog)
@property
def program(self): return self.__prog
def getEvaluation(self):
# On renvoie l'évaluation de l'agent
# (nombre de pièces nettoyées + 1) / ( len(self.knowledge) + 1 )
if hasattr(self,'nettoyage') and hasattr(self,'pieces_sales'):
if self.pieces_sales == 0: _score = 0
else: _score = (self.nettoyage / self.pieces_sales) * 10
else:
raise AttributeError("'nettoyage' or 'pieces_sales' missing")
if not self.vivant: _score -= 100 ; _rho = 0
elif self.energie < 25: _rho = Fraction(1,2)
elif self.energie < 50: _rho = Fraction(2,3)
elif self.energie < 75: _rho = Fraction(3,4)
else: _rho = 1
return _score + _rho * self.energie / 100
def getDecision(self,percepts):
self.__tour += 1 # aspi a survécu un tour de plus
if percepts == []:
_rep = self.program.decoder(self.cpt)
self.cpt += 1
return _rep
return self.program.decoder(self.__gp.find(percepts))
class Aspirateur_PG(Aspirateur):
"""
prog: un programme genetique, par défaut None
gp: un GeneratePercept, par défaut None
lCap: valeur par défaut []
"""
def __init__(self, prog = None, gp = None, lCap = []):
if gp is not None:
self.__stock = gp
elif lCap == []:
self.__stock = None
else:
self.__stock = GeneratePercept(lCap, objetsStatiques)
if prog is None:
if lCap == []:
self.__chromosome = ProgramGenetic(1, 8, "A G D R".split(), plagiatUnaire)
else:
self.__chromosome = ProgramGenetic(1, self.__stock.howMany, "A G D R".split(), plagiatUnaire)
elif isinstance(prog, ProgramGenetic):
if lCap != []:
assert (len(prog) == self.__stock.howMany), "pas compatible"
self.__chromosome = prog
else:
raise AssertionError("{} expected got {}"
.format(ProgramGenetic, type(prog)))
lAct = list(self.__chromosome.actions)
super().__init__(lCap, lAct)
self.__energy = 100
self.__cpt = 0
self.reset()
def reset(self):
""" initialisation de certaines variables pour chaque simulation """
self.vivant = True
self.cpt = 0
self.repos = 0
self.energie = 100
self.__cptalive = 0
@property
def stock(self): return self.__stock
@property
def energie(self): return self.__energy
@energie.setter
def energie(self,v):
assert isinstance(v, int), "int expected found {}".format(type(v))
self.__energy = max(0, min(100, v)) # force la valeur entre 0 et 100
if self.__energy == 0:
self.vivant = False
@property
def vivant(self): return self.__vivant
@vivant.setter
def vivant(self, v):
if isinstance(v, bool): self.__vivant = v
@property
def cpt(self): return self.__cpt
@cpt.setter
def cpt(self, v):
assert isinstance(v,int)
self.__cpt = min(max(0,v % len(self.program)),len(self.program)-1)
@property
def nbTours(self):
""" renvoie le nombre d'itérations pendant lesquelles aspi est vivant """
return self.__cptalive
@property
def program(self): return self.__chromosome
def getEvaluation(self):
""" renvoie l'évaluation de l'agent """
score = (self.nettoyage / self.dirty) * 10 if self.dirty != 0 else 0
index = int(self.energie / 25)
index = min(index, 3)
link = [1/2 * self.energie / 100, 2/3 * self.energie / 100, 3/4 * self.energie / 100, self.energie / 100]
if not self.vivant: score -= 100
else: score += link[index]
return score
def getDecision(self, percepts):
""" deux cas à traiter suivant que percepts = [] ou pas """
self.__cptalive += 1
if percepts == []:
return self.program.decoder(self.cpt)
return self.program.decoder(self.__stock.find(percepts))
