Нечеткий язык разметки - Fuzzy markup language

Fuzzy Markup Language ( FML ) - это язык разметки специального назначения, основанный на XML , используемый для описания структуры и поведения нечеткой системы независимо от аппаратной архитектуры, предназначенной для хоста и его запуска.

Обзор

FML был разработан и разработан Джованни Акампора во время его докторской диссертации. курс компьютерных наук в Университете Салерно, Италия, в 2004 году. Первоначальная идея, вдохновившая Джованни Акампора на создание FML, заключалась в необходимости создания совместной нечеткой структуры, нацеленной на автоматическое управление жилой средой, характеризующейся множеством разнородных устройств, чьи взаимодействия были посвящены максимальному комфорту человека при ограничениях по энергосбережению. Этот фреймворк представляет собой один из первых конкретных примеров Ambient Intelligence . Помимо этого новаторского приложения, основным преимуществом использования XML для описания нечеткой системы является функциональная совместимость аппаратного и программного обеспечения. Действительно, все, что нужно для чтения файла FML, - это соответствующая схема для этого файла и анализатор FML. Такой подход разметки значительно упрощает обмен нечеткими системами между программным обеспечением: например, приложение машинного обучения может извлекать нечеткие правила, которые затем могут быть считаны непосредственно в механизм нечеткого вывода или загружены в нечеткий контроллер. Кроме того, с помощью таких технологий, как XSLT , можно скомпилировать FML на язык программирования по вашему выбору, готовый для встраивания в любое приложение, которое вам нравится. Как заявил Майк Уоттс в своем популярном блоге Computational Intelligence:

«Хотя мотивация Acampora к разработке FML, по-видимому, заключается в разработке встроенных нечетких контроллеров для приложений окружающего интеллекта, FML может стать настоящим подарком для разработчиков алгоритмов извлечения нечетких правил: из моего собственного опыта во время моей докторской диссертации я знаю, что при проектировании файла форматирование и реализация соответствующих синтаксических анализаторов для извлечения правил и механизмов нечеткого вывода может быть настоящей проблемой, занимающей столько же времени, сколько реализация самого алгоритма извлечения правил. Я бы предпочел использовать что-то вроде FML для своей работы ».

Полный обзор FML и связанных приложений можно найти в книге под названием « О силе нечеткого языка разметки» под редакцией Джованни Акампора, Чан-Шинг Ли, Винченцо Лоя и Мей-Хуэй Ван, опубликованной Springer в серии « Исследования нечеткости». и мягкие вычисления .

Синтаксис, грамматика и аппаратный синтез

FML позволяет кодировать нечеткие системы с помощью набора коррелированных семантических тегов, способных моделировать различные компоненты классического нечеткого контроллера, такие как база знаний, база правил, нечеткие переменные и нечеткие правила. Следовательно, теги FML, используемые для построения нечеткого контроллера, представляют набор лексем, используемых для создания нечетких выражений. Чтобы разработать правильно сформированный язык на основе XML, контекстно-свободная грамматика FML определяется посредством схемы XML, которая определяет имя, тип и атрибуты, характеризующие каждый элемент XML. Однако, поскольку программа FML представляет только статическое представление контроллера нечеткой логики, предоставляется так называемый транслятор расширяемого языка таблиц стилей (XSLT) для изменения этого статического представления на вычислимую версию. Действительно, модули XSLT могут преобразовывать нечеткий контроллер на основе FML в компьютерный язык общего назначения с помощью файла XSL, содержащего описание перевода. На этом уровне управление исполняется для оборудования. Короче говоря, FML состоит из трех слоев:

• XML для создания нового языка разметки для управления нечеткой логикой;
• схема XML для определения юридических строительных блоков;
• Расширяемые преобразования языка таблиц стилей (XSLT) для преобразования нечеткого описания контроллера в определенный язык программирования.

Синтаксис FML

Синтаксис FML состоит из тегов и атрибутов XML, которые описывают различные компоненты контроллера нечеткой логики, перечисленные ниже:

• нечеткая база знаний;
• нечеткая база правил;
• Механизм логического вывода
• подсистема фаззификации;
• подсистема дефаззификации.

