TDK dolgozat. Fuzzy Rule Interpolation Toolbox implementálása. Miskolci Egyetem. Készítette: Sávoli Dénes Levente Programtervez Informatika

TDK dolgozat

Miskolci Egyetem

Fuzzy Rule Interpolation Toolbox implementálása

Készítette: Sávoli Dénes Levente 2008. Programtervez® Informatika

Témavezet®: Krizsán Zoltán

Miskolc, 2012

A bemutatott kutató munka a TÁMOP-4.2.1.B-10/2/KONV-2010-0001

jel¶ projekt részeként az Európai Unió támogatásával, az Európai Szociális Alap társnanszírozásával valósul meg.

2

Tartalomjegyzék

1. Bevezetés

5

2. Téma elméleti kifejtése

7

2.1. 2.2. 2.3. 2.4. 2.5.

Fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Objektum Orientált Programozás . . . . . . . . . . . . . . . . . . . . . Dinamic Link Library (DLL) . . . . . . . . . . . . . . . . . . . . . . . . Fuzzy Rule Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . Fis fájl felépítése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1. System szekció . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.2. Inputok leírása . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.3. Outputok leírása . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.4. Szabályok részletezése . . . . . . . . . . . . . . . . . . . . . . . 2.6. Obs fájl felépítése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7. Fuzzy Rule Interpolation based on POlar Cuts (FRIPOC) . . . . . . . 2.7.1. Fuzzy sEt interpolAtion based on linguistic Term shifting and polar cuts (FEAT-p) m¶ködése . . . . . . . . . . . . . . . . . . 2.7.2. Single rUle REasoning based on polar cuts (SURE-p) m¶ködése

3. Fejleszt®i dokumentáció

3.1. Forrásfájlok feldolgozásának leírása . . . . . . . . . . . . . . . 3.1.1. Fájlfeldolgozó osztályok (*.s, *.obs) . . . . . . . . . . 3.1.2. CPoint . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.3. CMembershipFunction . . . . . . . . . . . . . . . . . . 3.1.4. CPartition . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.5. CRule . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.6. CSystem . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.7. CFISFile . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.8. CObservation . . . . . . . . . . . . . . . . . . . . . . . 3.1.9. COBSFile . . . . . . . . . . . . . . . . . . . . . . . . . 3.2. Egylépéses szabály-interpolációs módszerek . . . . . . . . . . . 3.2.1. A lineáris szabály-interpolációs (KH) módszer . . . . . 3.2.2. Relatív fuzzy jelleg meg®rzésén alapuló módszer (CRF) 3.2.3. Módosított α vágat alapú szabály-interpoláció (MACI) 3.2.4. A VKK módszer . . . . . . . . . . . . . . . . . . . . . 3.3. A kétlépéses FRIPOC módszer dokumentálása . . . . . . . . . 3.3.1. CFEAT_P . . . . . . . . . . . . . . . . . . . . . . . . 3.3.2. FRIPOC . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4. Módszerek paramétereinek áttekintése . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

7 8 11 12 13 13 14 15 15 16 16 17 17 19

19 19 20 20 21 22 22 23 24 24 24 25 27 29 31 33 33 35 35 3

4. Összefoglalás

37

Irodalomjegyzék

38

4

1. fejezet Bevezetés

A dolgozatom témája a Fuzzy Szabály-Interpolációs módszerek implementálása. A probléma, amire a dolgozat épül, hogy ugyan teljesen fed® szabálybázis esetén létezik egy lib, de ritka szabálybázis esetén ezt még csak MATLAB-ban [1] valósították meg. A MATLAB környezetben megírt toolbox használatával az a gond, hogy szükség van a program felhasználó szint¶ ismeretéhez, továbbá ennek használata er®sen lassítja a feldolgozás sebességét. Ezért érdemesebb egy alacsony szint¶ programozási nyelven megírni ezt, amivel akár valós id®ben is használni tudjuk az interpolációs módszereket. Ahhoz, hogy a témát könnyen elsajátíthatóvá tegyem szükségességét érzem néhány fontos fogalom leírásának. A dolgozat elejét a fuzzy, mint szó és a fuzzy jelleg leírásával kezdem el. Ez a fogalom nagyon fontos számunkra, hiszen az egész dolgozat e köré épül. Ha nem vagyunk tisztában ezzel, akkor a következ® leírást nehéz lesz feldolgozni. Ezért is fogalmazom meg részletesen ezt a témakört már a dolgoztom elején. A választott nyelv, melyen a Toolbox-ot elkészítettem a C++. Ennek a nyelvnek az alapja a C nyelv, szintaktikája nem tér el t®le. A fontos különbség viszont, hogy a C++ egy objektum orientált nyelv. Ezért is fontos, hogy az objetum orientált programozásról (OOP) ejtsek néhány szót. Az OOP-t az emberek hónapokig, akár évekig is tanulják, mire megfelel®en magas szinten elsajátítják használatát. Amit én leírtam róla az egy apró töredéke az egész témának. Ebb®l akár egy külön dolgozatot is lehetne írni. Az én forráskódom megértéséhez viszont bizonyos dolgokra szükség lehet az OOP témekörében, ezeket írom le nagyvonalakban a 2.2. fejezetben. Mivel ez a Toolbox olyan céllal készült, hogy szinte bármilyen rendszeren használható legyen, ezért elengedhetetlen volt egy olyan közös formátum deniálása, amelyet sokan ismernek, használnak és bizonyított is a programozók körében. A választás ezért esett a dll-re, melyet ugyan Windows alapú operációs rendszerek tudnak csak használni (*.dll), de kis módosítással (*.so) akár Linux alatt is m¶köd®képes. A dll céljáról, történetér®l írtam néhány sort a 2.3. fejezet keretében. A fenti fogalmak tisztázása után a program és a módszerek elméleti leírásával folytatom, hogyan m¶ködik és mit miért kellett létrehoznom. El®ször a módszerek implemetálásához szükséges f®bb osztályokról ejtek néhány szót, majd a módszerek alapgondolatáról és implementálásának menetér®l. A fejleszt®i dokumentációs rész megértéséhez elengedhetetlen az elméleti háttér ismerete, ezért a 2.5. és 2.6. fejezetekben egy módszer implementálásához szükséges fájlok felépítését taglalom. A 2. fejezet végén a FRIPOC módszer alapgondolatát és menetét ismertetem. Az eljárás két másik metódus segítségével számítja ki az új szabályt. A fejleszt®i dokumentáció részben els® ízben a két fájlfeldolgozó osztályt, valamint az 5

ahhoz készült adattároló osztályok adattagjait és függvényeit elemzem. Végül pedig a 3.1. fejezetben leírt osztályokat használó fuzzy szabály-interpolációs eljárások implementálásának módját, függvényeit fejtem ki. A célom egy olyan átlátható osztály struktúra létrehozása, amely biztosítja a különböz® módszerek azonos használatát és könny¶ kiterjeszthet®ségét. Egy felhasználónak ne legyen szüksége arra, hogy ismerje az eljárások számítási modelljét. A platformfüggetlenség érdekében az új toolbox dinamikus könyvtárban lesz elérhet® (*,dll, *.so). Az ilyen könyvtárak a legtöbb programozási nyelvben használhatóak valamilyen módon. Ennek elérése érdekében a már meglév® MATLAB kód alapján kell megterveznem a módszereket, majd implemetálni azokat a választott környezetben.

6

2. fejezet Téma elméleti kifejtése

2.1. Fuzzy Kezdetnek, szeretnék néhány szót ejteni a fuzzy jellegr®l. Mi is a fuzzy jelleg? Ha a szó szoros értelmét tekintjük, homályos, elmosódott. Ebb®l is látszik mennyire találó a neve, hiszen esetünkben is elmosódott határú halmazokról beszélhetünk. Ezek a halmazok abban térnek el az általános értelemben vettekt®l, hogy nem adjuk meg konkrétan azt, hogy a halmazon belül vagy kívül helyezkedik el egy-egy elem. Egy mér®számmal jelezzük azt, hogy az egyes elemeket mennyire tartalmazzák a halmazok. Azért jobbak ezek az éles határok használatánál, mert ha jobban belegondolunk, gyakran a valós életben sem tudjuk egyértelm¶en kimondani, hogy egy adott dolog benne van-e egy megszabott halmazban vagy sem. Mindent, amit az eddig megszokott módon értelmeztünk megadhatunk fuzzy halmazok segítségével is. A fuzzy jelleget általában egy [0,1] intervallumból vett számmal adjuk meg, ahol az egy jelenti a teljes, a nulla pedig a nem egyezést. A köztes értékek pedig részleges egyezést írnak le. Vegyük például az emberi tulajdonságokat. Minden embernek vannak tulajdonságaik, melyek nem minden esetben jellemz®ek rá teljes mértékben. Ilyenkor használhatjuk a fuzzy halmazt. Megadhatjuk, hogy az adott tulajdonság mennyire jellemzi a kiválasztott személyt. A dolgozatom témája a fuzzy interpolációs módszerek implementálása C++ nyelven. Napjainkban már az informatikában is egyre kevésbé tudjuk használni az éles határú halmazokat döntések meghozásához.

2.1. ábra. Példa fuzzy halmazra Nézzük például a fenti ábrát. A hómérséklet fuzzy jellegét jól használhatjuk ez esetben ventilátorok szabályozására is. De az emberi agy m¶ködése sem er®s határok 7

2.2. Objektum Orientált Programozás

meghúzásának segítségével dönt, hanem mérlegeli a lehetséges eseteket és a neki leginkább megfelel®t választja. Ez a folyamat az ember számára egyszer¶, de a számítógépek esetén kódok egész sorának kell lefutni egy jó eredmény létrejöttéhez. Ahhoz, hogy ez belátható id®n belül megtörténjen kellett egy eszköz, melynek segítségével gyorsan hozhatók döntések. Ezért találták ki a fuzzy halmazokat, melyek már közelebb állnak az ember döntési stratégiájához. Itt a határok nem választhatók el konkrétan. Az elmosódás miatt megmondható egy dologról, hogy mennyire jellemzi az adott tulajdonság. Ennek segítségével a végén a rá leginkább jellemz® adatokat kaphatjuk meg. Ezen logika megvalósítására hozták létre az FRI Toolbox-ot. Egyetlen hátulüt®je ennek, hogy csak MatLab-ban használható. Az toolboxban több interpolációs módszer is helyet kapott, ezen módszerek implementálását kezdtem el C++ környezetben. Fogalmak: teljesen fed® szabálybázis:

Minden lehetséges bemeneti érték (meggyelés) esetén rendelkezésre kell álljon legalább egy olyan szabály, amelynek antecedens része metszi vagy átfedi a meggyelést minden bemeneti dimenzióban. ritka szabálybázis

Nem minden lehetséges bemeneti érték (meggyelés) esetén áll rendelkezésre olyan szabály, amelynek antecedens része metszi vagy átfedi a meggyelést minden bemeneti dimenzióban. fuzzy rule interpolation (FRI) [2]

A szabály-interpoláció egy olyan eljárás, amely ritka szabálybázis esetén egy meggyelés alapján valamely módszer segítségével kitölti a hiányzó részeket (interpolál).

2.2. Objektum Orientált Programozás A módszereket C++ nyelven fogom implementálni. Ennek a nyelvnek az egyik f® tulajdonsága, hogy objektum orientált. Mit is jelent ez? A nevéb®l is adódik, hogy a nyelv objektumokra épül. Minden objetumot egy osztály megírásával, majd példányosításával hozhatunk létre. Minden osztálynak lehetnek adattagjai, függvényei. Két speciális függvény a konstruktor és a destruktor, amik az osztály példányosításakor, illetve törlésekor hívódnak meg. A konstruktor jellemz®en egy olyan függvény, melynek neve megegyezik az osztály nevével, valamint üres a visszatérési értéke. A metódus paraméterei azok a paraméterek, melyeket egy osztály példányosításakor meg kell adnunk. Használata lehet üres paraméterekkel is, jellemz®en olyan esetekben, amikor csak változókat szeretnénk inicializálni. A destruktor szintén az osztály nevét viseli, azzal a különbséggel, hogy egy ∼ (tilde) jelet kell a név elé írnunk, jelezve ezzel, hogy destruktorról van szó. Itt az osztályban létrehozott változóinkat kell, ajánlatos törölnünk, ha nem szeretnénk, hogy a programunk sok memóriát használjon, esetleg ezért belassuljon. 1 2 3 4 5 6 7 8

