Page d'accueil>Lié à la programmation>Code Source AI
Télécharger

FuzzyLite

Les bibliothèques FuzzyLite pour Fuzzy Logic Control font référence à fuzzylite (C++), pyfuzzylite (Python) et jfuzzylite (Java).

L' objectif des bibliothèques FuzzyLite est de concevoir facilement et d'exploiter efficacement des contrôleurs à logique floue suivant un modèle de programmation orienté objet avec une dépendance minimale aux bibliothèques externes.

Licence

fuzzylite est sous double licence GNU GPL 3.0 et sous licence propriétaire à des fins commerciales .

Vous êtes fortement encouragé à soutenir le développement des bibliothèques FuzzyLite en achetant une licence de QtFuzzyLite .

QtFuzzyLite est la meilleure interface utilisateur graphique disponible pour concevoir facilement et exploiter directement des contrôleurs à logique floue en temps réel. Disponible pour Windows, Mac et Linux, son objectif est d' accélérer considérablement la conception de vos contrôleurs à logique floue, tout en fournissant une interface utilisateur très utile , fonctionnelle et esthétique . Veuillez le télécharger et le consulter gratuitement sur fuzzylite.com/downloads.

Documentation

Visitez fuzzylite.com/documentation

Caractéristiques

(6) Contrôleurs : Mamdani, Takagi-Sugeno, Larsen, Tsukamoto, Inverse Tsukamoto, Hybrid

(25) Termes linguistiques : (5) Basique : Triangle, Trapèze, Rectangle, Discret, SemiEllipse. (8) Étendu : Bell, Cosinus, Gaussian, GaussianProduct, PiShape, SigmoidDifference, SigmoidProduct, Spike. (7) Bords : Arc, Binaire, Concave, Rampe, Sigmoïde, SShape, ZShape. (3) Fonctions : Constante, Linéaire, Fonction. (2) Spécial : Agrégé, Activé.

(7) Méthodes d'activation : Générale, Proportionnelle, Seuil, Premier, Dernier, Le plus bas, le plus élevé.

(9) Conjonction et implication (T-Norms) : Minimum, AlgebraicProduct, BoundedDifference, DrasticProduct, EinsteinProduct, HamacherProduct, NilpotentMinimum, LambdaNorm, FunctionNorm.

(11) Disjonction et agrégation (normes S) : Maximum, AlgebraicSum, BoundedSum, DrasticSum, EinsteinSum, HamacherSum, NilpotentMaximum, NormalizedSum, UnboundedSum, LambdaNorm, FunctionNorm.

(7) Défuzzificateurs : (5) Intégrale : Centroïde, Bissectrice, SmallestOfMaximum, LargestOfMaximum, MeanOfMaximum. (2) Pondéré : WeightedAverage, WeightedSum.

(7) Haies : toutes, pas, extrêmement, rarement, assez, très fonctionnelles.

(3) Importateurs : FuzzyLite Language fll , Fuzzy Inference System fis , Fuzzy Control Language fcl .

(7) Exportateurs : C++ , Java , FuzzyLite Language fll , FuzzyLite Dataset fld , R script, Fuzzy Inference System fis , Fuzzy Control Language fcl .

(30+) Exemples de contrôleurs Mamdani, Takagi-Sugeno, Tsukamoto et Hybrid de fuzzylite , Octave et Matlab, chacun inclus dans les formats suivants : C++ , Java , fll , fld , R , fis et fcl .

Exemple

Langage FuzzyLite 

 # File: ObstacleAvoidance.fll
Engine : ObstacleAvoidance
InputVariable : obstacle
  enabled : true
  range : 0.000 1.000
  lock-range : false
  term : left Ramp 1.000 0.000
  term : right Ramp 0.000 1.000
OutputVariable : mSteer
  enabled : true
  range : 0.000 1.000
  lock-range : false
  aggregation : Maximum
  defuzzifier : Centroid 100
  default : nan
  lock-previous : false
  term : left Ramp 1.000 0.000
  term : right Ramp 0.000 1.000
RuleBlock : mamdani
  enabled : true
  conjunction : none
  disjunction : none
  implication : AlgebraicProduct
  activation : General
  rule : if obstacle is left then mSteer is right
  rule : if obstacle is right then mSteer is left 
 // File: ObstacleAvoidance.cpp
# include < fl/Headers.h >

fl::Engine* engine = fl::FllImporter().fromFile( " ObstacleAvoidance.fll " );

C++ 

 // File: ObstacleAvoidance.cpp
# include < fl/Headers.h >

using namespace fuzzylite ;

Engine* engine = new Engine;
engine-> setName ( " ObstacleAvoidance " );
engine-> setDescription ( " " );

