Inicio>Relacionado con la programación>Código Fuente de IA
Descargar

FuzzyLite

Las bibliotecas FuzzyLite para control de lógica difusa se refieren a fuzzylite (C++), pyfuzzylite (Python) y jfuzzylite (Java).

El objetivo de las bibliotecas FuzzyLite es diseñar fácilmente y operar eficientemente controladores de lógica difusa siguiendo un modelo de programación orientado a objetos con una dependencia mínima de bibliotecas externas.

Licencia

fuzzylite tiene doble licencia GNU GPL 3.0 y una licencia propietaria para fines comerciales .

Le recomendamos encarecidamente que apoye el desarrollo de las bibliotecas FuzzyLite comprando una licencia de QtFuzzyLite .

QtFuzzyLite es la mejor interfaz gráfica de usuario disponible para diseñar y operar directamente controladores de lógica difusa en tiempo real. Disponible para Windows, Mac y Linux, su objetivo es acelerar significativamente el diseño de sus controladores de lógica difusa, al mismo tiempo que proporciona una interfaz de usuario muy útil , funcional y hermosa . Por favor, descárgalo y compruébalo gratis en fuzzylite.com/downloads.

Documentación

Visita fuzzylite.com/documentation

Características

(6) Controladores : Mamdani, Takagi-Sugeno, Larsen, Tsukamoto, Inverse Tsukamoto, Hybrid

(25) Términos lingüísticos : (5) Básicos : Triángulo, Trapezoide, Rectángulo, Discreto, SemiElipse. (8) Extendido : Campana, Coseno, Gaussiano, Producto Gaussiano, Forma Pi, Diferencia Sigmoidea, Producto Sigmoideo, Spike. (7) Aristas : Arco, Binario, Cóncavo, Rampa, Sigmoide, SShape, ZShape. (3) Funciones : Constante, Lineal, Función. (2) Especial : Agregado, Activado.

(7) Métodos de activación : General, Proporcional, Umbral, Primero, Último, Mínimo, Máximo.

(9) Conjunción e implicación (Normas T) : Mínimo, Producto algebraico, Diferencia acotada, Producto drástico, Producto Einstein, Producto Hamacher, NilpotentMinimum, LambdaNorm, FunctionNorm.

(11) Disyunción y agregación (normas S) : máximo, suma algebraica, suma limitada, suma drástica, suma Einstein, suma Hamacher, máximo nilpotente, suma normalizada, suma ilimitada, norma lambda, norma de función.

(7) Defuzzificadores : (5) Integral : centroide, bisectriz, menor del máximo, mayor del máximo, media del máximo. (2) Ponderado : promedio ponderado, suma ponderada.

(7) Coberturas : Cualquiera, Ninguna, Extremadamente, Rara vez, Algo, Mucha, Función.

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

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

(30+) Ejemplos de controladores Mamdani, Takagi-Sugeno, Tsukamoto e híbridos de fuzzylite , Octave y Matlab, cada uno incluido en los siguientes formatos: C++ , Java , fll , fld , R , fis y fcl .

Ejemplo

Idioma difusoLite 

 # 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);

Operación 

 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 ()));
}

Compilar, vincular y ejecutar

Una vez que tenga un motor escrito en C++, puede compilarlo para crear un archivo ejecutable que enlace a la biblioteca fuzzylite . La vinculación puede ser estática o dinámica. Básicamente, las diferencias entre vinculación estática y dinámica son las siguientes.

El enlace estático incluye la biblioteca fuzzylite en su archivo ejecutable, lo que aumenta su tamaño, pero el ejecutable ya no necesita tener acceso a los archivos de la biblioteca fuzzylite .

Los enlaces dinámicos no incluyen la biblioteca fuzzylite en su archivo ejecutable, por lo que reducen su tamaño, pero el ejecutable debe tener acceso al archivo de la biblioteca compartida fuzzylite . Al utilizar enlaces dinámicos, asegúrese de que los archivos de la biblioteca compartida estén en el mismo directorio que el ejecutable o que sean accesibles a través de variables ambientales: 

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

ventanas

Los comandos para compilar tu motor en Windows son los siguientes:

C++11 (predeterminado) 

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

Los comandos para compilar tu motor en Unix son los siguientes:

C++11 (predeterminado) 

 # 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

Chacer

Alternativamente, puede usar CMake para construir su proyecto vinculándolo a fuzzylite . Por favor, consulte la aplicación de ejemplo disponible en ejemplos/aplicación.

Construyendo desde la fuente

Puede crear la biblioteca fuzzylite desde el código fuente utilizando CMake (cmake.org).

Consulte .github/workflows para obtener más detalles.

Unix 

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

ventanas 

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

Opciones de construcción

Las siguientes opciones de construcción disponibles:

-DFL_USE_FLOAT=ON construye los binarios usando el tipo de datos fl::scalar como float en lugar de double . De forma predeterminada, los binarios se crean usando -DFL_USE_FLOAT=OFF . Si fuzzylite se compila con -DFL_USE_FLOAT=ON , entonces las aplicaciones que se vinculan a fuzzylite también deben especificar este indicador de compilación.

-DFL_CPP98=ON compila archivos binarios utilizando funciones C++98 en lugar de C++11 . De forma predeterminada, los archivos binarios se crean utilizando -DFL_CPP98=OFF . Si usa C++98 , no podrá comparar el rendimiento de su motor usando la clase Benchmark y no podrá ejecutar ninguna de las pruebas.

-DFL_BACKTRACE=OFF deshabilita la información de seguimiento en caso de errores. De forma predeterminada, los binarios se crean usando -DFL_BACKTRACE=ON . En Windows, la información de seguimiento requiere la biblioteca externa dbghelp , que generalmente está disponible en su sistema.

Documentación

El código fuente de fuzzylite está muy bien documentado utilizando el formato doxygen y la documentación está disponible en fuzzylite.com/documentation. Si desea generar la documentación localmente, puede generar la documentación html desde el archivo Doxyfile usando la línea de comando: doxygen Doxyfile . La documentación se creará en la carpeta docs .

binarios

Después de compilar desde el código fuente, los siguientes son los archivos binarios relevantes que se crearán en el modo Release . En el modo Debug , los nombres de los archivos terminan en -debug (por ejemplo, fuzzylite-debug.exe ).

ventanas

  • aplicación de consola: fuzzylite.exe
  • biblioteca compartida: fuzzylite.dll , fuzzylite.lib
  • biblioteca estática: fuzzylite-static.lib

linux

  • aplicación de consola: fuzzylite
  • biblioteca compartida: libfuzzylite.so
  • biblioteca estática: libfuzzylite-static.a

Impermeable

  • aplicación de consola: fuzzylite
  • biblioteca compartida: libfuzzylite.dylib
  • biblioteca estática: libfuzzylite-static.a

Consola

La aplicación de consola de fuzzylite te permite importar y exportar tus motores. Su uso se puede obtener ejecutando el binario de la consola. Además, la consola se puede configurar en modo interactivo. La FuzzyLite Interactive Console le permite evaluar un controlador determinado proporcionando manualmente los valores de entrada. La consola interactiva se activa especificando un archivo de entrada y un formato de salida. Por ejemplo, para interactuar con el controlador ObstacleAvoidance , la consola interactiva se inicia de la siguiente manera: 

fuzzylite -i ObstacleAvoidance.fll -of fld

Contribuyendo

Todas las contribuciones son bienvenidas, siempre que sigan las siguientes pautas:

  • El código fuente es consistente con los estándares de la biblioteca.
  • La contribución está debidamente documentada y probada, planteando problemas cuando corresponde
  • La contribución tiene la licencia FuzzyLite.

Referencia

Si está utilizando las bibliotecas FuzzyLite, cite la siguiente referencia en su artículo:

Juan Rada-Vilela. Bibliotecas FuzzyLite para control de lógica difusa, 2018. URL https://fuzzylite.com.

O usando bibtex : 

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

fuzzylite® es una marca registrada de FuzzyLite Limited
jfuzzylite™ es una marca comercial de FuzzyLite Limited
pyfuzzylite™ es una marca comercial de FuzzyLite Limited
QtFuzzyLite™ es una marca comercial de FuzzyLite Limited

Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo