Fuzzy Markup Language ( FML ) es un lenguaje de marcado de propósito específico basado en XML , utilizado para describir la estructura y el comportamiento de un sistema difuso independientemente de la arquitectura de hardware dedicada a alojarlo y ejecutarlo.
FML fue diseñado y desarrollado por Giovanni Acampora durante su curso de doctorado en Ciencias de la Computación, en la Universidad de Salerno , Italia, en 2004. La idea original que inspiró a Giovanni Acampora a crear FML fue la necesidad de crear un marco cooperativo basado en algoritmos difusos destinado a controlar automáticamente un entorno vital caracterizado por una plétora de dispositivos heterogéneos cuyas interacciones se dedicaban a maximizar el confort humano bajo restricciones de ahorro de energía. Este marco representó uno de los primeros ejemplos concretos de inteligencia ambiental . Más allá de esta aplicación pionera, la principal ventaja de usar XML para describir un sistema difuso es la interoperabilidad de hardware/software. De hecho, todo lo que se necesita para leer un archivo FML es el esquema apropiado para ese archivo y un analizador FML. Este enfoque de marcado hace que sea mucho más fácil intercambiar sistemas difusos entre software: por ejemplo, una aplicación de aprendizaje automático podría extraer reglas difusas que luego podrían leerse directamente en un motor de inferencia difusa o cargarse en un controlador difuso. Además, con tecnologías como XSLT , es posible compilar el FML en el lenguaje de programación que elijas, listo para integrarlo en cualquier aplicación que desees. Como afirma Mike Watts en su popular blog Computational Intelligence: [1]
"Aunque la motivación de Acampora para desarrollar FML parece ser desarrollar controladores difusos integrados para aplicaciones de inteligencia ambiental, FML podría ser una verdadera bendición para los desarrolladores de algoritmos de extracción de reglas difusas: por mi propia experiencia durante mi doctorado, sé que tener que diseñar un formato de archivo e implementar los analizadores apropiados para la extracción de reglas y los motores de inferencia difusa puede ser un verdadero dolor de cabeza, y llevar tanto tiempo como implementar el algoritmo de extracción de reglas en sí. Hubiera preferido mucho más usar algo como FML para mi trabajo".
Se puede encontrar una descripción completa de FML y aplicaciones relacionadas en el libro titulado On the power of Fuzzy Markup Language [2] editado por Giovanni Acampora, Chang-Shing Lee, Vincenzo Loia y Mei-Hui Wang, y publicado por Springer en la serie Studies on Fuzziness and Soft Computing .
FML permite codificar sistemas difusos a través de una colección de etiquetas semánticas correlacionadas capaces de modelar los diferentes componentes de un controlador difuso clásico como base de conocimiento, base de reglas, variables difusas y reglas difusas. Por lo tanto, las etiquetas FML utilizadas para construir un controlador difuso representan el conjunto de lexemas utilizados para crear expresiones difusas. Para diseñar un lenguaje basado en XML bien formado, se define una gramática libre de contexto FML mediante un esquema XML que define nombre, tipo y atributos que caracterizan cada elemento XML. Sin embargo, dado que un programa FML representa solo una vista estática de un controlador de lógica difusa, se proporciona el llamado eXtensible Stylesheet Language Translator (XSLT) para cambiar esta vista estática a una versión computable. De hecho, los módulos XSLT son capaces de convertir el controlador difuso basado en FML en un lenguaje informático de propósito general utilizando un archivo XSL que contiene la descripción de la traducción. En este nivel, el control es ejecutable para el hardware. En resumen, FML se compone esencialmente de tres capas:
La sintaxis FML se compone de etiquetas y atributos XML que describen los diferentes componentes de un controlador de lógica difusa que se enumeran a continuación:
En detalle, la etiqueta de apertura de cada programa FML es <fuzzySystem>la que representa el controlador difuso que se está modelando. Esta etiqueta tiene dos atributos: name e ip . El primer atributo permite especificar el nombre del controlador difuso y ip se utiliza para definir la ubicación del controlador en una red informática. La base de conocimiento difuso se define por medio de la etiqueta <KnowledgeBase>que mantiene el conjunto de conceptos difusos utilizados para modelar la base de reglas difusas. Para definir el concepto difuso relacionado con el sistema controlado, <KnowledgeBase> la etiqueta utiliza un conjunto de etiquetas anidadas:
<FuzzyVariable>define el concepto difuso;<FuzzyTerm>define un término lingüístico que describe el concepto difuso;Los atributos de <FuzzyVariable>la etiqueta son: name , scale , domainLeft , domainRight , type y, solo para una salida, acquisition , defuzzifier y defaultValue . El atributo name define el nombre del concepto difuso, por ejemplo, temperatura ; scale se utiliza para definir la escala utilizada para medir el concepto difuso, por ejemplo, grado Celsius ; domainLeft y domainRight se utilizan para modelar el universo del discurso del concepto difuso, es decir, el conjunto de valores reales relacionados con el concepto difuso, por ejemplo [0°,40°] en el caso de grado Celsius; la posición del concepto difuso en la regla (parte consecuente o parte antecedente) se define por el atributo type (entrada/salida); el atributo acquisition define el método de acumulación que es un método que permite la combinación de resultados de una variable de cada regla en un resultado final; el atributo defuzzifier define el método utilizado para ejecutar la conversión de un conjunto difuso, obtenido después del proceso de agregación, en un valor numérico para entregarlo en la salida al sistema; El atributo defaultValue define un valor real que se utiliza únicamente cuando no se ha activado ninguna regla para la variable en cuestión. En cuanto a tag <FuzzyTerm>, utiliza dos atributos: name , que se utiliza para identificar el valor lingüístico asociado al concepto difuso, y complement , un atributo booleano que define si es verdadero y es necesario considerar el complemento de la función de pertenencia definida por los parámetros dados. Las etiquetas de forma difusa, que se utilizan para completar la definición del concepto difuso, son:
<TRIANGULARSHAPE><RIGHTLINEARSHAPE><LEFTLINEARSHAPE><PISHAPE><GAUSSIANSHAPE><RIGHTGAUSSIANSHAPE><LEFTGAUSSIANSHAPE><TRAPEZOIDSHAPE><SSHAPE><ZSHAPE><RECTANGULARSHAPE><SINGLETONSHAPE>Cada etiqueta de modelado utiliza un conjunto de atributos que define el contorno real del conjunto difuso correspondiente. La cantidad de estos atributos depende de la forma del conjunto difuso elegido.
Para hacer un ejemplo, considere el sistema de inferencia de propinas descrito en el tutorial de Mathworks Matlab Fuzzy Logic Toolbox. Este sistema Mamdani se utiliza para regular las propinas en, por ejemplo, un restaurante. Tiene dos variables de entrada ( comida y servicio ) y una de salida ( propina ). El código FML para modelar parte de la base de conocimiento de este sistema difuso que contiene las variables comida y propina se muestra a continuación.
<?xml version="1.0" encoding="UTF-8"?> <fuzzySystem nombre= "newSystem" ip= "127.0.0.1" > <KnowledgeBase> <FuzzyVariable nombre= "comida" dominioizquierdo= "0.0" dominioderecho= "10.0" escala= "" tipo= "entrada" > <FuzzyTerm nombre= "delicioso" complemento= "falso" > <LeftLinearShape Parámetro1= "5.5" Parámetro2= "10.0" /> </FuzzyTerm> <FuzzyTerm nombre= "rancio" complemento= "falso" > <TriangularShape Parámetro1= "0.0" Parámetro2= "2.0" Parámetro3= "5.5" /> </FuzzyTerm> </FuzzyVariable> ........... <FuzzyVariable nombre= "propina" dominioizquierdo= "0.0" dominioderecho= "20.0" escala= "Euro" valorPredeterminado= "0.0" defuzzificador= "COG" acumulación= "MÁX" tipo= "salida" > <FuzzyTerm nombre= "promedio" complemento= "falso" > <TriangularShape Parámetro1= "5.0" Parámetro2= "10.0" Parámetro3= "15.0" /> </FuzzyTerm> <FuzzyTerm nombre= "barato" complemento= "falso" > <TriangularShape Parámetro1= "0.0" Parámetro2= "5.0" Parámetro3= "10.0" /> </FuzzyTerm> <FuzzyTerm nombre= "generoso" complemento= "falso" > <TriangularShape Parámetro1= "10.0" Parámetro2= "15.0" Parámetro3= "20.0" /> </FuzzyTerm> </FuzzyVariable> </KnowledgeBase> ............ </sistemafuzzy> Una etiqueta especial que también se puede utilizar para definir una forma difusa es <UserShape>. Esta etiqueta se utiliza para personalizar la forma difusa (forma personalizada). El modelado de la forma personalizada se realiza a través de un conjunto de <Point>etiquetas que enumeran los puntos extremos del área geométrica que define la forma difusa personalizada. Obviamente, los atributos utilizados en <Point>la etiqueta son las coordenadas x e y. En cuanto al componente de base de reglas, FML permite definir un conjunto de bases de reglas, cada una de ellas describe un comportamiento diferente del sistema. La raíz de cada base de reglas se modela mediante <RuleBase>una etiqueta que define un conjunto de reglas difusas. La <RuleBase>etiqueta utiliza cinco atributos: name , type , activationMethod , andMethod y orMethod . Obviamente, el atributo name identifica de forma única la base de reglas. El atributo type permite especificar el tipo de controlador difuso (Mamdani o TSK) con respecto a la base de reglas en cuestión. El atributo activationMethod define el método utilizado para el proceso de implicación; el atributo andMethod y orMethod definen, respectivamente, el algoritmo and y or que se utilizará por defecto. Para definir la regla simple <Rule>se utiliza la etiqueta. Los atributos utilizados por la <Rule>etiqueta son: name , connector , operator y weight . El atributo name permite identificar la regla; connector se utiliza para definir el operador lógico utilizado para conectar las diferentes cláusulas en la parte antecedente (and/or); operator define el algoritmo a utilizar para el conector elegido; weight define la importancia de la regla durante el paso del motor de inferencia. La definición de la parte antecedente y consecuente de la regla se obtiene utilizando las etiquetas <Antecedent>y <Consequent>. <Clause>La etiqueta se utiliza para modelar las cláusulas difusas en la parte antecedente y consecuente. Esta etiqueta utiliza el modificador de atributo para describir una modificación del término utilizado en la cláusula. Los valores posibles para este atributo son: above , below , extremely , intensify , more or less , norm , not , plus , slight , something , very , none . Para completar la definición de la cláusula difusa se deben utilizar las etiquetas <Variable> y anidadas . Una secuencia de etiquetas realiza una base de reglas difusas.<Term><Rule>
Como ejemplo, considere una regla Mamdani compuesta por (la comida es rancia) O (el servicio es muy malo) como antecedente y la propina es barata como consecuente. La parte antecedente está formada por dos cláusulas: (la comida es rancia) y (el servicio es malo) . La primera cláusula antecedente usa comida como variable y rancio como término difuso, mientras que la segunda cláusula antecedente usa servicio como variable, pobre como término difuso y muy como modificador; la cláusula consecuente usa propina como variable difusa y barato como término difuso. La regla completa es:
SI (la comida está rancia) O (el servicio es muy malo) ENTONCES (la propina es barata) .
Veamos cómo FML define una base de reglas con esta regla.
<RuleBase name= "Rulebase1" activationMethod= "MIN" andMethod= "MIN" orMethod= "MAX" type= "mamdani" > <Rule name= "reg1" connector= "or" operator= "MAX" weight= "1.0" > <Antecedente> < Cláusula> <Variable> comida </Variable> <Término> rancio </Término > </ Cláusula> <Cláusula modificador= "muy" > <Variable> servicio </Variable> < Término > pobre </Término> </ Cláusula > </Antecedente> <Consecuente> <Cláusula> <Variable> propina </Variable> < Término > barato </ Término> < / Cláusula > </Consecuente> </Regla> ............ </RuleBase> Ahora, veamos un sistema Takagi-Sugeno-Kang que regula el mismo problema. La diferencia más importante con el sistema Mamdani es la definición de una variable de salida diferente tip . La <TSKVariable>etiqueta se utiliza para definir una variable de salida que se puede utilizar en una regla de un sistema Tsk. Esta etiqueta tiene los mismos atributos de una variable de salida Mamdani, excepto por el atributo domainleft y domainright porque una variable de este tipo (llamada variable tsk) no tiene un universo de discurso. La <TSKTerm>etiqueta anidada representa una función lineal y, por lo tanto, es completamente diferente de <FuzzyTerm>. La <TSKValue>etiqueta se utiliza para definir los coeficientes de la función lineal. El siguiente fragmento de código FML muestra la definición de la variable de salida tip en un sistema Tsk.
<?xml version="1.0" encoding="UTF-8"?> <fuzzySystem name= "newSystem" ip= "127.0.0.1" > <KnowledgeBase> ....... <TSKVariable name= "tip" scale= "null" accumulation= "MAX" defuzzifier= "WA" type= "output" > <TSKTerm name= "average" order = "0" > <TSKValue> 1.6 </TSKValue> </TSKTerm> <TSKTerm name= "cheap" order ="1" > <TSKValue> 1.9 </TSKValue> <TSKValue> 5.6 </TSKValue> <TSKValue> 6.0 </TSKValue> </TSKTerm> < TSKTerm name = "generous" order = " 1 " > <TSKValue> 0.6 </TSKValue> <TSKValue> 1.3 </TSKValue> <TSKValue> 1.0 </TSKValue> </TSKTerm> </TSKVariable> <KnowledgeBase> .......... </fuzzySystem > La definición de FML del componente de base de reglas en un sistema Tsk no cambia mucho. La única diferencia es que la <Clause>etiqueta no tiene el atributo modificador.
Como ejemplo, considere una regla tsk compuesta por (la comida está rancia) O (el servicio es muy malo) como antecedente y, como consecuente, propina=1.9+5.6*comida+6.0*servicio que puede escribirse como la propina es barata de manera implícita. Por lo tanto, la regla puede escribirse de esta manera:
SI (la comida está rancia) O (el servicio es muy malo) ENTONCES (la propina es barata) .
Veamos cómo FML define una base de reglas con esta regla.
<RuleBase name= "Rulebase1" activationMethod= "MIN" andMethod= "MIN" orMethod= "MAX" type= "tsk" > <Rule name= "reg1" connector= "or" operator= "MAX" weight= "1.0" > <Antecedente> <Cláusula> <Variable> comida </Variable> < Término> rancio </ Término > </Cláusula> < Cláusula> <Variable> servicio </Variable> < Término> pobre </Término> </ Cláusula > </Antecedente> <Consecuente> < Cláusula> <Variable> propina </Variable> <Término> barato </ Término > </ Cláusula> </Consecuente> </Regla> ............ </RuleBase> Las etiquetas FML utilizadas para crear un controlador difuso representan el conjunto de lexemas utilizados para crear expresiones difusas. Sin embargo, para lograr un lenguaje basado en XML bien formado, es necesaria una gramática FML libre de contexto, que se describe a continuación. La gramática libre de contexto FML se modela mediante un archivo XML en forma de un Documento de esquema XML (XSD) que expresa el conjunto de reglas a las que debe ajustarse un documento para ser considerado un documento FML válido . Con base en la definición anterior, a continuación se presenta una parte del XSD FML relacionado con la definición de la base de conocimientos.
<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs= "http://www.w3.org/2001/XMLSchema" > ........ <xs:complexType name= "TipoBaseDeConocimiento" > <xs:sequence> <xs:choice minOccurs= "0" maxOccurs= "ilimitado" > <xs:element name= "VariableDifusa" type= "TipoVariableDifusa" /> <xs:element name= "VariableTSK" type= "TipoVariableTSK" /> </xs:choice> </xs:sequence> </xs:complexType> <xs:complexType name= "TipoVariableDifusa" > <xs:sequence> <xs:element name= "TérminoDifuso" type= "TipoTérminoDifuso" maxOccurs= "ilimitado" /> </xs:sequence> <xs:attribute name= "nombre" tipo= "xs:string" uso= "obligatorio" /> <xs:attribute name= "desfuzzificador" valor predeterminado= "COG" > <xs:simpleType> <xs:restricción base= "xs:string" > <xs:patrón valor= "MM|COG|COA|WA|Personalizado" /> </xs:restricción> </xs:simpleType> </xs:attribute> <xs:attribute name= "acumulación" valor predeterminado= "MÁX" > <xs:simpleType> <xs:restricción base= "xs:string" > <xs:patrón valor= "MÁX|SUMA" /> </xs:restricción> </xs:simpleType> </xs:attribute> <xs:attribute name= "escala" tipo= "xs:string" /> <xs:atributo nombre= "dominioizquierdo" tipo= "xs:float" uso= "obligatorio" /> <xs:atributo nombre= "dominioderecho" tipo= "xs:float" uso= "obligatorio" /> <xs:nombre del atributo= "valorPredeterminado" tipo= "xs:float" valor predeterminado= "0" /> <xs: nombre del atributo= "tipo" valor predeterminado= "entrada" > <xs:tipoSimple> <xs:base de restricción = "xs:cadena" > <xs: valor del patrón= "entrada|salida" /> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> <xs:complexType nombre= "TipoDeTérminoFuzzy" > <xs:choice> <xs:element nombre= "FormaLinealDerecha" tipo= "TipoDeParámetroDos" /> <xs:element nombre= "FormaLinealIzquierda" tipo= "TipoDeParámetroDos" /> <xs:element nombre= "FormaPI" tipo= "TipoDeParámetroDos" /> <xs:element nombre= "FormaTriangular" tipo= "TipoDeParámetroTres" /> <xs:element nombre= "FormaGaussiana" tipo= "TipoDeParámetroDos" /> <xs:element nombre= "FormaGaussianaDerecha" tipo= "TipoDeParámetroDos" /> <xs:element nombre= "FormaGaussianaIzquierda" tipo= "TipoDeParámetroDos" /> <xs:element nombre= "FormaTrapezoidal" tipo= "TipoCuatroParámetros" /> <xs:elemento nombre= "FormaSingleton" tipo= "TipoUnParámetro" /> <xs:elemento nombre= "FormaRectangular" tipo= "TipoDosParámetros" /> <xs:elemento nombre= "FormaZ" tipo= "TipoDosParámetros" /> <xs:elemento nombre= "FormaS" tipo= "TipoDosParámetros" /> <xs:elemento nombre= "FormaUsuario" tipo= "TipoFormaUsuario" /> </xs:elección> <xs:tipoComplejo nombre= "TipoDosParámetros" > <xs:atributo nombre= "Parámetro1" tipo= "xs:flotante" uso= "obligatorio" /> <xs:atributo nombre= "Parámetro2" tipo= "xs:flotante" uso= "obligatorio" /> </xs:tipoComplejo> <xs:tipoComplejo nombre= "ThreeParamType" > <xs: nombre del atributo= "Param1" tipo= "xs:flotante" uso= "requerido" /> <xs:atributo nombre= "Parámetro2" tipo= "xs:flotante" uso= "requerido" /> <xs:atributo nombre= "Parámetro3" tipo= "xs:flotante" uso= "requerido" /> </xs:complexType> <xs:complexType nombre= "FourParamType" > <xs:attribute nombre= "Parámetro1" tipo= "xs:float" uso= "obligatorio" /> <xs:attribute nombre= "Parámetro2" tipo= "xs:float" uso= "obligatorio" /> <xs:attribute nombre= "Parámetro3" tipo= "xs:float" uso= "obligatorio" /> <xs:attribute nombre= "Parámetro4" tipo= "xs:float" uso= "obligatorio" /> </xs:complexType> <xs:complexType nombre= "UserShapeType" > <xs:sequence> <xs:element nombre= "Punto" tipo= "PointType" minOccurs= "2" maxOccurs= "ilimitado" /> </xs:sequence> </xs:complexType> <xs:complexType nombre= "PointType" > <xs:attribute name= "x" type= "xs:float" use= "required" /> <xs:attribute name= "y" type= "xs:float" use= "required" /> </xs:complexType> <xs:complexType name= "RuleBaseType" > <xs:attribute name= "name" type= "xs:string" use= "required" /> <xs:attribute name= "activationMethod" default= "MIN" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:pattern value= "PROD|MIN" /> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name= "andMethod" default= "MIN" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:patrón valor= "PROD|MIN" /> </xs:restricción> </xs:simpleType> </xs:attribute> <xs:attribute name= "orMethod" default= "MAX" > <xs:simpleType> <xs:restricción base= "xs:cadena" > <xs:patrón valor= "PROBOR|MAX" /> </xs:restricción> </xs:simpleType> </xs:attribute> <xs:attribute name= "type" use= "required" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:pattern value= "TSK|Tsk|tsk|Mamdani|mamdani" /> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> <xs:complexType name= "MamdaniRuleBaseType" > <xs:complexContent> <xs:extension base= "RuleBaseType" > <xs:sequence> <xs:element name= "Regla" type= "MamdaniFuzzyRuleType" minOccurs= "0" maxOccurs= "ilimitado" /> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType> <xs:complexType name= "TipoDeAntecedente" > <xs:sequence> <xs:element name= "Cláusula" type= "TipoDeCláusula" maxOccurs= "ilimitado" /> </xs:sequence> </xs:complexType> <xs:complexType name= "TipoDeConsecuenciaMamdani" > <xs:sequence> <xs:element name= "Cláusula" type= "TipoDeCláusula" maxOccurs= "ilimitado" /> </xs:sequence> </xs:complexType> <xs:complexType name= "TipoDeCláusula" > <xs:sequence> <xs:element name= "Variable" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:whiteSpace value= "contraer" /> <xs:pattern value= "(([AZ])|([az]))+([AZ]|[az]|[0-9])*" /> </xs:restricción> </xs:simpleType> </xs:elemento> <xs:elemento nombre= "Término" tipo= "xs:cadena" > </xs:elemento> </xs:secuencia> <xs:atributo nombre= "modificador" uso= "opcional" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:pattern valor= "encima|debajo|extremadamente|intensificar|más_o_menos|norma|no|más|ligeramente|algo|muy" /> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> .......... </xs:esquema>Dado que un programa FML sólo realiza una vista estática de un sistema difuso, se proporciona el denominado eXtensible Stylesheet Language Translator (XSLT) para cambiar esta vista estática a una versión computable. En particular, la tecnología XSLT se utiliza para convertir una descripción de un controlador difuso en un lenguaje informático de propósito general para ser computado en varias plataformas de hardware. Actualmente, se ha implementado un programa FML que convierte XSLT en código Java ejecutable. De esta manera, gracias a las capacidades de transparencia proporcionadas por las máquinas virtuales Java, es posible obtener un controlador difuso modelado de manera de alto nivel por medio de FML y ejecutable en una plétora de arquitecturas de hardware a través de tecnologías Java. Sin embargo, XSLT también se puede utilizar para convertir programas FML en lenguajes heredados relacionados con un hardware particular o en otros lenguajes de propósito general.
{{cite book}}: |work=ignorado ( ayuda )