Szakdolgozat. FRIToolbox - fuzzy szabályinterpolációs benchmark feladatok kidolgozása. Miskolci Egyetem

Szakdolgozat

Miskolci Egyetem

FRIToolbox - fuzzy szabályinterpolációs benchmark feladatok kidolgozása

Készítette: Asztalos Balázs 2008. Programtervez® Informatika

Témavezet®: Krizsán Zoltán

Miskolc, 2012

Miskolci Egyetem Gépészmérnöki és Informatikai Kar

Szám:

Alkalmazott Matematikai Tanszék

Szakdolgozat Feladat

Asztalos Balázs (HAP8V1) programtervez® informatikus jelölt részére.

A szakdolgozat tárgyköre: numerikus eljárások tesztelése A szakdolgozat címe: FRIToolbox - fuzzy szabályinterpolációs benchmark feladatok kidolgozása

A feladat részletezése: A

C++-ban

készül® módszerek bencsmárkolása, tesztelése.

Szempontrendszer felállítása a módszerek összehasonlításához. Javaslat a módszerek ellen®rzésére a szempontrendszer alapján.

Témavezet®: Krizsán Zoltán egyetemi tanársegéd Konzulens: Dr. Karácsony Zsolt, egyetemi adjunktus A feladat kiadásának ideje:

................................. szakfelel®s

2

1. szükséges (módosítás külön lapon) A szakdolgozat feladat módosítása nem szükséges

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

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

dátum

témavezet®(k)

2. A feladat kidolgozását ellen®riztem: témavezet® (dátum, aláírás):

konzulens (dátum, aláírás):

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

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

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

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

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

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

3. A szakdolgozat beadható: ......................

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

dátum

témavezet®(k)

4. A szakdolgozat . . . . . . . . . . . . . . . . . . . szövegoldalt . . . . . . . . . . . . . . . . . . . program protokollt (listát, felhasználói leírást) . . . . . . . . . . . . . . . . . . . elektronikus adathordozót (részletezve) ................... . . . . . . . . . . . . . . . . . . . egyéb mellékletet (részletezve) ................... tartalmaz. ......................

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

dátum

témavezet®(k)

5. bocsátható A szakdolgozat bírálatra nem bocsátható A bíráló neve: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ......................

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

dátum

szakfelel®s

6. A szakdolgozat osztályzata a témavezet® javaslata:

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

a bíráló javaslata:

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

a szakdolgozat végleges eredménye: . . . . . . . . . . . . . . . .

Miskolc, . . . . . . . . . . . . . . . . . . . . . . . .

................................. a Záróvizsga Bizottság Elnöke

3

Tartalomjegyzék

1. Bevezetés

6

2. Téma elméleti kifejtése

8

2.1.

Fuzzy alap fogalmak

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

8

2.2.

Interpolációs módszerek ismertetése . . . . . . . . . . . . . . . . . . . .

10

2.2.1.

Lineáris szabály-interpoláció (KH módszer) . . . . . . . . . . . .

10

2.2.2.

VKK módszer . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

2.2.3.

Relatív fuzzy jelleg meg®rzésén alapuló szabályinterpoláció (CRF) 12

2.2.4.

Módosított

2.2.5.

Polár-vágaton alapuló halmaz-interpoláció (FEAT-p)

α-vágat

alapú szabály-interpoláció (MACI)

. . . . .

13

. . . . . .

14

2.3.

Szempont rendszer

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

15

2.4.

Javaslatok a szempontrendszer kezelésére . . . . . . . . . . . . . . . . .

16

3. Módszerek elemzése 3.1.

3.2.

17

A KH módszer id®bonyolultságának elemzése . . . . . . . . . . . . . . .

17

3.1.1.

Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

17

3.1.2.

getAlphaLevelsFromParams

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

18

3.1.3.

acutsFromParams . . . . . . . . . . . . . . . . . . . . . . . . . .

19

3.1.4.

getAllaCuts

19

3.1.5.

NearestTwoRules

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

19

3.1.6.

interpolate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

20

A MACI módszer id®bonyolultságának elemzése . . . . . . . . . . . . .

20

3.2.1.

konstruktor

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

20

3.2.2.

setRP

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

21

3.2.3.

getFlanks

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

21

3.2.4.

localRefPointsLeftFlanksRightFlanksALevels . . . . . . . . . . .

21

3.2.5.

acutsFromParams . . . . . . . . . . . . . . . . . . . . . . . . . .

21

3.2.6.

cut2params

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

22

3.2.7.

interpolate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

22

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

3.3.

Google Test

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

3.4.

Módszerek id®igényének mérése a gyakorlatban

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

24

3.5.

A Google teszt felépítése . . . . . . . . . . . . . . . . . . . . . . . . . .

27

4. Fejleszt®i dokumentáció

24

30

4.1.

A KH eljárás során felhasznált struktúrák

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

30

4.2.

Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

32

4.3.

acutsFromParams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

33

4.4.

getAllaCuts

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

35

4.5.

removeDuplicates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35

4

4.6.

getAlphaLevelsFromParams

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

36

4.7.

NearestTwoRules

4.8.

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

36

interpolate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

39

5. Összefoglalás

42

Irodalomjegyzék

43

Adathordozó használati útmutató

44

5

1. fejezet Bevezetés

A fuzzy halmazok logikája viszonylag új tudományág. El®ször L.A.Zadeh írt róla [1] 1965-ben. A fuzzy halmazok jelentése elmosódott, azaz többérték¶ halmazok. Lehet®séget ad arra, hogy az elemek csak részben legyenek tagjai az adott halmaznak, így lehet®séget ad olyan esetek megvalósítására, melyet matematikailag csak nehezen lehetne felírni. Gyakran felhozott példa erre a homok kupac meghatározása. Adott egy kupac homok, amelyet homokszemenként csökkentünk. Így matematikailag már az els® homokszem elvétele után nem lesz homokkupac.

Kupac = k ∗ homokszem. Kupac − homokszem ̸= Kupac k∈N Azonban a józan ész szerint még mindig homokkupac maradt. Els®sorban az informatikában, a logikai szemantikában és a matematikai logikában használják. Gyakorlati megvalósításának legf®bb felhasználása a fuzzy kontroll azaz a fuzzy logikán alapuló irányítás, melyet a háztartási gépekt®l a robotokig sok helyen felhasználnak. A fuzzy logikának köszönhet®en ezek a berendezések megfelel®bben tudnak m¶ködni. Például képzeljünk el egy robot járm¶vet, mely irányításánál ezt nem használják fel. A járm¶ érzékeli, ha letért a kívánt útról, ennek megfelel®en kiadja a korrigáló parancsot, de azt nem tudja eldönteni milyen mértékben szükséges korrigálni. Ennek hatására a lehetséges maximálissal elfordítja a járm¶vet, így minden eltérésnél hirtelen irányváltoztatásokkal korrigálja magát a járm¶. Míg a fuzzy logika lehet®séget ad annak észlelésére, hogy mekkora mérték¶ az eltérés, szükséges-e már beavatkozni, vagy még hibahatáron belüli az eltérés, és ha szükséges beavatkozni mekkora mértékben kell elfordulni, hogy korrigáljuk a hibát.

6

1.1. ábra. Útvonal példa

Ideális esetben minden elképzelhet® esethez tartozik egy fuzzy halmaz és hozzá egy eredmény halmaz, azonban ez a gyakorlatban elképzelhetetlen. Ezért a meglév® adatok alapján interpolációval számolják ki a szükséges eredményeket. Példaképp legyen adva egy konzervgyár ahol alma konzerveket készítenek. Egy futószalagon sorba érkez® almákról kell egy gépnek eldöntenie, hogy érett-e vagy sem. Ha piros akkor érett ha zöld akkor nem. Azonban a pirosnak rengeteg árnyalata létezhet, melyek nem mindegyikére lehet megadva mit tegyen. Ebben az esetben valamely interpolációs módszer segítségével meg lehet adni mi legyen a teend® anélkül, hogy az adott esetet ismerné a gép. A fuzzy logika rengeteg különböz® módszert foglal magába, és egyre növekv® használata ellenére nincsen egy olyan általános programozói könyvtár hozzá, amely ezeket mind magába foglalja. Az egyetlen ilyen könyvtár az FRItoolbox [7], amely a Matlabhoz van kialakítva, azonban ennek hátránya, hogy er®sen platformfügg®, és egyszer¶ rendszerek használatakor nem lehetséges, vagy túl id®igényes a használata. Ezért a cél egy általános célú programozói könyvtár kialakítása, a hozzá tartozó keretrendszer megírása és a metódusok implementálása, valamint ezek tesztelése. Ezentúl rengeteg különböz® eljárás létezik. Sokan elkészítettek egy eljárást mely nekik pont megfelelt és publikálták. Azonban nincs egy átfogó szempontrendszer, mely alapján a felhasználók, programozók eldönthetnék, melyik eljárás fog megfelelni a követelményeiknek, melyek használata esetén kell a legkevesebb hibára számítani, illetve melyeket nem tudják felhasználni az adott fuzzy rendszerek kezelésére. A célom ennek a szempontrendszernek az alapjainak kidolgozása.

7

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

2.1. Fuzzy alap fogalmak

Fuzzy halmaz:

A Fuzzy halmazok elmosódott halmazok, így lehetséges hogy egyes

elemeket csak részben tartalmaznak. A fuzzy halmazok geometriai alakja változatos lehet. A singletontól a trapéz és háromszög formákon át, a gauss-görbékig rengeteg formáció elképzelhet®. A fuzzy halmaz két f® része lehet egy mag és a

[0, 1] közötti érték. A Fuzzy halmazok jelölése a nagy ABC egyes bet¶ivel történik. Rendszerint Ai ∗ ∗ az i-edik antecedenst jelöli. Bi az ideik konzekvenst. A a meggyelést, B pedig

tartók. Az egyes elemkhez tartozik egy tagsági érték mely egy

a konklúziót jelöli.

Mag:

A mag azokat az elemeket jelöli, amelyek teljes mértékben bele tartoznak az

adott fuzzy halmazba, azaz a tagsági függvényük értéke

Tartó:

1.

Jelölésük

[A]1

A tartó azon elemekb®l áll melyeket csak részben tartalmaz a fuzzy halmaz.

Alfa vágat:

A fuzzy logikában gyakran használt fogalom az

α-vágat.

Ennek segítsé-

gével kilehet számolni egy fuzzy halmaz szélességeit, egymástól vett távolságait. Jelölése:

[A]α

Normál fuzzy halmaz:

Azt a halmazt nevezzük normál fuzzynak melynek létezik

magja.

Konvex fuzzy halmaz:

Olyan fuzzy halmaz, melynek bármely alfa vágata konvex

halmaz.

Tagsági függvény: Fuzzy jelleg:

Egy fuzzy halmaz.

Egy halmaz tartóinak szélessége.

8


2.1. ábra. Fuzzy halmaz

9