c l a s s osztaly { osztaly () { // konstruktor kódja } ~osztaly () { // destruktor kódja } 8

2.2. Objektum Orientált Programozás

9

} Kód 2.1. Konstruktor és destruktor Az adattagok legjobban a szimpla változókhoz hasonlítanak ugyanúgy van típusuk és megnevezésük. Használhatunk továbbá az osztályban megírt függvényeket is. Három további kulcsszó is megadható az adattagok és függvények el®tt, ezek a public, protected és private. Ezeknek legf®bb szerepük az örökl®désnél van. A public kulcsszót akkor használjuk, ha azt szeretnénk, hogy bárki hozzáférhessen a függvényünkhöz, adattagunkhoz. Ilyenkor semmi kötöttség nincs szabadon olvashatók és változtathatók az változók értékei. Az örökl®désnél legfontosabb a protected lehet, ugyanis ezt olyankor használjuk, ha a függvényt, adattagot az osztályon belül és annak gyermekeinél szeretnénk hogy használható legyen. Protected esetén, csak osztályokon belül használhatók, példányosítás után már nem láthatunk semmit ezekb®l. Az utolsó private a legszigorúbb, hiszen ezt olyankor használjuk, ha csak az adott osztályban szeretnénk, hogy láthatóak legyenek a függvények és adattagok. Azokat sem példányosításkor, sem pedig örökítéskor nem láthatjuk.

1 2 3 4 5 6 7 8

c l a s s osztaly { private : int a ; // ez csak az osztályon belül használható protected : int b ; // ez az osztályon belül és leszármazottjaiban használható public : int c ; //bárhonnan elérhet® //a konstruktor és destruktor mindíg publikus osztaly () { // változók i n i c i a l i z á l á s a }

9 10 11 12 13 14 15 16 17

}

~osztaly () { // változók t ö r l é s e } Kód 2.2. Public, private és protected

Megadhatjuk továbbá, hogy egy osztály konkrét példányosítására ne legyen szükség a függvénye használata el®tt. Ilyenkor a static kulcsszót kell használnunk a függvény neve és visszatérési értékének megadása el®tt. Ez esetben az osztály neve után két darab kett®spontot írva használhatjuk a benne lév® statikus függvényt. Ilyen függvény például a main is, ami futtatáskor automatikusan meghívódik. 1 2 3 4 5 6 7 8

c l a s s Statikus { public : s t a t i c void Metodus () { // végrehajtandó utasítások } } //Meghívása Statikus : : Metodus () ; Kód 2.3. Statikus metódus

9

2.2. Objektum Orientált Programozás

A programkódban használt továbbá a virtual is, amely a többszörös örökl®désnél használatos. Például, ha egy ®sb®l két utódot származtatunk, majd ebb®l a két utódból egy közös új utódot származtatunk ennek segítségével. Ilyenkor az ®sosztály mez®i két példányban is léteznének. Ezt elkerülhetjük a virtuális öröklés segítségével. Ekkor az utód lemond az ®sosztály mez®ir®l, abban az esetben, ha valamely testvéréban az megtalálható. Tehát az ®sosztály dönthet arról, hogy hány példányban legyenek jelen a mez®i. A konstruktor soha sem lehet virtuális.

2.2. ábra. Példa a virtuális ®sre Ha létrehozunk egy osztályt, melyben virtuális függvények vannak, majd abból származtatunk egy másikat, amelyben ezeket felüldeniáljuk és példányosításnál a gyermek osztályokra mutató mutatóit egy, az ®sosztály példányaként hozunk létre, akkor az ®sosztály a gyermeke által felüldeniált függvényt fogja használni. Ezt az el®fordulási módot az alábbi példán keresztül mutatom be. 1 2 3 4 5 6 7 8 9 10

c l a s s CPolygon { protected : int szelesseg , magassag ; // csak az osztály és leszármazottjai számára látható public : void beallitOldalak ( int a , int b){ szelesseg = a; magassag = b ; }

11 12 13 14 15 16 17 18 19

};

// v i r t u á l i s területszámító függvény v i r t u a l int t e r u l e t () { return (0) ; }

// négyzet osztály , mely ö r ö k l i a polygon adattagjait és függvényeit c l a s s CNegyzet : public CPolygon { public : 10

2.3. Dinamic Link Library (DLL)

20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

};

// területszámítás f e l ü l d e f i n i á l á s a int t e r u l e t () { return ( s z e l e s s e g ∗ magassag ) ; }

//háromszög osztály , mely ö r ö k l i a polygon adattagjait és függvényeit c l a s s CHaromszog : public CPolygon { public : // területzámítás f e l ü l d e f i n i á l á s a int t e r u l e t () { return ( s z e l e s s e g ∗ magassag / 2) ; } }; int main () { //−−−−−−−−−−Osztályok példányosítása −−−−−−−−−− CNegyzet negyzet ; CHaromszog haromszog ; CPolygon polygon ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−Minden osztályból polygon lesz −−−−−−− CPolygon ∗ poly1 = &negyzet ; CPolygon ∗ poly2 = &haromszog ; CPolygon ∗ poly3 = &polygon ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−−−Oldalak b e á l l í t á s a −−−−−−−−−−−−−− poly1 −>beallitOldalak (4 ,5) ; poly2 −>beallitOldalak (4 ,5) ; poly3 −>beallitOldalak (4 ,5) ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− //−−−−−−−−−−Eredmények kiíratása −−−−−−−−−−−−−− cout << poly1 −>t e r u l e t () << endl ; cout << poly2 −>t e r u l e t () << endl ; cout << poly3 −>t e r u l e t () << endl ; //−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− return 0;

} /∗ Out : 20 10 0 ∗/

Kód 2.4. Polymorzmus példa Abban az esetben ha itt a területet a virtual kulcsszó nélkül használtuk volna, az output mind a háromszor nullát adott volna eredményül.

2.3. Dinamic Link Library (DLL) Ez a fejezet a *.dll fájlok alapelvér®l és történetér®l fog szólni. Egy dll fájlt szinte minden programnyelven felhasználhatunk, valamely módon inkludálhatjuk kódunkba. 11

2.5. Fis fájl felépítése

A *.dll fájl a Windows operációs rendszerekben egy megosztott függvénykönyvtár, ami önáll® m¶ködésre nem képes, azonban egyszerre akár több program is használhatja azokat. A Windows rendszer rengeteg *.dll-t használ a m¶ködése során, ezzel megkönnyítve a programozók munkáját. Ezeket a fájlokat önállóan futó programok használják beépül® modulként, feldolgozva a bennük szerepl® algoritmusokat, adatokat. A DLL el®nyeit és hátrányait gy¶jtöttem össze az alábbi néhány sorban. El®nyök:

• Akár több program is használhat egy azonos DLL-t • Ilyen esetben a DLL csupán egyszer lesz betölt®dve a memóriába • A C++ nyelven elkészített DLL-eket más alkalmazásokban is használhatjuk • Csak akkor tölt®dnek be a memóriába, amikor a függvényeit meghívjuk valós id®ben Hátrányok:

• Ha egy DLL hiányzik, vagy rossz verziószámú, a program nem megfelel®en, vagy egyáltalán nem fog futni • Az ún. DLL hell hiba hiányzó, vagy a DLL-ben egy másik DLL-re mutató linkek esetében • Csak Windows alatt használható Az utolsó hátrány kiküszöbölhet® például a Linux alatt használt hasonló felépítés¶ shared object-ek (*.so) használatával.

2.4. Fuzzy Rule Interpolation A Fuzzy Szabály-Interpolációs módszerek különböznek egymástól, mindegyik más módon számítja ki a következtetést, viszont van egy rendszer, amely az egészet összefogja. A rendszer két csoportra bontja az interpolációs módszereket. Az egy- és a kétlépéses típusokra. Az egy lépésesek egyetlen lépésben határozzák meg a következtetést. A kétlépésesek a Generalized Methodology [13] Baranyi, Kóczy és Gedeon által kidolgozott általánosított módszertan alapján számolnak. Ez a módszer megadja, hogy az els® lépésben három dolgot kell megvalósítnia a módszernek:

• Az interpolált szabály antecedens halmazai alakjának a meghatározása. • A konzekvens halmazok helyzetének (referencia pontjainak) meghatározása. • Az interpolált szabály konzekvens halmazai alakjának meghatározása. Az els® lépés után a másodikban az újonnan létrehozott szabály használatával el®állítja a következtetést. Mivel a halmazok általános esetben eltér®ek lehetnek, ezért a következményt egy egyszabályos következtetés segítségével állítja el®. Ez a két módszer lefedi az összes fuzzy szabály-interpolációs metódust.

12

2.5. Fis fájl felépítése

2.5. Fis fájl felépítése Az implementáció els® lépése a struktúra kialakítása. A már meglév® toolbox használ egy speciálisan erre a célra kitalált s és obs fájlt. A s fájlban egy fuzzy rendszer leírása található, az obs fájlban pedig egy meggyeléshalmaz. A két fájl segítségével kikövetkeztethet® az eredmény. A különböz® kikövetkeztetési módszerek az interpolációs módszerek. A ritka szabálybázis esetén alkalmazzuk ezeket meggyelések megadásának segítségével. Ez a két fájl egy speciális ini fájlként fogható fel. Az ini fájlok összes jellemz®je megtalálható rajtuk, egyedül a kiterjesztésben térnek el azoktól. Ezért is szeretném néhány mondatban leírni egy ini fájl szerkezeti felépítését:

• Minden egyes szakasz, szekció négyzetes zárójelekbe ([section]) foglalva jelenik meg új sorban és a következ® ilyen sorig tart. • A szakaszokon belül név, érték párok tlálhatók egyenl®ség jellel elválasztva (név=érték). Minden egyes párt új sorba írva választunk el egymástól. • Kommentezni  ;  és  #  jelekkel lehet. A s fájlok négy f® részb®l épülnek fel: 1. System 2. Input(ok) 3. Output(ok) 4. Rules részekb®l.

2.5.1. System szekció System rész megadása:

[System] Name='System_name' Type='típus' Version=1.0 NumInputs=n NumOutputs=m NumRules=k AndMethod='' OrMethod='' ImpMethod='' AggMethod='' DefuzzMethod=''

13

2.5. Fis fájl felépítése

Értelmezési táblázat: Name

A rendszer neve, ami tetszés szerint választható.

Type

Rendszer típusának megadására szolgál. Lehetséges értékek: Mamdani, Sugeno

Version

Verziószám, mindíg az aktuális beírása javasolt.

NumInput

A rendszerben található input elemek száma.

NumOutputs

Az outputelemek száma a rendszerben.

NumRules

Leírt szabályok száma a rendszer belül.

AndMethod

Az és metódus típusa. Megadható értékek: min, prod, . . . , saját

OrMethod

A vagy metódus típusa. Felvehet® értékek: max, probor, . . . , saját

ImpMethod

Az implikáció metódus típusa. Használható értékek: min, prod, . . . , saját

AggMethod

Az aggregáció metódus típusa. Beírható értékek: max, sum, probor, . . . , saját

DefuzzMethod

A defuzzikálás metódus típusa. Lehetséges értékek: centroid, bisector, mom, lom, som, . . . , saját 2.1. táblázat.

2.5.2. Inputok leírása [Inputn] Name='input_name' Range=[r1 r2] NumMFs=mfs MF1='A_{n;1}':'típus',[helyek]![értékek] .. . MFmfs='A_{n;mfs}':'típus',[helyek]![értékek] Ahol n a 2.5.1 pontban megadott inputok száma és mfs a tagsági függvények száma. Értelmezési táblázat: Name

Az input neve, ami tetszés szerint választható.

Range

Ezzel az adattal adhatjuk meg, hogy milyen intervallumban tekintse az inputot a program.

NumMFs

Az MF mozaikszó a membership function tagsági függvény rövidítése. Ezeknek a függvényeknek a száma adható meg itt.

MF-ek

A tagsági függvényeket leíró értékek megadása történik itt. 2.2. táblázat. 14

2.5. Fis fájl felépítése

A tagsági függvények értelmezési táblázata:

A_{n;mfs}

Az adott MF nevét adhatjuk meg ilyen alakban.

típus

MF típusa adható meg ezen értékkel. Általunk használt típusok: "trimf", "trapmf"

helyek

Típustól függ®en megadott számok halmaza, melyek a függvény x értékeit képviselik.

értékek

A fent megadott typustól függ®en megadott számok, melyek a tagsági függvény y értékeit képviselik. 2.3. táblázat.

2.5.3. Outputok leírása [Outputm] Name='output_name' Range=[r1 r2] NumMFs=mfs MF1='A_{m;1}':'típus',[helyek]![értékek] .. .

MFmfs='A_{m;mfs}':'típus',[helyek]![értékek] Ahol m a 2.5.1 pontban megadott inputok száma. Megadása a 2.5.2 pontban megadottak alapján.

2.5.4. Szabályok részletezése A szabályokat egy mátrixban adjuk meg, melynek minden sora egy-egy szabályt jelent. A szabályok megadásának alakja egy speciálisan felépített mátrix. Ha m input és n output található a rendszerben, a szabályok oszlopszáma m + n + 2. Az els® m oszlop reprezentálja a rendszer inputjait. Minden oszlop tartalmaz egy számot, ami a tagsági függvény (MF) sorszámát jelöli. A következ® n oszlop mutatja a rendszer inputjait. Minden oszlop tartalmaz egy számot, ami a tagsági függvény (MF) sorszámát jelöli. Az m + n + 1 számú oszlop tartalmazza a súlyt, melyet a szabályra alkalmazunk. Ez a súlyozási szám nulla és egy közötti szám lehet, általában egynek szokták hagyni. Az m + n + 2 sorszámú oszlop 1 ha a szabályhoz tartozó fuzzy operátor AND (és). Ez a szám 2, ha az operátor OR (vagy). Példa: [ ] 1 1 1 1 1

1 2 2 1 2 15

2.7. Fuzzy Rule Interpolation based on POlar Cuts (FRIPOC)

Ha a rendszer két inputtal és egy outputtal rendelkezik, a szabályok a következ®képpen alakulnak: "If Input 1 is MF 1 and Input 2 is MF 1, then Output 1 is MF 1." "If Input 1 is MF 1 or Input 2 is MF 2, then Output 1 is MF 2."

2.6. Obs fájl felépítése Az obs fájl a következ® képpen adandó meg:

NumInputs=n ObsName='Observation_name' [Observation] OBS1='A*_1':'típus',[helyek]![értékek] .. .

OBSn='A*_n':'típus',[helyek]![értékek] A NumInputs után adható meg az inputok száma. Az ObsName névhez tartozó értékkel az observation nevét adhatjuk meg. [Observation] szakasznyitást követ®en felsorolhatjuk az input adatokat. Ezek az adatok a 2.5.2 pontban leírt módon alkalmazhatók.

2.7. Fuzzy Rule Interpolation based on POlar Cuts (FRIPOC) A FRIPOC a kétlépéses interpolációs módszerek közé tartozik, amely polár-vágatok segítségével állapítja meg a következményt. A kétlépéses szabály-interpolációs módszerek a Baranyi, Kóczy és Gedeon által kidolgozott Generalized Methodology of fuzzy rule interpolation (GM) [13] szerint jellemezhet®k. Az els® lépésben három feladatot kell megoldani: 1. Antecedens halmazai alakjának meghatározása valamely interpoláció segítségével 2. A konzekvens halmazok helyzetének meghtározása 3. Konzekvens halmazok alakjának meghatározása. A második lépésben történik a következmény el®állítása egy egyszabályos interpolációs módszer segítségével. A FRIPOC metódus a lépéseket két másik módszer használatával valósítja meg. Ezek a Fuzzy sEt interpolAtion based on linguistic Term shifting and polar cuts (FEAT-p) és a Single rUle REasoning based on polar cuts (SURE-p) metódusok. Ezt a módszert Johanyák és Kovács [18] dolgozta ki 2006-ban. A GM els® lépésében a FEAT-p [20] határozza meg az új szabály feltétel részét, majd a konzekvens halmaz helyzetét Shepard (1968) [19] többdimezióra kiterjesztett interpolációjával számítja. A második lépést a SURE-p [21] eljárás végzi el, mellyel végül megkapjuk a következményt. 16

2.7. Fuzzy Rule Interpolation based on POlar Cuts (FRIPOC)

2.7.1. Fuzzy sEt interpolAtion based on linguistic Term shifting and polar cuts (FEAT-p) m¶ködése Ez a módszer a halmazok egybetolásával, majd polár vágatok létrehozásával határozza meg az új szabályt. El®ször meghatározza a halmazok referencia pontjait, majd a meggyelés referencia pontjába tolja az összes halmazt. Az új nyelvi érték alakjának számításához vezették be a polárvágat fogalmát. Egy poláris koordináta rendszert illesztenek a kapott halmazhoz úgy, hogy a középpont egybeessen a nyelvi érték referencia pontjának megfelel® halmazelemmel. A polárvágat egy értékpár, mely a halmazt egy pontját leírja a poláris távolsággal (p) és a poláris szöggel (θ).

2.3. ábra. Polár vágat A polár vágatokat úgy kapjuk meg, hogy az azonos polár szög alatti polár távolságok súlyozott átlagát vesszük. A súlyozás miatt a referencia ponthoz közelebbi halmazok nagyobb hatással vannak a végeredményre. A módszer el®nye, hogy bármilyen halmazalakra képes megfelel® eredményt hozni. A hátránya pedig a szakaszonként való nem lineariás miatt a sok polár vágat megkövetelése. Ezért nagy számításigény¶, valamint kevés polár vágat esetén a halmazalakok nagyban eltérhetnek az eredetit®l.

2.7.2. Single rUle REasoning based on polar cuts (SURE-p) m¶ködése A nevéb®l is látszik, hogy ez a módszer egy szabályt vesz gyelembe és ebb®l következteti ki az újat. Ezért volt szükség a FEAT-p metódusra. Így már egy szabállyal tud dolgozni ez a módszer. Ez a következtetési módszer polárvágatok és súlyozott átlagszámítás segítségével oldja meg a szabály következtetést. A számításokat π/2-es polár szögnél kezdjük, majd jobb és bal oldalra haladva kiszámítjuk a többi pontot is. A módszer el®nye, hogy a halmazoknak nem szükséges azonos

17

2.7. Fuzzy Rule Interpolation based on POlar Cuts (FRIPOC)

alakúaknak, valamint magasságúaknak sem lenni. Hátránya, hogy nem képes az alakzat típúsának meg®rzésére.

18

3. fejezet Fejleszt®i dokumentáció

3.1. Forrásfájlok feldolgozásának leírása Az egyes osztályok szemléltetésére a legjobban az osztálydiagramok használhatók. A következ® néhány oldalban ezen diagramok részletezem, ismertetem. Az egyes alfejezetek egy-egy osztályt képviselnek. Az osztályok sorrendje nem véletlen, a FIS fájlból való beolvasáskor vett fordított sorrend. Ez a sorrend azért fonotos, mert ha visszafelé kezdem el sorolni az osztályokat a végére a legnagyobb osztálynál érthet®bbek leszenek az adattagok, függvények.

3.1.1. Fájlfeldolgozó osztályok (*.s, *.obs) CFISFile

CSystem

+FORCED : bool = true

-m_ssystemName : string -m_ssystemType : string -m_ssystemRefType : string -m_ssystemVersion : string -m_method : map<string, string> +Input : vector +Output : vector +Rule : vector

+readFIS(stringstream &) : CSystem * +readFIS(char *) : CSystem * +writeFIS(char *, CSystem *, bool) : void +writeFIS(char *, stringstream &, bool) : void

CRule -m_nInputNum : vector -m_nOutputNum : vector -m_nWeight : int -m_nOperator : int +CRule(string, size_t, size_t) +getInputsIndex() : vector +getOutputsIndex() : vector +getWeight() : int +getConnection() : int +toString() : string CPartition

-Rule

-Input

-m_MFs : vector -m_sname : string -m_frangeS : double[2] +CPartition(string, string, vector<string>) +getMFs() : vector +getName() : string +getRange() : double * +toString() : string

-setSystemName(string) : void -setSystemType(string) : void -setSystemVersion(string) : void -setSystemRefType(string) : void -setMethods(string, string, string, string, string) : void +CSystem() +CSystem(string, string, double, string, string, string, string, string) +CSystem(string, string, string, string, string, string, string, string) +getSystemName() : string +getSystemType() : string +getSystemVersion() : string +getMethods() : map<string, string> +toString() : string

-Output

CObservation -m_MFs : vector -m_sname : string +CObservation(string, vector) +CObservation(string, vector<string>) +getMFs() : vector +getObservationName() : string +toString() : string

COBSFile +readOBS(stringstream &) : CObservation +readOBS(char *) : CObservation

-m_MFs CMembershipFunction

-m_stype : string -m_sname : string -m_MFs -m_shape : vector +CMembershipFunction(string) CPoint +CMembershipFunction(string, string, vector<double>, vector<double>) -m_fx : double +CMembershipFunction(string, string, vector) -m_fy : double +CMembershipFunction(double *, double *, int) +CPoint() +getName() : string +CPoint(double, double) +getType() : string +getX() : double +getPoints() : vector -m_shape +getY() : double +xToVector() : vector<double> +setX(double) : void +yToVector() : vector<double> +setY(double) : void +xToDouble() : double * +setPoint(double, double) : void +yToDouble() : double * +distance(CPoint) : double +getSize() : int +equals(CPoint) : bool +toString() : string

3.1. ábra. Fájlfeldolgozó osztályok és kapcsolataik 19

3.1. Forrásfájlok feldolgozásának leírása

A fentebbi osztálydiagram a kés®bb elemzésre kerül® osztályok kapcsolatát vázolja. A kapcsolatokból jól látható egy FIS fájl felépítése is.

3.1.2. CPoint A CPoint osztály egy síkbeli pont tárolását teszi lehet®vé. A pontokat x és y koordinátájuk alapján jellemzzük. Adattagok m_fx

Abszcissza tárolására használatos adattag.

m_fy

Az ordináta adat tárolódik ebben az adattagban.

Függvények CPoint()

Az osztály konstruktora, ennek segítségével inicializálható a Pont.

getX()

Visszaadja a pont x koordinátáját.

getY()

Visszatér a pont y koordinátájával.

setX()

A pontnak csak az abszcisszáját írhatjuk át a függvény segítségével.

setY()

Az y koordináta átírása egy újra.

setPoint()

Egy új pontot lehet beállítani a metódussal, mely felváltja a jelenleg osztályban lév®t.

distance()

Függvény, mely kiszámítja az osztály, valamint a paraméterében kapott szintén CPoint osztály közötti el®jel nélküli euklideszitávolságot.

equals()

Összehasonlít két pontot. Saját magát, valamint az argumentumban megadott pontot. Igaz, ha a két pont egybevágó, hamis ellenkez® esetben. 3.1. táblázat.

3.1.3. CMembershipFunction Egy tagsági függvény egy halmaz leírását teszi lehet®vé, annak pontjai, típusa és neve megadásával. Ezek a függvények a CPoint osztályban tárolt pontok összességei. A pontok darabszámától függ®en lehet singleton, háromszög, trapéz, vagy polygon. Speciális eset a Gauss-görbe, ezen görbék tárolására ez a módszer nem alkalmas.

20

3.1. Forrásfájlok feldolgozásának leírása

Adattagok m_stype

Metódusunk típusát hivatott tárolni.

m_sname

Függvénynek adott név tárolója.

m_shape

Pontvektor, az el®z® alfejezetben megadott pontok halmaza.

Függvények CMembershipFunction()

A konstruktorban a név és típus megadása után a pontok vektora kerül beírásra. Ezek segítségével már leírható egy MF.

getName()

Visszaadja a függvény nevét.

getPoints()

Lekérhetjük vele a pontvektort, melyet a fent leírt adattag tárol.

getType()

Típus lekérdezése.

xToVector()

A pontok abszcisszáit egy vektorba tárolja, így adja vissza.

yToVector()

Az ordinátákat vektorba gy¶jti, majd a vektort adja vissza.

xToDouble()

A függvény pontjainak abszcisszáját egy double típusú tömbbe képzi le, majd visszatér vele.

yToDouble()

Tagsági függvény összes pontjának ordinátáját gy¶jti ki egy double típusú tömbbe, majd vissza adja a tömböt.

getSize()

A tömb méretét nem tudjuk lekérdezni, ezért ezzel a metódussal lekérdezhetjük a pontok számát.

toString()

Ez a metódus a java programozás nyelvhez hasonlóan szöveggé alakítja az osztályt. A mi esetünkben ez azt jelenti, hogy a FIS fájl eredeti formátumára hozza. 3.2. táblázat.

3.1.4. CPartition A partíciók tárolását CPartition osztályok teszik lehet®vé. Minden egyes osztály dimenziót ír le, melyben tagsági függvények szerepelnek. Az összefügg® tárolás érdekében kib®vítettük egy range taggal is, ami azt az intervallumot határozza meg, amelyben a tagsági függvényeket nézzük.

21

3.1. Forrásfájlok feldolgozásának leírása

Adattagok m_MFs

Az el®z® alfejezetben elemzett tagsági függvények vektora.

m_sname

Az input általunk megadott neve.

m_frangeS

A függvény értelmezési tartományát tárolja.

Függvények CPartition() Ennek az osztálynak a konstruktorában a fentebb leírt három adattag típust kell megadni. getMFs()

A membership function-ök vektorát lehet lekérdezni.

getName()

Megadott in-output adat nevét érhetjük el a függvénnyel.

getRange()

Értelmezési tartomány kérdezhet® le a metódussal.

toString()

FIS fájlban megadott módon kiírja az osztály adatait. 3.3. táblázat.

3.1.5. CRule Az interpolációs módszerek alkalmazásához elengedhetetlenek a szabályok, melyek leírják az egyes függvények közti kapcsolatot. Ezen kapcsolatok kezelésére íródott a CRule osztály. Az osztályban csak a függvények indexei tárolódnak, így kevesebb helyet foglal. Adattagok m_nInputNum

Inputok száma. Fontos a szabályellen®rzések miatt.

m_nOutputNum

Kimeneti adatok száma. Szabályellen®rzések céljából.

m_nWeight

A szabály súlyozása, a szám a 0 és 1 tartományból kerül ki.

m_nOperator

AND/OR kapcsolati operátor tárolása.

Függvények CRule()

Szabálybázisunk konstruktora, mely a szabály szöveges megadásával, valamint az in-outputok számának beírsása után létrehozza a szabálybázist és ellen®rzi a validitásást.

getInputsIndex()

Lekérdezi a szabályhoz tartozó inputok indexeit.

getOutputsIndex() Visszaadja a szabályhoz tartozó outputok sorszámait getWeight()

Lekérdezhet® a függvény segítségével a súlyozás.

getConnection()

A kapcsolat kódjának lekérése. Nulla, vagy egy.

toString()

Visszaadja a FIS-ben tárolt módon a szabályt. 3.4. táblázat.

3.1.6. CSystem Az egyik legfontosabb osztály, a keretrendszer használatához elengedhetetlen. Ez felel az egyes partíciók és szabályok összefogásáról. Egy rendszerben megtalálhatók az input, output halmazok, valamint az egyes halmazok összekötésére szolgáló szabályok is. 22

3.1. Forrásfájlok feldolgozásának leírása

Az interpolációs módszerek ezt a rendszert kapják meg és olvassák ki bel®le a nekik szükséges adatokat. Adattagok m_ssystemName

A rendszernek adott név.

m_ssystemType

Rendszer típusa.

m_ssystemRefType

A referencia pont számításának típusa.

m_ssystemVersion

Verziószám tárolása, megadása egyszer¶síti a kés®bbi szerkesztést és átláthatósaágot.

m_method

Metódusok tárolására kialakított vektor. Egyszer¶bb kezelhet®ség érdekében.

m_Input

Inputok halmaza, mindegyik rendelkezik tagsági függvénnyel.

m_Output

Outputok halmaza, mindegyik rendelkezik tagsági függvénnyel.

m_Rule

Szabályok leírása.

Függvények CSystem()

A konstruktorban több mindent is meg lehet adni. Rendszer adatainak megadása után létrehozza a megfelel® osztályt

setSystemName()

Rendszer név beállítása, szintén csak inicializálásnál.

setSystemType()

Render típusának átállítása, nem módosítható osztályon kívülr®l.

setSystemVersion()

Verziószám átírása. Konstruktoron keresztül hívódik meg.

setsystemRefType()

Referencia pont számítási metódus beállítása

setMethods()

Metódusok beállítása. Csak konstruktorból.

getSystemName()

Rendszernek adott névvel tér vissza a függvény.

getSystemType()

A rendszer típusát írja le.

getSystemVersion()

Verziószám lekérdezése.

getMethods()

A rendszer metódusainak visszaadása egy vektorban.

toString()

A FIS formafájl alapján visszatért a rendszer adataval egy szöveges változóba. 3.5. táblázat.

3.1.7. CFISFile Az osztály egy stringstream-ben, vagy szövegfájlban lév® s tartalmátt olvassa be a fent leírt system egy példányába.

23

3.2. Egylépéses szabály-interpolációs módszerek

Adattagok FORCED

Egy konstans adattag, melynek köszönhet®en beállíthatjuk az er®ltetett fájl felülírást.

Függvények readFIS

FIS fájl olvasása. A függvény több féle paraméterrel is meghívható.

writeFIS

FIS fájl írása. A függvény több féle paraméterrel is meghívható. 3.6. táblázat.

3.1.8. CObservation Az observation osztályban létrejönnek a kiolvasott meggyelések. Fontos, hogy annyi meggyelésünk legyen, ahány dimenziós az input adat. Minden inputhoz tartozik egy meggyelés. Adattagok m_MFs

Azok a tagsági függvények, melyekb®l a meggyelés felépül.

m_sname

Meggyelés neve

Függvények CObservation

Konstruktor, mellyel a meggyelés osztály példányosítható.

getMFs

Lekérdezhet® vele a meggyelés tagsági függvényeinek vektora.

getObservationName

Meggyelés neve kérhet® le a függvény használatval.

toString

Visszaadja az observation példány adatait karaktersorozatban. Felépítése az obs fájl alapján történik. 3.7. táblázat.

3.1.9. COBSFile Az osztály egy stringstream-ben, vagy szövegfájlban lév® obs tartalmátt olvassa be a fentebb leírt observation egy példányába. Függvények readOBS

Static metódus, ezzel olvasható be egy obs fájl. 3.8. táblázat.

3.2. Egylépéses szabály-interpolációs módszerek Az egylépéses módszerek egyetlen lépésben állítják el® a következményt. Ezen módszerek meghatározó képvisel®i a KH [6] melyet Kóczy és Hirota vezetett be, a FIVE [8] (Kovács és Kóczy), a MACI [7] (Tikk and Baranyi), az IMUL [9] (Wong, Gedeon, and 24

3.2. Egylépéses szabály-interpolációs módszerek

Tikk), és VKK [10] (Vass, Kalmár and Kóczy). Az eddig C++ nyelven implementált módszerek a KH [6], CRF [12] (Kóczy, Hirota és Gedeon), MACI [7] és a VKK [10]. A következ®kben ezen módszerek kódjait fogom részletezni.

3.2.1. A lineáris szabály-interpolációs (KH) módszer CObservation

CSystem

CKH -m_params : t_params -m_fis : t_fis -m_rule : vector -m_NearestLeft : int -m_NearestRight : int

<<struct>> t_partition (CKH) <<struct>> t_obs (CKH) <<struct>> t_mf (CKH)

-removeDuplicates(vector<double>) : vector<double> -getAllaCuts(vector*) : void -acutsFromParams(t_mf *, double [2]) : void -getAlphaLevelsFromParams(vector) : vector<double> -NearestTwoRules(vector) : void -all(vector<double>, string, vector<double>) : bool -all(vector<double>, string, double) : bool -any(vector<double>, string, vector<double>) : bool -any(vector<double>, string, double) : bool +init(string) : void +CKH(CSystem *) +interpolate(observation : CObservation) : vector

CFRIMethod

<<struct>> t_rule (CKH) <<struct>> t_fis (CKH) <<struct>> t_params (CKH)

<<struct>> t_AlphaLevels (CKH)

3.2. ábra. KH módszer osztálydiagramja A KH módszer a becsült következménye ugyanolyan arányban osztja fel a két közrefogó szabály konzekvenseinek távolságát, mint amilyen arányban a meggyelés felosztja ugyanezen szabályok antecedens halmazainak távolságát. [2]

diα (A1 , A∗ ) : diα (A∗ , A2 ) = diα (B1 , B ∗ ) : diα (B ∗ , B2 ) A képletben A1 , A2 a szabályok antecedens halmazai, A∗ a meggyelés és B ∗ a becsült következmény. Az i L, vagy U lehet, ami az alsó és fels® távolságot szimbolizálja (d).

25

3.2. Egylépéses szabály-interpolációs módszerek

Adattagok m_params

A KH metódus lehetséges paramétereinek tárolására létrehozott változó.

m_s

Fis fájlnak létrehozott struktúra, mely a metódus saját elemeivel b®vítve lett.

m_rule

Szabályok tároloását lehet®vé tev® vektor.

m_NearestLeft

Bal oldali szomszéd indexe. Számítások közben kerül feltöltésre.

m_NearestRight

Jobb szomszéd indexe tárolódik a változóban. A számítások során kerül feltöltésre.

Függvények removeDuplicated()

Törli az α vágatok számításánál keletkezett duplikált adatokat. Például olyankor, ha azonos szinten helyezkednek el.

getAllaCuts()

Az összes feldolgozható adatot tekintve létrehozza az α vágásokat.

acutsFromParams()

A paraméterek alapján elvégzi az α vágást.

getAlphaLevelsFromParams()

Megalkotja az α szinteket a paraméterek alapján. Ez azért szükséges, mert a halmazok magassága nem biztos, hogy egyforma.

NearestTwoRules()

Lekérdezi a két szomszédos szabályt, majd eltárolja ®ket a m_NearestLeft és m_NearestRight adattagokba.

all()

A MATLAB all() függvényével azonos metódus. Két vektor és egy relációs jel megadásával visszaadja, hogy a bal oldali vektor elemei a megadott relációban vannak-e a jobb oldali vektor minden elemével.

any()

A MATLAB any() függvényével azonos metódus. Két vektor és egy relációs jel megadásával visszaadja, hogy a bal oldali vektor elemei közül legalább egy a megadott relációban van-e a jobb oldali vektor egy elemei közül eggyel.

init()

Felhasználói paraméterek feldolgozására létrehozott függvény.

CKH()

Konstruktor, mely a rendszerb®l felépíti a bels® típusú struktúrát.

interpolate()

A publikus interpolate() metódus, amely elvégzi az interpolációt. 3.9. táblázat.

26

3.2. Egylépéses szabály-interpolációs módszerek

3.2.2. Relatív fuzzy jelleg meg®rzésén alapuló módszer (CRF) CSystem

CMembershipFunction

CRF -sizeA : int -sizeB : int -m_antX : double** -m_antY : double** -m_resX : double** -m_resY : double** -m_obsX : double* -m_obsY : double* -rightAntecedent() : int -leftAntecedent() : int -CRFdistance(int, double) : double -toRates(double, double) : double +CRF(CSystem) +CRFinterpolate() : CMembershipFunction

CFRIMethod

3.3. ábra. CRF módszer osztálydiagramja A módszert Kóczy, Hirota és Gedeon [12] fejlesztette ki. Ez a módszer a GK-nak a továbbfejlesztett változata, amely az általános Convex Normal Fuzzy (CNF) halmazokra lett kib®vítve. Továbbá ez a módszer többbemenet¶ rendszerek esetén is alkalmazható. A következményt a FERI módszer segítségével számítja ki egy ún. különbségi mértéket bevezetve. Ez a mérték a fuzzy jelleg és a magtávolság kapcsolatát jellemzi. A végeredmény a konzekvens magtávolság és antecedens magtávolság arányának és a meggyelés magszélességének szorzatából adódik. A végs® számítást a FERI [22] végzi.

27

3.2. Egylépéses szabály-interpolációs módszerek

Adattagok sizeA

Antecedens oldal tagsági függvényeinek száma tárolódik a változóban.

sizeB

A konzekvens oldal tagsági függvényeinek számának tárolására szolgáló változó.

m_antX

Antecedens oldal x koordinátáinak vektora.

m_antY

Az antecedens oldal y koordinátáinak vektora.

m_resX

Konzekvensek abszcisszáinak vektora.

m_resY

A Konekvensek ordinátái egy vektorba foglalva.

m_obsX

Meggyelés adott pontbeli szélességei.

m_obsY

A meggyelés adott pont beli magasságának tárolására létrehozott vektor változó.

Függvények rightAntecedent() Kikeresi a t®le jobbra lév® legközelebbi antecedenst. leftAntecedent()

Megkeresi a balra legköelebb es® antecedenst.

CRFdistance()

A távolság számolására használandó függvény.

toRates()

Távolságok arányokká alakítása.

CRF()

Az osztály konstruktora, amely inicializálja a kapott rendszer értékeit.

CRFinterpolate() Ez a metódus végzi el az interpolációt a fentebbi függvények segítségével. 3.10. táblázat.

28

3.2. Egylépéses szabály-interpolációs módszerek

3.2.3. Módosított α vágat alapú szabály-interpoláció (MACI) CSystem

CObservation

CMACI -m_params : t_params -m_fis : t_fis -m_concl : t_mf -m_rule : vector -v_max(a : vector<double>) : double -m_det(a : vector>) : double -m_inv(a : vector>, b : vector>*) : void -m_zeros(a : vector>*, size : int) : void -m_adj(a : vector>, b : vector>*) : void -v_div(a : vector<double>, b : vector<double>, c : vector<double>*) : void -m_mul(a : vector>, b : vector>, c : vector>*) : void -m_mult(a : double, b : vector>, c : vector>*) : void -m_mulv(a : vector<double>, b : vector>, c : vector<double>*) : void -m_mulv2(a : vector>, b : vector<double>, c : vector<double>*) : void -cut2params(mf : t_mf *, aCuts : vector<double>) : void -acutsFromParams(mf : t_mf *, range : double [2], aCuts : vector<double>) : void -setRP(mf : t_mf *) : void -getFlanks(mf : t_mf *) : void -localRefPointsLeftFlanksRightFlanksALevels(data : vector*, aCuts : vector<double>*) : void -removeDuplicates(data : vector<double>) : vector<double> +CMACI(CSystem *) +interpolate(CObservation) : vector

<<struct>> t_mf (CMACI) <<struct>> t_obs (CMACI) <<struct>> t_params (CMACI) <<struct>> t_partition (CMACI) <<struct>> t_fis (CMACI) <<struct>> t_rule (CMACI)

CFRIMethod

3.4. ábra. MACI osztálydiagramja A MACI módszer, melyet Tikk és Baranyi [7] dolgozott ki egy olyan térbe viszi át a számításokat, amelyben kiküszöbölhet® a nem értelmezhet® következmény. Ez a szabályinterpoláció minden halmazt két vektor segítségével ír le. Kettébontja az adott alakzatot a referenciapontnál jobb (fels®) és bal oldali (alsó) részre. Az ez utáni számításokat a két élre egymástól függetlenül végezzük. Az ezután transzformált térben a FERI [22] segítségével számítjuk a következményt.

29

3.2. Egylépéses szabály-interpolációs módszerek

Adattagok m_params

Paraméterek tárolása történik a változóban.

m_s

Fis struktúra tárolására alkalmas adattag.

m_concl

A konklúzió elhelyezésére létrehozott változó.

m_rule

Szabályok szerinti indexeket tárolja.

Függvények v_max()

Kiválasztja egy vektorból a legnagyobb elemet.

m_det()

Egy négyzetes mátrix determinánsát számítja ki.

m_inv()

Mátrix invertálást megvalósító függvény.

m_zeros()

A metódus egy nullmátrixot hoz létre.

m_adj()

Egy mátrix adjungáltját kiszámító függvény.

v_div()

Egy vektor minden elemét elosztja egy másik vektor minden elemével. Csak azonos nagyságú vektorok esetén hasznáható.

m_mul()

Mátrixok összeszorzása történik az eljárás segítségével.

m_mult()

Mátrix skalárral való szorzása.

m_mulv()

Egy mátrix megszorzása balról egy vektorral.

m_mulv2()

Mátrix szorzása jobbról egy vektorral.

cut2params()

α vágatok paraméterekké konvertálása.

acutsFromParams()

Az α vágatok elkészítése a paraméterek tudatában.

setRP()

Referenciapontok kszmítását végz® függvény.

getFlanks()

A tagsági függvényeket két oldalra bontja szét a referenciapontoknál.

localRefPointsLeftFlanksRightFlanksALevels()

Lokális referenciapont alapján kiszámítja a jobb és bal oldali tartó α vágatait.

removeDuplicates()

Törli az α vágatok számításánál keletkezett duplikált adatokat. Például olyankor, ha azonos szinten helyezkednek el.

CMACI()

A konstruktor, amely inicializálja a MACI-nak szükséges

interpolate()

Az interpolációt végrehajtó metódus. 3.11. táblázat.

30

3.2. Egylépéses szabály-interpolációs módszerek

3.2.4. A VKK módszer CSystem

CMembershipFunction

CVKK +size : int +m_antX : double** +m_antY : double** +m_conX : double** +m_conY : double** +m_obsX : double* +m_obsY : double* +x : double[4] +y : double[4] +CVKK(CSystem *) +VKK_Interpolate(CSystem) : CMembershipFunction +CheckAnte(double *, int) : bool +distance(double *, double) : double +dist(double, double) : double +mid(double, double) : double +center(double *, double) : double +distance(int, double) : double +width(double *, double) : double +destroyer() : void

CFRIMethod

3.5. ábra. VKK módszer osztálydiagramja A VKK [10] (Vass, Kalmár és Kóczy) módszer kiküszöbölte a KH [6] egyik leggyakoribb hibáját, az érvénytelen következmény halmazokat. Ezt úgy vitte véghet, hogy új távolságméréseket vezetett be és az α vágatok szélessége alapján végezte a számításokat.

31

3.3. A kétlépéses FRIPOC módszer dokumentálása

Adattagok size

Méret tárolására létrehozott változó.

m_antX

Antecedens oldal x koordinátáinak vektora.

m_antY

Az antecedens oldal y koordinátáinak vektora.

m_conX

Konzekvensek abszcisszáinak vektora.

m_conY

A Konekvensek ordinátái egy vektorba foglalva.

m_obsX

Meggyelés adott pontbeli szélességei.

m_obsY

A meggyelés adott pont beli magasságának tárolására létrehozott vektor változó.

Függvények CVKK()

A VKK módszer konstruktora, inicializálja a használandó változókat és az alapértelmezett paramétereket.

VKK_Interpolate() VKK interpolációs függvény, amely elvégzi a végleges következtetést. CheckAnte()

Megállapítja az antecedensek közül, hogy van e a meggyeléshez tartozó jobb és bal oldali.

distance()

Az α magasságban lév® antecedens és meggyelés pontjainak el®jeles távolságát számolja ki.

dist()

Két pont el®jeles távolságát számítja ki.

mid()

A két pontot összeköt® szakasz középpontját számítja ki.

center()

Az α vágat magasságában kiszámítja az infínum és szuprénum segítségével a vágat-beli pontok közepét.

width()

Kiszmítja az α vágat-beli szélességeket.

destroyer()

Eltörli a memóriában maradt adatokat. 3.12. táblázat.

32

3.3. A kétlépéses FRIPOC módszer dokumentálása

3.3. A kétlépéses FRIPOC módszer dokumentálása CObservation

CFEAT_P

<<struct>> t_interpolated (CFEAT_P)

+m_interpolatedAntecedent : vector +m_interpolatedConsequent : vector #M_PI : double #m_numOfpCuts : size_t #m_SetInterpolationWeight : t_Weight #m_RPtype : string #m_fis : t_fis

<<struct>> t_partition (CFEAT_P) <<struct>> t_fis (CFEAT_P) <<struct>> t_mf (CFEAT_P)

+CFEAT_P(CSystem *) +CFEAT_P(CSystem *, args : string) +init(string) : void #setRP(mf : t_mf *) : void #setShift(t_mf *, double) : void #PcutsFromParams(t_mf *, double [2]) : void #pcuts2params(t_interpolated *) : void #SetAverageFrompCut(vector, t_interpolated *) : void #determineAntecedentShapes(observation : CObservation) : void #determineConsequentPositions(observation : CObservation) : void #determineConsequentShapes(observation : CObservation) : vector

GM CSystem

CFRIPOC -m_ConsequentPositionWeight : t_Weight -m_rule : vector +m_interpolatedConclusion : vector +CFRIPOC(pSys : CSystem *) +interpolate(observation : CObservation) : vector +init(args : string) : void

<<struct>> t_rule (CFRIPOC) <<struct>> t_Weight (CFEAT_P)

3.6. ábra. FRIPOC és FEAT-p osztálydiagramja Az osztálydiagramból kiolvasható, hogy sok bels® struktúrát használtam. Ez azért van, mert a FRIPOC [18] számolás közben a már meglév® s-t b®víti ki. Ennek egy új osztályt létrehozni fölösleges lett volna, ezért döntöttem a bels® struktúra kialakítása mellett. Ezek a nevüknek megfelel® osztályokból kiolvassák a szükséges adatokat, majd a számolás során kib®vülnek a számított értékekkel. A conclusion-t visszaadó struktúra a számítás végén publikus adattagként megmarad a tesztelés és adatellen®rzés megkönnyítése miatt, de az interpolate metódus visszatérési értéke egy CMembershipFunction. Mint ahogy a a 2.7 pontban leírtam a FRIPOC [18] kétlépéses szabály-interpoláció. Ezért van szükség a FEAT-p [20], valamint a FRIPOC-ba [18] inkludált SURE-p [21] metódusokra is. A FEAT-p [20] az els® lépést, majd a Shepard [19] algoritmus segítségével a SURE-p [21] a második lépést hajtja vére.

3.3.1. CFEAT_P Az osztály az els® lépés els® három allépést hivatott számolni. A benne lév® három függvény is ezt szemlélteti. Ebb®l származatatom kés®bb a FRIPOC osztályt is, ami ennek metódusait és adattagjait használja.

33

3.3. A kétlépéses FRIPOC módszer dokumentálása

Adattagok m_interpolatedAntecedent

Az új interpolált antecedens tárolása történik ebben a változóban.

m_interpolatedConsequent

A konzekvens oldal számított adatai tárolódnak az adattagban.

m_PI

A PI számot tartalmazza tizenöt tizedesjegy pontossággal. Polárvágatok számításánál szükséges.

m_numOfpCuts

A polár vágatok száma.

m_SetInterpolationWeight

Interpoláció súlyozási száma. Alapértelmezetten: 181

m_RPType

A referencia pont számításának metódusát tárolja. Alapértelmezetten: corecentre

m_s

Egy s fájl saját kib®vített struktúrája. Kib®vítés alatt a referencia pontos, polár végatok és távolságokat értem, amik alapesetben nincsenek egy s fájlban.

Függvények CFEAT_P()

Az osztály konstruktora, paraméterében megkapja a system-et.

init()

Osztály inicializásálására használatos függvény, melynek segítségével paramétereket adhatunk át a számítás módosítása érdekében.

setRP()

Referencia pontok számítása történik a metódussal.

setShift()

A tagsági függvény referencia pontba való eltolását határozza meg.

PcutsFromParams()

A tagsági függvények koordinátáit polár vágatokká konvertálja.

pcuts2params()

Polár vágatokat paraméterekké konvertálja a függvény.

SetAvarageFrompCut() A polár vágatok súlyozott átlagát számítja ki. Így a meggyeléshez közelebbi szabályok nagyobb jelent®séggel bírnak. determineAntecedentShapes()

Antecedens alakzat számítása.

determineConsequentPositions()

Konzekvens halmazok pozícióinak kiszámítása.

determineConsequentShapes()

Konzekvens szabály alakjának meghatározása. 3.13. táblázat.

34

3.4. Módszerek paramétereinek áttekintése

3.3.2. FRIPOC A FRIPOC [18] módszer a kétlépéses szabály-interpolációs módszerek közé tartozik. A módszert az els® lépést elvégz® CFEAT_P [20] osztályból származtattuk. Ebben az osztályban meghívjuk az els® lépés három alapfüggvényét, majd a SURE-p [21] metódus segítségével kiszámítjuk a követkeményt. Az osztályban ezért csak az interpolate() metódust volt szükség implementálni, a többit örökli az ®sét®l. Adattagok m_ConsequentPositionWeight

Konzekvens halmazok súlyozását tárolja.

m_rule

Szabályok tárolására létrehozott bels® típus.

m_interpolatedConclusion

Ebben tárolódik a conclusion, amit az osztály interpolate metódusa kiszámít.

Függvények CFRIPOC()

Az osztály konstruktora, paraméterében megkapja a systemet, valamint a CFEAT_P-t meghívja.

init()

Osztály inicializásálására használatos függvény, melynek segítségével paramétereket adhatunk át a számítás módosítása érdekében.

interpolate()

A metódus megkapja a meggyelést és a FEAT-p segítségével és a SURE-p egyszabályos módszerrel kiszámítja a conclusiont és egy tagsági függvényként visszatér vele. 3.14. táblázat.

3.4. Módszerek paramétereinek áttekintése KH

• AlphaLevels.Type - breakpoints és userdened lehet, alapértelmezés: breakpoints. • AlphaLevels.NumOfaCuts - abban az esetben, ha a típus userdened, meg kell adnunk a polárvágatok számát. • w - megadható a súlyozási sám is, alapértelmezés: 2.

CRF

• FuzzinessType - megadható a fuzzy jelleg is. Ez a paraméter három értéket vehet fel, a corerelative, supportrelative és a mean értékeket. Alapértelmezetten a corerelative használatos. • NumOfPoints - ezzel a beállítással módosíthatjuk a pontok számát, amely alap esetben 101 darab. 35

3.4. Módszerek paramétereinek áttekintése

• w - megadható a súlyozási sám is, alapértelmezés: 2.

VKK

• AlphaLevels.Type - breakpoints és userdened lehet, alapértelmezés: breakpoints. • AlphaLevels.NumOfaCuts - abban az esetben, ha a típus userdened, meg kell adnunk a polárvágatok számát. • w - megadható a súlyozási sám is, alapértelmezés: 2.

MACI

• RPtype - Referencia pont számításának módja. Lehetséges értékek: corecentre, corecentreprojection, supportcentre. Alapértelmezés: corecentre • NumOfPoints - Pontok száma határozható meg vele. Alap esetben: 101. • w - súlyozási szám, alapesetben 2.

FRIPOC

• NumOfpCuts - Polár vágatok számának beállítása, alapértelmezetten 181. • RPtype - Referenciapont számítás típusa, amely alapértékként a corecentre-t kapja. Lehetséges értékei: corecentre, corecentreprojection, supportcentre. • SetInterpolationWeight.Type - Az interpoláció súlyozásának típusa állítható be a paraméter segítségével. Választható értékek: 1 és 2. Alapérték: 1. • SetInterpolationWeight.p - A súlyozás 1-es típus esetén a p mér®számmal állítandó be. Alapértelmezés: 2. • SetInterpolationWeight.lambda - A súlyozási típus 2-re állításakor használatos λ paraméter. • ConsequentPositionWeight.Type - Konzekvens halmazok súlyozásának típusa állítható itt be a fenti s¶lyozási típushoz hasonlóan. • ConsequentPositionWeight.p - A súlyozás 1-es típus esetén a p mér®számmal állítandó be. Alapértelmezés: 2. • ConsequentPositionWeight.lambda - A súlyozási típus 2-re állításakor használatos λ paraméter. • AntecedentDimensionWeight.Type - Antecedens halmaz dimenzió súlyozáshoz használt mér®szám. Alapérték: 1. 36

4. fejezet Összefoglalás

A dolgozat végére áttekintésre került a fuzzy jelleg fogalma, beláttuk az elmosódott határok fontosságát a hétköznapi problémák informatikai megoldásának során. Körüljártuk az Objektum Orientáltság néhány fontos gondolatát egy-egy kisebb programkódon keresztül. Foglalkoztunk továbbá a DLL fájlok alapvet® szükségességével, annak el®nyeit és hátrányait felsorakoztatva. Az alapfogalmak bevezetése után a Fuzzy Rule Interpolation Toolbox használatának megkezdéséhez szükséges Fuzzy Interface System (FIS) és Observation (OBS) fájlokkal, azok felépítésével. Megismerkedhettünk egy általam a C++ nyelven leprogramozott módszer elméleti leírásával. Ez a módszer a Fuzzy Rule Interpolation based on POlar Cuts (FRIPOC), magyarul egy kétlépéses Fuzzy Szabály-Interpolációs eljárás, amely polár vágatok alkalmazásán alapul. Az elméleti leírás után részletesen átnéztük a két fájl felépítését, valamint a felépüléséhez szükséges osztályok felépítését, metódusainak és adattagjainak leírását. Végül pedig az eddig implementált fuzzy szabály-interpolációs eljárások leprogramozásának menetét is szemléltettem. Elértem azt, hogy az egyes módszerek használatához a felhasználónak nem kell ismernie azok számítási lépéseit. Valamint hogy a program a jól átlátható keretbe foglalás miatt könnyedén kib®víthet® lett újabb interpolációs metódusokkal. A dolgozatom továbbfejlesztési lehet®sége lehet egy olyan program megalkotása, amely azonos input adatok esetén elemzi és megajánlja a számunkra használandó módszert. Valamint az eddig nem implementált módszerek leprogramozása és új módszerek esetleges megalkotása is fontos továbbfejlesztési szempont. Számomra ez a dolgozat el®segítette a fuzzy jelleg fontosságának megismerését és a dinamikus könyvtárak fontosságának meglátását. Elértem azt a célt, hogy a megismert eljárások leprogramozása közben új tapasztalatokkal gazdagodtam a C++ nyelv többrét¶ségének megismerése irányában és ezeket a kés®bbiek során is kamatoztathatom.

37

Irodalomjegyzék

[1] FRI Toolbox-SFMI ToolBox: http://fri.gamf.hu/onlinedoc/FRIT/

Online

documentation

2008



[2] Johanyák Zs. Cs.: Fuzzy szabály-interpolációs módszerek és mintaadatok alapján történ® automatikus rendszergenerálás, PhD disszertáció, Hatvany József Informatikai Tudományok Doktori Iskola, Miskolci Egyetem, Miskolc, 2007. [3] Fuzzy Logic Toolbox Online Documentation http://www.mathworks.com/help/toolbox/fuzzy/

1984-2011



[4] Berecz A., Johanyák Zs. Cs.: Kétlépéses szabály-interpolációs módszerek áttekintése, Acta Agraria Kaposváriensis (2008) Vol 12 No 2, 39-51 [5] Krizsán Zoltán: KÖZÖS FEJLESZTŽI KERETRENDSZER FUZZY SZABÁLY INTERPOLÁCIÓS MÓDSZEREKHEZ, Miskolci Egyetem (2012) [6] Kóczy L. T. and Hirota K., Rule interpolation by α-level sets in fuzzy approximate reasoning, BUSEFAL, vol. 46, no. Automne, pp. 115-123, 1991. [7] D. Tikk and P. Baranyi, "Comprehensive analysis of a new fuzzy rule interpolation method," IEEE Trans. On Fuzzy Systems, vol. 8, no. 3, pp. 281-296, 2000. [8] S. Kovács and L. T. Kóczy, "Application of an approximate fuzzy logic controller in an agv steering system, path tracking and collision avoidance strategy," Tatra Mountains Math. Publ., vol. 16, pp. 456-467, 1999. [9] K. W. Wong, T. D. Gedeon, and D. Tikk, "An improved multidimensional αcut based fuzzy interpolation technique," in Proc. of the Int. Conf. on Articial Intelligence in Science and Technology (AISAT'00), V. Karri and M. Negnevitsky, Eds., Hobart, Tasmania, Australia, December, 2000, pp. 33-38. [10] G. Vass, L. Kalmár, and L. T. Kóczy, "Extension of the fuzzy rule interpolation method," in Proc. of the Int. Conf. on Fuzzy Sets Theory and its Applications (FSTA'92), Liptovsk
y Jan, Slovakia, 1992, pp. 1-6. [11] Gedeon, T. D. and Kóczy, L. T.: Conservation of fuzziness in rule interpolation, in Proceedings of the Symposium on New Trends in Control of Large Scale Systems, Vol. 1, Herl'any, Slovakia, 1996, pp. 13-19. [12] Kóczy, L.T., Hirota, K. and Gedeon, T. D.: Fuzzy rule interpolation by the conservation of relative fuzziness, in Journal of Advanced Computational Intelligence, Vol. 4/1, 2000, pp. 95-101. 38

[13] P. Baranyi, L. T. Kóczy, and T. D. Gedeon, "A generalized concept for fuzzy rule interpolation," IEEE Trans. on Fuzzy Systems, vol. 12, no. 6, pp. 820-837, December 2004. [14] S. Yan, M. Mizumoto, and W. Z. Qiao, "An improvement to Kóczy and Hirota's interpolative reasoning in sparse fuzzy rule bases," Int. J. of Approximate Reasoning, vol. 15, pp. 185-201, 1996. [15] Z. H. Huang and Q. Shen, "Fuzzy interpolation with generalized representative values," in Proc. of the UK Workshop on Computational Intelligence, Loughborough, UK, September, 2004, pp. 161-171. [16] S. Jenei, "Interpolation and extrapolation of fuzzy quantities revisited - (I) An axiomatic approach," Soft Computing, vol. 5, pp. 179-193, 2001. [17] Johanyák Zs. Cs., Tikk D., Kovács Sz., és Wong K. W., Fuzzy rule interpolation Matlab toolbox - FRI toolbox, in Proc. of the IEEE World Congress on Computational Intelligence (WCCI'06), 15th Int. Conf. on Fuzzy Systems (FUZZ-IEEE'06). [18] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy Rule Interpolation Based on Polar Cuts, in Computational Intelligence, Theory and Applications, Springer Berlin Heidelberg, 2006, pp. 499-511. [19] Shepard, D.: A two dimensional interpolation function for irregularly spaced data, in Proceedings of the 23rd ACM International Conference, New York, USA, 1968, pp. 517-524. [20] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy set approximation using polar coordinates and linguistic term shifting, 4rd Slovakian-Hungarian Joint Symposium on Applied Machine Intelligence (SAMI 2006), Herl'any, Slovakia, 2006, pp. 219227. [21] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy Rule Interpolation Based on Polar Cuts, in Computational Intelligence, Theory and Applications, Springer Berlin Heidelberg, 2006, pp. 499-511. [22] Chong, A., Gedeon, T. D. and Kóczy, L. T.: A Hybrid Approach for Solving the Cluster Validity Problem, in Proceedings of the 14th International Conference on Digital Signal Processing, Santorini, Greece, 2002, pp. 1207-1210.

39