В деталях, открывающий тег каждой программы FML <FuzzyController> представляет собой моделируемый нечеткий контроллер. Этот тег имеет два атрибута: имя и ip . Первый атрибут позволяет указать имя нечеткого контроллера, а ip используется для определения местоположения контроллера в компьютерной сети. Нечеткая база знаний определяется с помощью тега, <KnowledgeBase> который поддерживает набор нечетких концепций, используемых для моделирования нечеткой базы правил. Для определения управляемой системы, связанной с нечеткой концепцией, <KnowledgeBase> тег использует набор вложенных тегов:

• <FuzzyVariable> определяет нечеткое понятие;
• <FuzzyTerm> определяет лингвистический термин, описывающий нечеткое понятие;
• набор тегов, определяющих форму нечетких наборов, относится к нечетким терминам.

Атрибуты <FuzzyVariable> тега: имя , масштаб , domainLeft , domainRight , type и только для вывода, накопление , defuzzifier и defaultValue . Имя атрибут определяет имя нечеткой концепции, например, температуры ; шкала используется для определения шкалы, используемой для измерения нечеткого понятия, например, градус Цельсия ; domainLeft и domainRight используются для моделирования вселенной дискурса нечеткого понятия, то есть набора реальных значений, относящихся к нечеткому понятию, например [0 °, 40 °] в случае градуса Цельсия; положение нечеткого понятия в правиле (последовательная часть или предшествующая часть) определяется атрибутом типа (ввод / вывод); атрибут накопления определяет метод накопления, то есть метод, позволяющий объединить результаты переменной каждого правила в окончательный результат; атрибут defuzzifier определяет метод, используемый для выполнения преобразования из нечеткого набора, полученного после процесса агрегации, в числовое значение для передачи его в систему; Атрибут defaultValue определяет реальное значение, используемое только в том случае, если для рассматриваемой переменной не сработало правило. Что касается тега <FuzzyTerm> , он использует два атрибута: имя, используемое для идентификации лингвистического значения, связанного с нечетким понятием, и дополнение , логический атрибут, который определяет, если он истинен, необходимо учитывать дополнение функции принадлежности, определенной заданными параметрами. Теги нечеткой формы, используемые для завершения определения нечеткой концепции, включают:

• <TRIANGULARSHAPE>
• <RIGHTLINEARSHAPE>
• <LEFTLINEARSHAPE>
• <PISHAPE>
• <GAUSSIANSHAPE>
• <RIGHTGAUSSIANSHAPE>
• <LEFTGAUSSIANSHAPE>
• <TRAPEZOIDSHAPE>
• <SSHAPE>
• <ZSHAPE>
• <RECTANGULARSHAPE>
• <SINGLETONSHAPE>

Каждый тег формирования использует набор атрибутов, который определяет реальную схему соответствующего нечеткого набора. Количество этих атрибутов зависит от выбранной формы нечеткого множества.

В качестве примера рассмотрим систему вывода типпера, описанную в Mathworks Matlab Fuzzy Logic Toolbox Tutorial. Эта система Мамдани используется для регулирования раздачи чаевых, например, в ресторане. У него две переменные на входе ( еда и услуги ) и одна на выходе ( подсказка ). Код FML для моделирования части базы знаний этой нечеткой системы, содержащей переменные food и tip , показан ниже.

 
<?xml version="1.0" encoding="UTF-8"?>
<FuzzyController name="newSystem" ip="127.0.0.1">
    <KnowledgeBase>
        <FuzzyVariable name="food" domainleft="0.0" domainright="10.0" scale="" type="input">        
            <FuzzyTerm name="delicious" complement="false">
                <LeftLinearShape Param1="5.5" Param2="10.0"/>
            </FuzzyTerm>
            <FuzzyTerm name="rancid" complement="false">
                <TriangularShape Param1="0.0" Param2="2.0" Param3="5.5"/>
            </FuzzyTerm>
        </FuzzyVariable>
        ...........
    	<FuzzyVariable name="tip" domainleft="0.0" domainright="20.0" scale="Euro" defaultValue="0.0" defuzzifier="COG"        
 	               accumulation="MAX"  type="output">
            <FuzzyTerm name="average" complement="false">
                <TriangularShape Param1="5.0" Param2="10.0" Param3="15.0"/>
            </FuzzyTerm>
            <FuzzyTerm name="cheap" complement="false">
                <TriangularShape Param1="0.0" Param2="5.0" Param3="10.0"/>
            </FuzzyTerm>
            <FuzzyTerm name="generous" complement="false">
                <TriangularShape Param1="10.0" Param2="15.0" Param3="20.0"/>
            </FuzzyTerm>
        </FuzzyVariable>
    </KnowledgeBase>
    ............