2.2. Interpolációs módszerek ismertetése Egyik célom egy átfogó jól használható szempontrendszer felállítása, mely alapján besorolhatóak és rangsorolhatóak az egyes interpolációs módszerek megbízhatósága. Ehhez létfontosságú felmérni az egyes eljárások hibáit hátranyit hiányosságait. Az alábbi fejezetben néhány módszer áttekintése következik a szemponttrendszer alapjainak felállításához.

2.2.1. Lineáris szabály-interpoláció (KH módszer) Ezt a módszert Kóczy és Hirota dolgozta ki [2]. A módszer azon a meggyelésen alapszik, hogy a meggyelést közrezáró két antecedenshez tartozó konzekveseket, a becsült következmény olyan arányban osztja fel, mint a meggyelés a két antecedent. Az eljárás

α

-vágat alapú így az arányok az alábbi képlet szerint alakulnak

dxα (Ai , A∗ ) : dxα (A∗ , Aj ) = dxα (Bi , B ∗ ) : dxα (B ∗ , Bj ) ahol

x

azt jelöli hogy alsó vagy fels® távolság ot nézünk, az

cedens,

Bi , Bj

Ai , Aj

(2.1)

a két közrefogó ate-

pedig a hozzájuk tartozó konzekvensek. Elméletileg végtelen számú

α

-vágatra lenne szükség az eredmény pontos számítására, de ez a gyakorlatban nem lehetséges, valamint szakaszosan lineáris halmazok esetén, igaz nem ®rzi meg linearitását, de a gyakorlati alkalmazásoknál az eltérés elhanyagolható, így elégséges csak a töréspontokban számolni az

α -vágatokat. A módszer hátránya hogy csak részben rendezést

tesz lehet®vé, amennyiben az antecedensek átfedik egymást nem lehet egyértelm¶en eldönteni, hogy melyik a legközelebbi antecedens.(2.2. ábra) Valamint bizonyos esetekben az eljárás nem szabályos fuzzy halmazokat ad eredményül. Gyakran a fuzzy jellege a magon belül esik illetve másik gyakori probléma, hogy a halmaz tartói metszik egymást egy homokóra szer¶ alakzatot eredményezve.(2.3. ábra) Továbbá csak és kizárólag Konvex Normált Fuzzy (CNF) halmazok esetében m¶ködik. El®nye, hogy szakaszosan lineáris esetekben az eljárás id®komplexitása meglehet®sen alacsony.

2.2. ábra. A két halmaz átfedi egymást így a KH távolságok alapján nem dönthet® el melyik el®zi meg a másikat

10


2.3. ábra. KH homokóra hiba

2.2.2. VKK módszer Nevét a megalkotóiról kapta Vass, Kalmár és Kóczy [3]. Ez a módszer kiküszöböli a KH módszer egyik leggyakorabbi hibáját, hogy gyakran a következmény halmaz fuzzy jellegei metszik egymást, így egy homokóra szer¶ alakzat keletkezik.(2.3. ábra) Ehhez a VKK másképp értelmezi a távolságokat mint a KH. Továbbra is alfa vágat alapú,

α-vágat mentén a halmazok köα-vágat szélességét használja.(2.4.

azonban nem nincs alsó és fels® távolság, hanem az zéppontjainak távolságát veszi alapul, valamint az ábra)

2.4. ábra. VKK távolsogok A következmény halmaz középpontját az

α

-vágat mentén úgy kapjuk, hogy a két

közrezáró antecedens halmaz középpontja és a meggyelés középpontjának arányát rávetítjük az antecedensehez tartozó konzekvensek köt® képzeletbeli szakaszra. Az

α-vágat

α-vágat

menti középpontjait össze-

mentén a széls® pontokat pedig úgy kapjuk

11


hogy a becsült következmény szélességének felét kivonjuk a középpontból, így kapjuk az

α-vágat

menti inmumot, a szuprémumát pedig úgy kapjuk, hogy a középponthoz

hozzáadjuk a szélességének a felét. Hátránya, hogy továbbra is el®fordulhat szabálytalan halmaz, úgy, hogy a tartó és a mag egy szakasza egybe eshet egy félrebillent fuzzyhalmazt eredményezve. Hasonlóan a KH módszerhez nem ®rzi meg szakaszonkénti linearitását, de az eltérés a gyakorlatban elhanyagolható.

2.2.3. Relatív fuzzy jelleg meg®rzésén alapuló szabályinterpoláció (CRF) A módszert Kóczy, Hirota és Gedeon dolgozta ki [4]. Azon a meggyelésen alapul, hogy rendszerint a meggyelés fuzzy jellegét, a vele szomszédos szabály azonos oldali (hozzá közelebbi) fuzzy jelege és a hozzá tartozó konzekvens nagyobb mértékben befolyásolja a meggyelést, mint az azonos oldalon elhelyezked® fuzzy jellegek. Ezért a módszer a meggyelés és a legközelebbi szabály magjainak távolságát veszi gyelemben, és ezt a szakaszt osztja fel az azonos oldali (egymással szembe lév®) fuzzy jellegekkel. Az így kapott arányokat vetíti rá a konzekvensek és becsült következmény magtávolságaira. A következmény magszélességét a konzekvens magtávolság és az antecedens magtávolság arányának és a meggyelés magszélességének szorzatából számolja az eljárás.

2.5. ábra. CRF input

12


2.6. ábra. CRF output

B1 a hozzá tartozó konzekvens. Jól meggyelhet®, hogy a konzekvens fels® fuzzy jellege (B1U F ) duplájára növekszik az ∗ antecedenséhez képest (A1U F ), ennek megfelel®en a konklúzió fuzzy jellege (B LF ) is ∗ a meggyelés fuzzy jellegének (A LF ) duplájára növekedett. Ugyan ennek megfelel®en A (2.5.) és (2.6.) ábrán

A1

a bal oldali szabály és

lett számítva a következmény fels® fuzzy jelege is.

A1U F : B1U F = A∗ LF : B ∗ LF A∗ U F : B ∗ U F = A2LF : B2LF Az eljárás CNF halmazok esetén alkalmazható. El®nye, hogy amennyiben szabályos fuzzy halmazokra alkalmazzák, a következmény is szabályos fuzzy halmaz lesz. Az eredmény halmaz alakja megegyezik a meggyelés alakjával (trapéz esetén trapéz, háromszög esetén háromszög, singleton esetén singleton lesz az eredmény)

2.2.4. Módosított α-vágat alapú szabály-interpoláció (MACI) A módszert Tikk és Baranyi dolgozta ki [5]. Ez a megoldás egy vektorreprezentációt alkalmazva egy olyan térbe transzformálja a megoldásokat ahol, ahol kiküszöbölhet®ek a hibás fuzzy halmazt adó eredmények. Az eljárás a halmaz tartóinak töréspontjait két vektorban tárolja. Amennyiben nincsenek töréspontok egy sor

α-vágattal számított ér-

téket tárolnak el benne. Ezt követ®en egymástól függetlenül végzik el a számításokat a két vektorra. Három szög alakú halmazok esetén a vektorok egy-egy síkbeli pontot eredményeznek. Amennyiben az eredmény a konzekvenseket reprezentáló vektor síkbeli pontjaira kifeszített téglalap területén belülre esik, és egy

l

vonal felett akkor az

eredmény egy érvényes fuzzy halmaz. El®nye hogy minden esetben szabályos fuzzy halmazt eredményez. A módszer eredetileg egydimenziós esetekre lett kidolgozva, de több dimenzióban is alkalmazható. A módszer akár nem konvex halmazok esetén is alkalmazható. Bár ez az eljárás sem ®rzi meg szakaszonkénti linearitását, de a gyakorlatban elhanyagolható az eltérés.

13


2.2.5. Polár-vágaton alapuló halmaz-interpoláció (FEAT-p) A módszert Johanyák vezette be [6]. Ez a módszer polár koordinátákat használ. Ehhez bevezeti a polár vágat fogalmát ami egy halmaz pontját egy poláris szög és egy poláris távolság együtteseként ír le. A halmazokat els® lépésként eltolja úgy, hogy a referencia pontjuk egybeessen. Ezután az új halmaz úgy adódik, hogy a halmazokat adott szögben számított polár vágatainak súlyozott átlagát vesszük. Majd az ,így kapott eredményt az eltolások súlyozott átlagával visszatolja az eredményt.

2.7. ábra. Polár vágatok

14

2.3. Szempont rendszer

2.3. Szempont rendszer Mivel az eljárások többsége nem vagy vagy hibásan m¶ködik bizonyos esetekre, így érdemes egy szempontrendszert felállítani, mely alapján lehetséges osztályozni, besorolni az interpolációs módszereket. Ez sokban segítheti a leend® felhasználók döntését, hogy az adott eljárás megfelel-e számukra és a hibák ne az alkalmások futtatása során jelentkezzen, illetve ha mégis ezekre fel tudják készíteni azt.

inputdimenziók kezelése:

A legtöbb eljárás csak egydimenziós esetek kezelésére lett

kialakítva bár többségük Minkowski távolságok alkalmazásával kiterjeszthet® többdimenziós esetekre is.

szabályok alakja:

Az eljárások többsége csak meghatározott formájú fuzzy halmazok

esetén képes m¶ködni.

szabályok magassága:

Az legtöbb eljárás nem képes különböz® magasságú fuzzy

halmazok kezelésére.

szabályok helyzete:

Az interpolációs eljárások túlnyomó része csak akkor képes szá-

molni, ha van legalább 2 szabály mely közrefogja a meggyelésünket.

az eredmény hibás formája:

Sok módszer esetén a következmény halmaz nem sza-

bályos fuzzy halmaz. Módszerek

input

szabályok

eltér®

ma-

neve

dimenziók

alakja

gasságú

szabályok

mindig

helyzete

szabályos

szabályok

következményhalmaz

KH

Minkowski

CNF

nincs

legalább

2

nem

2

nem

2

igen

2

igen

2

igen

2

igen

2

igen

2

nem

2

nem

közrefogó VKK

Minkowski

CNF

nincs

legalább közrefogó

CRF

Minkowski

CNF

nincs


MACI

Minkowski

NF

nincs


IMUL

több

di-

CNF

nincs

menzió FIVE

több

közrefogó di-

menzió SCM

több

Háromszög

nincs

szingleton di-

konvex

több


igen

menzió ST

legalább


di-

menzió

konvex,

igen

nem szing-


leton FEAT-p

több menzió

di-

tetsz®leges

igen


15

2.4. Javaslatok a szempontrendszer kezelésére

2.4. Javaslatok a szempontrendszer kezelésére

input dimenziók problémája:

Ezek ellen®rzése egyszer¶ a FIS le tartalmazza, hány

input dimenziót tartalmaz a rendszer. Továbbá a legtöbb rendszer Minkowski távolságok alkalmazásával kiterjeszthet® több dimenzióra. Amennyiben a módszer egyáltalán nem alkalmas több dimenzióra akkor az input dimenzióinak ellen®rzésével a hibás futás megel®zhet®.

eltér® magasságok:

Ha az eljárás csak normált fuzzy halmazok esetén alkalmazható,

abban az esetben ellen®rizni kell, hogy a halmaz törésponjai közül legalább az egyik

y=1

értéket vesz fel.

szabályok alakja:

Amennyiben a módszer csak bizonyos formájú halmazokra alkal-

mazható, akkor (például: trapéz, háromszög, szingleton) ez könnyen ellen®rizhet® a FIS fájl beolvasásakor illetve adatainak feldolgozásánál mivel tárolja az alakzat formáját. A halmaz konvexitásának ellen®rzéséhez meg kell keresni a halmaz lokális maximum pontjait. Amennyiben csak 1 lokális maximuma van vagy ez a mag, de abból csak 1 van akkor a halmaz konvex. Ehhez meg kell keresni az els® olyan

yi >= yi+1 . Amennyiben ez yi = yi+1 = 1 akkor a lokális maximumot yj > yj+1 (j > i) pontot. Ha yi = yi+1 ̸= 1 akkor máris tudjuk, hogy nem konvex a halmaz. Ezt követ®en olyan pontot keresünk, melyre igaz, hogy yk < yk+1 (k > j ) amennyiben ilyen pontot ahol

tároló változót megnöveljük egyel és megkeressük az

pontot találtunk a halmaz nem konvex.

Szabályok helyzete:

Amennyiben a módszer csak akkor m¶ködik ha van legalább

2 olyan szabály mely közrefogja a meggyelést, akkor az eljárástól függ®en kell ellen®rizni a fuzzy rendszert. Amennyiben az eljárás referencia pontokat használ, akkor ki kell számolni a halmazok referencia pontjait, majd ellen®rizni, hogy

RP xi < RP xo bs valamint, hogy Amennyiben az eljárás α-vágat alapú ak-

létezik-e egy olyan pont amelyre igaz, hogy létezik-e egy

RP xj > RP xo bs

pont.

kor, ellen®rizni kell, hogy létezik-e egy olyan halmaz, melyre igaz, hogy az összes

α-vágat

mentén a meggyelést®l vett el®jeles távolság negatív. Valamint ellen-

®rizni kell, hogy létezik-e legalább egy olyan halmaz, melyre igaz, hogy az összes

α-vágat

mentén a meggyelést®l vett el®jeles távolság pozitív.

a hátránya, hogy ezeknek a számítások úgyis elvégzésre kerülnek az interpolációs eljárás során, így amennyiben kivételt dob a rendszer erre fel lehet készülni.

Szabályos következményhalmaz:

Mivel a különböz® eljárások eltér®en számolnak,

így nem lehet a számítás elvégzése el®tt ellen®rizni, hogy milyen eredményt fogunk kapni, csakis utólag tudjuk ellen®rizni, úgy, hogy ellen®rizzük, hogy az összes töréspont növekv® sorrendbe rendezett-e.

xi < xi + i 0 < i < n − 1

ahol

n

a

halmaz töréspontjainak száma.

Referencia pont:

Egy halmaz azon pontja, mely kitüntetett szerepet kap általában a

távolságok számítása során kap szerepet kiválasztása többféle képen is történhet.

16

3. fejezet Módszerek elemzése

A felhasználók számára fontos információ lehet az eljárások id®bonyolultsága mivel különböz® programok rendszerek esetén lehet, hogy a sebesség sokkal fontosabb mint a pontosság, valamint hasonló pontosságú és megbízhatóságú eljárások közül is lehetnek eltér® futásidej¶ek. Egy algoritmus id®bonyolultsága az input méretének monoton függvénye. Erre leggyakrabban a nagy ordó-t (O(g(n))) használják amely egy fels® becslést mond a függvény id®bonyolultságára.

f (n) függvény növekedési rendje: O(g(n)), ha létezik olyan n0 probléma küszöbméret, hogy ha n a probléma mérete egyenl® a küszöbmérettel, vagy annál nagyobb, akkor az f (n) függvényérték nemnegatív és a g(n) függvényérték c konstans szorosától nem nagyobb. Azt mondjuk, hogy az

pozitív

c

konstans és pozitív

f (n) = O(g(n)),

ha

∃c > 0

és

n0 > 0,

hogy

∀

minden

n ≥ n0

esetén

0 ≤ f (n) ≤ cg(n)

A módszerek elemzéséhez az implementált módszereket, sorról sorra végig követtem, így megkaptam a függvények ciklikus bonyolultságát, mely jól közelíti a módszerek id®igényét.

3.1. A KH módszer id®bonyolultságának elemzése

3.1.1. Konstruktor A konstruktor függvény gy¶jti ki a KH algoritmus futása során felhasznált adatokat, majd ezeket struktúrákba rendezi. A konstruktor végig nézi az összes input partíciót. Minden partícióban végignézi a tartalmazott szabályokat. Ezeknek a halmazoknak az x és y pontjait valamint a nevét és formáját letárolja.

pin : az input particiók száma, mini : az i-edik paricióban lév® halmazok száma, nini,j : az i-edik parició j -edik halmazának töréspontjainak

száma

∑∑ O( (2 ∗ nini,j )) pin mini

i=1 j=1

17


Majd ugyan ezt elvégzi az output dimenziókra is.

pout : az output particiók száma, mouti : az i-edik paricióban lév® halmazok száma, nouti,j : az i-edik parició j -edik halmazának töréspontjainak

száma

pout mouti ∑ ∑ (2 ∗ nouti,j )) O( i=1 j=1 Végül kigy¶jti az összes szabályt és letárolja. Ez száma:

O(p)

lépés, így a konstruktor lépés-

pout mouti pin mini ∑ ∑ ∑ ∑ (2 ∗ nouti,j ) + p) (2 ∗ nini,j ) + O( i=1 j=1

i=1 j=1 Azonban az

O(p)

tag nem befolyásolja jelent®sen a függvényt.

3.1.2. getAlphaLevelsFromParams Töréspontok esetén kigy¶jti egy változóba a töréspontok pozícióját, hogy minden egyes töréspontban lehessen

α-vágatot

számolni. Ehhez egy ciklus végig megy az összes in-

put partíción és el®ször a partícióhoz tartozó meggyelések töréspontjainak y pozícióit ∑p gy¶jti ki. Ez O( i=1 ni ) lépés ahol pin az input partíciók száma, ni az i-edik partícióhoz tartozó meggyelés töréspontjainak száma. Ezt követ®en az antecedenseinek y pozícióit is belerakja. Ez:

pin mini ∑ ∑ O( (nini,j ))ahol i=1 j=1


száma

Majd a konzekvens partíciók halmazainak töréspontjait is belerakja a változóba. Ez

pout mouti ∑ ∑ O( (2 ∗ nouti,j ))ahol i=1 j=1

pout : az output particiók száma, mouti : az i-edik paricióban lév® halmazok száma, nouti,j : az i-edik parició j -edik halmazának töréspontjainak Végül pedig az egybe es®

α-vágatokat

száma

eltávolítja a változóból. Ez további:

pout mouti pin mini pin ∑ ∑ ∑ ∑ ∑ O( (2 ∗ nouti,j ) + (nini,j ) ∗ ni ) i=1 j=1

i=1 j=1

i=1

lépés. Így összesen

pout mouti pin mini pin ∑ ∑ ∑ ∑ ∑ O(2 ∗ ( (2 ∗ nouti,j ) + (nini,j ) ∗ ni )) i=1 j=1

i=1 j=1

i=1

lépést tesz a függvény.

18


3.1.3. acutsFromParams A függvény kiszámolja egy halmaz

α-vágatok

menti inmumait és szuprémumait. Tra-

péz, háromszög, és singleton esetén a függvény futásideje

O(n) ahol

n

az

α-vágatok

száma. Míg poligonok esetén a függvény futásideje

O(n ∗ m) ahol

n

az

α-vágatok

száma,

m

pedig a halmaz töréspontlainak száma. Erre azért van

szükség, mert ki kell keresni, mely két törés pont között helyezkedik el az adott

α-vágat.

3.1.4. getAllaCuts Ez a függvény számítja az összes halmaz összes

α-vágat

menti inmumait és szupré-

mumait. Ehhez az acutsFromParams függvényt használja fel ami a legrosszabb esetben, így

z

darab halmaz esetén ahol

z

O(n ∗ m)

futásidej¶

tartalmazza az összes input

és output partíció valamint a meggyelések halmazait is, a függvény lépésszáma a legrosszabb esetben

O(n ∗ m ∗ z).

3.1.5. NearestTwoRules A függvény megkeresi a meggyeléshez legközelebbi atecedenst. Ehhez az összes antecedens halmazhoz ki kell számolni az összes

α-vágat

mentén a

távolságokat minden egyes partícióban. Ehhez

p ∑ O(( ni ) ∗ m) i=1 lépés szükséges. Ahol

m

az

α-vágatok

száma

p

a partíciók száma

ni

pedig az i-edik

partíció antecedenseinek száma. Ezek után a partícióban ellen®rizni kell, hogy mely halmazok alsó illetve fels® távolságai összese megel®zi-e a meggyelés halmazt, azaz minden távolság érték negatív-e. Így eldönthetjük, hogy bal oldi antecedens-e. Ez

O(n ∗ m ∗ p) lépés. Hasonlóan ellen®rizni kell, hogy jobb oldali-e az adott antecedens. Szintén

O(n ∗ m ∗ p) lépés. Ezek után már a partícióktól függetlenül kiválasztja a legközelebbi jobb és bal oldali szabályt. Ehhez végigkell nézni az összes szabályt és a szabályt az összes szabállyal össze kell hasonlítani. Ez

O((n ∗ p)2 ∗ m) lépést igényel mind a jobb mind a bal oldali antecedens kiválasztásakor. Így a függvény lépésszáma

O((n ∗ m ∗ p) + O((n ∗ p)2 ∗ m)) mivel az

O((n ∗ p)2 ∗ m)) jóval nagyobb léptékben növekszik, mint az O((n ∗ m ∗ p), így

az elhagyható.

19

3.2. A MACI módszer id®bonyolultságának elemzése

3.1.6. interpolate Ez a függvény végzi el magát a KH interpolációt, és tér vissza a becsült következmény halmazzal. Els® lépésben a paraméterén keresztül megkapott meggyeléseinek az adatait gy¶jti ∑p ki struktúrákba. Ez O( i=1 ni ) ahol p a meggyelés partíciók száma. ni pedig az i-edik partíció meggyelésének töréspontjainak száma. Ezután elágazás következik attól függ®en, hogy a felhasználó a töréspontok mentén

α-vágat alapján szeretne interpolálni. Amennyiszámú α-vágat esetén egyenletes távolságra elhelyezett

vagy a felhasználó által deniált számú ben a felhasználó által deniált

α-vágattal

tölti fel a változót, míg a töréspontok esetén a getAlphaLevelsFromParams

függvényt használja aminek a futásideje:

pout mouti pin mini pin ∑ ∑ ∑ ∑ ∑ O(2 ∗ ( (2 ∗ nouti,j ) + (nini,j ) ∗ ni )) i=1 j=1

i=1 j=1

i=1

Ezt követ®en a getAllaCuts következik ami O(n∗m∗z) futásidej¶. Majd a NearestTwo2 Rules hívása következik O((n ∗ p) ∗ m)) futásid®vel. Ezt követ®en pedig az α-vágatok mentén az arányok alapján kiszámítja a következményhalmaz pontjait az összes output 2 partícióra. Ez O(p ∗ m) id® bonyolultságú. Ezek közül az O((n ∗ p) ∗ m)) id®bonyolultsága a legnagyobb, így ez fogja meghatározni a függvény növekedését.


