Archives de septembre 2013

La logique floue (fuzzy logic) – Exemple en C# avec Aforge.Fuzzy

Introduction

La logique floue est un domaine de l’intelligence artificielle, elle se rapproche du raisonnement humain. Contrairement à des calculs rigides, qui se base sur des ensembles bien définis, elle utilise des ensembles flous ou imprécis. Elle s’appuie sur la théorie mathématique des ensembles flous qui est une extension de la théorie des ensembles.

Pour vous montrer l’utilisation de la bibliothèque .Net Aforge.Net, nous allons nous baser sur l’exemple décris dans l’excellent article de Franck Dernoncourt que je vous invite à lire : http://franck-dernoncourt.developpez.com/tutoriels/algo/introduction-logique-floue/

L’objectif sera de décider du pourboire à donner à la fin d’un repas au restaurant en fonction de la qualité du service ainsi que de la qualité de la nourriture.

Étapes pour définir un système flou

Représentation d’un système d’inférence avec Aforge.net

Fig4

  • Input et Output

Il est nécessaire dans un premier temps de définir les différentes entrées et sorties du système :

    • Input    : Nourriture          =   noté sur une échelle de  0 à 10
    • Input    : QualiteService    =   noté sur une échelle de  0 à 10
    • Output : Pourboire           =    montant donné de 0 à 30 euros

Code avec la librairie Aforge.Net :

var lvNourriture = new LinguisticVariable("Nourriture", 0, 10);
    var lvQualiteService = new LinguisticVariable("QualiteService", 0, 10);
    var lvPourboire = new LinguisticVariable("Pourboire", 0, 30);

  • La Fuzzification

Nous devons définir des variables dites “variables linguistiques” qui seront utilisées pour définir les règles du système. Il y a ici 3 variables linguistiques  : Nourriture, QualiteService, Pourboire.

Pour chacune de ces variables, il est nécessaire de qualifier les éléments de ces ensembles flous

    • Input    : Nourriture          =   {Execrable, Delicieux}
    • Input    : QualiteService  =   {Mauvais, Bon, Excellent}
    • Output : Pourboire           =   {Faible, Moyen, Eleve)}

Pour chacun de ces éléments il est nécessaire de lui adjoindre une fonction d’appartenance, le plus souvent définie par des segments de droites.

is-var-nourriture

Code avec Aforge.Net :  les fonctions trapézoïdales ont plusieurs constructeurs, ici le trapèze est ouvert sur la droite, puis sur la gauche en formant une ligne infinie.

//Trapèze avec ligne infinie sur la droite
    var fsExecrable = new FuzzySet("Execrable", new TrapezoidalFunction(1, 3, TrapezoidalFunction.EdgeType.Right));
    //Trapèze avec ligne infinie sur la gauche
    var fsDelicieux = new FuzzySet("Delicieux", new TrapezoidalFunction(7, 9, TrapezoidalFunction.EdgeType.Left));

Exemple: une note pour la qualité de la nourriture de 1 est considérée comme exécrable; une note de 2 est considéré comme 50% exécrable; et 3 sort du périmètre de ce qualificatif.

is-var-service

Code avec Aforge.Net :

var fsMauvais = new FuzzySet("Mauvais", new TrapezoidalFunction(0, 5, TrapezoidalFunction.EdgeType.Right));
    var fsBon = new FuzzySet("Bon", new TrapezoidalFunction(0, 5, 10));
    var fsExcellent = new FuzzySet("Excellent", new TrapezoidalFunction(5, 10, TrapezoidalFunction.EdgeType.Left));

Exemple: Pour la qualité de service, une note de 5 est considérée comme 100% bon, une note de 8,5 est considérée comme 50% excellent.

is-var-pourboire

Code avec Aforge.Net :

var fsFaible = new FuzzySet("Faible", new TrapezoidalFunction(0, 5, 10));
    var fsMoyen = new FuzzySet("Moyen", new TrapezoidalFunction(10, 15, 20));
    var fsEleve = new FuzzySet("Eleve", new TrapezoidalFunction(20, 25, 30));

Exemple: Pour le pourboire, un montant de 5 € est 100% faible, 22.5€ est considéré comme 50% élevé.

Il faut maintenant associer les qualificatifs aux différents ensembles flous :

    lvNourriture.AddLabel(fsExecrable);  //Ajout du qualificatif exécrable à l’ensemble flou Nourriture
    lvNourriture.AddLabel(fsDelicieux);  //Ajout du qualificatif délicieux à l’ensemble flou Nourriture 
    lvQualiteService.AddLabel(fsMauvais); //Ajout du qualificatif mauvais à l’ensemble flou Qualité de service
    lvQualiteService.AddLabel(fsBon);     //Ajout du qualificatif bon à l’ensemble flou Qualité de service
    lvQualiteService.AddLabel(fsExcellent); //Ajout du qualificatif excellent à l’ensemble flou Qualité de service 
    lvPourboire.AddLabel(fsFaible); //Ajout du qualificatif faible à l’ensemble flou Pourboire 
    lvPourboire.AddLabel(fsMoyen);  //Ajout du qualificatif moyen à l’ensemble flou Pourboire 
    lvPourboire.AddLabel(fsEleve);  //Ajout du qualificatif élevé à l’ensemble flou Pourboire 
  • Base de connaissance

Nous allons créer une base regroupant les variables linguistiques créées juste avant.

var fuzzyDb = new Database();      //Création de la base 
    fuzzyDb.AddVariable(lvNourriture); //Ajout des variables linguistiques
    fuzzyDb.AddVariable(lvQualiteService);
    fuzzyDb.AddVariable(lvPourboire);
  • Initialisation du système d’inférence

// Création system inference
    // Initialise la méthode de défuzzification : centre de gravité
    var inferenceSys = new InferenceSystem(fuzzyDb, new CentroidDefuzzifier(1000));

Le constructeur a besoin de la base regroupant l’ensemble des variables linguistiques et d’une méthode de défuzzification.

  • Définition des règles floues

les règles du système sont les suivantes :

    • Si le service est mauvais ou la nourriture est exécrable alors le pourboire est faible.
    • Si le service est bon alors le pourboire est moyen.
    • Si le service est excellent ou la nourriture est délicieuse alors le pourboire est élevé.

Ce qui se traduit en code par :

    inferenceSys.NewRule("Rule 1", "IF QualiteService IS Mauvais OR Nourriture IS Execrable THEN Pourboire IS Faible");
    inferenceSys.NewRule("Rule 2", "IF QualiteService IS Bon THEN Pourboire IS Moyen");
    inferenceSys.NewRule("Rule 3", "IF QualiteService IS Excellent OR Nourriture IS Delicieux THEN Pourboire IS Eleve");
  • Défuzzification & Output

// Initialise les données d'entrées
    inferenceSys.SetInput("QualiteService", noteQualiteService);
    inferenceSys.SetInput("Nourriture", noteNourriture);
    // Evalue la donnée de sortie : Pourboire = Output
    resPourboire = inferenceSys.Evaluate("Pourboire");


Source complète de l’exemple :

static void Main(string[] args)
{
WritePourboire(7, 9);
    WritePourboire(2, 9);
    WritePourboire(5, 6);
    WritePourboire(2, 3);
    Console.ReadLine();
}

public static void WritePourboire(float noteQualiteService, float noteNourriture)
{
    #region Input (Qualité de service)
    var lvQualiteService = new LinguisticVariable("QualiteService", 0, 10);

    var fsMauvais = new FuzzySet("Mauvais", new TrapezoidalFunction(0, 5, TrapezoidalFunction.EdgeType.Right));
    var fsBon = new FuzzySet("Bon", new TrapezoidalFunction(0, 5, 10));
    var fsExcellent = new FuzzySet("Excellent", new TrapezoidalFunction(5, 10, TrapezoidalFunction.EdgeType.Left));

    lvQualiteService.AddLabel(fsMauvais);
    lvQualiteService.AddLabel(fsBon);
    lvQualiteService.AddLabel(fsExcellent);
    #endregion

    #region Input (Nourriture)
    var lvNourriture = new LinguisticVariable("Nourriture", 0, 10);

    var fsExecrable = new FuzzySet("Execrable", new TrapezoidalFunction(1, 3, TrapezoidalFunction.EdgeType.Right));
    var fsDelicieux = new FuzzySet("Delicieux", new TrapezoidalFunction(7, 9, TrapezoidalFunction.EdgeType.Left));

    lvNourriture.AddLabel(fsExecrable);
    lvNourriture.AddLabel(fsDelicieux);
    #endregion

    #region Output (Pourboire)
    var lvPourboire = new LinguisticVariable("Pourboire", 0, 30);

    var fsFaible = new FuzzySet("Faible", new TrapezoidalFunction(0, 5, 10));
    var fsMoyen = new FuzzySet("Moyen", new TrapezoidalFunction(10, 15, 20));
    var fsEleve = new FuzzySet("Eleve", new TrapezoidalFunction(20, 25, 30));

    lvPourboire.AddLabel(fsFaible);
    lvPourboire.AddLabel(fsMoyen);
    lvPourboire.AddLabel(fsEleve);
    #endregion

    #region Système Inference
    // Base de données pour les variables linguistiques
    // Nourriture(Execrable, Delicieux) 0 - 10
    // QualiteService(Mauvais, Bon, Excellent) 0 - 10
    // Pourboire(Faible, Moyen, Eleve) 0 - 30
    var fuzzyDb = new Database();
    fuzzyDb.AddVariable(lvNourriture);
    fuzzyDb.AddVariable(lvQualiteService);
    fuzzyDb.AddVariable(lvPourboire);

    // Creation system inference
    // Initialise la methode de défuzzification : centre de gravité
    var inferenceSys = new InferenceSystem(fuzzyDb, new CentroidDefuzzifier(1000));
    // Ajoute des regles
    inferenceSys.NewRule("Rule 1", "IF QualiteService IS Mauvais OR Nourriture IS Execrable THEN Pourboire IS Faible");
    inferenceSys.NewRule("Rule 2", "IF QualiteService IS Bon THEN Pourboire IS Moyen");
    inferenceSys.NewRule("Rule 3", "IF QualiteService IS Excellent OR Nourriture IS Delicieux THEN Pourboire IS Eleve");
    #endregion

    #region Exemple
    // Initialise les données d'entrées
    inferenceSys.SetInput("QualiteService", noteQualiteService);
    inferenceSys.SetInput("Nourriture", noteNourriture);

    // Evalue la donnée de sortie : Pourboire
    var resPourboire = -1f;
    try
    {
        resPourboire = inferenceSys.Evaluate("Pourboire");
    }
    catch (Exception ex)
    {
        throw new Exception(string.Format("Erreur : {0}", ex.Message));
    }
    Console.WriteLine("Nourriture: {0}  + QualiteService : {1} = Pourboire : {2}", 
        noteNourriture, noteQualiteService, resPourboire);
    #endregion
}

Sortie du programme :

Nourriture: 9  + QualiteService : 7 = Pourboire : 20,43472
Nourriture: 9  + QualiteService : 2 = Pourboire : 15,64511
Nourriture: 6  + QualiteService : 5 = Pourboire : 14,99998
Nourriture: 3  + QualiteService : 2 = Pourboire : 9,324404

Publicités

Poster un commentaire

Les patterns de construction dans le framework.Net

Les patterns de construction ont pour rôle de masquer la complexité de création des objets et de rendre le système indépendant du processus d’instanciation des classes. Pour ce faire ces patterns privilégient l’utilisation des Interfaces ou des classes abstraites dans la relation entre les objets en masquant les classes concrètes au client final.

Le choix entre Classe Abstraite et Interface ?

– Choisir une classe abstraite si la classe doit contenir des comportements par défauts, comme par exemple une méthode codée dans la classe abstraite qui pourra être utilisée par l’ensemble des classes concrètes.

– Choisir une interface si toutes les classes concrètes ont leurs propres implémentations.

  • Définition des Patterns de créations :

  1. Abstract Factory : Ce modèle fournit une interface pour créer des familles d’objets liés ou dépendants sans spécifier leurs classes concertes. Créer des objets, de classes abstraites différentes, mais de mêmes familles de classes concrètes. L’abstract factory ne fait rien d’autre que de créer des objets à la différence du pattern Factory Method. Dans ce pattern il faut utiliser un singleton pour n’avoir q’une seule instance de chacune des fabriques concrètes.
  2. Factory Method : Permets de déléguer aux sous-classes l’instanciation au travers d’une méthode abstraite de création des objets. L’appel du constructeur des sous-classe peut être fait en passant un paramètre a la Factory Method. La différence avec Abstract Factory, est que la classe possède d’autres responsabilités que le simple fait de créer des objets.
  3. Singleton : Ce modèle garantit qu’une classe n’a qu’une seule instance et fournit un point d’accès à celle çi.
  4. Builder : Permet d’abstraire la construction d’objets complexe : objets composés – par exemple la fenêtre d’une application composée de différents menus, d’un titre, etc. Sans se soucier par exemple du style de rendu (menu classique, Ruban office …)
  5. Prototype : Il est utilisé pour créer un objet en double ou clone de l’objet courant.
  • Patterns de créations dans le framework.Net :

Voici un exemple de code C# utilisant les 5 types de pattern de conception présent dans le framework.net :

public int DbProviderFactoryPatterns()
{
    // 1 - Abstract Factory : Classes concrètes SQL.. / ODBC.. / OLEDB..
    // Familles de produits : Connection / Command, etc. Commence par CreateXXX
    var dbProviderFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");// 2 - Factory Method

    var dbConnection = dbProviderFactory.CreateConnection();                        // 3 - Factory Method

    var singletonSqlClientFactory = SqlClientFactory.Instance;                      //  4 - Singleton

    if (singletonSqlClientFactory.Equals(dbProviderFactory))
    {
        Console.WriteLine("Provider SQL");
    }

    var connectionStringBuilder = dbProviderFactory.CreateConnectionStringBuilder();//  5 - Builder
    connectionStringBuilder.ConnectionString =                                      //  5 - Builder
        "Data Source=ServerName;Initial Catalog=DatabaseName;Persist Security " +
        "Info=True;Connection Timeout =60;Integrated Security=SSPI";

    dbConnection.ConnectionString = connectionStringBuilder.ConnectionString;

    var dbCommand = dbProviderFactory.CreateCommand();                       // 6 - Factory Method
    dbCommand.CommandType = CommandType.Text;
    dbCommand.CommandText = "select count(*) from Table1";
    dbCommand.Connection = dbConnection;

    if (dbCommand is ICloneable)
    {
        var prototypeDbCommand = (ICloneable)dbCommand;                       // 7 - Prototype
        var dbCommand2 = (DbCommand)prototypeDbCommand.Clone();               // 7 - Prototype
        dbCommand2.CommandText = "select count(*) from Table2";
    }

    try
    {
        dbConnection.Open();
        return dbCommand.ExecuteNonQuery();
    }
    finally
    {
        if (dbConnection.State != System.Data.ConnectionState.Closed)
            dbConnection.Close();
    }
    return -1;        
}

Diagramme UML des classes :

image

  • Abstract Factory : System.Data.Common.DbProviderFactory
Abstraction Fabrique concrète Classe abstraite à créer(famille de produits) Classe concrète à créer(famille de produits) Commentaires
DbProviderFactory SqlClientFactoryOdbcFactory DbCommandDbConnection OdbcCommand
SqlCommand
OdbcConnection
SqlConnection
Le pattern utilise un singleton pour ne disposer que d’une seule instance des fabriques concrètes pour l’ensemble des clients l’utilisant.Les méthodes CreateXXX sont des Factory Method chargées de créer chacune des familles de produits
  • Factory Method  : System.Data.Common.DbProviderFactories

Dans ce cas la factory method ne respecte pas le pattern avec son abstraction comme nous pourrons le voir dans la classe System.Net.WebRequest, mais grâce au paramètre passé à cette méthode (par réflexion) elle renverra l’instance du singleton d’une des fabriques concrète : SqlClientFactory ou OdbcFactory

  • Singleton  : System.Data.SqlClient.SqlClientFactory.Instance

Les instances uniques de chacune des factory sont créées ici par le constructeur statique de la classe en temps qu’instance de classe : OdbcFactory.Instance et SqlClientFactory.Instance

  • Builder  : System.Data.Common.DBConnectionStringBuilder
Abstraction Monteur concret Classe à monter
DBConnectionStringBuilder SqlConnectionStringBuilder
OdbcConnectionStringBuilder
StringString
  • Prototype  : System.ICloneable
Abstraction Classe à instance unique
ICloneable SqlCommand
OdbcCommand
SqlConnection
OdbcConnction
  • Autre exemples :

Voici d’autres exemples de ces patterns de création dans le framework :

public void WebRequestPatterns()
{
    var uriBuilder = new UriBuilder();                //  8 - Builder
    uriBuilder.Scheme = "http";
    uriBuilder.Host = "www.google.fr";

    var webRequest = WebRequest.Create(uriBuilder.Uri);  // 9 - Factory Method

    var webResponse = webRequest.GetResponse();          // 10 - Factory Method
}
public void XmlPatterns()
{
    var xmlDocument = new XmlDocument();
    xmlDocument.Load("file.xml");
    var xmlNode = xmlDocument.CloneNode(true);          // 11 - Prototype
}

Diagramme UML du pattern Factory Method de WebRequest

image

, , , , , , ,

Poster un commentaire

%d blogueurs aiment cette page :