Программное обеспечение решения обратных задач в виде композиции нечетких соответствий

Современные исследования систем искусственного интеллекта в области принятия решений в нечетких условиях (при нечеткой исходной информации) в основном базируются на парадигме использования мягких и символьных вычислений. Разработка экспертных систем нечеткой диагностики востребована в таких областях человеческой деятельности как медицина, управление и диагностика сложных техно-

генных систем и систем принятия решений в социально-экономических, биологоэкологических и других сферах функционирования социума.

Целью настоящего исследования является разработка программного комплекса для решения обратной задачи, сформулированной в виде композиции нечетких соответствий [1].

Постановка задачи

Пусть k=1p                         j=1, n                        j=1, n

A» p =( aM 0,1], Xp, . =( XjH 0,1], B„. =( bj)e[ 0,1]

i = 1 ^m                         k = 1, p                        i = 1, m

Исследуются решения правого нечеткого реляционного уравнения [2]: AoX = B .

Очевидно, рассматриваемое уравнение представляет собой n независимых систем в каждой из которых m уравнений вида:

a 11	a 12	' "    a 1 p		(x ) x 1 j		f b1?
a 21	a 22	a 2 p		x 2 j	—	b 2 j	( j	= 1, n )
v a m 1	am 2	••   a mp j		I x pj J		b . < mj J

Исследование решения уравнения A ° X = B осуществлялось для трех наиболее распространенных треугольных норм (логического, алгебраического и граничного произведений) и простейших индуцированных ими импликаторов (левых и правых).

max (T (ak, x^. )) = bj

Таким образом, исходное уравнение сводится к системам k                  или min (I (aik, xk-))=by (i=1, m; j=1, n)

^k                                      , соответственно.

В этом случае реализована возможность нахождения решения 9 видов уравнений при ( i = 1, m ; j = 1, n )

(табл.)

Известно [2], что в настоящее время не существует достаточно эффективного метода решения уравнений подобного класса. Поэтому в данной работе предложена практическая методология и реализация решения обратных задач для нечетких ре-

ляционных уравнений общего вида в среде пакета символьной математики Wolfram Mathematica.

Программная реализация

Текст функции, которая возвращает список пересечений интервалов из l1 и l2 .

Таблица

Используются t-нормы	Используются соответствующие импликаторы
max ( min ( a *, x ^ ) ) = b y	min ( max ( 1 - a k , x k ) ) = Ьц	min ( max ( 1 - x j , aik ) ) = b y
max ( a ik • X y ) = b y	min ( 1 - a ik + a ik • хку ) = b y	min ( 1 - x kj + x k-- a ik ) = b y
max ( max ( aik + xkj - 1,0 ) ) = b	min ( min ( 1 - a ik + xk 7 ,1 ) ) = b	min ( min ( 1 - x k + a ik ,1 ) ) = b

Range[Min[(Length[£1], Length[12]}] ] (диал— [ми- (длина         (длина

Функция, решающая соответствующее нечеткое уравнение

SolveARowB[arow_, b_] : = Module[(n, helper, selected}, n = Length[arow]I

(♦ Возвращает решение, при котором на месте 1 получаем b при композиции *)

helper [i_] : =

If[j? = i, If [arow [ [xr] ] = b, Interval[(b, 1} ], Interval [b] ] ,

[условный ■ [условный оператор [интервал             [интервал

If[arow[[a]] = b II I MemberQ [selected, s] , Interval [ (0, 1} ], Interval [ [в, b}]]] 8/0

[условный оператор         [элемент списка?           [интервал             [интервал

Range[n] j

[диапазон

(* Номера столбцов, на местах которых можно получить значение Ь при композиции *)

selected = Select [Range[n] , arow [[ »] ] >=b8]j [выбрать [диапазон helper /0 selected]

Решение одной из систем уравнений

SolveAMatrixBColuen[aw?trix_, bcoLumn_1 : = Module[(dd, cret, filt, result, next},

(* Фильтрует решенин, которые включаются в другие решения *)

(* Возвращает False для столбцов с пустыми множествами *)

(* Возвращает столбец, с преобразованиями: Interval[ (х, х)] => к *)

fHt[L ] := 1Т[М1п[л] -Мах [л], М1п[л], Л] &  /в Ц

(* Решает первое уравнени *)

result = SolveARowB[omatrix[ [1] ], bcolumn[ [1] ] ] j

(* Решает остальные уравнение •)

For[i = 2, i s Length [bcotumn], i**,

[цикл ДЛЯ         [длина

(* Решает следующие уравнение *} next = SoIveARowB[omatrix((i] ) , bcolumn[ [i] ) ] ;

(* Комбинирует все текущие решение с предыдущими *)

(* Фильтрует решения с пустыми множествами *)

result = Select[result, cret]j [выбрать

(* Фильтрует решения, которые включается в другие *)

____ result = dd[result] ____________________________________________________________

Функция, решающая систему систем уравнений

SolveAMatrixBMatrix[oznotrix_, bmotrix_] 8= Module[(helper, btrans, result, n), [программный модуль

(♦ Функция для комбинирования решений нескольких систем ♦)

helper[ret_, 1_ ] :=

If[Length[I] = 0, ret, helper[Append[ret, л], Drop[L, 1]] & /6 First[t]]j

I™ [длина                           [добавить в конец [отбросить          [первый

(* Транспонирует матрицу, для обращения к столбцам, а не к строкам *)

btrans = Transpose [ixnotrix] j

(* Решает все системы отдельно*)

result = SolveAMatrixBColumn[arotrix, btrans[ (л) )) &/6 Range[Length[btrans]] ;

n = Length[result]j

(* Комбинирует полученные решения *)

result = helper[{}, result]j

MatrixForm[Transpose[л] ] &/6 Flatten[result, n - 1]]

матричная ■ транспозиция           I yn постить

Практическая апробация

Выполним решение тестовой задачи:

/1.0 0.8 0,7 1.0'

0-9

M 0,2

0.7

0.2

0.2

SolveAMat rixBMat rix [ 0.1 6.9 9.8 6.5 л

1.0 0.5 0.2J

При использовании импликации в виде логического произведения получим следующее решение:

0.9                 8.7

Interval'{0j 0-1}] Interval;;0? 0.2}]

Interval; ;&, 0*1}] Interval;*®, 6*2})

0.9

Interval;<0, 0.1

Interval;10j 0.1 . Interval;{0, 0Л

0,7 Interval; [0, 0.2}] 0.2 Interval[<0, 0.2}]

r         0.9                   6.7

Interval;"0, 0.1}] Interval ;{0, 0.2}] ■

Interval; ;0j 0.1}] Interval ;{0, 6.2}] J

L Interval; ;0, 0Л}]          0.2

Первая из систем имеет единственное решение, а вторая три. Семантическая интерпретация получаемых решений достаточно полно исследована, например, в [2].

При использовании граничного произведения получим следующее решение:

0.9                0.7 0.2                  0.2 Interval[{0, 0.3}]           0.4 t Interval [ {0, 0-6} ] Interval [ {0, 0.7} ] j 0.9          Interval >;0, 0.7}] ‘ 0.2                 0.2 Interval[{0j 0.3}]          0.4 , Interval[ {0, 0.6}]          0.7

0.9                 0.7 0.2                  0.2 lnterval[{0, 0.3}] lnterval[{0? 0.4}] .Interval[{0j 0.6} ]          0.7 0.9          Interval;<0, 0.7}] " 0.2                0.2 lnterval[{0j 0.3}] lnterval[{0, 0.4}] Interval[ {0, 0. 6}]          0.7

1