3.2.1. konstruktor Ennek a függvénynek a feladata az eljárás során használt struktúrákat inicializálni. A konstruktor végig nézi az összes input partíciót. Minden partícióban végignézi a tartalmazott szabályokat. Ezeknek a halmazoknak az x és y pontjait valamint a nevét és formáját letárolja.


száma

∑∑ O( (2 ∗ nini,j )) pin mini

i=1 j=1 Majd ugyan ezt elvégzi az output dimenziókra is.

pout : az output particiók száma, mouti : az i-edik paricióban lév® halmazok száma, nouti,j : az i-edik parició j -edik halmazának töréspontjainak

száma

∑∑ O( (2 ∗ nouti,j )) pout mouti

i=1 j=1 Végül kigy¶jti az összes szabályt és letárolja. Ez száma:

O(p)

lépés, így a konstruktor lépés-

pin mini pout mouti ∑ ∑ ∑ ∑ O( (2 ∗ nini,j ) + (2 ∗ nouti,j ) + p) i=1 j=1

i=1 j=1 20


Azonban az

O(p)

tag nem befolyásolja jelent®sen a függvényt.

3.2.2. setRP A setRP feladata, hogy kiszámítsa egy adott tagsági függvény referencia pontját. Ezt több féle képen számíthatja a referencia pont eshet a magközéppontjába, veheti a töréspontok koncentrálódásának központját, továbbá a halmaz teljes szélességének középpontját. Ezek kiszámítása trapéz háromszög és szingleton esetén:

O(1)

3.2.3. getFlanks Ennek a függvények feladata kiszámítani a halmaz tartóit. A jobboldali tartó a referenciapont utáni törések pozíció a baloldali tartó pontjai a referencia pont el®tti töréspontok koordinátái. Ennek ciklikus bonyolultsága

O(m) Ahol

m

a töréspontok vagy pedig az

α-vágatok

száma.

3.2.4. localRefPointsLeftFlanksRightFlanksALevels A localRefPointsLeftFlanksRightFlanksALevels függvény feladata, hogy kigy¶jti a jobb és bal oldali tartókhoz tartozó

α-vágatokat.

Ehhez végig kell néznie az összes partíció,

összes meggyelésének összes töréspontját és ezeket letárolja. Ennek id®bonyolultsága:

p : a particiók száma, mi : az i-edik paricióban lév® halmazok száma, ni,j : az i-edik parició j -edik halmazának töréspontjainak O(

p mi ∑ ∑

száma

(ni,j )

i=1 j=1

3.2.5. acutsFromParams A függvény kiszámolja egy halmaz

α-vágatok

menti inmumait és szuprémumait. Tra-

péz, háromszög, és singleton esetén a függvény futásideje

O(n) ahol

n

az

α-vágatok

száma. Míg poligonok esetén a függvény futásideje

O(n ∗ m) ahol

n

az

α-vágatok

száma,

m

pedig a halmaz töréspontlainak száma. Erre azért van

szükség, mert ki kell keresni, mely két törés pont között helyezkedik el az adott

α-vágat.

21


3.2.6. cut2params Ennek a függvénynek a feladata sorba rendezni a pontokat megel®zve, hogy hibás eredményhalmazt kapjunk, ez a halmaz készíti fel az eredmény halmazt a visszatérésre. Els® lépésben növekv®sorrendbe rendezi az

α-vágatokat.

Majd az

α-vágatok

mentén

vett kiszámított töréspontokat feltölti. Ebb®l következ®en a függvény futásideje

O(m) ahol

m

a töréspontok száma.

3.2.7. interpolate Els® lépésként feldolgozza a meggyelést. Kiszámítja a referenciapontját, majd a tartók adatait is eltárolja végül pedig berakja az Ennek id®igénye:

α-vágatok közé a töréspontjainak magasságát.

p ∑ mi ) O( i=1

ahol

p

a partíciók száma

mi

pedig az

i-edik

partíció töréspontjainak száma.

Ezt követ®en a localRefPointsLeftFlanksRightFlanksALevels függvény a tartók adatait számítja ki az input és output particiókra.

p : az input és output particiók száma, mi : az i-edik paricióban lév® halmazok száma, ni,j : az i-edik parició j -edik halmazának töréspontjainak p mi ∑ ∑ (2 ∗ ni,j )) O(

száma

i=1 j=1 Ezt követ®en eltávolítja az ismétl®déseket az be mivel sorbarendezi az

α-vágat-okat

α-vágatokat. Ez O(n2 ) id®t vesz igény-

és az egymást követ® ismétl®déseket eltávolítja.

Következ® lépésben kiválasztja a két legközelebbi jobb és bal oldali antecedns halmazt. ∑p Ez O( i=1 mi ) ahol p az input partíciók száma és mi az i-edik partíció antecedenseinek száma. Az szuprémumok és inmumok feltöltése.

pin mini ∑ ∑ O( (nini,j ))ahol i=1 j=1


száma

Ezt követ®en a két közrefogó halmaz és a meggyelés jobb és baloldali tartóinak súlyozott távolságát számítja ki. Ezt követ®en megtörténik az új dimenzióba való át2 transzformálás melynek id®bonyolultsága O(m ) ahol m a vágatok száma. Végül pedig

22


következik az output dimenziók következmény halmazainak kiszámítása. Ennek id®bonyolultsága:

O(

pout ∑

αL2i + αUi2 ))

i=1

pout a kimen® dimenziók száma αL : az i-edik patició baloldali tartóinak α-vágatainak száma αR : az i-edik patició jobboldali tartóinak α-vágatainak száma (3.1) A gyakorlatban az

α-vágatok

száma csekély, így túlnyomó részt az input parciális

és az antecedensek és konzekvensek száma befolyásolja az eljárás id® bonyolultságát.

23

3.4. Módszerek id®igényének mérése a gyakorlatban

3.3. Google Test Az fejlesztés alatt álló szoftverr®l fontos meggy®z®dni, hogy helyesen számol, illetve a szoftver leend® felhasználói is tájékozódhatnak ezek alapján mind a szoftver megbízhatóságáról. Valamint mivel a legtöbb eljárás bizonyos inputok esetén szabálytalan fuzzy halmazt eredményezhet, így a tesztek alapján a leend® felhasználók felkészülhetnek milyen esetekben kell helytelen eredményre számítaniuk. Továbbá az egyes eljárások egymáshoz viszonyított futásidejér®l is informálódhatnak. Ezért szükséges egy teszt keretrendszer használata. A választás a Google Test-re [9] esett mivel

•

alkalmas C++ kódok tesztelésére

•

támogatja a 3 f® operációs rendszert (Windows, Linux, Mac)

•

a teszt esetek elkülönülnek a forráskódtól, így az átlátható marad

•

a teszt nem áll meg az els® hibánál hanem tovább lép a következ® tesztre

•

a teszt esetek elkülönülnek egymástól, így könnyen kideríthet® melyik tesztnél következett be hiba

•

a keretrendszer automatikusan nyomon követi az összes deniált tesztet, így azokat nem szükséges összegy¶jteni, vagy egyesével futtatni

•

a keretrendszer gyorsan m¶ködik

•

ingyenes

•

az alapok pár perc alatt eltanulhatók

3.4. Módszerek id®igényének mérése a gyakorlatban A módszerek méréséhez a google tesztet használtam, mivel ez a tesztkörnyezet nem csak a függvények megbízhatóságáról, helyes m¶ködésér®l tud információt adni, hanem az egyes tesztesetek futás idejér®l is képes információt nyújtani.

3.1. ábra. Teszt 50 antecedens esetén

24





25



3.6. ábra. Teszt 300 antecedens esetén A teszteket 50 100 150 200 250 és 300 elem¶ egydimenziós input és output rendszerrel végeztem el. A teszteléshez trapéz formájú konvex normál fuzzy halmazokat használtam, mivel ezekkel minden eljárás képes dolgozni. Az halmazokat a program kód generálja, mind az input mind az output dimenzió halmazai egymástól egyenletes távolságra helyezkedtek el. Az

Ai -edik

antecedenshez a

Bi -edik

konzekvens tartozik. A

tesztek alapján jól meggyelhet®, hogy az eljárások id®igénye az input halmazok számával négyzetes összefüggésben van. A jobb átláthatóság érdekében (3.4. ábra) grakonon is összegezve vannak az adatok.

26


3.5. A Google teszt felépítése Az alábbiakban látható egy példa a Google teszt m¶ködésére, felépítésére. Ez a teszt méri a KH alagoritmus futásidejét. A teszt egy külön fájlban található a kódtól függetlenül. A tesztet a RUN_ALL_TESTS(); parancs keresi ki és hívja meg az összes többi tesztel együtt. Az eredmény egy konzol ablakban jelenik. Amennyiben sikeresen lefut a teszt abban az esetben zöld színnel kiírt OK felirat jelzi. Amennyiben a futás során nem várt kivétel keletkezett az adott teszt futását megszakítja, illetve amennyiben nem a várt eredmények adódtak, akkor piros FAIL felirat jelzi a sikertelenséget. Ezentúl a teszt futás idejét is leméri és kiírja. 1

TEST( S p e e d t e s t , KH_speed_test )

{

A TEST argumentumában két adatot kell megadni. Az els® a teszt gy¶jt®címe. A tesztek csoportosítva kerülnek lefutásra és amennyiben azonos a nevük a egy csoportban kiértékelésre kerül, hogy az összes tesztb®l, mennyi futott le sikeresen. Valamint az összes a csoportban lév® teszt lefutásának idejér®l is információt kapunk. A második argumentum pedig az adott teszteset elnevezése. 2

try {

3

const

4

stringstream

5

fis

int

<<

n= s i z e ; fis ;

" [ S y s t e m ] " <<

endl

6

<<

"Name= ' S p e e d t e s t ' " <<

7

<<

" Type = ' S p a r s e ' " <<

8

<<

" V e r s i o n = 2 . 0 " <<

endl

9

<<

" NumInputs=1" <<

endl

10

<<

" NumOutputs=1" <<

11

<<

" NumRules=1" <<

12

<<

" AndMethod = ' ' " <<

13

<<

" OrMethod = ' ' " <<

14

<<

" ImpMethod = ' ' " <<

endl

15

<<

" AggMethod = ' ' " <<

endl

16

<<

" D e f u z z M e t h o d = 'COG ' " <<

17

<<

endl

18

<<

" [ I n p u t 1 ] " <<

19

<<

"Name= ' i n p u t 1 ' " <<

20

<<

" Range =[ "<<

21

<<

"NumMFs="<< n <<

for ( int

23

fis

<< }

25

fis

endl endl

<<

endl

"MF" <<

i

"<<

<<

"Name= ' o u t p u t ' " <<

28

<<

" Range =[ "<<

29

<<

"NumMFs="<< n <<

for ( int

31

fis

<<

<<

−n/2+ i + 0 . 0 −n/2+ i + 1 . 0 <<" ] ! [ 0

1

−n/2+ i + 0 . 0 −n/2+ i + 1 . 0 <<" ] ! [ 0

1

<<" 1

"<< 0] "

endl "<
endl

endl ;

i = 1 ; i <=n ; i ++){

<<

"MF" <<

−n/2+ i + 0 . 3

<<

"<<

endl

−n/2<<"

30

fis

<<"

endl

27

34

−n/2+ i + 0 . 6

endl ;

" [ O u t p u t 1 ] " <<

33

endl

<<" = 'A_{ 1 ; "<
<<"

<<

}

endl "<
endl ;

26

32

endl

i = 1 ; i <=n ; i ++){

<<

−n/2+ i + 0 . 4

24

endl

endl

−n/2<<"

22

endl

endl

i

<<" = 'B_{ 1 ; "<
<<"

"<<

−n/2+ i + 0 . 5

<<"

"<<

<<" 1

"<< 0] "

endl ;

endl

endl

27


35

<<

endl

36

<<

" [ R u l e s ] " <<

37

for ( int

38

fis

39

endl ;

i = 1 ; i <=n ; i ++){

<< i

<<" ,

"<< i

<<"

(1)

:

1 " <<

endl ;

}

A teszt els® lépésként generál egy FIS stringstream-et ami a fuzzy rendszer adatait tárolja. A rendszer egy input partícióból és egy output partícióból áll. A partícióban a tagsági függvények trapéz alakúak és egymástól 1 egység távolságra helyezkednek el. 40

stringstream

41

o b s <<

42

<<

"ObsName= ' O b s e r v a t i o n _ 1 ' " <<

43

<<

" [ O b s e r v a t i o n ] " <<

44

<<

"OBS1= 'A _1 ' : ' t r i m f ' , [

obs ;

" NumInputs=1" <<

endl

∗

45

∗ sys

46

CSystem

47

CObservation

=

−0.4

0.0

CFISFile : : readFIS (

c_obs

endl

endl 0.4]![0

fis

1

0 ] " <<

endl ;

) ;

= COBSFile : : readOBS (

obs

) ;

Ezt követ®en beállítja a meggyelést. 48

CKH KH = CKH(

49

string

50

sys

) ;

param=" A l p h a L e v e l s _ T y p e=u s e r d e f i n e d&A l p h aL e v e l s _ N u m Of a C u t s=5" ;

KH. i n i t ( param ) ;

Megadja az inti függvényben, hogy milyen paraméterek mellett fusson le majd az interpolációs eljárás. Ebben az esetben a felhasználó által meghatározott pontokban fogja számítani az

α-vágatokat.

51

KH. i n t e r p o l a t e (

52

} c a t c h ( CFRIException

53

cout

<<

Ebben az esetben pedig 5

c_obs

α-vágat

mentén fog számolni.

) ; ex ) {

ex . getMessage ( ) ;

Amennyiben kivétel keletkezett a futás során kiírja a kivételhez tartozó hibaüzenetet. 54 55

} }

Mivel a teszt a sebesség mérésére van kialakítva, így az eredmények ellen®rzése nem szerepel benne. Amennyiben az eredményeket is szeretnénk ellen®rizni a legtöbb esetben az alábbi parancsok használhatóak: Ellen®rzés típusa:

fatális hiba

nem fatális hiba

egyenl®ség:

ASSERT_EQ(val1, val2);

EXPECT_EQ(val1, val2);

nem egyenl®ség:

ASSERT_NE(val1, val2);

EXPECT_NE(val1, val2);

kisebb mint:

ASSERT_LT(val1, val2);

EXPECT_LT(val1, val2);

kisebb vagy egyenl®:

ASSERT_LE(val1, val2);

EXPECT_LE(val1, val2);

nagyobb mint:

ASSERT_GT(val1, val2);

EXPECT_GT(val1, val2);

nagyobb vagy egyenl®:

ASSERT_GE(val1, val2);

EXPECT_GE(val1, val2);

28


A különbség az ASSERT és EXPECT között, hogy ha az ASSERT hibás eredményt érzékel, akkor az adott teszt futtatása meg is áll, míg az EXPECT esetén tovább fut a teszt és a végén a konzol ablakban láthatjuk mely eredmények vizsgálatánál volt hiba.

29

4. fejezet Fejleszt®i dokumentáció

4.1. A KH eljárás során felhasznált struktúrák 1

typedef

2

string

3

int

4

}

=s t r u c t { Type ;

NumOfaCuts ;

t_AlphaLevels ;

t_AlphaLevels: az alfa vágatok számításához szükséges adatokat tároló struktúra. Type: egy szöveges típus értéke lehet "brakepoints" vagy "userdened". "brakepoints" esetében a töréspontokban számolja az alfa vágatokat. "userdened" esetében egyenletesen felosztja az intervallumot a felhasználó által meghatározott alfa vágatra. NumOfaCuts: az alfa vágatok számát tárolja.

1

typedef

=s t r u c t {

2

string

3

t_AlphaLevels

4

int

5

}

InterpolationType ; AlphaLevels ;

w;

t_params ;

t_params: az interpolációs eljáráshoz szükséges paramétereket tároló struktúra. InterpolationType: az interpolációs módszer típusa. Ez esetben "KH" AlphaLevels: az

α-vágatok

adatait tároló struktúra.

w: a súlyozás.

1

typedef

=s t r u c t {

2

v e c t o r

antecedent ,

3

int

connection ;

4 5

weight ,

v e c t o r dL , }

consequent ;

dU ;

t_rule ;

t_rule: egy dimenzió szabályait leíró objektum. antecedent: az antecedensek azonosítói.

30

4.1. A KH eljárás során felhasznált struktúrák

consequent: a konsekvensek azonosítói. weight: sújozás. connection: kapcsolatok dL: alsó távolságok dU: fels® távolságok

1

typedef

=s t r u c t {

2

string

name ;

3

string

type ;

4

v e c t o r

5

}

params ,

params ,

inf ,

sup ,

dL ,

dU

t_mf ;

t_mf: egy tagsági függvény (membership function) adatait leíró struktúra. P l. : A{ 1, 1} singlmf, trimf, trapmf .

name: az adott tagsági függvény elnevezése type: a tagsági függvény típusa

params: az adott tagsági függvény pontjainak az abszcisszái. paramsy: az adott tagsági függvény pontjainak ordinátái. inf: az adott tagsági függvény inmumai. sup: az adott tagsági függvény szuprémumai. dL: a függvény meggyelést®l vett alsó távolságai. dU: a függvény meggyelést®l vett fels® távolságai.

1

typedef

=s t r u c t {

2

string

name ;

3

double

range [ 2 ] ;

4

v e c t o r mf ;

5

}

t_partition ;

t_partition: Az egyes partíciók vagy más néven dimenziók adatait tároló struktúra. Mind a bemeneti adatok dimenziója, mind a következmény adatok dimenzióit ez a struktúra tárolja name: a partíció neve.

P l. : Input1

range: az adott partíció két széls® értékét tároló tömb. A határokon túllógó meggyelések a határoknál el lesznek vágva. mf: a particióhoz tartozó tagsági függvények adatait tároló adatszerkezet.

1

typedef

=s t r u c t {

2

v e c t o r

3

v e c t o r

4 5

v e c t o r }

input ,

output ;

aCuts ;

leftrules ,

rightrules ;

t_fis ;

t_s: a teljes FIS fájl adatait tároló struktúra. Ebben található az összes bemen® és következmény partíció, az

α-vágatok információ, valamint a jobb és bal oldali szabályok 31

4.2. Konstruktor

azonosítói. input: a bemen® adatok partícióit tárolja. output: a következmények partíciót tárolja. aCuts: az alfa vágatok adati. leftrules: a bal oldali szabályok azonosítóit tárolja. rightrules: a jobb oldali szabályok azonosítóit tárolja.

1

typedef

=s t r u c t {

2

string

3

v e c t o r mf ;

4

}

name ;

t_obs ;

t_obs: a meggyelés adatait tároló struktúra. name: a meggyelés elnevezése.

P l. : Observation1

mf: a meggyeléseket jellemz® tagsági függvényeket tárolja.

4.2. Konstruktor A KH osztály az FRIMethode osztályból van származtatva amely az összes egylépéses metódus vázát alkotó osztály. A konstruktor egy CSystem típusú osztályt kap paraméterként. A konstruktor feladata az interpolációs eljárás során felhasználandó adatok kigy¶jtése, tárolása. A konstruktor els® lépés ként kigy¶jti az input partíciók adatait. Feltölti a t_partition struktúrába a partíciók nevét, majd a partíció határait. Ezt követ®en egy ciklus eltárolja az összes információját és belerakja a t_partition struktúrába. A halmazoknak a nevét x és y pozícióit valamint, a halmaz formáját (típusát) tárolja le. Majd a partíció adatait az m_s struktúrába tárolja. Ezt követ®en ugyan ezt elvégzi a konzekvensek particióira is. 1

CKH : : CKH( CSystem

2

t_partition

3

t_mf

4

for ( int

∗ sys )

:

CFRIMethod ( s y s ) {

part ;

mf ;

−>I n p u t . s i z e ( ) ; i ++){ −>I n p u t [ i ] . getName ( ) ; p a r t . r a n g e [ 0 ] = s y s −>I n p u t [ i ] . g e t R a n g e ( ) [ 0 ] ; p a r t . r a n g e [ 1 ] = s y s −>I n p u t [ i ] . g e t R a n g e ( ) [ 1 ] ; for ( int j = 0 ; j <s y s −>I n p u t [ i ] . getMFs ( ) . s i z e ( ) ; j ++){ mf . name = s y s −>I n p u t [ i ] . getMFs ( ) [ j ] . getName ( ) ; mf . p a r a m s = s y s −>I n p u t [ i ] . getMFs ( ) [ j ] . x T o V e c t o r ( ) ; mf . p a r a m s y = s y s −>I n p u t [ i ] . getMFs ( ) [ j ] . y T o V e c t o r ( ) mf . t y p e = s y s −>I n p u t [ i ] . getMFs ( ) [ j ] . g e t T y p e ( ) ;

5

i =0;

p a r t . name =

6 7 8 9 10 11 12 13

i <s y s sys

p a r t . mf . push_back (

mf

14

}

15

m _ f i s . i n p u t . push_back (

16

p a r t . mf . c l e a r ( ) ;

17

;

) ;

part

) ;

}

A konstruktor els® lépés ként kigy¶jti az input partíciók adatait. Feltölti a t_partition struktúrába a partíciók nevét, majd a partíció határait. Ezt követ®en egy ciklus eltárolja

32

4.3. acutsFromParams

az összes információját és belerakja a t_partition struktúrába. A halmazoknak a nevét x és y pozícióit valamint, a halmaz formáját (típusát) tárolja le. Majd a partíció adatait az m_s struktúrába tárolja.

−>Output . s i z e ( ) ; i ++){ −>Output [ i ] . getName ( ) ; p a r t . r a n g e [ 0 ] = s y s −>Output [ i ] . g e t R a n g e ( ) [ 0 ] ; p a r t . r a n g e [ 1 ] = s y s −>Output [ i ] . g e t R a n g e ( ) [ 1 ] ; for ( int j = 0 ; j <s y s −>Output [ i ] . getMFs ( ) . s i z e ( ) ; j ++){ mf . name = s y s −>Output [ i ] . getMFs ( ) [ j ] . getName ( ) ; mf . p a r a m s = s y s −>Output [ i ] . getMFs ( ) [ j ] . x T o V e c t o r ( ) ; mf . p a r a m s y = s y s −>Output [ i ] . getMFs ( ) [ j ] . y T o V e c t o r ( ) mf . t y p e = s y s −>Output [ i ] . getMFs ( ) [ j ] . g e t T y p e ( ) ;

18

for ( int

19

i =0;

i <s y s

p a r t . name =

20 21 22 23 24 25 26 27

sys

p a r t . mf . push_back (

mf

28

}

29

m _ f i s . o u t p u t . push_back (

30

p a r t . mf . c l e a r ( ) ;

31

;

) ;

part

) ;

}

Ezt követ®en ugyan ezt elvégzi a konzekvensek partícióira is. 32

t_rule

33

for ( int

rule ;

−>R u l e . s i z e ( ) ; i ++){ = s y s −>R u l e [ i ] . g e t I n p u t s I n d e x ( ) ; . c o n s e q u e n t = s y s −>R u l e [ i ] . g e t O u t p u t s I n d e x ( ) . c o n n e c t i o n = s y s −>R u l e [ i ] . g e t C o n n e c t i o n ( ) ; . w e i g h t = s y s −>R u l e [ i ] . g e t W e i g h t ( ) ; i =0;

i <s y s

34

rule . antecedent

35

rule

36

rule

37

rule

38

m_rule . push_back (

39

rule

;

) ;

}

40 41

m_params . I n t e r p o l a t i o n T y p e

42

m_params . A l p h a L e v e l s . Type =

43 44

m_params . w =

=

"KH" ;

" brakepoints " ;

2;

}

Végül pedig a szabályokat is letárolja, és beállítja az alapértelmezett interpolációs beállításokat azaz, hogy az interpoláció típusa KH a töréspontokban számolja az

α-vágatokat

és a súlyozás értéke 2.

4.3. acutsFromParams Az acutsFromParams függvény feladata kiszámolni a halmazok inmumát és szuprémumát az összes

α-vágat

mentén. Jelenleg a módszer singleton háromszög és trapéz

halmazok kezelésére képes. Amennyiben ett®l eltér® alakzatot tartalmaz a rendszer akkor kivételt dob. A függvény a paraméterében egy tagsági függvényt tároló struktúrát kap meg. 1

void

CKH : : a c u t s F r o m P a r a m s ( t_mf

2

int

3

string

numOfaCuts = type

∗ mf ,

double

range [ 2 ] ) {

m_fis . aCuts . s i z e ( ) ;

−

= mf >t y p e ;

4 5 6 7

if (

type

for ( int

−

== " s i n g l m f " i =0;

){

i
mf > i n f . push_back (

−

i ++){

mf >p a r a m s [ 0 ]

) ;

33


−

8

mf >s u p . push_back (

9

−

mf >p a r a m s [ 0 ]

) ;

}

Amennyiben a meggyelésünk szingleton (egyérték¶ halmaz abban az esetben nincs más dolgunk, mint az összes

α-vágat-ra

beállítani a halmaz x pozícióját, mivel az

α-

vágatok minden esetben ebben a pontban metszik. 10

} else

if (

type

== " t r i m f "

){

− − mf−>p a r a m s [ 1 ] −

− −

11

double

dpi

= mf >p a r a m s [ 1 ]

mf >p a r a m s [ 0 ] ;

12

double

dps

=

mf >p a r a m s [ 2 ] ;

13

for ( int

i =0;

− mf−> i n f mf−> i n f

14

i
15 16 17

[ i ]

=

[ i ]

=

− − mf−>s u p [

m _ f i s . a C u t s [ i ] ∗ d p s + mf−>p a r a m s [ 2 ] − min ( 0 . 0 − mf−>s u p [ i ] , 0 . 0 − r a n g e [ 0 ] ) ; min ( mf−>s u p [ i ] , range [ 1 ] ) ;


19

mf >s u p [ i ]

=

i ]

=

21

m_fis . aCuts [ i ]

) ;

0.0

18 20

i ++){

∗ d p i + mf−>p a r a m s [ 0 ] − min ( 0 . 0 − mf−> i n f [ i ] , 0 . 0 − r a n g e [ 0 ] ) ; min ( mf−> i n f [ i ] , range [ 1 ] ) ;


) ;

0.0

}

Ha a tagsági függvény alakja háromszög akkor le kell tárolni a fuzzy jellegének szélességét. Ezeket a dpi és dps változók tárolják. Majd pedig az úgy kapjuk, hogy az

α-vágat

α-vágat

menti inmumot

magasságát megszorozzuk a bal oldali és az így kapott

értéket, hozzáadjuk a halmaz bal alsó sarkának pozíciójához. Ehhez hasonlóan kapjuk a szuprémumot is csak ott a jobb oldali fuzzy jelleg szélességének (ez egy negatív szám mivel a mag x pozíciójából vonjuk a jobb alsó sarok x pozícióját) szorzatát adjuk hozzá a halmaz jobb szélének pozíciójához. Ez azért számolható így, mivel a a halmaz magassága egy 0-1 közötti érték, és a magasság egyenesen arányos a fuzzy jelleg szélességével. Pl.: ha az

α-vágat

20%-os magasságban helyezkedik el akkor a vágat a a fuzzy jelleg

szélességének 20%-ánál fogja metszeni a halmazt. Ezek után még ellen®rizni kell, hogy az adott inmum és szuprémum a partíció határai közé esik-e amennyiben nem akkor a partició végpontja keról eltárolásra a vágat pozíciója helyett. 22

} else

if (

type

== " t r a p m f "

){

− − mf−>p a r a m s [ 2 ] −

− −

23

double

dpi

= mf >p a r a m s [ 1 ]

mf >p a r a m s [ 0 ] ;

24

double

dps

=

mf >p a r a m s [ 3 ] ;

25

for ( int

i =0;

− mf−> i n f mf−> i n f

26

i
27 28 29

[ i ]

=

[ i ]

=

− − mf−>s u p [

m _ f i s . a C u t s [ i ] ∗ d p s + mf−>p a r a m s [ 3 ] − min ( 0 . 0 − mf−>s u p [ i ] , 0 . 0 − r a n g e [ 0 ] ) ; min ( mf−>s u p [ i ] , range [ 1 ] ) ;


31

mf >s u p [ i ]

=

i ]

=

33

m_fis . aCuts [ i ]

) ;

0.0

30 32

i ++){

∗ d p i + mf−>p a r a m s [ 0 ] − min ( 0 . 0 − mf−> i n f [ i ] , 0 . 0 − r a n g e [ 0 ] ) ; min ( mf−> i n f [ i ] , range [ 1 ] ) ;


) ;

0.0

}

Amennyiben a meggyelés trapéz formájú, akkor a háromszöghöz nagyon hasonlóan kell számolni. Annyiban tér el, hogy a halmaz jobb és baloldali fuzzy jellegének számolásánál a mag jobb és bal sarát kell gyelembe venni. 34

}

else

{

34


35

// throw

36

throw

37 38

CFRIException ( CFRIException : ,

" not

implemented

__LINE__,

__FILE__) ;

yet " ;

} }

4.4. getAllaCuts Ennek a függvénynek a feladata meghívni az acutsFromParams függvényt az összes partíció, összes meggyelésére, atecedensére és konzekvensére. Így az összes halmaz inmuma és szuprémuma kiszámításra kerül. 1

void

2

CKH : : g e t A l l a C u t s ( v e c t o r

for ( int

i =0;

3

acutsFromParams (

4

for ( int

5

j =0;

&o b s

−>a t ( i )

,

i ++){

m_fis . i n p u t [ i ] . r a n g e ) ;

j <m _ f i s . i n p u t [ i ] . mf . s i z e ( ) ;

acutsFromParams (

6

∗ obs ) {

i <m _ f i s . i n p u t . s i z e ( ) ;

j ++){

&m _ f i s . i n p u t [ i ] . mf [ j ] ,

m_fis . i n p u t [ i ] . r a n g e ) ;

}

7

}

8 9

for ( int

10 11

i <m _ f i s . o u t p u t . s i z e ( ) ;

j =0;

i ++){

j <m _ f i s . o u t p u t [ i ] . mf . s i z e ( ) ;

acutsFromParams (

12

&m _ f i s . o u t p u t [ i ] . mf [ j ] ,

j ++){ m_fis . o u t p u t [ i ] . r a n g e ) ;

}

13 14

i =0;

for ( int

} }

4.5. removeDuplicates A függvény feladata, hogy egy tömbb®l (vector) az összes ismétl®d® elemet eltávolítsa és az új ismétl®désmentes tömbbel térjen vissza. Ehhez el®ször rendezi az adatokat. Majd egy új tömbbe ami a visszatérési változó belerakjuk a vektor utolsó elemét. Ezt követ®en egy ciklussal végig nézzük visszafelé haladva a már rendezett tömb elmeit, hogy megegyeznek-e az ell®ttük lév® elemmel. Amennyiben eltér®ek akkor belerakjuk az újonnan létrehozott ismétl®dés mentes tömbbe. 1

v e c t o r CKH : : r e m o v e D u p l i c a t e s ( v e c t o r

2

v e c t o r

3

sort (

4

r v . push_back (

5

for ( int

6 7

d a t a . end ( )

) ;

− 1] ) ; i >=0; i −−){

data [ data . s i z e ( )

i =d a t a . s i z e ( ) !=

− 2;

data [ i +1])

r v . push_back (

8

data [ i ]

) ;

}

9 10

data . begin ( ) ,

i f ( data [ i ]

data ) {

rv ;

return

rv ;

}

Erre a függvényre az ismétl®d®

α-vágatok

eltávolításánál van szükség.

35


4.6. getAlphaLevelsFromParams Ez a függvény akkor lesz használva ha a töréspontokban szeretnénk számolni az

α-

vágatokat. Az inputja egy vector amely a meggyeléseket tárolja. A függvény egy vectorral tér vissza melyben az

α-vágatok

magasságai találhatóak.

Ehhez egy vectorba kigy¶jti az összes input partíció tagsági függvényeinek töréspontjainak magasságát, a partíciókhoz tartozó meggyelések töréspontjainak magasságát, valamint a konzekvensek partíciók meggyeléseinek töréspontjainak magasságait

1

v e c t o r CKH : : g e t A l p h a L e v e l s F r o m P a r a m s ( v e c t o r

2

v e c t o r

obs ) {

al ;

3 4

for ( int

5

i =0;

for ( int

6

i <m _ f i s . i n p u t . s i z e ( ) ;

j =0;

a l . push_back (

7

}

8

for ( int

9

j =0;

for ( int

10

o b s [ i ] . paramsy [ j ]

) ;

j <m _ f i s . i n p u t [ i ] . mf . s i z e ( ) ; j ++){

k =0;

k<m _ f i s . i n p u t [ i ] . mf [ j ] . p a r a m s y . s i z e ( ) ;

a l . push_back (

11

i ++){

j
m _ f i s . i n p u t [ i ] . mf [ j ] . p a r a m s y [ k ]

k++){

) ;

}

12

}

13

}

14 15

for ( int

16

i =0;

for ( int

17

for ( int

18

i <m _ f i s . o u t p u t . s i z e ( ) ; i ++){

j =0;

j <m _ f i s . o u t p u t [ i ] . mf . s i z e ( ) ;

k =0;

a l . push_back (

19

j ++){

k<m _ f i s . o u t p u t [ i ] . mf [ j ] . p a r a m s y . s i z e ( ) ; m _ f i s . o u t p u t [ i ] . mf [ j ] . p a r a m s y [ k ]

k++){

) ;

}

20

}

21

}

Amint az összes töréspont magassága el lett tárolva, a vectorra meghívja a removeDuplicates függvényt, amely eltávolítja bel®le az összes ismétl®dést, így nem lesz többször ugyan az azon

α-vágat

mentén a halmazok inmum és szuprémum értéke többször is

kiszámolva, és fölöslegesen eltárolva. 1

al

=

removeDuplicates (

al

) ;

2 3 4

return

al ;

}

4.7. NearestTwoRules A NearestTwoRules függvény kiszámítja az antecedensek meggyeléshez vett távolságait az

α-vágatok

mentén és ezek alapján kiválasztja a meggyelést közrefogó legköze-

lebbi két antecedens halmazt. A függvény a meggyeléseket tároló tagsági függvények struktúráját kapja bemenetként. Vissza térési értéke nincs a számításait az osztály adattagjaiban tárolja.

36


1 2 3

void

CKH : : N e a r e s t T w o R u l e s (

int

lefti

righti

= =

v e c t o r

obs

){

0, 0;

4 5 6

for ( int

7 8 9

i =0;

for ( int

i <m_rule . s i z e ( ) ; i ++){

j =0;

j <m _ f i s . a C u t s . s i z e ( ) ;

m_rule [ i ] . dL . push_back (

0

) ;

m_rule [ i ] . dU . push_back (

0

) ;

j ++){

}

Els® lépésként a szabályok alsó és fels® távolságát 0-ákkal töltjük fel. 10

for ( int

j =0;

j <m _ f i s . i n p u t . s i z e ( ) ;

j ++){

11

t_mf A =

m _ f i s . i n p u t [ j ] . mf [ m_rule [ i ] . a n t e c e d e n t [ j ] ] ;

12

t_mf

=

Ast

obs [ j ] ;

13 14

for ( int

k =0;

k<m _ f i s . a C u t s . s i z e ( ) ; k++){

− −

15

A . dL [ k ]

=

Ast . i n f [ k ]

16

A . dU [ k ]

=

Ast . sup [ k ]

17

m_rule [ i ] . dL [ k ]

+= pow (

abs (

A . dL [ k ]

) ,

m_params . w

) ;

18

m_rule [ i ] . dU [ k ]

+= pow (

abs (

A . dU [ k ]

) ,

m_params . w

) ;

19

A. i n f [ k ] ; A. sup [ k ] ;

}

20 21

m _ f i s . i n p u t [ j ] . mf [ m_rule [ i ] . a n t e c e d e n t [ j ] ] . dL = A . dL ;

22

m _ f i s . i n p u t [ j ] . mf [ m_rule [ i ] . a n t e c e d e n t [ j ] ] . dU = A . dU ;

23

}

24

for ( int

j =0;

j <m _ f i s . a C u t s . s i z e ( ) ; j ++){

25

m_rule [ i ] . dL [ j ]

= pow (

m_rule [ i ] . dL [ j ] ,

1.0

/

m_params . w

) ;

26

m_rule [ i ] . dU [ j ]

= pow (

m_rule [ i ] . dU [ j ] ,

1.0

/

m_params . w

) ;

27

}

Ezt követ®en kiszámítja az

α-vágat

menti súlyozott távolságokat és ezt a megadott

szabály struktúrájába eltárolja. 28

bool

29 30

isLeft

isRight for ( int

31

true ,

true ;

j =0;

j <m _ f i s . i n p u t . s i z e ( ) ; j ++){

v e c t o r dL =

32

dU =

33

if (

34

isLeft

isLeft

35

}

36

if (

37

m _ f i s . i n p u t [ j ] . mf [ m_rule [ i ] . a n t e c e d e n t [ j ] ] . dL ,

m _ f i s . i n p u t [ j ] . mf [ m_rule [ i ] . a n t e c e d e n t [ j ] ] . dU ; &&

=

isRight

isRight

38

=

(

any ( dL ,

"<" ,

0.0)

||

any (

dU ,

"<" ,

0.0

)

)

){

false ;

&&

(

any ( dL ,

">" ,

0.0)

||

any (

dU ,

">" ,

0.0

)

)

){

false ;

}

39

}

40

if (

41

isLeft

&&

isRight

if ( lefti

==

0) {

42

isRight

43

}

44

else

45

if (

isLeft

46 47

=

=

=

false ;

righti =

){

== 0

){

false ;

} }

37


Majd ellen®rzi, hogy az összes

α-vágat

mentén a meggyelés jobb vagy bal oldalá-

ra esik-e. Amennyiben mind jobb oldalra esik akkor a szabályt jobb oldalaira álltja amennyiben, mind baloldali akkor a szabály baloldali. 48

if (

isLeft

){

49

m _ f i s . l e f t r u l e s . push_back (

50

l e f t i ++;

51

}

52

else

if (

isRight

) ;

){

53

m _ f i s . r i g h t r u l e s . push_back (

54

r i g h t i ++;

55

i

i

) ;

}

56

}

57

if (

58

lefti

throw

== 0

){

C F R I E x c e p t i o n ( C F R I E x c e p t i o n : : KH_NO_LEFT_ANTECEDENT,

__LINE__,

__FILE__) ;

59

}

60

if (

61

righti

throw

== 0

)

C F R I E x c e p t i o n ( C F R I E x c e p t i o n : : KH_NO_RIGHT_ANTECEDENT,

__LINE__,

__FILE__) ;

Amennyiben az antecedens baloldali akkor növeljük a baloldali antecedensek számát és eltárolja az indexét a baloldali antecedenesk közé, amennyiben jobb oldali akkor a jobboldali indexek számát növeli és a jobboldaliak közé helyezi az indexét. Ha a valamelyik oldalon nincs egyetlen antecedens sem akkor kivételt dob. 62

m_NearestLeft

63

for ( int

64

if (

i =1;

all ( )

65

=

m_fis . l e f t r u l e s [ 0 ] ;

i <m _ f i s . l e f t r u l e s . s i z e ( ) ;

i ++){

m_rule [ m _ f i s . l e f t r u l e s [ i ] ] . dL ,

"<" ,

m_rule [ m _ N e a r e s t L e f t ] . dL

&&

all (

m_rule [ m _ f i s . l e f t r u l e s [ i ] ] . dU ,

"<" ,

m_rule [ m _ N e a r e s t L e f t ] . dU )

){

66

m_NearestLeft

67

=

i ;

}

68

}

69 70

m_NearestRight

71

for ( int

72

if (

i =1;

all ( dL

73

)

all ( )

74

m_fis . r i g h t r u l e s [ 0 ] ; i ++){

m_rule [ m _ f i s . r i g h t r u l e s [ i ] ] . dL ,

"<" ,

m_rule [ m _ N e a r e s t R i g h t ] .

&&

m_rule [ m _ f i s . r i g h t r u l e s [ i ] ] . dU ,

"<" ,

m_rule [ m _ N e a r e s t R i g h t ] . dU

){

m_NearestRight

75

=

i ;

}

76 77

=

i <m _ f i s . r i g h t r u l e s . s i z e ( ) ;

} }

Végül pedig kiválasztásra kerül a legközelebbi jobb és baloldali antecedens. Ehhez eltárolja legközelebbiként az els® bal illetve jobboldali halmazt, majd összehasonlítja a soron következ®vel. Amennyiben szükséges átállítja a legközelebbi bal illetve jobboldali halmaz indexét.

38


4.8. interpolate Végül következzen az interpolate függvény. Ez a függvény tér vissza az eredménnyel és ez az egyetlen függvénye az osztálynak amely publikus, így elérhet® a felhasználók számára. Ez a függvény hívja az összes többit a számítások elvégzéséhez. 1

v e c t o r CKH : : i n t e r p o l a t e ( C O b s e r v a t i o n

2

v e c t o r

3

v e c t o r

observation ){

rv ;

concl ;

4 5

t_obs

6

o b s . name =

7

for ( int

8

t_mf

obs ; o b s e r v a t i o n . getObservationName ( ) ;

i =0;

9

mf . name =

10

mf . p a r a m s

11

mf . p a r a m s y

12

mf . t y p e

13 14

i
i ++){

mf ; o b s e r v a t i o n . getMFs ( ) [ i ] . getName ( ) ; =

=

o b s e r v a t i o n . getMFs ( ) [ i ] . x T o V e c t o r ( ) ;

=

o b s e r v a t i o n . getMFs ( ) [ i ] . y T o V e c t o r ( ) ;

o b s e r v a t i o n . getMFs ( ) [ i ] . g e t T y p e ( ) ;

o b s . mf . push_back (

mf

) ;

}

Els® lépésként eltárolja a saját struktúrájába. 16

int

numofacuts ;

if (

m_params . A l p h a L e v e l s . Type . c o m p a r e ( " b r e a k p o i n t s " )==0

17 18 19

m_fis . aCuts

20 21

numofacuts }

else

if (

numofacuts

23

f o r ( double

o b s . mf

){

) ;

m_fis . aCuts . s i z e ( ) ; ){

= m_params . A l p h a L e v e l s . NumOfaCuts ; i =0;

i <=1;

i +=( f l o a t ) 1

/

( numofacuts

−

1) ) {

m _ f i s . a C u t s . push_back ( i ) ;

25 26

=

getAlphaLevelsFromParams (

m_params . A l p h a L e v e l s . Type . c o m p a r e ( " u s e r d e f i n e d " )==0

22 24

=

} }

27 28

getAllaCuts (

&o b s . mf

Ezt követ®en kiszámítja az

) ;

α-vágatok

magasságait annak megfelel®en, hogy a felhasz-

náló a töréspontokban vagy saját maga által meghatározott számú töréspontok mentén szeretné számolni az

α-vágatokat. Majd a getAllaCuts kiszámolja az α-vágatok mentén

az összes összes tagsági függvény inmumát és szuprémumát. 29

for ( int

30 31 32 33 34

i =0;

for ( int

i <m _ f i s . i n p u t . s i z e ( ) ; i ++){

j =0;

j <m _ f i s . i n p u t [ i ] . mf . s i z e ( ) ;

j ++){

m _ f i s . i n p u t [ i ] . mf [ j ] . dL =

m _ f i s . i n p u t [ i ] . mf [ j ] . i n f ;

m _ f i s . i n p u t [ i ] . mf [ j ] . dU =

m _ f i s . i n p u t [ i ] . mf [ j ] . s u p ;

} }

35 36

NearestTwoRules (

o b s . mf

) ;

Majd pedig a közrefogó szabályok kiválasztása következik a NearestTwoRules függvénnyel.

39


37

v e c t o r dLA1Ast =

m_rule [ m _ N e a r e s t L e f t ] . dL ;

38

v e c t o r dLA2Ast =

m_rule [ m _ N e a r e s t R i g h t ] . dL ;

39 40

v e c t o r dLA1A2 ;

41

for ( int

42 43

i =0;

i
dLA1A2 . push_back (

i ++){

dLA1Ast [ i ]

+ dLA2Ast [ i ]

) ;

}

Eztkövet®en a két közrefogó halmaz

α-vágat

menti alsó távolságait számolja ki.

44

v e c t o r dUA1Ast =

m_rule [ m _ N e a r e s t L e f t ] . dU ;

45

v e c t o r dUA2Ast =

m_rule [ m _ N e a r e s t R i g h t ] . dU ;

46

v e c t o r dUA1A2 ;

47

for ( int

48 49

i =0;

i
dUA1A2 . push_back (

i ++){

dUA1Ast [ i ]

+ dUA2Ast [ i ]

) ;

}

Majd a két közrefogó halmaz

α-vágat

menti fels® távolságait számolja ki.

50

for ( int

51

int

B1nr

= m_rule [ m _ N e a r e s t L e f t ] . c o n s e q u e n t [ i ] ;

52

int

B2nr

= m_rule [ m _ N e a r e s t R i g h t ] . c o n s e q u e n t [ i ] ;

i =0;

i <m _ f i s . o u t p u t . s i z e ( ) ;

i ++){

53 54

t_mf

B1 =

m _ f i s . o u t p u t [ i ] . mf [ B1nr ] ;

55

t_mf

B2 =

m _ f i s . o u t p u t [ i ] . mf [ B2nr ] ;

56 57

v e c t o r dLB1B2 ,

58 59

dUB1B2 ; for ( int

j =0;


60

dLB1B2 . push_back (

B2 . i n f [ j ]

61

dUB1B2 . push_back (

B2 . s u p [ j ]

62

− −

B1 . i n f [ j ]

) ;

B1 . s u p [ j ]

) ;

}

Kiszámításra kerül a szabályokhoz tartozó antecedensek 63 64

t_mf if

(

α-vágat

menti távolságokat.

mf ; all (

dLB1B2 ,

">" ,

0.0)

65

v e c t o r dLB1Bst ,

66

for ( int

j =0;

&&

all (

dUB1B2 ,

">" ,

0.0)

){

dUB1Bst ;


67

dLB1B2 [ j ]

=

abs (

dLB1B2 [ j ]

) ;

68

dUB1B2 [ j ]

=

abs (

dUB1B2 [ j ]

) ;

69 70

dLB1Bst . push_back (

dLA1Ast [ j ]

71

dUB1Bst . push_back (

dUA1Ast [ j ]

∗ ∗

dLB1B2 [ j ]

/

dLA1A2 [ j ]

) ;

dUB1B2 [ j ]

/

dUA1A2 [ j ]

) ;

72 73

mf . i n f . push_back (

B1 . i n f [ j ]

+ dLB1Bst [ j ]

) ;

74

mf . s u p . push_back (

B1 . s u p [ j ]

+ dUB1Bst [ j ]

) ;

75

}

76 77

c o n c l . push_back (

78

}

79

else

if (

all (

mf

dLB1B2

) ;

,

"<" ,

80

v e c t o r dLB2Bst ,

81

for ( int

j =0;

0.0

)

&&

all (

dUB1B2 ,

"<" ,

0.0

)

){

dUB2Bst ;


82

dLB1B2 [ j ]

=

abs (

dLB1B2 [ j ]

) ;

83

dUB1B2 [ j ]

=

abs (

dUB1B2 [ j ]

) ;

40


84 85

dLB2Bst . push_back (

dLA2Ast [ j ]

86

dUB2Bst . push_back (

dUA2Ast [ j ]

∗ ∗

dLB1B2 [ j ]

/

dLA1A2 [ j ]

) ;

dUB1B2 [ j ]

/

dUA1A2 [ j ]

) ;

87 88

mf . i n f . push_back (

B2 . i n f [ j ]

+ dLB2Bst [ j ]

) ;

89

mf . s u p . push_back (

B2 . s u p [ j ]

+ dUB2Bst [ j ]

) ;

90

}

91

c o n c l . push_back (

92

mf

) ;

}

Végül annak megfelel®en, hogy a konzekvensek milyen sorrendben helyezkednek el, kiszámítja az

α-vágat

menti pozíciókat. Ezt követ®en pedig az eredményhalmazok tö-

réspontjait megfelel® sorrendbe helyezi és összeállítja egy CMembershipFunction-ba és végül visszatér vele. 93

stringstream

94

st

95

c o n c l [ i ] . name =

<<

st ;

∗

"B^ _" <<

i ; st . str () ;

96 97

for ( int

j =m _ f i s . a C u t s . s i z e ( )

− 1;

98

c o n c l [ i ] . p a r a m s . push_back (

99

c o n c l [ i ] . p a r a m s y . push_back (

100

}

101

for ( int

j =0;

c o n c l [ i ] . p a r a m s . push_back (

103

c o n c l [ i ] . p a r a m s y . push_back (

j

−−){ ) ;

m_fis . aCuts [ j ]

) ;

j <m _ f i s . a C u t s . s i z e ( ) ;

102 104

j >=0;

concl [ i ] . inf [ j ]

j ++){

c o n c l [ i ] . sup [ j ]

) ;

m_fis . aCuts [ j ]

) ;

}

105 106

r v . push_back ( params ,

107

CMembershipFunction (

c o n c l [ i ] . paramsy

)

c o n c l [ i ] . name ,

" polymf " ,

concl [ i ] .

) ;

}

108 109 110

return

rv ;

}

41

5. fejezet Összefoglalás

A fuzzy logika a mesterséges intelligencia és a logika egy viszonylag új ága. Ennek ellenére mára rengeteg interpolációs módszer készült már el, és rendszeresen készülnek további módszerek, melyek más-más probléma megoldásán, illetve a logika más és más irányú megközelítésén alapszanak. Ebben a dolgozatban felmértem néhány már meglév® eljárás hibáit gyenge pontjait. Ezek alapján felállítottam egy szempontrendszert, melynek segítségével a felhasználók, programozók felmérhetik, milyen eljárások nyújtanak megoldást az általuk felállított fuzzy rendszer megoldására. Elkészült egy ajánlás a szempontrendszerhez, hogy mi szerint lehet ellen®rizni, hogy az adott problémát képes-e kezelni a módszer, illetve az eredménye szabályos fuzzy halmaz lett-e. Ennek alapján a jöv®ben létrejöv® interpolációs eljárások tesztelésében nyújthat nagy segítséget. Ezen szempontrendszer alapját az alapját szolgálhatja egy kés®bbiekben készül® bencsmárk rendszernek. Továbbá a MATLAB környezetben meglév® FRIToolbox alapján készül egy programozói könyvár C++ alapokon, melyb®l egy DLL fog elkészülni. Ezt a továbbiakban olyan projektek során lehet, majd felhasználni ahol a MATLAB-ban megíródott FRIToolbox túl id®igényes vagy a platformfügg®ség miatt nem használható. Ebben a készül® programozói könyvtárban elkészítettem a KH eljárást. Továbbá a KH és MACI módszerek id®bonyolultságát a forráskód alapján elemeztem. További lépésként egy olyan bencsmárk rendszer jöhet létre, mely egy sor teszteset lefuttatásával a jöv®ben elkészül® tetsz®leges interpolációs módszereket rangsorolni tudja aszerint, mely szempontoknak felelt meg az adott eljárás.

42

Irodalomjegyzék

[1] Zadeh, L. A.: Fuzzy Sets, in Information and Control, Vol. 8, 1965, pp. 338-353. [2] Koczy, L. T. and Hirota, K.: Rule interpolation by

α-level sets in fuzzy approximate

reasoning, in Journal BUSEFAL, URA-CNRS, Vol. 46, Toulouse, France, 1991, pp. 115-123. [3] Vass, G., Kalmár, L. and Kóczy, L. T.: Extension of the fuzzy rule interpolation method, in Proceedings of the International Conference on Fuzzy Sets Theory Applications (FSTA '92), Liptovsky Mikulas, Czechoslovakia, 1992, pp. 1-6. [4] 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. [5] Tikk, D. and Baranyi, P.: Comprehensive analysis of a new fuzzy rule interpolation method, in IEEE Transactions on Fuzzy Systems, Vol. 8, 2000, pp. 281-296. [6] Johanyak Zsolt Csaba: Fuzzy szabály-interpolációs módszerek és mintaadatok alapján történ® automatikus rendszergenerálás [7] FRI Toolbox

http://fri.gamf.hu/toolbox/

[8] László

T.

Kóczy,Domonkos

Tikk:

Fuzzy

rendszerek

http://ottomat.hu/archivum/Fuzzy/fuzzy_rendszerek_.pdf [9] Google test

http://code.google.com/p/googletest/

[10] Krizsán Zoltán: KÖZÖS FEJLESZTI KERETRENDSZER FUZZY SZABÁLY INTERPOLÁCIÓS MÓDSZEREKHEZ, Miskolci Egyetem (2012)

43

Adathordozó használati útmutató

5.1. ábra. Mappa szerkezet

Fájl struktúra: •

Debug: Az FRIToolbox projectjei által debug módban generált .exe és .lib fájlok.

•

fritoolbox: Az interpolációs eljárások és keretrendszer forráskódját tároló könyvtár.

•

fritoolboxdemo: Egy minta project mappája az FRI toolbox használatára

•

gtest: Ebben a könyvtárban találhatóak a google teszt teljes forráskódja.

•

Release: Az FRIToolbox projectjei által debug módban generált .exe és .lib fájlok.

•

tests: Ebben a könyvtárban találhatóak az FRIToolbox tesztjeinek projectje és forrásai.

•

fritoolbox.sln: Egy Visual Studio 2010-es solution le. Ez foglalja össze az összes projectet.

Project létrohozása: Amennyiben új projectben szeretnénk felhasználni a FRIToolboxot akkor a Release mappában lév® fritoolbox.lib fájlt kell behívni az adott projectbe, továbbá az fritoolbox mappában lév® header leokat kell hozzá adni az új projecthez.

Lefordított projectek futtatása: Amennyiben a lefordított programokat szeretnénk futtatni akkor a Release mappában lév® .exe kiterjesztés¶ fájlokat kell futtatni.

44

Szakdolgozat. FRIToolbox - fuzzy szabályinterpolációs benchmark feladatok kidolgozása. Miskolci Egyetem

Recommend Documents