</FuzzyController>

Специальным тегом, который, кроме того, можно использовать для определения нечеткой формы, является <UserShape> . Этот тег используется для настройки нечеткой формы (нестандартной формы). Моделирование пользовательской формы выполняется с помощью набора <Point> тегов, в которых перечислены крайние точки геометрической области, определяющие пользовательскую нечеткую форму. Очевидно, что атрибуты, используемые в <Point> теге, - это координаты x и y. Что касается компонента базы правил, FML позволяет определять набор баз правил, каждая из которых описывает свое поведение системы. Корень каждой базы правил моделируется <RuleBase> тегом, который определяет нечеткий набор правил. <RuleBase> Тег использует пять атрибутов: имя , тип , activationMethod , andMethod и orMethod . Очевидно, что атрибут name однозначно определяет базу правил. Типа атрибут позволяет указать вид нечеткого контроллера (Мамдань или ТСК) относительно базы правил в вопросе. ActivationMethod атрибут определяет метод , используемый для процесса импликации; andMethod и orMethod атрибут определяет, соответственно, и и или алгоритм использования по умолчанию. Для определения единого правила используется <Rule> тег. В <Rule> теге используются следующие атрибуты : имя , соединитель , оператор и вес . Имя атрибут позволяет определить правила; коннектор используется для определения логического оператора, используемого для соединения различных предложений в предшествующей части (и / или); оператор определяет алгоритм, который будет использоваться для выбранного коннектора; вес определяет важность правила во время шага механизма вывода. Определение предшествующее и последующее правило части получают с помощью <Antecedent> и <Consequent> теги. <Clause> тег используется для моделирования нечетких предложений в предшествующей и последующей частях. Этот тег использует модификатор атрибута для описания модификации термина, используемого в предложении. Возможные значения этого атрибута: выше , ниже , чрезвычайно , усилить , более или менее , норма , нет , плюс , немного , немного , очень , нет . Для того, чтобы завершить определение нечеткого пункта вложенные <Variable> и <Term> теги должны быть использованы. Последовательность <Rule> тегов реализует нечеткую базу правил.

В качестве примера рассмотрим правило Мамдани, состоящее из (еда прогорклая) ИЛИ (обслуживание очень плохое) как предшествующее, а чаевые - как следствие, дешевые . Предшествующая часть состоит из двух предложений: (еда прогорклая) и (плохое обслуживание) . Первое предложение-предшественник использует пищу как переменную и прогорклый как нечеткий термин, тогда как второе предложение-предшественник использует услугу как переменную, бедную как нечеткий термин и очень как модификатор; в последующем предложении подсказка используется как нечеткая переменная, а дешевый - как нечеткий термин. Полное правило:

ЕСЛИ (еда прогорклая) ИЛИ (обслуживание очень плохое) ТО (чаевые дешевые) .

Давайте посмотрим, как FML определяет базу правил с помощью этого правила.

 
<RuleBase name="Rulebase1" activationMethod="MIN" andMethod="MIN" orMethod="MAX" type="mamdani">
      <Rule name="reg1" connector="or" operator="MAX" weight="1.0">
           <Antecedent>
                <Clause>
                    <Variable>food</Variable>
                    <Term>rancid</Term>
                </Clause>
                <Clause modifier="very">
                    <Variable>service</Variable>
                    <Term>poor</Term>
                </Clause>
            </Antecedent>
            <Consequent>
                <Clause>
                    <Variable>tip</Variable>
                    <Term>cheap</Term>
                </Clause>
            </Consequent>
      </Rule>
      ............
</RuleBase>

Теперь давайте посмотрим на систему Такаги-Сугено-Канга, которая регулирует ту же проблему. Наиболее важным отличием от системы Мамдани является определение наконечника другой выходной переменной . <TSKVariable> Тег используется для определения выходной переменной , которая может быть использована в правилах системы ТСК. Этот тег имеет те же атрибуты выходной переменной Mamdani, за исключением атрибута domainleft и domainright, потому что переменная этого типа (называемая tsk-variable) не имеет универсума для обсуждения. Вложенный <TSKTerm> тег представляет собой линейную функцию и полностью отличается от <FuzzyTerm> . <TSKValue> Тег используется для определения коэффициентов линейной функции. Следующий фрагмент кода FML показывает определение выходной переменной tip в системе Tsk.

 
<?xml version="1.0" encoding="UTF-8"?>
<FuzzyController 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>
    ..........