InputVariable* obstacle = new InputVariable;
obstacle-> setName ( " obstacle " );
obstacle-> setDescription ( " " );
obstacle-> setEnabled ( true );
obstacle-> setRange ( 0.000 , 1.000 );
obstacle-> setLockValueInRange ( false );
obstacle-> addTerm ( new Ramp( " left " , 1.000 , 0.000 ));
obstacle-> addTerm ( new Ramp( " right " , 0.000 , 1.000 ));
engine-> addInputVariable (obstacle);

OutputVariable* mSteer = new OutputVariable;
mSteer -> setName ( " mSteer " );
mSteer -> setDescription ( " " );
mSteer -> setEnabled ( true );
mSteer -> setRange ( 0.000 , 1.000 );
mSteer -> setLockValueInRange ( false );
mSteer -> setAggregation ( new Maximum);
mSteer -> setDefuzzifier ( new Centroid( 100 ));
mSteer -> setDefaultValue (fl::nan);
mSteer -> setLockPreviousValue ( false );
mSteer -> addTerm ( new Ramp( " left " , 1.000 , 0.000 ));
mSteer -> addTerm ( new Ramp( " right " , 0.000 , 1.000 ));
engine-> addOutputVariable ( mSteer );

RuleBlock* mamdani = new RuleBlock;
mamdani-> setName ( " mamdani " );
mamdani-> setDescription ( " " );
mamdani-> setEnabled ( true );
mamdani-> setConjunction (fl::null);
mamdani-> setDisjunction (fl::null);
mamdani-> setImplication ( new AlgebraicProduct);
mamdani-> setActivation ( new General);
mamdani-> addRule (Rule::parse( " if obstacle is left then mSteer is right " , engine));
mamdani-> addRule (Rule::parse( " if obstacle is right then mSteer is left " , engine));
engine-> addRuleBlock (mamdani);

Opération 

 using namespace fuzzylite ;

std::string status;
if ( not engine-> isReady (&status))
    throw Exception( " [engine error] engine is not ready: n " + status, FL_AT);

InputVariable* obstacle = engine-> getInputVariable ( " obstacle " );
OutputVariable* steer = engine-> getOutputVariable ( " steer " );

for ( int i = 0 ; i <= 50 ; ++i){
    scalar location = obstacle-> getMinimum () + i * (obstacle-> range () / 50 );
    obstacle-> setValue (location);
    engine-> process ();
    FL_LOG ( " obstacle.input = " << Op::str (location) << 
        " => " << " steer.output = " << Op::str (steer-> getValue ()));
}

Compiler, lier et exécuter

Une fois que vous disposez d’un moteur écrit en C++, vous pouvez le compiler pour créer un fichier exécutable lié à la bibliothèque fuzzylite . La liaison peut être statique ou dynamique. Fondamentalement, les différences entre les liens statiques et dynamiques sont les suivantes.

La liaison statique inclut la bibliothèque fuzzylite dans votre fichier exécutable, augmentant ainsi sa taille, mais l'exécutable n'a plus besoin d'avoir accès aux fichiers de la bibliothèque fuzzylite .

La liaison dynamique n'inclut pas la bibliothèque fuzzylite dans votre fichier exécutable, réduisant ainsi sa taille, mais l'exécutable doit avoir accès au fichier de bibliothèque partagée fuzzylite . Lorsque vous utilisez la liaison dynamique, assurez-vous que les fichiers de bibliothèque partagés se trouvent soit dans le même répertoire que l'exécutable, soit qu'ils sont accessibles via des variables d'environnement : 

rem Windows:
set PATH = " pathtofuzzylitereleasebin;%PATH% " 
 # Unix:
export LD_LIBRARY_PATH= " /path/to/fuzzylite/release/bin/: $LD_LIBRARY_PATH "

Fenêtres

Les commandes pour compiler votre moteur sous Windows sont les suivantes :

C++11 (par défaut) 

rem static linking:
cl.exe ObstacleAvoidance.cpp fuzzylite - static .lib / Ipath / to / fuzzylite / EHsc / MD
rem dynamic linking:
cl.exe ObstacleAvoidance.cpp fuzzylite.lib / Ipath / to / fuzzylite / DFL_IMPORT_LIBRARY / EHsc / MD

C++98 

rem static linking:
cl.exe ObstacleAvoidance.cpp fuzzylite - static .lib / Ipath / to / fuzzylite / DFL_CPP98 = ON / EHsc / MD
rem dynamic linking:
cl.exe ObstacleAvoidance.cpp fuzzylite.lib / Ipath / to / fuzzylite / DFL_IMPORT_LIBRARY / DFL_CPP98 = ON / EHsc / MD

Unix

Les commandes pour compiler votre moteur sous Unix sont les suivantes :

C++11 (par défaut) 

 # static linking
