Inférence à chaînage avant sans variables

Solutions du code

Module .../moteur_sans_variables/regle_sans_variables.py

class RegleSansVariables:
    """ Représentation d'une règle d'inférence pour le chaînage sans\
        variables.
    """

    def __init__(self, conditions, conclusion):
        """ Construit une règle étant donné une liste de conditions et une\
            conclusion.

            :param list conditions: une collection de propositions (sans\
            variables) nécessaires pour déclencher la règle.
            :param conclusion: la proposition (sans variables) résultant du\
            déclenchement de la règle.
        """

        self.conditions = set(conditions)
        self.conclusion = conclusion

    def depend_de(self, fait):
        """ Vérifie si un fait est pertinent pour déclencher la règle.

            :param fait: un fait qui doit faire partie des conditions de\
            déclenchement.
            :return: ``True`` si le fait passé en paramètre fait partie des\
            conditions de déclenchement.
        """
        return fait in self.conditions

    def satisfaite_par(self, faits):
        """ Vérifie si un ensemble de faits est suffisant pour prouver la\
            conclusion.

            :param list faits: une liste de faits.
            :return: ``True`` si les faits passés en paramètres suffisent à\
            déclencher la règle.
        """
        return self.conditions.issubset(faits)

    def __repr__(self):
        """ Représentation d'une règle sous forme de string. """
        return '{} => {}'.format(str(list(self.conditions)),
                                 str(self.conclusion))

Module .../moteur_sans_variables/chainage_avant_sans_variables.py

from .chainage import Chainage

class ChainageAvantSansVariables(Chainage):
    """ Un moteur d'inférence à chaînage avant sans variables. """

    def chaine(self):
        """ Effectue le chaînage avant sur les faits et les règles contenus\
            dans la base de connaissances.
        """
        queue = self.connaissances.faits[:]
        self.reinitialise()

        while len(queue) > 0:
            fait = queue.pop(0)

            if fait not in self.solutions:
                self.solutions.append(fait)
                self.trace.append(fait)

                # Vérifie si des règles sont déclenchées par le nouveau fait.
                for regle in self.connaissances.regles:
                    if regle.depend_de(fait) and regle.satisfaite_par(self.solutions):
                        queue.append(regle.conclusion)
                        self.trace.append(regle)

        return self.solutions

Documentation du code

class moteur_sans_variables.regle_sans_variables.RegleSansVariables(conditions, conclusion)

Représentation d’une règle d’inférence pour le chaînage sans variables.

__init__(conditions, conclusion)

Construit une règle étant donné une liste de conditions et une conclusion.

Paramètres:
  • conditions (list) – une collection de propositions (sans variables) nécessaires pour déclencher la règle.
  • conclusion – la proposition (sans variables) résultant du déclenchement de la règle.
__repr__()

Représentation d’une règle sous forme de string.

depend_de(fait)

Vérifie si un fait est pertinent pour déclencher la règle.

Paramètres:fait – un fait qui doit faire partie des conditions de déclenchement.
Retourne:True si le fait passé en paramètre fait partie des conditions de déclenchement.
satisfaite_par(faits)

Vérifie si un ensemble de faits est suffisant pour prouver la conclusion.

Paramètres:faits (list) – une liste de faits.
Retourne:True si les faits passés en paramètres suffisent à déclencher la règle.
class moteur_sans_variables.connaissance.BaseConnaissances(constructeur_de_regle)

Une base de connaissances destinée à contenir les faits et les règles d’un système de chaînage avant.

__init__(constructeur_de_regle)

Construit une base de connaissances.

Le paramètre constructeur_de_regle doit être une fonction prenant deux arguments : la liste des conditions d’une règle et sa conclusion. La fonction doit retourner une règle du type désiré.

Paramètres:contructeur_de_regle – une fonction construisant une règle.
ajoute_faits(faits)

Ajoute une liste de faits dans la base de connaissances.

Paramètres:faits (list) – une liste de faits.
ajoute_regles(descriptions)

Ajoute des règles dans la base de connaissances.

L’argument est une liste de descriptions, chacune composée d’une liste de conditions et d’une conséquence.

Paramètres:descriptions (list) – une liste de descriptions de règles.
ajoute_un_fait(fait)

Ajoute un fait dans la base de connaissances.

Paramètres:fait – un fait.
ajoute_une_regle(description)

Ajoute une règle dans la base de connaissances étant donné sa description.

Une règle est décrite par une liste (ou un tuple) de deux éléments : une liste de conditions et une conclusion.

Les conditions et la conclusion doivent être des propositions.

Paramètres:description – une description de règle.
class moteur_sans_variables.chainage.Chainage(connaissances)

Le squelette d’un moteur d’inférence.

Cette classe n’est pas censée être instanciée directement. Elle doit être sous-classée par des classes filles qui implémentent la méthode chaine.

Variables:
  • self.trace – représente l’ordre dans lequel les propositions ont été déduites et dans lequel les règles ont été appliquées (à utiliser pour débugger votre code).
  • self.solutions – doit contenir les solutions du chaînage.
__init__(connaissances)

Initialise le moteur d’inférence sans variables.

Paramètres:connaissances – la base de connaissances.
affiche_solutions(indent=None)

Affiche les solutions d’un chaînage après l’appel à chaine.

Paramètres:indent (str) – l’identation souhaitée au début de chaque ligne (quatre espaces par défaut).
affiche_trace(indent=None)

Affiche la trace d’un chaînage après l’appel à chaine.

Paramètres:indent (str) – l’identation souhaitée au début de chaque ligne (quatre espaces par défaut).
chaine()

Effectue le chaînage.

Si des solutions sont trouvées, elles sont placées dans self.solutions et également retournées.

Retourne:les solutions.
reinitialise()

Réinitialise le moteur.

La trace et les solutions sont à nouveau vides après l’appel à cette méthode.

class moteur_sans_variables.chainage_avant_sans_variables.ChainageAvantSansVariables(connaissances)

Bases: moteur_sans_variables.chainage.Chainage

Un moteur d’inférence à chaînage avant sans variables.

ChainageAvantSansVariables.__init__(connaissances)

Initialise le moteur d’inférence sans variables.

Paramètres:connaissances – la base de connaissances.
ChainageAvantSansVariables.affiche_solutions(indent=None)

Affiche les solutions d’un chaînage après l’appel à chaine.

Paramètres:indent (str) – l’identation souhaitée au début de chaque ligne (quatre espaces par défaut).
ChainageAvantSansVariables.affiche_trace(indent=None)

Affiche la trace d’un chaînage après l’appel à chaine.

Paramètres:indent (str) – l’identation souhaitée au début de chaque ligne (quatre espaces par défaut).
ChainageAvantSansVariables.chaine()

Effectue le chaînage avant sur les faits et les règles contenus dans la base de connaissances.

ChainageAvantSansVariables.reinitialise()

Réinitialise le moteur.

La trace et les solutions sont à nouveau vides après l’appel à cette méthode.