def __init__(self, probaExploitation : float,
lCap: TupLst = [],
lAct: TupLst = "Gauche Droite Aspirer".split(),
learn: bool =False) -> None :
super().__init__(lCap,lAct)
assert 0 <= probaExploitation <= 1, "Probability expected"
assert isinstance(learn,bool), "Boolean expected got %s" % type(learn)
# initialisation de variables privées __XXX (nom à choisir)
self.__kb = KB() # base de données vide
self.__proba = probaExploitation
self.__learn = learn
self.reset()
def __init__(self, probaExploitation, lCap=[], lAct="Gauche Droite Aspirer".split(), learn=False):
super(Aspirateur_KB,self).__init__(lCap,lAct)
assert 0 <= probaExploitation <= 1, "Probability expected"
assert isinstance(learn, bool), "Boolean expected got %s" % type(learn)
self.__knowbase = KB() # base de données vide
self.__probaExploitation = probaExploitation
self.__learn = learn
self.__lastAction = None # dernière action choisie
self.__lastPercept = None # dernier percept reçu
# self.compteurs = collections.OrderedDict()
self.compteurs = {'alea': 0, 'exploitation' : 0, 'total' : 0, 'exploration': 0}
def __init__(self,
probaExploitation,
lCap=[],
lAct="Gauche Droite Aspirer".split(),
learn=False):
super(Aspirateur_KB, self).__init__(lCap, lAct)
assert 0 <= probaExploitation <= 1, "Probability expected"
assert isinstance(learn, bool), "Boolean expected got %s" % type(learn)
self._dicAspi["know"] = KB() # base de données vide
self._dicAspi["exploit"] = probaExploitation
self._dicAspi["learn"] = learn
self._dicAspi["lastaction"] = None # dernière action choisie
self._dicAspi["lastpercept"] = None # dernier percept reçu
self.compteurs = {
'alea': 0,
'exploitation': 0,
'total': 0,
'exploration': 0
}
class Aspirateur_KB(Aspirateur):
""" 4 paramètres
probaExploitation: pas de valeur par défaut
lCap: valeur par défaut []
lAct: valeur par défaut la liste des 3 actions Gauche Droite Aspirer
learn: valeur par défaut False (pas d'apprentissage)
"""
def __init__(self, probaExploitation, lCap=[], lAct="Gauche Droite Aspirer".split(), learn=False):
super(Aspirateur_KB,self).__init__(lCap,lAct)
assert 0 <= probaExploitation <= 1, "Probability expected"
assert isinstance(learn, bool), "Boolean expected got %s" % type(learn)
self.__knowbase = KB() # base de données vide
self.__probaExploitation = probaExploitation
self.__learn = learn
self.__lastAction = None # dernière action choisie
self.__lastPercept = None # dernier percept reçu
# self.compteurs = collections.OrderedDict()
self.compteurs = {'alea': 0, 'exploitation' : 0, 'total' : 0, 'exploration': 0}
@property
def apprentissage(self): return self.__learn
@apprentissage.setter
def apprentissage(self, v):
assert isinstance(v, bool), "pas bool."
self.__learn = v
@property
def knowledge(self): return copy.deepcopy(self.__knowbase)
@knowledge.setter
def knowledge(self, v):
assert isinstance(v, KB), "pas KB"
self.__knowbase = v
@property
def probaExploitation(self): return self.__probaExploitation
# def getEvaluation(self):
# # super().getEvaluation()
# return (self.nettoyage+1)/(len(self.knowledge)+1)
def getDecision(self, percepts):
assert isinstance(percepts,(list,tuple)), "%s should be list or tuple" % percepts
assert len(percepts) == len(self.capteurs), "percepts and capteurs do not match"
assert all([x in objetsStatiques for x in percepts]), "bad percepts %s" % percepts
self.__lastPercept = percepts
rule_lst = self.__knowbase.find(percepts)
if len(rule_lst) == 0:
action = choice(self.actions)
self.compteurs['alea'] += 1
else:
base_actions = [regle.conclusion for regle in rule_lst]
notbase_actions = list(set(self.actions) - set(base_actions))
best_rule = max(rule_lst, key = lambda rule: rule.scoreMoyen)
r = random()
if r < self.probaExploitation:
action = best_rule.conclusion
self.compteurs['exploitation'] += 1
else:
num = rule_lst.index(best_rule)
other_rules = rule_lst[:num] + rule_lst[(num+1):]
if len(other_rules) !=0:
_ = choice(other_rules)
action = _.conclusion
if _.scoreMoyen < 0 and len(notbase_actions) != 0:
action = choice(notbase_actions)
else:
action = choice(notbase_actions)
self.compteurs['exploration'] += 1
self.compteurs['total'] += 1
self.__lastAction = action
return self.__lastAction
def setReward(self, value):
super(Aspirateur_KB,self).setReward(value)
if self.apprentissage:
r = Rule(self.__lastPercept, self.__lastAction, value)
_ = self.knowledge
_.add(r)
self.knowledge = _
class Aspirateur_KB(Aspirateur):
""" 4 paramètres
probaExploitation: pas de valeur par défaut
lCap: valeur par défaut []
lAct: valeur par défaut la liste des 3 actions Gauche Droite Aspirer
learn: valeur par défaut False (pas d'apprentissage)
"""
def __init__(self, probaExploitation : float,
lCap: TupLst = [],
lAct: TupLst = "Gauche Droite Aspirer".split(),
learn: bool =False) -> None :
super().__init__(lCap,lAct)
assert 0 <= probaExploitation <= 1, "Probability expected"
assert isinstance(learn,bool), "Boolean expected got %s" % type(learn)
# initialisation de variables privées __XXX (nom à choisir)
self.__kb = KB() # base de données vide
self.__proba = probaExploitation
self.__learn = learn
self.reset()
def reset(self):
""" réinitialisation de variables possibles """
self.__lastAction = None # dernière action choisie
self.__lastPercept = None # dernier percept reçu
# compteurs pour statistiques
self.compteurs = {'alea': 0, 'exploration': 0, 'exploitation': 0, 'total': 0 }
@property
def apprentissage(self): return self.__learn
@apprentissage.setter
def apprentissage(self,v):
# on vérifie que v est un booléen et si oui on affecte la_variable_privée_contenant_learn
if isinstance(v,bool): self.__learn = v
@property
def knowledge(self): return copy.deepcopy(self.__kb)
@knowledge.setter
def knowledge(self,v):
# on vérifie que v est une KB, si oui on affecte la_variable_privée_contenant_la_base_de_connaissance
if isinstance(v,KB): self.__kb = v
@property
def probaExploitation(self): return self.__proba
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'):
return (self.nettoyage +1) / (len(self.knowledge) + 1)
else: raise AttributeError("no attribut 'nettoyage' found")
def getDecision(self,percepts):
assert isinstance(percepts,(list,tuple)), "%s should be list or tuple" % percepts
assert len(percepts) == len(self.capteurs), "percepts and capteurs do not match"
assert all([ x in objetsStatiques for x in percepts ]), "bad percepts %s" % percepts
# On sauvegarde percepts dans la_variable_privée_contenant_le_dernier_percept
# On récupère la liste des règles dont la condition correspond aux percepts
# Si la liste est vide on choisit une action au hasard
# Sinon
# On calcule les actions les actions dans la base pour ce percept
# On calcule les actions pas dans la base pour ce percept
# On cherche l'action ayant le meilleur score moyen (elle existe)
# On tire un nombre aléatoire (r) que l'on compare à la probabilité d'exploitation
# si r < probaExploitation alors
# l'action choisie est celle déterminée par le scoreMoyen maximum
# sinon on pioche de manière équiprobable dans les autres actions
# si pas d'autres on pioche aléatoirement dans les actions pas dans la base
# si elle existe mais que son score est négatif et qu'il y a des actions pas dans la base
# on prend une action aléatoire
# On sauvegarde dans la_variable_privée_contenant_la_dernière_action_choisie
# On renvoie l'action
self.__lastPercept = percepts
_rules = self.knowledge.find(percepts)
if _rules == [] :
_a = random.choice(self.actions)
self.compteurs['alea'] += 1
else:
_possibles = [_.conclusion for _ in _rules ]
_newActions = [_ for _ in self.actions if _ not in _possibles ]
_best = _rules[0] # existe
for r in _rules:
if r.scoreMoyen > _best.scoreMoyen : _best = r
if random.random() < self.probaExploitation: # Exploitation
_a = _best.conclusion
self.compteurs['exploitation'] += 1
elif len(_rules) == 1:
_a = random.choice( _newActions )
self.compteurs['alea']+= 1
else: # d'autres choix possible
_residu = _rules[:]
_residu.remove( _best )
_choix = random.choice( _residu )
if _choix.scoreTotal < 0 and _newActions != [] :
_a = random.choice( _newActions )
self.compteurs['alea'] +=1
else:
_a = _choix.conclusion
self.compteurs['exploration'] += 1
self.__lastAction = _a # sauvegarde
self.compteurs['total'] += 1
return self.__lastAction
def setReward(self,value):
super(Aspirateur_KB,self).setReward(value)
if self.apprentissage:
# On crée une Rule avec les 3 paramètres percepts,action,value r = Rule(....)
# On ajoute cette règle dans la base grace à self.knowledge.add(r)
self.__kb.add(Rule(self.__lastPercept,self.__lastAction,value))