g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite-static --std=c++11
 # dynamic linking
g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite

C++98 

 # static linking
g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite-static -DFL_CPP98=ON
 # dynamic linking
g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite -DFL_CPP98=ON

CMake

Alternativement, vous pouvez utiliser CMake pour créer un lien vers fuzzylite . Veuillez vous référer à l'exemple d'application disponible sur exemples/application.

Construire à partir de la source

Vous pouvez créer la bibliothèque fuzzylite à partir des sources en utilisant CMake (cmake.org).

Vérifiez .github/workflows pour plus de détails.

Unix 

cmake -B build/ -G " Unix Makefiles "  .
cmake --build build/ --parallel
ctest --test-dir build/

Fenêtres 

cmake -B build/ -G " NMake Makefiles " .
cmake --build build/
ctest --test-dir build/

Options de construction

Les options de construction suivantes disponibles :

-DFL_USE_FLOAT=ON construit les binaires en utilisant le type de données fl::scalar comme float au lieu de double . Par défaut, les binaires sont construits en utilisant -DFL_USE_FLOAT=OFF . Si fuzzylite est construit avec -DFL_USE_FLOAT=ON , alors les applications liées à fuzzylite doivent également spécifier cet indicateur de compilation.

-DFL_CPP98=ON construit des binaires en utilisant les fonctionnalités C++98 au lieu de C++11 . Par défaut, les binaires sont construits en utilisant -DFL_CPP98=OFF . Si vous utilisez C++98 , vous ne pourrez pas comparer les performances de votre moteur à l'aide de la classe Benchmark et vous ne pourrez exécuter aucun des tests.

-DFL_BACKTRACE=OFF désactive les informations de backtrace en cas d'erreurs. Par défaut, les binaires sont construits en utilisant -DFL_BACKTRACE=ON . Sous Windows, les informations de trace nécessitent la bibliothèque externe dbghelp , qui est généralement disponible sur votre système.

Documentation

Le code source de fuzzylite est très bien documenté en utilisant le formatage doxygen , et la documentation est disponible sur fuzzylite.com/documentation. Si vous souhaitez générer la documentation localement, vous pouvez produire la documentation html à partir du fichier Doxyfile en utilisant la ligne de commande : doxygen Doxyfile . La documentation sera créée dans le dossier docs .

Binaires

Après la construction à partir des sources, voici les binaires pertinents qui seront créés en mode Release . En mode Debug , les noms de fichiers se terminent par -debug (par exemple, fuzzylite-debug.exe ).

Fenêtres

  • application console : fuzzylite.exe
  • bibliothèque partagée : fuzzylite.dll , fuzzylite.lib
  • bibliothèque statique : fuzzylite-static.lib

Linux

  • application console : fuzzylite
  • bibliothèque partagée : libfuzzylite.so
  • bibliothèque statique : libfuzzylite-static.a

Mac

  • application console : fuzzylite
  • bibliothèque partagée : libfuzzylite.dylib
  • bibliothèque statique : libfuzzylite-static.a

Console

L'application console de fuzzylite vous permet d'importer et d'exporter vos moteurs. Son utilisation peut être obtenue en exécutant le binaire de la console. De plus, la console peut être réglée en mode interactif. La FuzzyLite Interactive Console vous permet d'évaluer un contrôleur donné en fournissant manuellement les valeurs d'entrée. La console interactive est déclenchée en spécifiant un fichier d'entrée et un format de sortie. Par exemple, pour interagir avec le contrôleur ObstacleAvoidance , la console interactive se lance comme suit : 

fuzzylite -i ObstacleAvoidance.fll -of fld

Contribuer

Toutes les contributions sont les bienvenues, à condition de suivre les directives suivantes :

  • Le code source est conforme aux standards de la bibliothèque
  • La contribution est correctement documentée et testée, soulevant des problèmes le cas échéant
  • La contribution est sous licence FuzzyLite

Référence

Si vous utilisez les bibliothèques FuzzyLite, veuillez citer la référence suivante dans votre article :

Juan Rada-Vilela. Les bibliothèques FuzzyLite pour le contrôle de logique floue, 2018. URL https://fuzzylite.com.

Ou en utilisant bibtex : 

 @misc { fl::fuzzylite ,
    author = { Juan Rada-Vilela } ,
    title = { The FuzzyLite Libraries for Fuzzy Logic Control } ,
    url = { https://fuzzylite.com } ,
    year = { 2018 }
}

fuzzylite® est une marque déposée de FuzzyLite Limited
jfuzzylite™ est une marque commerciale de FuzzyLite Limited
pyfuzzylite™ est une marque commerciale de FuzzyLite Limited
QtFuzzyLite™ est une marque commerciale de FuzzyLite Limited

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout