Közös fejlesztői keretrendszer fuzzy szabály interpolációs módszerekhez
TDK dolgozat
Tóth Dávid IV. éves programtervező informatikus hallgató
konzulens: Krizsán Zoltán
Miskolci Egyetem Gépészmérnöki és Informatikai kar 2012 1
A bemutatott kutató munka a TÁMOP-4.2.1.B-10/2/KONV-2010-0001 TÁMOP 0001 jelű projekt részeként az Európai Unió támogatásával, az Európai Szociális Alap társfinanszírozásával valósul meg. meg
2
Tartalom 1
Bevezetés................................................................................................................................. 4
2
Téma elméleti kifejtése ........................................................................................................... 6
2.1
A Fuzzy..................................................................................................................................... 6
2.2
Megvalósítás módja ................................................................................................................ 9
2.2.1
Library.............................................................................................................................. 9
2.2.2
DLL (Dinamic Link Library) ............................................................................................... 9
2.2.3
A kiválasztott stratégia .................................................................................................. 12
2.3
FRI módszerek közös jellemzői.............................................................................................. 13
3
A keretrendszer ..................................................................................................................... 16
3.1
A keretrendszer szerkezete ................................................................................................... 19
3.2
A keretrendszer használata ................................................................................................... 23
3.3
DLL használata MATLAB alól.................................................................................................. 24
3.4
DLL betöltése Visual Studioba ............................................................................................... 25
3.5
A keretrendszerben található módszerek ............................................................................. 26
3.5.1
KH .................................................................................................................................. 26
3.5.2
VKK................................................................................................................................. 27
3.5.3
MACI .............................................................................................................................. 28
3.5.4
GK(CRF).......................................................................................................................... 29
3.5.5
FRIPOC ........................................................................................................................... 30
3.6
Módszerek összegzése .......................................................................................................... 30
4
Konklúzió ............................................................................................................................... 31
5
Irodalomjegyzék .................................................................................................................... 32
6
Ábrajegyzék ........................................................................................................................... 34
3
1 Bevezetés A fuzzy rendszerek a következtetést a fuzzy szabályok segítségével számolják ki. A karakterisztikája ezeknek a rendszereknek leírható ezekkel a szabályokkal. A klasszikus fuzzy következtető eljárások megkövetelik az input intervallum teljes lefedését, ami azt jelenti, hogy minden egyes lehetséges megfigyeléshez (observation) létezik legalább egy megelőzőantecedens, így kapjuk meg az érvényes következtetést (conclusion). A ritka fuzzy rendszerek oka lehet a hiányos ismeret, ami azt jelenti, hogy kevesebb ismeret áll rendelkezésre, mint amennyi szükséges lenne egy teljes szabály bázishoz, vagy a teljesítményt rontaná nagyban egy teljesen fedő rendszer. Számos fuzzy eljárás létezik, melyek eredményt adnak ebben az esetben is. Ezeket Fuzzy Szabály Interpolációs eljárásoknak hívják, melyek a meglévő szabályokból le tudják generálni a következtetést. Ezeket a módszereket két nagy csoportba lehet sorolni az alapján, hogy milyen stratégia szerint generálják az eredményt: direkt eljárás (más néven „egylépéses eljárás”), a másik pedig a „kétlépéses eljárás”. A kétlépéses módszerek először interpolálnak egy ideiglenes szabályt, ez alapján kiszámolják a következtetés pozícióját és alakját. A gyakorlatban többször előfordul a ritka szabálybázisú fuzzy rendszer, mint a teljes lefedettségű, mégis eddig nem volt olyan programozói keretrendszer, mely kezelte volna ezt az esetet, és több fuzzy interpolációs módszert is tartalmazna. Sajnos ennek köszönhető, hogy éles környezetben egyáltalán nem használták a ritka szabály bázisú fuzzy interpolációs módszereket. Több programozói könyvtár is létezik a teljes szabály bázisú rendszerekhez, de nincs egy se, ami a ritka szabály rendszer esetén is jó volna. Eddig,ha egy olyan programot akartak fejleszteni, mely ritka szabálybázist használ, akkor a programozónak, vagy programozóknak a kiválasztott módszert egy programnyelven meg kellett írni. Ha azonban valamilyen okból kifolyólag át tértek másik nyelvre, akkor minden módszert újra és újra implementálni és tesztelni kellett, ami egyáltalán nem költséghatékony, a befektetett időről pedig nem is beszélve. Azon fejlesztőknek, akik nincsenek teljesen tisztában a fuzzy rendszerekkel, nagy segítséget nyújthat a MATLAB-os Fuzzy Toolbox[8] (ezt a toolbox-otJohanyák Zsolt fejlesztette ki, mely könnyen használható, praktikus kutatásokhoz és bemutatókhoz, és letölthető GNU liszensz alatt [9]), ahol különböző módszereket próbálhatnak ki és 4
vethetik össze a kapott eredményeket.Azonban ha a projekt fejlesztési költségébe nem volt beleszámolva a MATLAB szoftver költsége, az plusz kiadást jelent, ugyanakkor a MATLAB alap szintű használatához is érteni kell, ami pedig időben jelent kiesést. Abban az esetben, ha gyors reakcióra van szükség, valós időben futó alkalmazásfejlesztésről van szó, a módszereket abban a nyelvben kell implementálni ahol használni is fogják azokat, mert minden beágyazott réteg jelentősen megnöveli a
rendszer
válaszidejét,
ezzel
csökkentve
a
program
használhatóságát.
A már említett MATLAB-os FRI Toolbox éles környezetbe való átültetése csak más nyelvbe való beágyazással történhet, de ennek több hibája is van. Nem támogatja csak a MATLAB saját nyelvét, nem használhatjuk más matematikai ingyenes szoftverből vagy natív programozói nyelvekből (Javat, C#vagy Pythont). A beágyazást C++ alkalmazásba meg tudjuk tenni, de ebben az esetben az eredmények kiértékelése nem elég gyors. Dolgozatom témája tehát egy olyan keretrendszer kifejlesztése, mely kezeli a ritka szabálybázisú fuzzy rendszereket, több, ma használatos programnyelvet is támogat, azonos programozói felülettel, könnyen bővíthető és elég gyors működést biztosít egy valós időben futó alkalmazásnak. Első lépésként a Windows és Linux operációs rendszerek
támogatását
tűztük
ki
célul,
azok
elterjedtsége
miatt.
Dolgozatomban a témát az alábbi részekre taglalom: -
Fuzzy bemutatása, DLL előnyei
-
Keretrendszer ismertetése
-
FRI metódusok jellemzői
-
Szerkezet: osztálydiagram és osztályok leírása
-
Keretrendszer használata, direkt és asszisztált módban
-
FRI metódusok, melyek implementálásra kerültek
5
2 Téma elméleti kifejtése 2.1
A Fuzzy Az életben vannak dolgok, amikről egyértelműen megállapítható, hogy mik azok
pontosan. Például egy pontyról meg tudjuk mondani, hogy hal, egy németjuhászról pedig azt, hogy kutya. Az ilyen helyzeteket könnyen szemléltethetjük a matematika nyelvén halmazokkal, Venndiagram (2.1.1. ábra) segítségével. Az Ahalmaznak minden eleméről elmondható, hogy teljes egészében az A-ban helyezkedik el. Ha logikailag szeretnénk megfogalmazni, akkor a halmazon belül lévő elemek igaz (1) értéket kapnak, az azon kívül esők pedig hamis (0) értékkel írhatóak le. Viszont vannak olyan fogalmak, tárgyak, stb, amiről már nem tudjuk egyértelműen megmondani, hogy melyik csoportba, hova tartoznak. Vegyük például az ember fején lévő hajszálakat, vagy éppen azok hiányát. Mi az a hajszál szám, ahonnan valakit már kopasznak lehet titulálni? Nyilván való, hogy ha egy szál haja sincs az illetőnek, az az egyén kopasz, és akinek dús frizurája van, ő egyáltalán nem sorolható ide. A két végpont között azonban vannak köztes állapotok is, hiszen az utcás sétálva nem csak dús hajú, vagy kopasz személyeket látni. Emberi nyelven nem nehéz megfogalmazni az ilyen és ehhez hasonló helyzeteket, de a matematika és az informatika nyelvén, hogy ez értelmezhetővé váljon, a fuzzy halmazokat használjuk. A fuzzy lehetővé teszi, hogy egy halmaz elemeiről azt is meg tudjuk mondani, mennyire van benne, nem csak 1-essel és 0-ával tudjuk jellemezni. Így tehát az imént említett A halmaz minden eleméhez hozzá tudunk rendelni egy számot 0 és 1 között. Ezek segítségével a halmaz elmélet nem korlátozódik éles határú halmazokra, hanem megadhatjuk, hogy az elemek mennyire tartozzanak bele egyes csoportokba, szokás ezért ezeket elmosódott élű halmazoknak is nevezni. A különbség szemléltetésének kedvéért ezt is Venndiagramon mutatom be elsőnek (2.1.2. ábra).
6
2.1.1. ábra:: Hagyományos Venn
2.1.2. ábra: Elmosódott élű halmaz Venn
diagram.
diagram használatával
Az általános iskolai padban ülve, matematika órán, még elegendőek voltak az éles (crisp) halmazok, melyeknek elemeiről egyértelműen meghatározható volt, hogy hova tartoznak. Később azonban ez a szemlélet már nem állja meg a helyét, hiszen vannak olyan dolgok, ok, amelyek egyszerre több helyre is tartoznak, de nem egyforma mértékben. Az emberek számára ez könnyen érthető, azonban mindezt a gondolatmenetet
átültetni
a
számítógépbe
már
nem
olyan
egyszerű.
Az előbbi példához visszatérve nem a hajszálak alapján mondható mondható valakiről hogy kopasz, hanem úgy is, hogy fejtetejénmilyen fejtetején %-ban ban van haj. Így tehát a 2.3. ábrán már egyértelműen tudjuk ábrázolni ezt az esetet.
2.1.3.ábra 3.ábra: Fuzzy halmazok ábrázolása
7
Amint látszik, vannak bizonyos részek ahol egyértelműen megmondható, melyik csoportba tartozik az illető, de vannak átfedések is.
8
2.2
Megvalósítás módja
Ahhoz hogy a keretrendszer minél szélesebb körben elterjedhessen, szem előtt kell tartani a következő pontokat 2.2.1
könnyen kezelhető legyen több, manapság elterjedt programnyelvet támogasson a keretrendszer programozásába befektetett munka a lehető leghatékonyabb legyen Library
A programnyelvek mindegyikének megvan a saját, betölthető könyvtára, melyben az adott nyelv szintaktikájának megfelelő kódok vannak. A lib-ek elve nem teszi lehetővé azt, hogy más programnyelvekbe is betölthető legyen, és a benne található függvényeket használni lehessen. Nem beszélve a típusok különbözőségéről. Tehát a keretrendszert az összes támogatni kívánt programnyelven meg kellene írni, ami rengeteg időbe tellne, ráadásul egyáltalán nem hatákony. További hátránya, hogy egyszerre csak egy program használhatja a belinkelt könyvtárat, tehát a megosztást nem támogatja. Összességébe elmondható, hogy a fent említett 3 kritériumból csupán 1-nek tesz eleget, mert nem támogat több nyelvet, és pont ezért a befektetett munka arányait tekintve nem lenne kifejezetten hatékony választás.
2.2.2
DLL (Dinamic Link Library)
Ahogy a neve is mutatja Dinami Link Library, magyarul talán leggyakrabban megosztott könyvtáraknak szokás hívni, azt jelenti, hogy a DLL-ben tárolt adatokat és függvényeket több alkalmazás is képes használni egy adott időben. Mint például a Windowsban a USER32.dll, vagy KERNEL32.dll, ezek azok a DLL-ek, melyek szükségesek
ahhoz,
hogy
a
Win32
alrendszer
működhessen.
Ha egy függvényt egyszer megírtak és DLL-be rakták, akkor azt bármelyik alkalmazás tudja használni anélkül, hogy a program forráskódjában szerepelne ez a függvény. Természetesen ugyan ez a helyzet az adatokkal. Előnyei: -
Alacsony memória használat: Azok a függvények és adatok, amiket összeállítottunk egy DLL-be, elérhetőek az összes program számára, melyek 9
használják azt. Attól függően, hogy töltődik be a DLL a programba, csak akkor töltődik be a memóriába, amikor szükség van rá. Így vagy úgy, kevesebb memóriát foglal. A DLL belsejében lévő kódok csak olvashatók, íráshoz nem adnak felhatalmazást, így mikor memóriába töltődnek, a memória read-only területére kerülnek. A rendszernek így lehetősége van le mapp-elni a DLL tartalmát a folyamat címtartományába. A DLL csak egyszer töltődik be a memóriába és ha egy alkalmazásnak szüksége van rá, a rendszer csak le map-eli a hívó program címtartományába. -
Kevesebb ki-be töltés: Képzeljük el, hogy két alkalmazás egyszerre használja ugyan azt a DLL-t, az egyik végez és kilép. De a DLL még bent marad a memóriában, mert figyeli, számolja, hogy épp hány alkalmazás használja. Amikor
ez
a
számláló
eléri
a
nullát,
csak
akkor
törli
magát.
Képzeljünk el egy másik helyzetet, mikor egy program egy olyan DLL-t akar használni ami már a memóriában van és más alkalmazás használja. A rendszer nem tölti be újra a DLL-t, csupán át map-eli az új alkalmazásnak, így az is tudja használni. Ez rengeteg időt és munkát spórol az operációs rendszernek, mivel sokkal lassabban olvassa be az adatot a HDD-ről, mint a memóriából. -
„Csak a polcról kell levenni”: Egy jól megtervezett DLL bármelyik másik programnak hasznos része lehet. Gondoljuk rá úgy, mint egy komponensre, aminek a működésében és funkcionalitásában teljesen biztosak vagyunk. Csak
be
kell
hívni
egy
másik
projektbe
és
már
működik
is.
Képzeljünk el egy olyan DLL implementációt, ami elvégzi az összes lehetséges számítást, melyre szükség van ahhoz, hogy grafikus szoftvert fejlesszünk. Ha ez egyszer kész, bármelyik másik ilyen programba bele tehetjük, minden probléma nélkül. -
Együttműködés több programnyelvvel: Egy DLL amit egy nyelven megírtunk, használhatjuk olyan alkalmazásokban is, melyeket más nyelven írunk. Fejlesztőknél ez gyakori, hogy optimalizált rutinokat írnak assembly-ben, majd ezeket összegyűjtik egy DLL-be, és később meghívják ezeket C-ben vagy Visual Basicben. A fejlesztők szempontjából nem túl szerencsés, hogy elég sok nyelv támogatja a DLL használatát, viszont nagyon kevés az olyan, ami alkalmas az írásra 10
is.Képzeljünk el egy alkalmazást, ami a DLL segítségével I/O műveleteket hajt végre Visual Basic-ben, használva az inportb és outportb függvényeket a CRT natív könyvtárból. A DLL-ek lehetővé teszik ilyen együttműködő kódokat. -
Könnyű utólagos javítások: Mivel könnyen előfordulhat, hogy egy termék eladása után derülnek ki a problémák. Ez kijavítani általában nagyon fáradtságos munka, újra buildelni egy nagy alkalmazást majd újra kiküldeni a vásárlóknak. Mindez elkerülhető, ha a projekt úgy van megtervezve, hogy könnyen kezelhető különálló modulokból kapcsolódik össze, melyek DLL formájában tárolódnak. Csak annyit kell tenni, hogy a hibás részt kijavítani és a vásárlók számára elérhetővé tenni, mint egy frissítést. Ugyanakkor ez az előny a DLL-ek legnagyobb hátránya is lehet. Minden attól függ, mennyire gondosan van megtervezve a kód.
Hátrány: -
A „DLL pokol”: Ez a legnagyobb probléma, amit a DLL-ek okozni tudnak. Amennyire lehet, el kell kerülni az olyan helyzeteket, amikor a fordító olyan hibát dob, hogy nem talál egy bizonyos részt a DLL-ben. Vagy egy másik esetben például telepítésre kerül egy új program, ezt követően az eddig fent lévők pedig hibásan futnak le, vagy el sem indulnak. Ezek egyértelműen a „DLL hell”-nek nevezett problémának a jelei. Leggyakrabban akkor fordul elő ilyen, ha a szoftver telepítője nem figyeli a verziószámban levő eltéréseket, és vagy egy újabb DLL-t ír felül egy régebbivel, vagy pont ellenkezőleg, egy régit módosít az újra, amiben viszont nagy változások történtek. A DLL-eknek visszafelé kompatibiliseknek kéne lenniük, ez csakis a tervezésen múlik, ezt azonban nehéz elérni.
2.2.2.1 Mit tartalmazhat egy DLL?
A DLL-ek általában kódokat, adatokat és forrásokat tartalmaznak. A kódok a readonly részen tárolódnak így könnyen használhatja egyszerre több alkalmazás is, de az adatokkal más a helyzet. Minden egyes alkalmazás, melynek szüksége van az adatokra, megkapja a saját privát másolatát, hacsak nem valaki megosztottnak nem jelöli meg őket. A kód részben tárolódnak az osztályok, illetve a függvények. Lehetnek olyan osztályok, melyekben a függvények és az adatok egy helyen tárolódnak, egy 11
egységet alkotnak, de az önálló függvények használhatnak globális változókat is. Az előbb felsoroltak egy, vagy több forrás fájlba van eltárolva, de ezek össze vannak „csomagolva” egy DLL fájlá. A DLL-ek másik DLL fájlból is importálhatnak függvényeket vagy osztályokat. 2.2.3
A kiválasztott stratégia
A fent leírtak alapján jól látszik, hogy a library csak akkor működne jól, ha egy programnyelv támogatása lenne a cél, és csak egy program futása lenne engedélyezve. A DLL ellenben rengeteg előnnyel rendelkezik, az egyetlen hátrányát pedig
jól
megválasztott
stratégia
jó
választásnak
tűnik
a
keretrendszer
létrehozásához, hiszen mind a 3. követelménynek eleget tesz: könnyen kezelhető, több nyelvet is támogat, ezért viszonylag kevés idő alatt megvalósítható vele.
12
2.3
FRI módszerek közös jellemzői A Fuzzy logikával dolgozó rendszerek a szabályokon alapszanak. A
szabálybázisnak két típusa létezik a sűrű illetve a ritka szabálybázis. Sűrű szabálybázisról akkor beszélünk, ha az input tér teljesen le van fedve, tehát minden lehetséges megfigyeléshez létezik legalább egy olyan szabály, melynek antecedns része átfedésben van vele és ez alapján érvényes konklúziót lehet generálni. Amennyiben a fent leírt eset nem teljesül, a szabálybázist ritkának tekintjük. Ritka szabálybázis esetén a klasszikus következtetési módszerek nem használhatóak. Ekkor az eredményt különböző közelítő eljárással számítják ki a rendelkezésre álló információk alapján, ezeket Fuzzy Szabály Interpolációs módszereknek hívják. Sűrű szabálybázisokat kezelő rendszerek már léteznek, de olyan, amely a ritka szabálybázisú eljárásokat összefogná és egy egységes keretrendszert alkotna, mely ingyenesen elérhető mindenki számára még jelen pillanatban nincs. Arról nem is beszélve, hogy a módszerek viszonylag nagy százaléka rosszul, vagy hiányosan dokumentált, esetleg nehezen fellelhető, megnehezítve így a fejlesztők dolgát. Ezért is fontos hogy össze legyenek gyűjtve, így akik ritka fuzzy rendszerekkel szeretnének foglalkozni a kutatás és programozás résszel ne kelljen foglalkozniuk. Ritka szabálybázis több féleképpen keletkezhet: -
Szakértőtől vagy más forrásból származó ismeretek, tapasztalatok nem elegendőek a teljes input terület lefedésére (ábra lehetséges)
-
Lehetséges, hogy a szabálybázis kezdetben sűrűnek számított, de a későbbi hangolás folyamán, az antecedens halmazok formája és pozíciója változhat, melynek következtében a halmazok között „lyukak” alakulhatnak ki (2.3.1. ábra).
-
A
sűrű
szabálybázis
a
sok
dimenziónak
és
az
inputhalmazoknak
köszönhetően túl nagy, meghaladja a hardver tárolási kapacitását, ezért mesterségesen megritkítják. -
Amennyiben az előbb említett helyzet nem jelent problémát, tehát a tárolás megoldható, a számítási idő még mindig elérhet olyan szintet, ami után már kénytelenek megritkítani a szabálybázist.
13
2.3.1. ábra: Példa sűrű és ritka szabálybázisra
A ritka szabálybázisú eljárások két csoportba sorolhatók. Az első csoportba tartozó eljárások az eredményt közvetlenül állítják elő becslés segítségével, ezeket egylépéses módszereknek nevezzük. A második csoport tagjai először egy ideiglenes szabályt alkotnak a már meglévők alapján, melynek antecedens része legalább részben fedi a megfigyelést, majd ezt követően az új szabály és a megfigyelés
közti
hasonlóság
alapján
számítják
ki
a
becsült
konklúziót.
Az egylépéses módszerek legjelentősebb tagjai: KH [1] (Kóczy és Hirota), MACI [2] (Tikk és Baranyai), FIVE [3] (Kovács és Kóczy), IMUL
[4]
(Wong,
Gedeon,
Tikk)
és
VKK
[5]
(Vass,
Kalmár,
Kóczy).
Legismertebb kétlépéses eljárások: GM [6], FRIPOC, ST [7]. A felsorolt módszerek közül jelenleg 3 + 2 implementált a keretrendszerben, de ez a szám változni fog, ahogy előrehaladnak a fejlesztések. Ezek a következők: KH [1], VKK [5], CRF [12], MACI [2], FRIPOC. Amint látható 4 egylépéses és egy kétlépéses módszer található eddig a keretrendszerben. Mivel az egylépéses módszerek leprogramozása kevesebb időt vesz igénybe és esetenként egyszerűbbek is, mint a kétlépésesek, ezért ebből került több implementálásra. A fuzzy interpolációs módszerek, melyek a keretrendszerbe kerülnek, figyelembe veszik az FRI technikákra vonatkozó általános szabályokat [10]: -
Érvénytelen eredmény elkerülése.
-
Legyen formaőrző. Ez azt jelenti, hogy a megadott megfigyelésnek és a kiszámított közelítő eredménynek az alakja hasonló kell, hogy legyen.
14
-
A „köztes” kapcsolatok megőrzése. Amennyiben a megfigyelés kétantecedens közt helyezkedik el, akkor a becsült eredménynek a szabálybázis szerinti két konzekvens közé kell esni.
-
Szabálybázissal való kompatibilitás. Megköveteli a modus ponens elvének teljesülsét. Ez azt jelenti, hogy ha egy megfigyelés egybeesik egy antecedensel, akkor a konklúziónak a szabálybázis szerinti konzekvensnek kell megfelelnie.
-
A becsült eredménynek meg kell tartania a fuzzy tulajdonságot. Két ellentétes megközelítése van ennek a témának az irodalomban. Az egyik szerint ha van egy singleton megfigyelésünk, akkor abból a módszernek egy szintén singletone következtetést kell készítenie. A másik vélemény szerint a konzekvens fuzzy tulajdonságait kell figyelembe venni a szabályok alapján. Singleton-t csak akkor kaphatunk ha az összes konzekvens amit a szabályokban figyelembe vesznek az interpolációnál, mindegyik singleton.
-
Közelítő képesség (stabilitás). A becsült szabálynak a lehető legjobban közelítenie kell a kapcsolatot két dimenzió antecedensei és konzekvensei között.
-
Szakaszonkénti linearitás megtartása. Ha a figyelembe vett fuzzy halmazok szakaszonként lineárisak, akkor a közelített halmazoknak is meg kell tartaniuk ezt a tulajdonságit.
-
Többdimenziós antecedens univerzumok használhatósága. Ez azt jelenti, hogy az FRI módszernek hasonló karakterisztikát kell mutatnia ha kiegészítik, és több dimenziós bementi tere lesz.
-
A fuzzy halmaz alakjára vonatkozó bármilyen jellegű megszorítás nélküli alkalmazás. Ezt a pontot nem feltétlen kell figyelembe venni, mert a gyakorlatban elég sűrűn találkozunk szakaszonként lineáris fuzzy halmaz és Gauss-görbe halmaz találkozásával.
15
3 A keretrendszer A keretrendszerrel szemben támasztott 3 fő követelmény: -
Kellően gyors legyen ahhoz, hogy valós időben tudjon reagálni, így éles helyzetekben is tökéletesen működjön
-
Széles körű használhatóság is fontos szempont. Azt szeretném elérni, hogy minél több projektben alkalmazható legyen, így segítve a keretrendszer elterjedését.
Ehhez pedig az kell, hogy minél több programozási nyelvbe
beágyazható legyen direkt, vagy asszisztált módban (ezekről később). Először a Java, C#, C++ és a MATLAB, illetve a Freemat matematika szoftverek támogatottak. -
Univerzális kezelőfelület kialakítása. Mivel több módszert is tartalmaz a keretrendszer, biztosítani kell a menet közbeni változtatás lehetőségét, mindezt úgy, hogy külsőleg nem teszünk különbséget az eljárások közt, kényelmessé téve felhasználó számára a használatot.
Ahhoz hogy a fenti kritériumoknak megfeleljen a keretrendszer, több féleképpen is elérhetővé kell tenni: először is egy programozói könyvtár formájában, melye C++ban használható, dinamikusan betölthető könyvtár (.dll fájl Windows, illetve .so fájlt Linux esetén. MAC támogatottság még nem megoldott), illetve egy úgynevezett wrapper osztály is elkészül a népszerűbb programnyelvekhez (Java, Python, C#). Az FRI módszerek használatának egységesítése úgy lett megoldva, hogy bármelyik metódust ugyan azzal az interface-el lehet kezelni. Az osztály hierarchia és az objektumorientált minták biztosítják ezt. A toolbox fő célja, hogy egyszerűsítse a programozók dolgát azzal, hogy szabványosított függvénykönyvtárat ad a kezükbe. A használat két féleképpen lehetséges: direkt módba és asszisztált módba. A direkt felhasználási mód lényege, hogy az osztályokat közvetlenül lehet elérni és példányosítani, majd a metódusait meghívni, minden féle közvetítő kód nélkül. Ebben az esetben a fejlesztő felelőssége, hogy létrehozza, eltárolja, majd miután elvégezte rajta a műveleteket, törölje azt. A rendszer tárolására a vektor a leg praktikusabb, ugyanis ilyenkor lekérdezhető a mérete (mely futás közben bármikor változtatható és ennek nagy szerepe van a program megírásában), törölhetőek és beilleszthetőek az 16
elemek bárhonnan, bárhova (csak hogy néhány előnyét említsem) a már adott operátorokkal. Az asszisztált mód azt jelenti, hogy minden művelet indirekt. A felhasználónak speciális paraméterekkel kell kérést küldenie a könyvtárnak, hogy egy új fuzzy rendszer létrejöjjön. Miután elkészült a fuzzy rendszer, egy belső listában tárolódik el. Ilyenkor a felhasználó nem tud arról, hogy hol is raktározódik el pontosan, a létrehozás és a törlés is egyszerű függvényhívások. Amikor már feleslegessé vált, egy
másik
függvényhívással
ismét
a
felhasználónak
kell
törölnie.
Az asszisztált mód szinte bármilyen nyelvben íródott program számára elérhető, de közvetlenül csak C++ alkalmazások használhatják (természetesen C++ban mind két mód elérhető). Ezzel a keretrendszerrel legcélszerűbb a C++t választani, mert ez egy objektum orientált nyelv, és mivel közvetlenül tudja elérni a könyvtárt, így megbízhatóbb és hatékonyabb, ugyanakkor támogatja a komplex, összetett típusokat is. A
programnyelvek
alapvetően
eltérnek
egymástól.
A
különböző
típusok
memóriában való tárolása és a funkcionális lehetőségei is eltérhetnek. Elkerülve a sokszínűségből adódó problémákat, a dll C-be íródott, mert szinte minden nyelv támogatja a tisztán C-ben íródott dll-eket. A mi esetünkben a C dll globális funkciói illesztőként működnek, amely a belső függvények programozói felületét szimpla funkciókká konvertálja. A háttérben ezek a függvények a belső osztályokból létrehoznak egy-egy példányt, melyek az objektummal kommunikálnak. A C nyelv széles körben támogatott, de csak egyszerű típusokat fogad el és nem objektum orientált. Mivel a C dll a felhasználói felület és a belső osztályok között került beillesztésre, a metódushívásokban csak egyszerű típusok szerepelhetnek, mint például lebegőpontos szám (double), tömb (array), egész (integer) és egyszerű típusra mutató pointer, de nem lehet például osztályra mutató pointer. Ezen problémák kezelésére az illesztő függvények tartalmaznak további plusz kódot, melyek a megfelelő objektumokat egyszerű paraméterek szerint építik fel. A dll-t használva, mely csak olyan függvényeket tartalmaz, amik egyszerű típusokat kezelnek, odafigyelő, pontos kódolást igényel, mert nem tudja lekérdezni a tömbök méretét. Mivel C esetében nincs lehetőség a tömb méretének lekérésére (különösen MATLAB esetében), ezért a legtöbb esetben beiktatásra került egy plusz változót, ami a tömbök méretét tartalmazza. Ha ez rossz értéket tárol, a program hibaüzenettel leáll. A helyes működés csak is a felhasználón múlik. 17
A dll lehetővé teszi, hogy egy számítógépen egy időben több program is használja egymás mellett, mert úgy lett megterezve, hogy megoldható legyen több fuzzy rendszer kezelése is. Ez azért lehetséges, mert letárolja a felhasználók rendszerét egy belső listába és minden egyes kérésnek van egy plusz paramétere, ami azonosítja a fuzzy-t. Ez a megoldás garantálja tehát azt, hogy egy programon belül több rendszer is működjön, és ami még fontosabb, több program futhat egymás mellett, egy időben. Alacsony szintű felhasználás esetén (.lib file) a fejlesztők példányosítani tudják az osztályokat, vagy akár felül is deifiniálhatják azokat. Könnyen származtathatnak új osztályokat a már létező FRI metódusok közül. A dll sima C-be íródott, mert ez a leginkább kompatibilis más nyelvekkel, mint például Delphi, C# vagy Java. Összefoglalva a sima használat több lehetőséget ad, mint a támogató
mód,
de
nagyobb
a
felelősség
is.
Az imént felsorolt 9 pontot, melyet Baranyai és szerzőtársai határoztak meg, csak az egyes feltétel teljesíthető, mert több olyan módszer is van, mely a maradék csak 8at részben, vagy egyáltalán nem tudja kielégíteni. Közvetlen használat esetén, ha abnormális működés következik be, akkor ez egy kivételt vált ki. Asszistált módban ez a kivételkezelés nem működik, tehát a függvény visszatérési értéke lehet akár egy hiba kód is, ami minden esetben egy negatív egész szám (hiba mentes futás során ez a visszatérési érték nulla). Minden hibára különböző hibakódot és kivétet generáltunk a könnyebb, egyértelműbb hibakezelés miatt.
18
3.1
A keretrendszer szerkezete A toolbox alapja C++ban íródott, mivel ez egy gyors objektum orientált nyelv és
széles
körben
elterjedt.
Sok
osztály
már
előredefiniált,
de
az
objektum
orientáltságnak köszönhetően ezek felülírhatók, vagy származtathatóak belőlük új osztályok. Csak is a felhasználón múlik az, hogy hogy alakítja ezek után a kódot. A keretrendszer támogatja mind a kéttípusú eljárásokat, az egylépéseseket és a kétlépéseseket egyaránt. A kompatibilitás érdekében ugyan úgy, mint a MATLAB-os FRI Toolbox, a FIS fájlt használja adatok bevitelére. A FIS fájl tartalmazza a felhasználó ritka szabálybázisát, mely alapján a választott módszer meghatározza az eredményt. Valós körülmények között általánosságban az mondható el, hogy a szabálybázis nem szokott változni, csak a megfigyelés. Így tehát a jobb teljesítmény érdekében a megfigyelés nem egy OBS fájlból származik, hanem csupán egy függvény paramétereként adódik át a programnak. Általában az összes Fuzzy interpolációs módszernek lehetnek további input adatai, melyet felhasználhatnak a fejlesztők a kód írása során, ilyen például az alfa szintek. A paraméterek típusa és száma a kiválasztott módszertől függ, tehát egy paraméter lehet akár egy speciális karakter lánc is. A CFRIMethod osztály a közvetlen, vagy közvetett szülője az összes FRI metódusnak. Ez az osztály definiálja a közös interface-t az FRI módszereknek, így biztosítva a különböző módszerek egységes felületét. A felhasználó szemszögéből nézve, négy egyszerű lépést kell végrehajtania, hogy használni tudja bármelyik FRI módszert: 1. Rendszer létrehozása. Első lépésben a fuzzy rendszert kell előállítani FIS fájl használatával, vagy karakter lánccal. Ez a rendszer lehet ritka szabálybázisú is. 2. FRI módszer kiválasztása az előző lépésben létrejött rendszerhez. Ennél adja meg a felhasználó, hogy melyik módszert szeretné használni. Assziszált módban a nevet egyszerű string paraméterként kell átadni. A háttérben a kiválasztott metódus neve alapján létrejön a megfelelő objektum. Fontos megjegyezni, hogy ezt a lépést futás közben többször is végre lehet hajtani, a setup metódus segítségével. 3. FRI metódus inicializálása, ahol speciális paraméterek is megadhatók. A módszerek különböznek egymástól, így vannak olyanok amelyeknek további 19
adatokra van szükségük. Ezek a paraméterek fontos szerepet játszhatnak a végeredmény kiszámításában. Az initmetódus futás közben is képes adatokat fogadni a felhasználótól, melyeket kiválasztott módszer a számítások során felhasznál 4. A konklúzió meghatározása, amire akkor kerül sor, ha meghívódik az interpolate metódus. Ez a fő lépése az FRI módszereknek, melynek során a megfigyelésből és az input szabálybázisból kiszámítódik a becsült eredmény. Amennyiben valós időben futó alkalmazásról van szó, ez a lépés többször is meghívódik. Az egylépéses módszerek esetében, amit az 1-es képen láthatunk, az FRI metódus osztályát a COneStepMethod osztályból kell származtatni. A COneStepMethod deklarál egy virtuális metódust, melyet implementálni kell és felüldefiniálni. Ez a metódus számolja ki a becsült eredményt a kapott megfigyelés és a fuzzy rendszer felhasználásával. A megfigyelések egy Membershipfunctions (tagsági függvények) nevű vektorban vannak eltárolva, mint paraméterek, és innen lehet hivatkozni rájuk. A keretrendszer jelenleg az alábbi egylépéses módszereket tartamazza: KH [1] (CKH osztály) VKK [5] (CVKK osztály), MACI[2] (CMACI osztály) és CRF [12] (CCRF osztály).
Ha új egylépéses módszert szeretnénk létrehozni, akkor annak a
CCustom1StepMethod osztályból kell származnia és az interpolate metódusát felül kell definiálni (3.1.1. ábra).
20
3.1.1.ábra: Az egylépéses FRI módszerek struktúrája
A másik csoport tagjait a kétlépéses módszereknek hívjuk, és ahogy a 3.2.2-es ábrán láthatóaz FRI metódus(ok) a CGeneralizedMethod osztályból származnak, majd pedig felül kell definiálni a következő 3 osztályt: determineAntecedentShapes, determineConsequentPositions és a determineConsequentShapes osztályokat. Ezek a CGeneralizedMethod osztályból hívódnak meg szigorúan ragaszkodva az előbb látott sorrendhez. Itt a megfigyeléseket a paraméterként kapják meg, ami a MembershipFunction (Tagsági Függvények) vektorban vannak karakter láncként tárolva. A keretrendszer jelenlegi állapotában csak egy kétlépéses módszert tartalmaz ez pedig a FRIPOC (CFRIPOC osztály). Tehát amennyiben a programozó egy új kétlépéses módszert szeretne implementálni, annak a következő képpen kell történnie: 1. származtatja a metódusát a CGeneralizedMethod osztályból 2. Felüldefiniálja
a
következő
osztályokat:
determineAntecedentShapes,
determineConsequentPositions és determineConsequentShapes.
21
3.1.2. ábra: A kétlépéses FRI metódusok struktúrája
22
3.2
A keretrendszer használata
A natív könyvtárak közvetlenül csak C++ alól érhetők el, viszont így biztosított a leggyorsabb futás, viszont ahhoz, hogy ez teljesüljön, több munkát igényel a programozótól és nagyobb felelősséget, odafigyelést.
A dinamikus könyvtárat
különböző típusú programnyelvek használhatják, ide tartoznak a script nyelvek is, mint például a Perl, PHP, Python, Tcl és a Ruby. A támogatott nyelvek listájába bele tartozik a non-script alapú nyelvek is: C#, Java, Delphi. Ilyenkor a dll asszisztált módban használható. Elsődleges célként volt kitűzve, a MATLAB támogatása. A MATLAB egy olyan programozói platform, ami alkalmas algoritmusok fejlesztésére, adatok elemzésére és megjelenítésre, valamint numerikus számításokra. A program fő előnye a megjelenítés és a gazdag matematikai metódusgyűjtemény. A Fuzzy LogicToolbox lehetővé teszi, hogy fuzzy rendszereket fejlesszenek benne, de nem része az alap rendszernek és csak teljes fuzzy rendszerrel működik.A MATLAB lehetőséget nyújt a dll-ek használatára, ilyenkor meg kell adni a dll, valamint a header fájl teljes elérési útvonalát. A másik kulcsfontosságú eleme a koncepciónak az volt, hogy a támogatott nyelvek közé kerüljenek az ingyenes matematikai programnyelvek is. Első lépésben a FreeMat támogatását sikerült megoldani. AFreeMat egy ingyenes fejlesztői környezet gyors műszaki számításokhoz és tudományos prototípusok létrehozásához (elérhető a [11]). Hasonló a MATLAB-hoz, annyi különbséggel, hogy ez nyílt forráskód. A freeMat esetében a megosztott könyvtárak függvényeit, importálni kell használat előtt. Egy szövegfájlban megtalálható minden, ami szükséges a definiált függvény importálásához. A szintaktikája a függvények importálásának a következő: import(könyvtár neve, szimbólum, visszatérés, argumentumok), ahol a könyvtár nevét karakter láncként kell megadni. Jelen esetben ez ’fritoolbox.dll’. A második argumentum a szimbólum nevét kéri. Ez egy globális függvény belső nevét jelenti. A függvény harmadik paramétere a külső neve a választott függvénynek. Az utolsó egy karakter lánc, ami a visszatérési érték típusát határozza meg.
23
3.3
DLL használata MATLAB alól
A MATLAB hozzáfér a C külső rutinjaihoz, megosztott mappáihoz a parancssoron keresztül. Ez az interface megengedi, hogy a külső könyvtárakat a MATLAB betöltse a memóriába, és onnan elérje az FRI toolboxdll-jében lévő függvényeket. Bár a két nyelv máshogy kezeli a típusokat, a legtöbb esetben a típusok átadhatók a C-nek anélkül, hogy a programozónak kellene foglakoznia a konvertálással, mert a MATLAB megcsinálja helyette. A dll betöltése MATLAB alá, 3 egyszerű lépésből áll:
1. A loadlibrary függvényt kell elsőként meghívni két paraméterrel, a dll és a header fájl nevével.
2. A betöltés sikerességét a libfunctions függvénnyel tudjuk megnézni, ezért ezt kell következőnek meghívni. Ennek segítségével egy változóba be lehet tölteli a DLLben lévő összes függvényt.
3. Végül a calllib következik, melynek hatására a külső függvények is elérhetővé válnak, ha az előző két lépésben nem történt hiba. A calllibargumentum(ai) a külső függvényektől függnek. Első paraméterébe a DLL nevét kell megadni a .dll kiterjesztés nélkül. Másodikba a kiválasztott függvény neve kerül. Az összes többi pedig a függvénytől függ, ugyanis azok a DLL-ben lévő függvény paraméterei lesznek majd. A lépések kódjai alább, az Algorithm 1 példa programkódban láthatók. Algorithm 1 FRI DeveloperToolboxLibrary minta példája MATLAB-ban: loadlibrary( ’fritoolbox.dll’ , fritoolbox.h ) list = libfunctions( ’fritoolbox’ , ’-full’ ) calllib( ’fritoolbox’ , ’funcname’ , arg1 , ...,argN)
24
3.4
DLL betöltése Visual Studioba Visual Studioba betöltve egy projektet, vagy egy solution-t könnyen hozzá
tudjuk adni a DLL-t. Amennyiben egy solution-t töltöttünk be, keressük ki azt a projektet amelyikhez csatolni szeretnénk a könyvtárat. A projekt nevére jobb gombbal kattintva előugrik a menü, itt kikeresve a Propery opciót előjön egy ablak. ConfigurationPoperties, azon belül a Linker fül, majd pedig az Inputra kattintva máris szerkeszthetjük az AdditionalDependencies sort. Itt kell megadni a DLL illetve a LIB fájlt. Explicit módon is meg lehet hívni a DLL, ehhez a Visual Studio 3 függvényt kínál: LoadLibrary, GetProcAddress és a FreeLibrary.LoadLibrary-nak kell megadni a DLL nevét amit be szeretnénk tölteni. GetProcAddress pedig egy függvénypointert csinál minden egyes DLLben található metódushoz. Így ezen a pointeren keresztül érhetőek el a függvények. Amikor a DLL-t nem kívánjuk tovább használni,memória használati okokból ajánlott a FreeLibrary függvényt is meghívni, így az felszabadítja a könyvtár helyét.
25
3.5
A keretrendszerben található módszerek
Az előzőekben már volt róla szó, hogy jelen pillanatban a keretrendszer 4 módszert tartalmaz, ebből 3db egylépéses, 1db pedig a kétlépésesek közül került bele. A továbbiakban röviden bemutatásra kerülnek ezek a módszerek. 3.5.1
KH
Kóczy és Hirota[1] vezette be elsőként az alfa vágat alapú KH fuzzy távolág fogalmát (3.5.1.2. ábra). Ez az eljárás segít rendezni a fuzzy halmazokat. Az A halmaz akkor előzi meg B halmazt, ha bármely alfa vágat esetén [0, 1] inf(A)
3.5.1.1. ábra: Egy példa arra, amikor a
3.5.1.2. ábra: KH távolság értelmezése
KH távolság nem tud rendezni Az interpolációs módszer alapgondolata az volt, hogy a becsült eredményhalmaznak ugyan olyan arányban kell felosztania a két közrefogó konzekvens halmazok közötti távolságot, mint ahogy a megfigyelés a két legközelebbi antecedens közti távolságot. Az eljárás minden alfa vágat szintjén elvégzi ezeket a számításokat. Szakaszonként lineáris halmazok esetében elegendő csak a töréspontok magasságában alfa vágatokkal számolni. Ugyan az eljárás nem őrzi meg a szakaszonkénti linearitást, de az eltérés olyan kicsi, hogy elhanyagolható. A módszer előnye, hogy rendkívül gyors, azonban vannak olyan esetek, melyekre nem ad érvényes eredmény halmazt.
26
3.5.2
VKK
Vass, Kalmár és Kóczy[5] szintén alfavágat alapú rendezést javasolt a fuzzy halmazokra. A távolságot azonban teljesen máshogy értelmezik, mint a fenti esetben. Az alfa vágatot nem az előző módon, a halmaz két szélső pontjával határozzuk meg, hanem a halmaz középpontjával és a halmaz szélességével. Két halmaz távolságát pedig a középpontok euklideszi távolságával értelmezi (3.5.2.1. ábra). Ez alapján az A halmaz akkor előzi meg a B halmazt, ha minden alfa vágat magasságában A középpontja előrébb helyezkedik el, mint B középpontja. A megoldás előnye, hogy gyorsítja a távolság számítást, viszont még mindig csak részleges rendezést biztosít.
3.5.2.1.ábra: VKK távolság értelmezése Az interpolációs eljárás kiküszöböli a KH [1] egyik legnagyobb hibáját, az érvénytelen eredmény halmazt.Eztúgy érték el, hogy a távolságot másképp deifinálták, mint a KH [1] és a halmazok szélességével számol a módszer. Az előzőhöz hasonlóan ez is csak CNF halmazokkal működik. Hátránya, hogy nem tudja kezelni azt az esetet, amikor valamelyik halmaznak az alfa vágat magasságában a szélessége nulla (singleton). A szakaszonkénti linearitást ez az eljárás sem őrzi meg, de az eltérés itt is olyan kisméretű, hogy elhanyagolható.
27
3.5.3
MACI
Tikk és Baranyai [2] dolgozták ki a módosított alfa vágat alapú eljárást (ModifiedAlphabasedCutInterpolation, innen kapta a nevét). Az eljárás lényege, hogy a Yam által publikát vektorreprezentációs módszert alkalmazva a fuzzy halmazokat olyan térbe transzformálják ahol minden esetben érvényes következmény halmazt eredményeznek a számítások. A
szemléletesség
kedvéért
a
továbbiakban
háromszög
alakú
fuzzy
halmazokon lesz bemutatva a módszer. Minden halmazt két részre bont, jobb (alsó), bal (felső) részre, és a vektorokban a halmazok karakterisztikus pontjait tárolja. A számításokat ezek után külön végzik a jobb illetve a baloldalra. Az élek vektorait síkbéli pontokkal ábrázolva elmondható az, hogy csak akkor kapunk érvényes következtetés halmazt, ha a B* pont a B1 és B2 által határolt téglalapon belül, valamint az l vonalon felül helyezkedik el (3.5.3.1. ábra).
3.5.3.1. ábra: Grafikus szemléltetése az éleket leíró vektoroknak Transzformáljuk a B1 és B2 konzekvenseket egy olyan koordinátarendszerbe, amely kizárja az abnormalitás lehetőségét.
A B1 és B2 konvexitása biztosítja az új
rendszerbeli nem negatív értékeket. Ezek után számítsuk ki a következtetés helyét az új koordinátarendszerben, majd végül transzformáljuk vissza a kapott eredményt az eredeti rendszerbe. Ez a megoldás biztosítja a következtetés koordinátáinak monoton növekedését.
28
3.5.4
GK(CRF)
A módszert Gedeon és Kóczy[12] dolgozták ki, innen is a neve, valamint még Conservating of RelativeFuzzynes-nek is szokták hívni. Az eljárást trapéz alakú CNF halmazokra dolgozták ki, az eddigiekhez hasonlóan két közrefogó halmaz segítségével számolja ki az eredményt. Az eddigiektől eltérően, ez nem az alfa vágatok alapján becsli az eredményt. A szerzők ugyanis rájöttek arra, hogy az antecedens halmazok szárai általában hosszabbak, mint a megfigyelés élei. Ezért elegendő csak a számítandó oldalon lévő antecedens azonos oldali tartójával kalkulálni
(3.5.4.1.ábra).
A
következmény
helyzetének
becslésére
pedig
a
megfigyelés és a szomszédos antecedens magjának távolságát használja fel. Többdimenziós esetre is kiterjeszthető, ilyenkor a magok euklideszi távolságát használja.
3.5.4.1. ábra: Magtávolságok és magszélességek
29
3.5.5
FRIPOC
A keretrendszer jelenleg egyetlen kétlépéses módszere a polárvágat alapú szabály interpolációs eljárás, melyet Johanyák és Kovács dolgoztak ki [14]. A GM-et [6] követve első lépésben a segédszabály antecedens és konzekvens nyelvi értékeinek meghatározásának érdekébenpolár-vágat alapú halmaz-interpolációt (FEAT-p) [13] hajt végre. Mivel ezek a számítások nem függnek egymástól, ezért amennyire az adott programnyelv engedi, párhuzamosítással akár jelentős mértékben gyorsítható a módszer ezen része. A Shepard interpoláció [15] egy adoptált változata segítségével meghatározható az új szabály konzekvens halmazának referencia pontja. A következtetési folyamat második lépésében a szintén polár-vágat alapú SURE-p [14] eljárás segítségével határozzuk meg a következményt. 3.6
Módszerek összegzése
módszer neve
lépések száma
több dimenziós inputot is kezel-e
mindig érvényes-e a következmény
KH
1
kiterjesztve igen
nem
VKK
1
kiterjesztve igen
nem
CRF(GK)
1
kiterjesztve igen
igen
MACI
1
kiterjesztve igen
igen
FRIPOC
2
igen
igen
30
4 Konklúzió Több megoldás is létezik melyek feldolgozták a sűrű szabálybázis alapú módszereket, de eddig nem volt olyan, amely a ritka szabálybázisú eljárásokkal foglakozott volna, leszámítva a Johanyák által írt MATLAB FRI Toolbox-ot [8]. Ennek azonban a hátulütője, hogy csak MATLAB alól használható, és nem alkalmas valós környezetben való futtatásra. Az általam bemutatott keretrendszer, a MATLAB FRI Toolbox-hoz hasonlóan (legalábbis az abban felhasznált módszereket tekintve) a ritka szabálybázisú eljárásokat foglalja össze. A rendszerünk mindenki számára elérhető, több platformot is támogad (DLL technológiának köszenhetően), és elég gyors ahhoz, hogy valós környezetben
használható
legyen.
Az
egységes
kezelő
felületetnek
köszönhetőenbármely FRI módszert, könnyen tudunk használni a saját kódunkból. A rendszer még fejlesztés alatt áll, jelenleg 4db egylépéses és 1db kétlépéses módszert tartalmaz, ezek a következők: KH, VKK, CRF (GK), MACI és a FRIPOC. Mivel a lehető legtöbb programnyelv támogatása volt a cél, ezért dinamikus könyvtár (Windows-hoz .dll, valamintLinux-hoz .so), valamint wrapperosztály is elkészült C#, Java, Python nyelvekhez. Mind a két megoldás lehetővé teszi, a gyors, könnyű használatot, megkönnyíti a programozók dolgát, hiszen nem kell a módszerek implementációjával foglalkozniuk. Ugyanakkor a rendszer lehetővé teszi azt is, hogy a fejlesztők könnyedén, maguk bővítsék a keretrendszert akár egylépéses, akár kétlépéses módszerről van szó. Továbbfejlesztési lehetőség egy benchmark rendszer kifejlesztése, amely megkönnyíti a már implementált és későbbiekben beintegrált FRI módszerek javaslatát konkrét feladatok esetére.
31
5 Irodalomjegyzék [1] L. T. Kóczy and K. Hirota, “Ruleinterpolationby _-levelsetsin fuzzy approximatereasoning,” BUSEFAL, vol. 46, no. Automne, pp. 115–123, 1991. [2] D. Tikk and P. Baranyi, “Comprehensiveanalysis of a new fuzzy ruleinterpolationmethod,” IEEE Trans. onFuzzy Systems, vol. 8, no. 3, pp. 281–296, 2000. [3] S. Kovács and L. T. Kóczy, “Application of an approximatefuzzy logiccontrollerin an agvsteeringsystem, pathtracking and collisionavoidancestrategy,” Tatra MountainsMath. Publ.,vol. 16, pp. 456–467, 1999, http://www.mat.savba.sk/tatra/Full/16/31kovacz.ps. [4] K. W. Wong, T. D. Gedeon, and D. Tikk, “An improvedmultidimensional _cutbasedfuzzy interpolationtechnique,” inProc. of the Int. Conf. onArtificialIntelligencein Science and Technology (AISAT’00), V. Karriand M. Negnevitsky, Eds.,Hobart, Tasmania, Australia, December, 2000, pp. 33–38. [5] G. Vass, L. Kalmár, and L. T. Kóczy, “Extension of the fuzzy ruleinterpolationmethod,” inProc. of theInt. Conf. on Fuzzy SetsTheory and itsApplications(FSTA’92), Liptovsk´y Jan, Slovakia, 1992, pp. 1–6. [6] P. Baranyi, L. T. Kóczy, and T. D. Gedeon, “A generalizedconceptfor fuzzy ruleinterpolation,” IEEE Trans. on Fuzzy Systems, vol. 12, no. 6, pp. 820–837, December 2004. [7] S. Yan, M. Mizumoto, and W. Z. Qiao, “An improvementtoKóczy and Hirota’s interpolativereasoninginsparsefuzzy rulebases,” Int. J. of ApproximateReasoning, vol. 15, pp. 185–201, 1996. [8] Z. C. Johanyák, D. Tikk, S. Kovács, and K. W. Wong, “Fuzzy ruleinterpolationMatlabtoolbox – FRI toolbox,” inProc. of the IEEE World CongressonComputationalIntelligence (WCCI’06), 15th Int. Conf. on Fuzzy Systems (FUZZ-IEEE’06). Vancouver, BC, Canada: Omnipress, July 16–21, 2006, pp. 1427– 1433. [9] Z. Johanyák. Fuzzy ruleinterpolationmatlabtoolboxwebsite. [Online]. Available: http://fri.gamf.hu
32
[10] D. Tikk, Z. C. Johanyák, S. Kovács, and K. W. Wong, “Fuzzy ruleinterpolation and extrapolationtechniques: Criteria and evaluationguidelines,” Journal of Advanced ComputationalIntelligence and IntelligentInformatics, vol. 15, pp. 254–263, 2011. [11] Freematwebsite. [Online]. Available: http://freemat.sourceforge.net [12] Kóczy, L.T.,Hirota, K. and Gedeon, T. D.: Fuzzy ruleinterpolationbythe conservation of relativefuzziness, in Journal of Advanced Computational Intelligence, Vol. 4/1, 2000, pp. 95-101. [13] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy setapproximationusingpolarcoordinatesand linguisticterm shifting, 4rd SlovakianHungarianJointSymposiumonAppliedMachineIntelligence (SAMI 2006), Herl'any, Slovakia, 2006, pp. 219-227. [14] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy RuleInterpolationBasedonPolarCuts, inComputationalIntelligence, Theory and Applications, Springer Berlin Heidelberg, 2006, pp. 499-511. [15] Shepard, D.: A twodimensionalinterpolationfunctionforirregularlyspaceddata, inProceedings of the 23rd ACM International Conference, New York, USA, 1968, pp. 517-524.
33
6 Ábrajegyzék 2.1.1.ábra: Hagyományos Venn diagram. .......................................................... 6 2.1.2.ábra:Elmosódott élű halmaz Venn diagram használatával ........................ 6 2.1.3.ábra: Fuzzy halmazok ábrázolása ............................................................. 6 2.3.1.ábra: Példa sűrű és ritka szabálybázisra ................................................. 13 3.1.1.ábra: Az egylépéses FRI módszerek struktúrája ..................................... 20 3.1.2.ábra: A kétlépéses FRI metódusok struktúrája ........................................ 21 3.5.1.1.ábra: Egy példa arra, amikor a KH távolság nem tud rendezni............. 25 3.5.1.2.ábra: KH távolság értelmezése............................................................. 25 3.5.2.1.ábra: VKK távolság értelmezése........................................................... 26 3.5.3.1.ábra: Grafikus szemléltetése az éleket leíró vektoroknak..................... 27 3.5.4.1. ábra: Magtávolságok és magszélességek ........................................... 28
34