</FuzzyController>

Определение FML компонента базы правил в системе Tsk не сильно изменилось. Единственное отличие состоит в том, что у <Clause> тега нет атрибута модификатора.

В качестве примера рассмотрим правило tsk, составленное из (еда прогорклая) ИЛИ (обслуживание очень плохое) как предшествующее и, как следствие, чаевые = 1,9 + 5,6 * еда + 6,0 * услуга, которая может быть записана как чаевые дешевые в неявном виде. способ. Итак, правило можно записать так:

ЕСЛИ (еда прогорклая) ИЛИ (обслуживание очень плохое) ТО (чаевые дешевые) .

Давайте посмотрим, как FML определяет базу правил с помощью этого правила.

 
<RuleBase name="Rulebase1" activationMethod="MIN" andMethod="MIN" orMethod="MAX" type="tsk">
<Rule name="reg1" connector="or" operator="MAX" weight="1.0">
            <Antecedent>
                <Clause>
                    <Variable>food</Variable>
                    <Term>rancid</Term>
                </Clause>
                <Clause>
                    <Variable>service</Variable>
                    <Term>poor</Term>
                </Clause>
            </Antecedent>
            <Consequent>
                <Clause>
                    <Variable>tip</Variable>
                    <Term>cheap</Term>
                </Clause>
            </Consequent>
        </Rule>
	............
</RuleBase>

Грамматика FML

Теги FML, используемые для построения нечеткого контроллера, представляют набор лексем, используемых для создания нечетких выражений. Однако для реализации правильно сформированного языка на основе XML необходима контекстно-свободная грамматика FML, которая описывается ниже. Контекстно-свободная грамматика FML моделируется файлом XML в форме документа схемы XML (XSD), который выражает набор правил, которым документ должен соответствовать, чтобы считаться действительным документом FML. Основываясь на предыдущем определении, ниже приводится часть XSD FML, касающаяся определения базы знаний.

 
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">	
  ........
	<xs:complexType name="KnowledgeBaseType">
		<xs:sequence>
		   <xs:choice minOccurs="0" maxOccurs="unbounded">
			   <xs:element name="FuzzyVariable" type="FuzzyVariableType"/>
			   <xs:element name="TSKVariable" type="TSKVariableType"/>
			 </xs:choice>	
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="FuzzyVariableType">
		<xs:sequence>
			<xs:element name="FuzzyTerm" type="FuzzyTermType" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="name" type="xs:string" use="required"/>
		<xs:attribute name="defuzzifier" default="COG">
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:pattern value="MM|COG|COA|WA|Custom"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="accumulation" default="MAX">
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:pattern value="MAX|SUM"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="scale" type="xs:string" />
		<xs:attribute name="domainleft" type="xs:float"  use="required"/>
		<xs:attribute name="domainright" type="xs:float" use="required"/>
		<xs:attribute name="defaultValue" type="xs:float" default="0"/>
		<xs:attribute name="type"  default="input">
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:pattern value="input|output"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>
	<xs:complexType name="FuzzyTermType">
		<xs:choice>
			<xs:element name="RightLinearShape" type="TwoParamType"/>
			<xs:element name="LeftLinearShape" type="TwoParamType"/>
			<xs:element name="PIShape" type="TwoParamType"/>
			<xs:element name="TriangularShape" type="ThreeParamType"/>
			<xs:element name="GaussianShape" type="TwoParamType"/>
			<xs:element name="RightGaussianShape" type="TwoParamType"/>
			<xs:element name="LeftGaussianShape" type="TwoParamType"/>
			<xs:element name="TrapezoidShape" type="FourParamType"/>
			<xs:element name="SingletonShape" type="OneParamType"/>
			<xs:element name="RectangularShape" type="TwoParamType"/>
			<xs:element name="ZShape" type="TwoParamType"/>
			<xs:element name="SShape" type="TwoParamType"/>
			<xs:element name="UserShape" type="UserShapeType"/>
		</xs:choice>
        <xs:complexType name="TwoParamType">
		<xs:attribute name="Param1" type="xs:float" use="required"/>
		<xs:attribute name="Param2" type="xs:float" use="required"/>
	</xs:complexType>
	<xs:complexType name="ThreeParamType">
		<xs:attribute name="Param1" type="xs:float" use="required"/>
		<xs:attribute name="Param2" type="xs:float" use="required"/>
		<xs:attribute name="Param3" type="xs:float" use="required"/>
	</xs:complexType>
	<xs:complexType name="FourParamType">
		<xs:attribute name="Param1" type="xs:float" use="required"/>
		<xs:attribute name="Param2" type="xs:float" use="required"/>
		<xs:attribute name="Param3" type="xs:float" use="required"/>
		<xs:attribute name="Param4" type="xs:float" use="required"/>
	</xs:complexType>
	<xs:complexType name="UserShapeType">
		<xs:sequence>
			<xs:element name="Point" type="PointType" minOccurs="2" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="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:pattern value="PROD|MIN"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="orMethod" default="MAX">
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:pattern value="PROBOR|MAX"/>
				</xs:restriction>
			</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="Rule" type="MamdaniFuzzyRuleType" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="AntecedentType">
		<xs:sequence>
			<xs:element name="Clause" type="ClauseType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="MamdaniConsequentType">
		<xs:sequence>
			<xs:element name="Clause" type="ClauseType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="ClauseType">
		<xs:sequence>
			<xs:element name="Variable">
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
						<xs:pattern value="(([A-Z])|([a-z]))+([A-Z]|[a-z]|[0-9])*"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:element>
			<xs:element name="Term" type="xs:string">
			</xs:element>
		</xs:sequence>
		<xs:attribute name="modifier" use="optional">
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:pattern     
                                            value="above|below|extremely|intensify|more_or_less|norm|not|plus|slightly|somewhat|very"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
	</xs:complexType>
	..........
