Нечеткий язык разметки

(FML) Язык нечеткой разметки

Разработано	Джованни Акампора
Тип формата	Язык разметки
Расширено с	XML
Стандартный	ИЭЭЭ 1855-2016

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

Обзор

FML был спроектирован и разработан Джованни Акампорой во время работы над докторской диссертацией. курс компьютерных наук в Университете Салерно , Италия, в 2004 году. Первоначальная идея, вдохновившая Джованни Акампору на создание FML, заключалась в необходимости создания совместной нечеткой структуры, направленной на автоматическое управление средой обитания, характеризующейся множеством гетерогенных устройств, Взаимодействия были посвящены максимизации человеческого комфорта в условиях ограничений энергосбережения. Эта структура представляет собой один из первых конкретных примеров окружающего интеллекта . Помимо этого новаторского приложения, основным преимуществом использования 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: <fuzzySystem> который представляет моделируемый нечеткий контроллер. Этот тег имеет два атрибута: имя и IP . Первый атрибут позволяет указать имя нечеткого контроллера, а IP-адрес используется для определения местоположения контроллера в компьютерной сети. Нечеткая база знаний определяется с помощью тега <KnowledgeBase> который поддерживает набор нечетких понятий, используемых для моделирования базы нечетких правил. Чтобы определить нечеткое контролируемая система, связанная с концепцией, <KnowledgeBase> tag использует набор вложенных тегов:

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

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

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

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

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

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

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

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

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

Давайте посмотрим, как 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>

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

Определение компонента базы правил 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, используемые для создания нечеткого контроллера, представляют собой набор лексем, используемых для создания нечетких выражений. Однако для реализации правильно сформированного языка на основе XML необходима бесконтекстная грамматика FML, которая описана ниже. Бесконтекстная грамматика FML моделируется XML-файлом в форме документа схемы XML (XSD), который выражает набор правил, которым документ должен соответствовать, чтобы считаться действительным документом FML. На основе предыдущего определения ниже приведена часть FML XSD, касающаяся определения базы знаний.

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

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

• Ли, Чанг-Шинг; и др. (декабрь 2010 г.). «Оценка диеты на основе нечеткой онтологии типа 2 и нечеткого языка разметки». Международный журнал интеллектуальных систем . 25 (12): 1187–1216. дои : 10.1002/int.20449 . S2CID   13570946 . (требуется подписка)
• Акампора, Г.; Лойя, В. (2005). «Взаимодействие и масштабируемость нечеткого управления для адаптивной домашней среды». Транзакции IEEE по промышленной информатике . 1 (2): 97–111. дои : 10.1109/TII.2005.844431 . S2CID   8008285 .
• Акампора, Г.; Лойя, В. (2008). «Предложение повсеместных нечетких вычислений для окружающего интеллекта». Информационные науки . 178 (3): 631–646. дои : 10.1016/j.ins.2007.08.023 .
• Акампора, Г.; Ван, М.-Х.; Ли, К.-С.; Се, К.-Л.; Сюй, К.-Ю.; Чанг, К.-К. (2010). «Мультиагенты на основе онтологий для интеллектуальных приложений здравоохранения». Журнал окружающего интеллекта и гуманизированных вычислений . 1 (2): 111–131. дои : 10.1007/s12652-010-0011-5 . S2CID   35304577 .
• Акампора, Г.; Лойя, В.; Гаэта, М.; Василакос, А.В. (2010). «Взаимодействующие и адаптивные нечеткие сервисы для приложений окружающего интеллекта». Транзакции ACM в автономных и адаптивных системах . 5 (2): 1–26. дои : 10.1145/1740600.1740604 . S2CID   14234229 .