</xs:schema>

Синтез FML

Поскольку программа FML реализует только статическое представление нечеткой системы, предоставляется так называемый транслятор расширяемого языка таблиц стилей (XSLT) для преобразования этого статического представления в вычислимую версию. В частности, технология XSLT используется для преобразования нечеткого описания контроллера в компьютерный язык общего назначения для вычисления на нескольких аппаратных платформах. В настоящее время реализована XSLT-программа преобразования FML в исполняемый код Java. Таким образом, благодаря возможностям прозрачности, обеспечиваемым виртуальными машинами Java, можно получить нечеткий контроллер, смоделированный на высоком уровне с помощью FML и работающий на множестве аппаратных архитектур с помощью технологий Java. Однако XSLT также можно использовать для преобразования программ FML на устаревших языках, связанных с конкретным оборудованием, или на других языках общего назначения.

Рекомендации

дальнейшее чтение

• Ли, Чанг-Шинг; и другие. (Декабрь 2010 г.). «Оценка диеты на основе нечеткой онтологии 2-го типа и нечеткого языка разметки». Международный журнал интеллектуальных систем . 25 (12): 1187–1216. DOI : 10.1002 / int.20449 . (требуется подписка)
• Acampora, G .; Лойя, В. (2005). «Совместимость и масштабируемость нечеткого управления для адаптивной домотической структуры». IEEE Transactions по промышленной информатике . 1 (2): 97–111. DOI : 10.1109 / TII.2005.844431 .
• Acampora, G .; Лойя, В. (2008). «Предложение повсеместных нечетких вычислений для Ambient Intelligence». Информационные науки . 178 (3): 631–646. DOI : 10.1016 / j.ins.2007.08.023 .
• Acampora, G .; Wang, M.-H .; Lee, C.-S .; Hsieh, K.-L .; Hsu, C.-Y .; Чанг, К.-К. (2010). «Мультиагенты на основе онтологий для интеллектуальных приложений здравоохранения». Журнал окружающего интеллекта и гуманизированных вычислений . 1 (2): 111–131. DOI : 10.1007 / s12652-010-0011-5 .
• Acampora, G .; Loia, V .; Gaeta, M .; Василакос, А.В. (2010). «Совместимые и адаптивные нечеткие сервисы для приложений внешней разведки». ACM-транзакции в автономных и адаптивных системах . 5 (2): 1-26. DOI : 10.1145 / 1740600.1740604 .