Közeljövő: Intelligens rendszerek

A mesterséges intelligencia három kutatási irányba, úgymond lágy számítási modellbe (soft computing) sorolható:

Mesterséges neurális hálózatok

A mesterséges neurális hálózatok igyekeznek követni a biológiai idegrendszer felépítését és számítási analógiáját, azonban még messze nem rendelkeznek ezek mélyebb tulajdonságaival. Ez a tudományág nem új (a digitális számítógép előtt már létezett), viszont még kezdeti stádiumban van, és már az egyszerűsített modellek is jobb eredményeket produkálnak mint a hagyományos algoritmikus megoldások. Alkalmazásuk akkor hatékony, ha rengeteg információ áll rendelkezésre ám ezek hamis adatokat is tartalmazhatnak és a feldolgozásukhoz szükséges szabályok ismeretlenek. Neurális hálózatokat többek között karakterfelismerésre, képfeldolgozásra (pl. rendszámleolvasó kamerák), adatbányászatra és mérés/szabályzástechnikai feladatokra használnak.

A biológiai neuron (idegsejt) matematikai modelljét perceptronnak hívják. Az elektromos jeleket, melyeket az idegsejtben a dentritek befognak más neuronok axonjaitól, a perceptron numerikus értékkel reprezentálja. A dentritek és axonok közötti szinapszis az elektromos jeleket különböző mértékben modulálja. A perceptronban ez a beszorzás művelete egy értékkel, amit súlynak neveznek. A neuron csak akkor szolgáltat kimenő jelet, ha a bemeneteinek összessége meghalad egy adott küszöbértéket. A perceptronban ezt a jelenséget a súlyozott bemenetek összegzése képviseli, valamint az eredmény összehasonlítása egy küszöbértékkel (szűrése). Ahogy a biológiai neuron esetében is, a kimenet egy másik perceptron bemenetéül szolgál. A neuronok hálózata többnyire szövevényes, így az információ osztottan, a súlytényezők közvetítésével ábrázolódik. Ha néhány neuron vagy súlytényező kiesik, az nem lesz hatással a hálózat működésére.

Az első neurális hálózatot Frank Rosenblatt állította össze 1957-ben. Ez egy vizuálisan tanuló hálózat volt, ahol az érzékelő (retina) egy 20x20 fotoérzékelőből álló mátrix. Az erre vetített betű felismerése volt a cél, a vett fényerősséghez tartozó feszültség amplitúdója volt a bemenő adat. Ezek a jelek véletlenszerűen voltak a neuronokhoz kötve, melyek kimenetei a lehetséges megoldásokra csatlakoztak (pl. minden betűhöz tartozott egy-egy jelzőlámpa). A súlyok potenciométerekkel voltak beállítva, és ezek értékeit a tanulás folyamata alatt elektromos motorok változtatták. A hálózat tehát egy egyrétegű neuronhálózat volt (bemenet > neuron > kimenet). Kiderült azonban, hogy akárhány neuront alkalmaznak, egy réteggel nem oldható meg a lineárisnál bonyolultabb feladat, többrétegű hálózatot pedig még nem tudtak akkoriban betanítani. Egyszerű példaként a logikai kapukat hozták fel:

1. A neuronok felépítése

Ez határozza meg, hogy milyen feladatot lát el az adott neuron, azaz hogy milyen kezdeti súlymátrixból indul ki. A biológiából tudjuk, hogy az idegrendszer nem univerzális gép (nem Turing gép, amivel mindent meg lehet csinálni), hanem specializált. Az állati és az emberi idegrendszer is örökölt formában csak egy-egy funkciót tud jól ellátni. Például az agy hátsó részében lévő idegsejtek a látást, oldalban a mozgás, hallás, ízlelés, majd előre a beszéd szaglás stb. Ezeket nem lehet felcserélni, mert mindenik rész csak a saját specifikus feladatára van tervezve. Ez a technikában is így van.

A neuron alatt egy egyszerű processzort kell érteni, ami csak összegezni és szorozni tud. Egy hálózat neuronjai mind egyformák, és általánosan a következőképp néznek ki:

A zölddel jelölt neuron bemeneti oldalán fogadja a bemenetet ($ x_1...x_n $), melyet összeszoroz a súlyértékkel, aztán összeadja szorzatokat. A kimenet pedig a határértéktől függ. Eleinte úgy vélték, hogy ez bináris működésű, azaz a küszöbérték alatt nincs kimenet (nyugalmi állapot), fölötte pedig van (tüzelő állapot). Ebből arra következtettek, hogy bináris számítógép építhető belőle, és hogy az idegrendszer is bináris logikával működik.

A probléma hogy a bináris egységugrás nem differenciálható és ez nélkül a rejtett réteg neuronjai nem taníthatóak. A tanításhoz ugyanis ismerni kell a súlytényezők változásának irányát és mértékét. Amit tudni lehet az egyelőre csak annyi, hogy a kimenet helyes-e vagy sem, és ebből felírható egy hibafüggvény, ami az ismeretlen súlytényezőktől függ. A hibát úgy lehet csökkenteni, hogy kiszámoljuk a hibafüggvény tényezőinek parciális deriváltját. Ehhez viszont a függvény elemei differenciálhatóak kell legyenek, ami megköveteli, hogy a transzfer függvény szigmoid legyen:

\[f(S)=\frac{1}{1+e^{-S}}=\frac{1}{1+e^{-\sum{x_i w_i}}}\]

Így most már analitikusan is kiszámítható a súlytényező. A hibafüggvénynek az adott súlytényező szerinti parciális deriváltja nem más mint a meredeksége, ami alapján csökkenteni kell egy keveset a függvényen. Az új súlytényező értéke tehát olyan lesz, hogy lefele haladunk a függvényen (hegymászó módszer).

2. A neuronok összekötési módja (hálózati séma)

Ez határozza meg a teljesítményt. Egy általános séma a következő:

A szintek között minden össze van kötve mindennel, ezért ezt sokkal egyszerűbben is lehet ábrázolni:

A fenti mátrix ugyanaz az ábra mint az előző. Minden bemenet kapcsolódik minden kimenethez a súlytényezőkön keresztül. A mátrixos ábrázolás lehetővé teszi a mátrix műveletek használatát. Szerencsére a mai processzorok közvetlenül is támogatják a mátrix műveleteket (benne van az utasításkészletükben), hiszen a világot is mátrixként érzékelik. A bemeneti vektort megszorozzuk a súlymátrixszal és máris megvan a kimeneti vektor. Ha nem ismerjük a súlymátrixot, akkor az egész hálózat használhatatlan, tehát a tudást a súlytényezők adják.

Ezt a beállítást előrecsatolt sémának nevezik, mert az adatok csak előre haladnak. A visszacsatolt neurális hálózatban az adatok mindkét irányban haladhatnak. A kiszámított adatok visszakerülnek a hálózatba egyfajta memóriát tulajdonítva annak:

A kimenetből visszacsatolt adatok újabb súlymátrixot jelentenek és az így kapott nagy mátrix az előrecsatolt hálózatokra is alkalmazható:

\[{\color{green}{\begin{bmatrix}I_1 & I_2 & I_3 & I_4 & I_5 \end{bmatrix}}} \cdot {\color{blue}{\begin{bmatrix} W_{1,1} & \cdots &W_{1,5} \\ \vdots & \ddots &\vdots \\ W_{5,1} & \cdots & W_{5,5} \end{bmatrix}}} + {\color{red}{\begin{bmatrix} O_1 &O_2 & O_3 & O_4 & O_5 \end{bmatrix}}} \cdot {\color{Brown}{\begin{bmatrix} W_{1,1} & \cdots & W_{1,5} \\ \vdots & \ddots & \vdots \\ W_{5,1} & \cdots & W_{5,5} \end{bmatrix}}} =\] \[= {\color{red}{\begin{bmatrix} O_1 & O_2 & O_3 & O_4 & O_5\end{bmatrix}}}\]

Az összekötési séma függ a feladat típusától is. Az agyban is más-más struktúrájú az idegrendszer attól függően, hogy pl. vizuálisan vagy hangok alapján kell tanulnia. Miután megtaláltuk a feladatra legalkalmasabb összekötéseket, akkor be kell állítani a súlymátrixot, azaz meg kell tanítani a hálózatot.

3. A tanítási módszer

Ez határozza meg a tanítást és tesztelést, amíg a hálózat a kívánt viselkedést nem mutatja. A tanítás során minden lehetséges szituációt fel kell vázolni, például Rosenblatt minden lehetséges betűt és számot megmutatott a gépjének, amíg az meg nem tanulta osztályozni őket. A bemenő adatok struktúrája is azonos kell legyen és addig kell ezeket a gép bemenetére adni amíg az összest meg nem tanulja. Ezzel úgymond bemagolja a hálózat az adott anyagot és kívülről fújja. Intelligens viszont csak azután lesz miután felismeri a hasonló struktúrájú de nem teljesen ugyanolyan adatokat is, például a nyomtatott betű után a kézzel rajzolt nyomtatott betűt is. A tanító mintákat tehát két részre kell osztani, amelyből az egyiket ténylegesen megtanítunk a hálózatnak, a másikat pedig csak a tesztelésnél mutatjuk meg először. Ha ezeket is felismeri egy hibahatáron belül, akkor elmondható, hogy a hálózat működik. Ezt felügyelt tanításnak nevezik, mert felügyelhető a kimenő érték helyessége a célértékekhez viszonyítva. A tanítás célértékek nélkül is működhet, ilyenkor az osztályozható adatokat egy másik tanító algoritmussal tanítjuk (önszerveződő tanítás). A hálózat ebben az esetben magától osztályozni kezdi, megtalálja a káoszban a rendszert.

A felügyelt tanítás algoritmusa:

A súlyok véletlenszerű inicializálása
A tanítómintához tartozó kimenet kiszámítása
A kimenet és a célérték közti eltérés kiszámítása a hibafüggvény alapján
A súlytényezők módosítása a tanítási módszer szerint
A 2-3-4 ismétlése amíg a hibaérték egy adott küszöbérték alá nem kerül

Gyakorlatilag két módszer van amire az összes többi épül:

1) Hebb módszer

Ha két egymás utáni neuron ($O_1$ és $O_2$) egyszerre tüzel, akkor a közöttük lévő súlytényező megnövekszik, ha nem egyszerre tüzelnek, akkor lecsökken. Ezt a következőképp lehet leírni:

\[W_{2,1}(t+1)=W_{2,1}(t)+\alpha\cdot O_1 \cdot O_2\]

Az új súlytényező értéke egyenlő a régi érték plusz a két kimenet szorzata. Ha a kimenetek egyszerre pozitívak vagy egyszerre negatívak akkor a súlytényező megerősödik, ha ellentétes előjelűek akkor lecsökken. Hogy a változás mértéke ne legyen túl nagy be kell szorozni az $\alpha$ tanulási együtthatóval, ami általában nagyon kicsi (0 és 1 közötti). Látható, hogy az új súlytényező értéke nem függ a célértéktől, tehát ez a módszer akkor is tanul, ha nem tudja mit tanul. Másként fogalmazva osztályozni kezdi a bemenő adatokat felügyelet nélkül (önszerveződően). Az alábbi példában a Hebb-féle hálózat például pixelcsoportokat keres, a gyakori pixelcsoportok pedig rögzülnek a rendszerbe. Felsőbb szinteken a rendszer már címkézést végez:

A csoportosításkor a kimeneti neuronok versengenek anélkül, hogy kapcsolat lenne közöttük.

2) Delta módszer

Ebben az esetben már van célérték (felügyelt tanítás), de a képlet nem sokat változik:

\[W_{2,1}(t+1)=W_{2,1}(t)+\alpha\cdot O_1 \cdot(C-O_2)=W_{2,1}(t)+\alpha\cdot O_1 \cdot \Delta\]

Az utolsó (kimeneti) neuron helyett egy különbség (delta) van, a célérték és a kimeneti neuron különbsége. Ez érthető is, hisz ha a célérték nagyobb mint az eredmény, akkor meg kell növelni a súlytényezőt (a különbség pozitív lesz), hogy legközelebb kisebb legyen a hiba.

A hiba kiszámítása és a hiba-visszaterjesztés - Back Error Propagation

A hiba nem más, mint a célérték és az aktuális érték különbsége, ami lényegében a delta módszer képletének az utolsó tagja. A delta módszer tehát a hibái alapján tanul, a hiba függvényében javítja ki a súlytényezőket. A delta-szabály ezen variációja innen kapta a hiba-visszaterjesztés nevet, hiszen a kimeneti hibát visszaterjeszti a súlytényezőkre. A delta szabályhoz vezető út ennek a különbségnek a deriváltján át vezet. Egy több ($j$) kimenettel rendelkező hálózat hibája a különbségek összege:

\[E=\frac{1}{2}\displaystyle\sum_{j}(C_j-O_j)^2\]

Természetesen nem csak egy tanítóminta van, a hálózatnak több mindent is meg lehet tanítani. Ilyenkor mintánként is össze kell adogatni az eredményeket:

\[E=\frac{1}{2N}\displaystyle\sum_{n=1}^N\displaystyle\sum_{j}(C_j-O_j)^2\]

Ezt az utóbbit inkább a kötegelt tanításnál használják, ahol előbb lefuttatják a teljes tananyagot és csak utána javítgatnak a súlyokon. Az előző (szekvenciális tanítás) esetén viszont a kettővel való osztás azért van, mert a deriválásnál majd segít egyszerűsödni, a négyzetre emelés pedig azért, mert a kapott szám hanem túl kicsi lesz (általában nullához nagyon közeli), és a folytonos függvényeknél egyébként is négyzetes hibafüggvénnyel szokás számolni. A súlyok korrekcióját a gradiens (hegymászó) módszer segítségével kapjuk: a hibafüggvényt a súlytényezők szerint deriváljuk (tehát parciálisan) és megkapjuk a hibafüggvény meredekségét. A meredekséggel arányosan kicsit lefelé lépünk azaz ennek megfelelően módosítunk a súlytényezőn.

Példának legyen egy olyan hálózat, ami egy neuronból áll, egy tanítómintája van és transzfer-függvénye lineáris (a bemenetet vagy felismeri vagy nem):

\[E=\frac{1}{2}(C-O)^2\] \[O=S=\displaystyle\sum_{i}w_i\cdot I_i\]

Az $E$ hibafüggvény deriválását a láncszabállyal kell elvégezni. Az $i$-edik súlytényező szerinti parciális derivált:

\[\large{\frac{\partial E}{\partial W_i}=\color{red}{\frac{\partial E}{\partial O}}\cdot {\color{green}{\frac{\partial O}{\partial S}}}\cdot {\color{blue}{\frac{\partial S}{\partial W_i}}}}\]

Mivel most csak egy neuron van, az összegzést elhanyagolhatjuk. A részderiváltak:

\[\large{{\color{red}{\frac{\partial E}{\partial O}=\left(\frac{1}{2}(C-O)^2\right)^{'}=\frac{1}{2}\cdot 2 \cdot (C-O)=C-O}}}\] \[\large{{\color{green}{\frac{\partial O}{\partial S}=1}}}\] \[\large{{\color{blue}{\frac{\partial S}{\partial W_i}=\frac{\partial(W_1\cdot I_1+\cdots+W_n\cdot I_n)}{\partial W_i}=I_i}}}\]

végül az eredmény:

\[\frac{\partial E}{\partial W_i}={\color{red}{(C-O)}}\cdot{\color{green}1}\cdot {\color{blue}{I_i}}\]

Ez pedig nem más mint a delta módszerben szereplő súlytényező-módosítás:

\[W_{j,i}(t+1)=W_{j,i}(t)+\alpha\cdot {\color{blue}{I_i}}\cdot{\color{red}{(C_j-O_j)}}\]

A célja ennek a számításnak tehát az volt, hogy megkapjuk mennyivel kell módosítani a súlytényezőt, hogy a hiba legközelebb kisebb legyen. Az $O_i$ előző neuron-kimenet helyett most $I_i$ bemenet van, mert csak egy neuronnal dolgoztunk. Ha több neuron van, akkor:

\[W_{j,i}(t+1)=W_{j,i}(t)+\alpha\cdot {\color{blue}{O_i}}\cdot{\color{red}{(C_j-O_j)}}\]

Többrétegű hálózatnál az átviteli függvény szigmoid, a rejtett rétegben pedig nem ismert a célérték, ezért ott kicsit bonyolultabb a deriválás:

\[\large{\frac{\partial f(s)}{\partial s}=\left(\frac{1}{1+e^{-s}}\right)^{'}=\frac{1^{'}\cdot(1+e^{-s})-1\cdot (1+e^{-s})^{'}}{(1+e^{-s})^{2}}=\frac{(1+e^{-s})^{'}}{(1+e^{-s})^2}=\frac{e^{-s}}{(1+e^{-s})^2}=}\]

\[\large{=\frac{1}{1+e{-s}}\cdot \frac{e^{-s}}{1+e^{-s}}=\frac{1}{1+e^{-s}}\cdot \frac{e^{-s}+1-1}{1+e^{-s}}=\frac{1}{1+e^{-s}}\cdot \frac{(1+e^{-s})\cdot \left(1-\frac{1}{1+e^{-s}}\right)}{1+e^{-s}}=}\]

\[\large{=\frac{1}{1+e^{-s}}\cdot \left(1-\frac{1}{1+e^{-s}}\right)=f(s)\cdot(1-f(s))}\]

Az $E$ hibafüggvény $i$-edik súlytényező szerinti parciális deriváltja ugyanolyan mint fentebb, ám mivel a függvény szigmoid, a középső részderivált másképp alakul:

\[\large{{\color{green}{\frac{\partial O}{\partial S}=\frac{\partial f(S)}{\partial S}=f(S)\cdot(1-f(S))}}}\]

végül az eredmény:

\[\frac{\partial E}{\partial W_i}={\color{red}{(C-O)}}\cdot{\color{green}{f(S)\cdot(1-f(S))}}\cdot{\color{blue}{I_i}}\]

- A kimeneti réteg súlytényezőjének változása több neuron esetén (ha $j$ a kimeneti neuron):

\[W_{j,i}(t+1)=W_{j,i}(t)+\alpha\cdot {\color{blue}{O_i}}\cdot {\color{red}{(C_j-O_j)}}\cdot {\color{green}{f(S_j)\cdot(1-f(S_j))}}\]

Rejtett rétegek esetén, mikor több neuron vesz részt a tanulásban, akkor a lánc középső tagjánál a hibafüggvénynek a rejtett réteg kimenete szerinti parciális deriváltját kell venni:

\[\large{{\color{red}{\frac{\partial E}{\partial O_i}=\displaystyle\sum_{k=1}^M \frac{\partial E}{\partial I_k}\cdot \frac{\partial I_k}{\partial O_i}}}}\]

Ennek részderiváltjai:

\[\large{{\color{red}{\frac{\partial E}{\partial I_k}=\frac{\partial E}{\partial O_k}\cdot \frac{\partial O_k}{\partial I_k}=(C_k-O_k)\cdot O_k(1-O_k)}}}\]

\[\large{{\color{red}{\frac{\partial I_k}{\partial O_i}=W_{i,k}}}}\]

A hibafüggvény kimenet szerinti deriváltja:

\[\large{{\color{red}{\frac{\partial E}{\partial O_i}=\displaystyle\sum_{k=1}^{M}\left( (C_k-O_k)\cdot O_k(1-O_k)\cdot W_{i,k}\right)}}}\]

- A rejtett réteg súlytényezőjének változása (ha $j$ rejtett neuron):

\[W_{j,i}(t+1)=W_{j,i}(t)+\alpha\cdot {\color{blue}{O_i}}\cdot {\color{red}{\displaystyle\sum_{k=1}^{M}\left((C_k-O_k)\cdot O_k(1-O_k)\cdot W_{i,k}\right)}}\cdot {\color{green}{f(S_j)\cdot(1-f(S_j))}}\]

A $j$ neuron gradiense (parciális deriváltja) megkapható a $j$ utáni réteg lokális gradiensei segítségével. Mivel a kimeneti réteg gradiensei közvetlenül kiszámíthatóak, így visszafele haladva rétegről rétegre az összes lokális gradiens kiszámítható.

Ezeket a képleteket a tanító algoritmusban felhasználva tanítható lesz a hálózat. Azonban ez hegymászó módszer, ezért általában csak legutolsó esetben használatos. A hegymászó módszer csak kicsikéket lépeget a helyi hiba alapján és nem látja át az egész hálózat hibáját, ezért előfordulhat, hogy teljesen eltér a helyes iránytól. Ilyenkor elölről kell kezdeni és a végeredmény gyakorlatilag a szerencsétől függ. Léteznek sokkal kifinomultabb verziók, melyek nem pusztán lokális minimumokkal döntik el a helyes irányt.

Tippek a visszaterjesztéses módszerhez:

Nagy tananyag esetén a szekvenciális tanítás gyorsabb a kötegeltnél
A tanítóminták a lehető legnagyobb hibát eredményezzék (ekkor tartalmazzák a legtöbb információt)
Anti-szimmetrikus transzfer függvénnyel (pl. tangens hiperbolikus) gyorsabb a tanulás
A súlyok közel azonos mértékben változzanak (normalizálni kell őket)

Egy hálózat akkor nevezhető betanítottnak, ha a tanítómintákra helyes kimenetet ad, azaz jól osztályoz, vagyis a kapott függvény jól illeszkedik a tanítópontokra. A hálózat akkor általánosít jól, ha a tesztmintákra is helyes kimenetet szolgáltat. Ha csak a tanítómintákkal megy, akkor a következő a helyzet:

a tanítópontokra jól illeszkedik, de nagyon hullámzó a függvény
a tanítópontokat jól osztályozta, de az osztályokat elválasztó határok szabálytalanok

A következő ábrán egy jól általánosító és egy hullámzó függvény látható, ugyanazokon a tanítópontokon:

Ilyenkor a hálózatot túltanítottnak nevezik, és úgy lehet javítani rajta, hogy egyrészt egyszerűsítünk a hálózaton, másrészt feljebb visszük a hibahatárt.

A tanítási módszerek javítása

A tanulási együttható és a momentum konstans

A tanulási együttható ($\alpha$) nagy mértékben befolyásolja a tanítás sebességét. Ha túl kicsi akkor lassú lesz a konvergencia, ha túl nagy akkor instabillá válhat a tanulás. Ezt a paramétert menetközbe is változtathatjuk, de az instabilitást a momentum konstans ($\beta$) csillapíthatja. Ez azt a lendületet jelenti, amellyel a hibajavítás folyik, tehát figyelembe kell venni a korábbi hibajavítás mértékét is. Ha ez nagy lendületű volt, akkor ez túlviheti az algoritmust a lokális akadályokon.

\[W_i(t+1)=W_i(t)+\alpha\Delta O_i+{\color{red}{\beta\Delta(t-1)}}\]

A súlyértékhez hozzáadjuk az előző javítás értékét is, ahol $0<\beta <1$ ennek bevonásának a mértékét szabályozza.

A csökkenő hibahatár (descending epsilon)

A tanítóminták (tananyag) végigjárása során ez a módszer nem javít a súlytényezőkön minden esetben, hanem csak akkor, amikor az eredmény meghalad egy hibahatárt. Ez a hibahatár kezdetben nagy, a tanítóminták első végigjárásánál nagyobb hibákat is megenged magának a hálózat. Ezzel azt éri el, hogy a valamennyire ismert mintákat átugorja, és csak azokat tanulja amelyeket nem, vagy csak nagyon kicsit ismer. Miután végigjárta az összest, kicsit csökkent a hibahatáron, azaz szigorúbban veszi a leckét. Minden alkalommal kicsit szigorít az elvárásokon, míg végül az összes mintát ismerni fogja egészen kicsi hibahatárral.

A kis súlytényezők kiszűrése

A tanulás során rengeteg súlytényezőnek nullához nagyon közeli értéke lesz. Mivel a számítások során a súlytényezővel dolgozunk, teljesen felesleges a nullához közeli értékkel szorozni. Az ilyen súlytényezőket inkább nullává kell tenni és ezzel nagyot nő a hálózat futásideje és teljesítménye.

A növekvő és csökkenő hálózatépítés

A növekvő (vagy inkrementális) módszer esetében a hálózat minimális neuron számmal indul, majd lépésről lépésre növekszik. Kezdetben a kimenet és a bemenet között nincs semmi. Először betesz egy neuront majd megtanítja és teszteli. Ha nem jó az eredmény akkor berak még egy neuront, újra tanítja a hálózatot és teszteli. Ezt addig ismétli amíg a hálózat teljesíteni nem tudja a feladatot.

A fenti képen például kezdetben van 2 kimenet és 4 bemenet (a fekete néhyzetek a súlytényezők). Első lépésként berakjuk az A neuront és megkeressük a zöld súlytényezők értékeit hogy a hiba minimális legyen. A cél az, hogy a hiba a neuron által kisebb legyen mint mielőtt odakerült volna, az összehasonlítást pedig korrelációval végezzük. Ha a kimenet az új neuronnal még mindig nem tud a hibahatár alá esni, akkor betesszük a B neuront is. Ismét megtanítjuk a hálózatot, majd korrelációt végzünk. Ha elértük a hibahatárt és az újabb neuronok már nem javítanak a kimeneten, akkor kivehessük a e fölösleges neuronokat, mert azok fölösleges számításokat okoznak.

Az inkrementális hálózatépítés ellenkezője a metszés (vagy csökkenő hálózatépítés). Ebben az esetben jól betanítunk egy nagy hálózatot, majd csökkentjük a neuronok és súlyok számát addig amíg még jó eredményt ad. Általában ezt használják, mert a nagy hálózatot legtöbbször sikerül jól betanítani. Hátrány, hogy lassú vagy túltanított lehet (azaz jól illeszkedik, de nem jól általánosít). Ilyenkor hasznos a metszéses eljárás. Ez a gyakorlatban a kis súlytényezők kiszűrésével kezdődik, és ha egy nullára állított súly miatt a kimeneti hiba nem nőtt meg, akkor az adott neuron fölöslegesnek számít. A metszési eljárások két csoportba sorolhatók:

a) Regularizáció (büntetés)

A hálózat súlytényezőinek csökkentése érdekében büntetőtag alkalmazható, ami lehet pl. a hálózat súlyainak négyzetes összege vagy a súlyok abszolút értékének az összege. A módszer hátránya, hogy a csökkentés azoknál a súlyoknál is megtörténik, amelyek fontosak a hálózat megfelelő működéséhez, ezért a hiba általában nagyobb mint a szimpla visszaterjesztéses eljárás esetén. Ezen lehet javítani, ha bevezetünk egy újabb küszöbértéket, ami alá kerülő súlyokra lesz csak érvényes a csökkentés.

b) OBD (Optimal Brain Damage)

A módszer a hiba súlyok szerinti Taylor-sorba fejtéséből indul. A lineáris megközelítés magába foglalja a deriváltakat is, pontosabban egy parciális deriváltakból álló mátrixot, amit Hesse-mátrixnak hívnak. Ez tulajdonképpen a másodrendű Taylor-sorok négyzetes tagjának együtthatója. A Hesse-mátrix általában nem diagonális, ezzel szemben az OBD azt feltételezi hogy az (csak a főátlója különbözik nullától) és ezáltal nagyobb mértékű méretcsökkentést eredményez amit a legkevésbé fontos súlyok elhagyásával tesz.

A versengéses tanítás

A transzferfüggvény lineárisan növekvő, tehát nem szigmoid és nem egységugrásos:

A működéshez néhány alapvető feltételnek teljesülnie kell:

A súlytényezők összege minden neuronban egyenlő kell legyen 1-gyel.
A súlyértékek 0 és 1 között szabad mozogjanak
A bemenő adatok binárisak kell legyenek (1 vagy 0)

Ez a módszer úgy tanít, hogy megkeresi a legnagyobb kimenetet és a többi kimenetre úgy tekint mintha nullák lennének (nullára állítja őket). A kiválasztott kimenetnek megnézi, hogy milyen bemenetei vannak és a legnagyobbakat kicsit megerősíti, hogy biztos legyen, hogy következő alkalommal is ez a kimenet győz, ha újból ezt a tanítómintát kapja a hálózat. A legerősebb kimeneti neuron új súlytényezője:

\[W_{j,i}(t+1)=W_{j,i}(t)+\alpha \left(\frac{O_i}{m}-W_{j,i}(t)\right)\]

ahol $m$ az aktív bemenetek száma. A következő mintánál ugyanígy jár el és ennek előnye, hogy a hálózat nem tudja túltanulni magát, hanem minden mintát egyszerre csak egy kicsit tanul meg. Ha ugyanis csak akkor ugorna a következő mintára mikor az előzőt már tökéletesen tudja, akkor az új mintát már nehezebben tudná megtanulni és közben megsérülne az előző mintáról szerzett tudása is.

A versengéses tanítás oldalirányú gátlással

A biológiában sok példa van rá, hogy a szomszédos neuronok egymással is kapcsolódnak, ennél a módszernél tehát nem csak egy szimpla előrecsatolt hálózatról van szó. Az oldalirányú kapcsolatok célja hogy a neuronok gátolhassák egymást, azaz mikor egy neuron tüzel, akkor gátolja a szomszédját és ezáltal még inkább kiemelkedik a többi közül.

Teuvo Kohonen fonetikus írógépe (1982):

Kohonen azt a feladatot kapta, hogy építsen egy fonetikus írógépet. A megoldást olyan neurális hálózattal oldotta meg, ahol a szomszédos neuronok egymással is össze vannak kötve. Ráadott egy beszédmintát, kiválasztotta majd megerősítette a legnagyobb kimenetet, méginkább elnyomva annak szomszédjait. Vette a következőt és ugyanígy tett. Bevezetett egy olyan módszert, hogy a gátlások az elején nagyok, a tanulás vége fele pedig egyre kisebbek legyenek, azaz egyre kevésbé nyomják el a szomszédokat a tüzelő neuronok.

Látható hogy a hálózat két rétegből áll: a bemeneti réteg és a neuronháló, ami egyben a kimeneti réteg is. Kohonen az önszerveződő módszerrel tanította a hálózatot, tehát nincs célérték, a hálózat nem tudja mit kell tanuljon, de azt tudja hogy melyik kimenet a legerősebb és csak annak a súlytényezőit erősíti. Minél inkább hasonló két tanítóminta, annál kisebb lesz a távolság közöttük. Ettől fogva a hasonló tanítómintákra a győztes neuronok összetömörülnek, osztályokat alkotva.

\[d_j=||I-W_j ||=\sqrt{\displaystyle\sum_{i=1}^N(I_i-W_{j,i})^2}\]

ahol $d_j$ a súlyvektor ($W_j$) és a bemenő vektor ($I$) közti távolság, $I_i$ a bemenő vektor $i$-edik eleme, $W_{j,i}$ a neuronháló $j$-edik neuronja és az $i$-edik bemenet közti súlytényező, $N$ a bemeneti vektor elemeinek száma. A súlytényező módosítása:

\[W_{j,i}(t+1)=W_{j,i}(t)+\alpha(I_i-W_{j,i})\]

A tanulás során módosított környezet nagysága csökken:

\[N_j(t)=N(0)\left(1-\frac{t}{T}\right)\]

ahol $t$ az adott tanulási iteráció száma, $T$ a teljes tanulási ciklusok száma. A véletlenszerűen beállított súlytényezők tanulás közben egyre inkább felveszik a tanítóminta statisztikai eloszlását.

A gép érdekessége, hogy a bemenő hangminta (a mikrofon kimenetéből) átmegy egy 5,4kHz-es alul-áteresztő szűrőn, majd egy 12 bites ADC digitális mintákká alakítja azt. A minták ezután egy gyors Fourier transzformálttal az időtartományból frekvenciatartományba kerülnek. Ezek szolgáltatják a neurális hálózat bemeneti mintáit. Az ADC 13,3kHz-es mintavétellel dolgozta fel az 5,4kHz-es jelet, azaz 13.000 mintát produkált másodpercenként.

Ha a képlet adott, azt nem bizonyítani és levezetni, hanem alkalmazni kell. Programot írni például C-ben egy neurális hálózatról csupán a megértésben segít. A matematikai modellek gyorsan fejlődnek, az igazán mély matematikai elemzéssel készült neurális hálózatokat pedig szimulátorokba implementálják. Érdemes tehát olyan programokkal dolgozni amelyek már rendelkeznek a megírt neurális függvényekkel (pl. a Matlabban is vannak ilyen kiegészítők).

Példa - levezetve

A következő neurális hálózat bemeneti rétege 2 neuront, rejtett rétege 3 neuront és kimeneti rétege 2 neuront tartalmaz. A transzferfüggvény tangens szigmoid.

\[\large{f(s)=\frac{2}{1+e^{-2s}}-1}\]

Legyen a két bemenet $\Omega_{be}={\color{red}{0.6}}$ és $\lambda_{be}={\color{green}{0.92}}$ értékű. A kimeneten ugyanezeket várjuk. A súlytényezők:

$W_{\Omega A}=0.1$ $W_{\lambda A}=0.14$ $W_{A\alpha}=0.5$ $W_{A\beta}=0.56$

$W_{\Omega B}=0.17$ $W_{\lambda B}=0.22$ $W_{B\alpha}=0.9$ $W_{B\beta}=0.34$

$W_{\Omega C}=0.3$ $W_{\lambda C}=0.8$ $W_{C\alpha}=0.71$ $W_{C\beta}=0.2$

1. Bekapcsoláskor:

\[\large{\Omega_{ki}=\frac{2}{1 e^{-2\Omega_{be}}}-1=0.537}\]

\[\large{\lambda_{ki}=\frac{2}{1 e^{-2\lambda_{be}}}-1=0.7259}\]

\[A_{be}=(\Omega_{ki}\cdot W_{\Omega A})+(\lambda_{ki}\cdot W_{\lambda A})=0.1553; A_{ki}=\frac{2}{1+e^{-2A_{be}}}-1=0.1541\]

\[B_{be}=(\Omega_{ki}\cdot W_{\Omega B})+(\lambda_{ki}\cdot W_{\lambda B})=0.251; B_{ki}=\frac{2}{1+e^{-2B_{be}}}-1=0.2459\]

\[C_{be}=(\Omega_{ki}\cdot W_{\Omega C})+(\lambda_{ki}\cdot W_{\lambda C})=0.7418; C_{ki}=\frac{2}{1+e^{-2C_{be}}}-1=0.6302\]

\[\alpha_{be}=(A_{ki}\cdot W_{A\alpha})+(B_{ki}\cdot W_{B\alpha})+(C_{ki}\cdot W_{C\alpha})=0.7458\] \[ \alpha_{ki}=\frac{2}{1+e^{-2\alpha_{be}}}-1={\color{red}{0.6326} \text{ - csökkennie kell}}\]

\[\beta_{be}=(A_{ki}\cdot W_{A\beta})+(B_{ki}\cdot W_{B\beta})+(C_{ki}\cdot W_{C\beta})=0.7458\] \[ \beta_{ki}=\frac{2}{1+e^{-2\beta_{be}}}-1={\color{green}{0.2876} \text{ - nőnie kell}}\]

2. A kimeneti neuronok hibája közvetlenül kiszámítható a hibafüggvény bemenet szerinti parciális deriváltjából:

\[E_{\alpha}=\alpha_{ki}(1-\alpha_{ki})(\Omega_{be} \alpha_{ki})=-0.0076\]

\[E_{\beta}=\beta_{ki}(1-\beta_{ki})(\lambda_{be}-\beta{ki})=0.1296\]

3. Megváltoztatjuk a kimeneti réteg súlytényezőit:

\[W_{A\alpha}^{+}=W_{A\alpha}+E_{\alpha}A_{ki}=0.4988; W_{A\beta}^{+}=W_{A\beta}+E_{\beta}A_{ki}=0.58\]
\[W_{B\alpha}^{+}=W_{B\alpha}+E_{\alpha}B_{ki}=0.8981; W_{B\beta}^{+}=W_{B\beta}+E_{\beta}B_{ki}=0.3719\]
\[W_{C\alpha}^{+}=W_{C\alpha}+E_{\alpha}C_{ki}=0.7052; W_{C\beta}^{+}=W_{C\beta}+E_{\beta}C_{ki}=0.2817\]

4. Kiszámítjuk (visszaterjesztjük) a hibákat a rejtett rétegbe. Most sajnos nem lehet közvetlenül kiszámolni, mert nem ismerjük a célértéket, ezért visszaterjesztjük a hibát a kimeneti réteg két neuronjából:

\[E_A=A_{ki}(1-A_{ki})(E_{\alpha}W_{A\alpha}-E_{\beta}W_{A\beta})=-0.01\]
\[E_B=B_{ki}(1-B_{ki})(E_{\alpha}W_{B\alpha}-E_{\beta}W_{B\beta})=-0.0094\]
\[E_C=C_{ki}(1-C_{ki})(E_{\alpha}W_{C\alpha}-E_{\beta}W_{C\beta})=-0.0073\]

5. Megváltoztatjuk a rejtett réteg súlytényezőit:

\[W_{\lambda A}^{+}=W_{\lambda A}+E_A \lambda_{be}=0.1308; W_{\Omega A}^{+}=W_{\Omega A}+E_A \Omega_{be}=0.094\]
\[W_{\lambda B}^{+}=W_{\lambda B}+E_B \lambda_{be}=0.2114; W_{\Omega B}^{+}=W_{\Omega B}+E_B \Omega_{be}=0.1644\]
\[W_{\lambda C}^{+}=W_{\lambda C}+E_C \lambda_{be}=0.7933; W_{\Omega C}^{+}=W_{\Omega C}+E_C \Omega_{be}=0.2956\]

6. Tanulás után az értékek megváltoztak:

\[A_{be}=(\Omega_{ki}\cdot W_{\Omega A}^{+})+(\lambda_{ki}\cdot W_{\lambda A}^{+})=0.1454; A_{ki}=\frac{2}{1+e^{-2A_{be}}}-1=0.1444\]

\[B_{be}=(\Omega_{ki}\cdot W_{\Omega B}^{+})+(\lambda_{ki}\cdot W_{\lambda B}^{+})=0.2417; B_{ki}=\frac{2}{1+e^{-2B_{be}}}-1=0.2371\]

\[C_{be}=(\Omega_{ki}\cdot W_{\Omega C}^{+})+(\lambda_{ki}\cdot W_{\lambda C}^{+})=0.7346; C_{ki}=\frac{2}{1+e^{-2C_{be}}}-1=0.6259\]

\[\alpha_{be}=(A_{ki}\cdot W_{A\alpha}^{+})+(B_{ki}\cdot W_{B\alpha}^{+})+(C_{ki}\cdot W_{C\alpha}^{+})=0.7264\] \[\alpha_{ki}=\frac{2}{1+e^{-2\alpha_{be}}}-1={\color{red}{0.6209} \text{ - lecsökkent}}\]

\[\beta_{be}=(A_{ki}\cdot W_{A\beta}^{+})+(B_{ki}\cdot W_{B\beta}^{+})+(C_{ki}\cdot W_{C\beta}^{+})=0.3482\] \[ \beta_{ki}=\frac{2}{1+e^{-2\beta_{be}}}-1={\color{green}{0.3348} \text{ - megnőtt}}\]

7. A hibáknak közelebb kellett kerülniük nullához:

\[E_{\alpha}=\alpha_{ki}(1-\alpha_{ki})(\Omega_{be}-\alpha_{ki})=-0.0049\]

\[E_{\beta}=\beta_{ki}(1-\beta_{ki})(\lambda_{be}-\beta_{ki})=0.1303\]

Példa - Matlabban

A fenti példát Matlabba átültetve megvizsgálható, hogy hány lépéssel tanulja meg a leckét a hálózat, ha a hibahatár például $\pm 0.00001$. A Matlabról tudni kell, hogy nem ismer olyant hogy bemenő réteg. A legelső réteget már rejtett rétegként kezeli, ezért ha ez 2 neuronból áll ($\Omega$ és $\lambda$), akkor a 2 bemenet mindkettőhöz egyaránt csatlakozik. Hogy a fenti példát pontosan utánozni lehessen, a bemenő réteg elmarad, a bemenő két neuron helyett a két bemenet lesz, pontosabban azok kimeneti alakja:$\Omega_{be}={\color{red}{0.537}}$ és $\lambda_{be}={\color{green}{0.7259}}$ marad. Érdemes megnézni, hogy milyen tulajdonságokkal rendelkezik a neurális hálózati objektum és melyek azok amiket módosítani kell.

>> feedforwardnet

ans =

Neural Network ---> ezek a paraméterek string típusok

name: 'Feed-Forward Neural Network' ---> marad alapértelmezett

userdata: (your custom info) ---> marad alapértelmezett

dimensions: ---> ezek a paraméterek integer típusok

numInputs: 1 ---> 2 bemenet

numLayers: 2 ---> 2 réteg

numOutputs: 1 ---> csak olvasható

numInputDelays: 0 ---> marad alapértelmezett

numLayerDelays: 0 ---> marad alapértelmezett

numFeedbackDelays: 0 ---> marad alapértelmezett

numWeightElements: 10 ---> csak olvasható

sampleTime: 1 ---> Simulinkben használatos

connections: ---> ezek a paraméterek boolean mátrixok

biasConnect: [1; 1] ---> nincs torzítás

inputConnect: [1; 0] ---> 2 bemenet az 1. rétegbe

layerConnect: [0 0; 1 0] ---> marad előrecsatolt

outputConnect: [0 1] ---> kimenet 2. rétegből

subobjects: ---> ezeknek a paramétereknek további altulajdonságai vannak

inputs: {1x1 cell array of 1 input} ---> méret=1, tartomány=[-1 1]

layers: {2x1 cell array of 2 layers} ---> név, méret, transzferfüggvény

outputs: {1x2 cell array of 1 output} ---> marad alapértelmezett

biases: {2x1 cell array of 2 biases} ---> marad alapértelmezett

inputWeights: {2x1 cell array of 1 weight} ---> tanulás szimpla gradienssel

layerWeights: {2x2 cell array of 1 weight} ---> tanulás szimpla gradienssel

functions: ---> a függvényeket a metódusok használják

adaptFcn: 'adaptwb' ---> nincs rá szükség (adapt)

adaptParam: (none) ---> nincs rá szükség (adapt)

derivFcn: 'defaultderiv' ---> marad alapértelmezett

divideFcn: 'dividerand' ---> csak a tanítómintákra

divideParam: .trainRatio, .valRatio, .testRatio---> nincs rá szükség

divideMode: 'sample' ---> marad alapértelmezett

initFcn: 'initlay' ---> marad alapértelmezett (init)

performFcn: 'mse' ---> marad alapértelmezett

performParam: .regularization, .normalization ---> marad alapértelmezett

plotFcns: {'plotperform', plottrainstate, ploterrhist, plotregression}

plotParams: {1x4 cell array of 4 params} ---> nincs rá szükség (plotsom)

trainFcn: 'trainlm' ---> Visszaterjesztés gradienssel

trainParam: .showWindow, .showCommandLine, .show, .epochs, .time, .goal,

.min_grad, .max_fail, .mu, .mu_dec, .mu_inc, .mu_max

weight and bias values: ---> ezek a paraméterek double mátrixok

IW: {2x1 cell} containing 1 input weight matrix ---> kezdeti sulyok

LW: {2x2 cell} containing 1 layer weight matrix ---> kezdeti sulyok

b: {2x1 cell} containing 2 bias vectors ---> nincs rá szükség

methods: ---> metódusok, melyek a fenti paramétereket és függvényeket használják

adapt: Learn while in continuous use

configure: Configure inputs & outputs

gensim: Generate Simulink model

init: Initialize weights & biases

perform: Calculate performance

sim: Evaluate network outputs given inputs

train: Train network with examples ---> csak erre van szükség

view: View diagram ---> és talán erre

unconfigure: Unconfigure inputs & outputs

evaluate: outputs = ans(inputs)

A paraméterek módosítását a fenti sorrendben kell elvégezni. Érdemes erre egy függvényt írni, majd meghívni azt:

function [net] = pelda()

net = feedforwardnet; % ures kezdeti halozat objektum

% Dimenziok

net.numInputs = 2; % 2 bemenet

net.numLayers = 2; % 2 reteg

% Kapcsolatok

net.biasConnect = [0; 0]; % nincs torzitas

net.inputConnect = [1 1; 0 0]; % 2 bemenet az 1. retegbe

% Alobjektumok

net.inputs{1}.range = [-1 1]; % 1.bemenet tanitomintainak tartomanya

net.inputs{2}.range = [-1 1]; % 2.bemenet tanitomintainak tartomanya

net.inputs{1}.size = 1; % 1.bemenetre 1 tanitominta

net.inputs{2}.size = 1; % 2.bemenetre 1 tanitominta

net.layers{1}.name = 'Rejtett'; % 1.reteg neve

net.layers{2}.name = 'Kimeno'; % 2.reteg neve

net.layers{1}.size = 3; % 1.reteg neuronjainak szama

net.layers{2}.size = 2; % 2.reteg neuronjainak szama

net.layers{1}.transferFcn='tansig'; % 1.reteg transzferfuggvenye

net.layers{2}.transferFcn='tansig'; % 2.reteg transzferfuggvenye

net.inputWeights{1,1}.learnFcn='learngd'; % 1.beemnet - 1.reteg kozti tanulas

net.inputWeights{1,2}.learnFcn='learngd'; % 2.beemnet - 1.reteg kozti tanulas

net.layerWeights{2,1}.learnFcn='learngd'; % 2.-1. retegek kozti tanulas

% Fuggvenyek

net.divideFcn = 'dividetrain'; % csak a tanitomintakra indexeljen

net.trainFcn = 'traingd'; % visszaterjesztes gradienssel

net.trainParam.lr=1; % az algoritmus tanitasi tenyezoje

% Sulyok

net.IW{1,1}=[0.1; 0.17; 0.3]; %1.reteg 1.bemenetenek sulyai

net.IW{1,2}=[0.14; 0.22; 0.8]; %1.reteg 2.bemenetenek sulyai

net.LW{2,1}=[0.5 0.9 0.71; 0.56 0.34 0.2]; %2. es 1.reteg kozotti sulyok

end

>> net=pelda();

>> view(net)

A kimenő rétegnek csak egy kimenete lehet, tehát a két kimenetet ebben az esetben egymás után helyezi.

Bemenő adatok és céladatok:

>> be=[0.537; 0.7259];

>> cel=[0.6; 0.92];

Tanítás előtt a súlyértékek és a kimenet:

>> net.IW{1,1}

ans =

0.1000 ---> $W_{\Omega A}$

0.1700 ---> $W_{\Omega B}$

0.3000 ---> $W_{\Omega C}$

>> net.IW{1,2}

ans =

0.1400 ---> $W_{\lambda A}$

0.2200 ---> $W_{\lambda B}$

0.8000 ---> $W_{\lambda C}$

>> net.LW{2,1}

ans =

0.5000 0.9000 0.7100 ---> $W_{A \alpha}$ $W_{B \alpha}$ $W_{C \alpha}$

0.5600 0.3400 0.2000 ---> $W_{A \beta}$ $W_{B \beta}$ $W_{C \beta}$

>> net(be)

ans =

0.6326 ---> csökkennie kell

0.2876 ---> nőnie kell

A függvényben tanulási tényező értéke 1 lett, hogy ne lassítsa a tanulási folyamatot, bár ettől függetlenül a hálózat előbb utóbb úgyis megtanulja a mintákat, amennyiben a megfelelő algoritmust választottuk.

>> [ujnet tr]=train(net,be,cel);

>> ujnet(be)

ans =

0.6000 ---> lecsökkent

0.9200 ---> megnőtt

A tanítás leállítását érdemes a hibafüggvény deriváltjához (gradienséhez) fűzni. Ez tulajdonképpen a kiszámított hibák összege, ami ha eléri 0.00001-et, akkor megállhatunk, hisz jelen esetben csak 4 tizedes pontosságra van szükség. A hálózat 166-szor vette át a leckét (epoch), azaz 166-szor módosított a súlytényezőkön. Kisebb tanítási tényezővel még többet módosított volna de jóval kisebb mértékben. A fenti ablak is a tanítóparaméter egyik tulajdonsága (net.trainParam.showWindow), ami lehetőséget ad kirajzoltatni néhány eseménygörbét is. Az, hogy a hálózat mikor gyorsabb és mikor pontosabb, az a tanító algoritmustól, valamint a hiba- és a transzferfüggvénytől függ leginkább, aminek kiválasztása többnyire tapasztalti adatok alapján történik, és erre alkalmas a következő lágyszámítási módszer, a Fuzzy logika. A hálózat végterméke viszont nem maga a tanítás, hanem súlytényezők, melyekkel elérhető a célérték az adott tanítómintára az adott hibahatáron belül. Ebben a példában ezek a következők:

>> ujnet.IW{1,1}

ans =

0.4153 ---> $W_{\Omega A}$

0.2727 ---> $W_{\Omega B}$

0.4132 ---> $W_{\Omega C}$

>> ujnet.IW{1,2}

ans =

0.5662 ---> $W_{\lambda A}$

0.3589 ---> $W_{\lambda B}$

0.9531 ---> $W_{\lambda C}$

>> ujnet.LW{2,1}

ans =

0.2729 0.7180 0.3638 ---> $W_{A\alpha}$ $W_{B\alpha}$ $W_{C\alpha}$

0.9739 0.7389 1.0477 ---> $W_{A\beta}$ $W_{B\beta}$ $W_{C\beta}$

Fuzzy logika

Sok tanítási módszer létezik, legtöbbjük az eddig felsoroltak további variánsa, melyek közül sok egymással is kombinálható. Mi van akkor, ha nem tudjuk, hogy melyik a megfelelő? A biológiai idegrendszer sem tudja mindig, hogy adott helyzetben hogyan reagáljon. Tapasztalat során alakul ki, hogy mikor hogyan kell dönteni, ilyenkor úgymond "rendszereződnek a transzfer-függvények". Az eddig bemutatott neurális hálózatépítés úgy történt, hogy a transzfer függvényt, a hálózati struktúrát vagy az egyéb jellemzőket az ember választotta ki, mert tapasztalatból vagy mások tapasztalatából tudta hogy az adott feladatra melyik a legalkalmasabb. A hálózatnak ezek után csak az volt a dolga hogy használja azt, és megtanulja a bemenő adatokat osztályozni. A helyes struktúrát és a helyes transzfer függvényeket kísérletezéssel is ki lehet küszöbölni (pl. növekvő vagy csökkenő hálózatépítés), de van egy olyan logika, a Fuzzy logika, ami ezt sokkal egyszerűbbé teszi. A fuzzy logika és a neurális hálózat kombinációját neuro-fuzzy rendszernek, vagy a mesterséges intelligencia területén hibrid intelligencia rendszernek nevezik.

A fuzzy logika gyakorlatilag egy olyan halmazelméletre épül, ami leírhatóvá teszi a bizonytalanságot. A bizonytalanság általában vagy az események véletlenszerűségéből, vagy az információ félreérthetőségéből és pontatlanságából származik. Amikor a bizonytalanság a véletlen eseményekből ered, akkor a valószínűség számítás a megfelelő eszköz annak leírására. Bizonyos dolgokról statisztikát lehet készíteni, hogy milyen bemenetre milyen kimenet szokott lenni. A legtöbb bizonytalanságot azonban, főleg a komplex rendszerek esetén, az információ hiány váltja ki. Az olyan bizonytalanság, ami a rendszer komplexitása miatt merül fel, az a pontatlanságból származik, amikor is képtelenség megfelelő méréseket végezni az ismeretek hiánya vagy homályossága (fuzziness) miatt. Az ilyen fajta bizonytalanságot nem lehet képletesen levezetni, viszont a fuzzy halmazelmélet képes modellezi a fuzzy logika segítségével.

A biológiában olyan ez, mint mikor az ember ismeretlen kézírást olvas. Az információ ami eléje tárul pontatlan és ködös, de tapasztalatból tudja hogyan próbálkozhat elolvasni. Az emberi gondolkodás tehát nem bináris (igaz vagy hamis), hanem árnyalt (részben igaz és részben hamis) és mindig van egy tapasztalati (megtanult) alap, amihez viszonyítani lehet: mihez képest igaz és mihez képest hamis. Ezért is hívják ezt lágyszámításnak mert puhák, pontatlanok a határok. A "részben" szót százaléknak lehet tekinteni, például valami lehet 17%-ban igaz. Minden állításnak van egy igazságfüggvénye, ahol egyik tengely az igazságérték, másik a változó (adat).

Az igazságfüggvény a változótól függ és azt mutatja, hogy az adott változó mikor milyen értéknél számít igaznak. A fenti ábrán például a gyorsaság igazságfüggvénye látható. Egy "éles logikájú" számítógépes program ezt logikai egységugrással ábrázolná, 60km/óra felett az autó gyorsan, alatta nem halad gyorsan. A fuzzy görbe ezt jobban részletezi és nyelvezete sokkal jobban hasonlít az emberéhez. A görbe jobbra-balra csúsztatásával beállítható, hogy a 60km/óra mennyire számítson gyorsnak. Ez viszont nagyon relatív. Az ember fejében vezetés közben olyan gondolatok születnek, mint például "kicsit gyorsabban" és " ez már túl gyors". Ezek nem konkrét adatok, súlytényezők vagy számhalmazok, hanem homályos, pontatlan adatok. Mikor ezt másvalakitől hallja a sofőr (például az oktatótól), sokszor bizonytalanságot kelthet benne, de miután átlátja a helyzetet rájön hogy mit is jelentenek ezek pontosan. Ezt fuzzy logikával végzi. Ha ezeket az oktató egy számítógépnek mondja, akkor az nem tud mit kezdeni vele, kivéve hogyha rendelkezik egy olyan adathalmazzal, amiben benne van a "kicsit" és a "túl" igazságértéke. Ahhoz, hogy ilyennel rendelkezzen, méréseket kell végezni fel kell építeni egy fuzzy halmazkészletet. Ha ez megvan, kell venni a halmazokat, például a "gyors" halmazt és igazságértékeket rendelni az elemekhez. A halmaz elemei a mért adatok, ebben az esetben sebesség. Az igazságértéket tagsági értéknek is nevezik, mert elárulja, hogy az adat milyen mértékben tagja a "gyors" halmaznak. Ennek értelmében egy változó több halmazhoz is tartozhat, például a 30km/óra alatti értékek tagjai lehetnek a "lassú" halmaznak 0,5 feletti tagságértékkel. Ahogyan a fenti ábrán is a halmazhoz tartozó két érték alapján kirajzolódik egy görbe. Ez lehetne lineáris, szinuszos, lépcsős, Gauss, vagy akármilyen más, ebben az esetben éppen szigmoid alakú. Ezt tagságfüggvénynek vagy igazságfüggvénynek nevezik. A következő példa a fuzzy halmazok összefonódhatóságát szemlélteti:

Az, hogy mikor vagy hol alacsony és magas az üzemanyag az sok mindenhez viszonyítható: az időhöz, a szolgáltatóhoz, az országhoz, a minőséghez. Ezektől függetlenül elmondható, hogy a termelő szemszögéből a jó üzemanyagár 1,1 eurótól kezdődik. A fenti ábrán az 1,38 eurós összeg egyaránt számít jónak és magas árnak, de inkább magasnak (0,85) mint jónak (0,15). Ha a minőséget nézzük, ami lehet nagyon jó, akkor ezt az értéket inkább jónak, és nem magasnak ítélik. Az, hogy egy érték hová kerüljön, az halmazművelettel válik el (egyesítés - OR, metszés - AND, komplementer - NOT). Metszés során az 1,38 a "Jó" halmazhoz, egyesítés során a "Magas" halmazhoz fog tartozni. Hogy ezek közül melyiket kell használni azt a szabályok határozzák meg. A fuzzy halmazrendszernek tehát vannak szabályai. Az AND, OR és NOT alakú szabályokkal felépített következtetést megközelítő következtetésnek hívják.

Minden olyan program, ami mérési adatok alapján IF...THEN... szabályokat állít fel, az fuzzy logikával dolgozik. Ilyen például az olyan mosógép, amely a szennyezettség alapján adagolja a mosószert, az automata váltós autó, orvosi riasztórendszerek, az autók ABS rendszere, az automata pilótás metró, az automatikus fényképezőgép, a fordított inga elvén működő egyensúlyozó (segway), vagy a manuális képfókuszáló stb. A gépjárművekben és a liftekben az automata fék programja is tapasztalati értékek alapján dönti el, hogy mikor mennyire kell lassítani. Az fuzzy rendszer blokkvázlata a következő:

A rendszerben csak a zöld blokkok végeznek munkát. A bemenő változók a mérési adatok, a bemenő tagsági függvények pedig ezen adatok igazságértékei. Ezek alapján az adatokat a konkrét-fuzzy átalakító (fuzzifikáló) ködös értékké alakítja. Például ha a bemenő változó 45km/óra ami a tagsági függvényen 20%-os gyorsaságnak felel meg, akkor az átalakító kimenetén a "lassú" érték jelenik meg. A fuzzy szabályok eldöntik, hogy milyen értéknél hogyan kell reagálni, például "kicsit gyorsabban" vagy "sokkal gyorsabban" kell-e menni. A szabályokat szakértők fogalmazzák meg (tehát nem matematikusok), akik tapasztalatból, mérésekből tudják, hogy milyen értékre hogyan kell reagálni. A következtető (vagy inferencia) rendszer ezen szabályok alapján ismét ködös választ ad, pl. "kicsit gyorsabban", amit ismét konkrét értékké kell alakítani, hiszen a vezérlő csak arra kíváncsi, hogy konkrétan milyen sebességre gyorsítson. A rendszer legérzékenyebb pontja a következtető rendszer. Sokszor előfordul, hogy egyszerre több szabály is igaz az adott értékre. Egyik jobban, másik kevésbé, tehát egy olyan kiválasztó mechanizmus kell, amely megnézi melyik a legerősebb szabály, vagy átlagolja őket vagy pedig középértéket számol. A fuzzy-konkrét átalakító (defuzzifikáló) ezek után megnézi, hogy a „kicsit gyorsabban” kifejezésnek mekkora az igazságértéke. Ez lehet például 10%-os gyorsulás. Ebben az esetben az autó 49.5km/órára fog gyorsulni. A fuzzy logika előnye az, hogy probléma nélkül lehet alkalmazni a mostani gépeken, mert az észre sem veszi hogy megváltozott valami, továbbra is a bináris adatokat fogja látni.

Úgy is lehet fogalmazni, hogy a fuzzy logikával a technikába ültethető az, amit csak szóval lehet elmondani, de bizonyítani, levezetni nem lehet a matematikában. Emiatt mondják azt, hogy a neurális hálózatok tervezése sokkal inkább művészet, mintsem mérnöki munka. Egyébként a kémiában, biológiában, földrajztudományban, csillagászatban vagy bármilyen természettel kapcsolatos tudományágban nagy szerepet játszik a fuzzy logika, hisz a folyamatok nagy részét nem lehet matematikai egyenletekkel levezetni, nem lehet matematikai modellel jellemezni.

A konkrét-fuzzy átalakító

A fuzzy átalakítók a bemenetnél és a kimenetnél is rendelkezhetneknek tagsági függvényekkel. Ezek a változók igazságértékét adják meg, egészen pontosan halmazokba sorolják őket. Az „igaz” és „hamis” halmaz viszont nem feltétlenül diszjunkt, lehet közös elem is. A hagyományos logikának ez ellentmond, mert abban nincs olyan hogy egy változó egyszerre igaz is és hamis is. A fuzzy logikában sincs ilyen, viszont van olyan, hogy egyik változó igazabb mint a másik. Például egy 180 cm magasságú ember magasnak számít, de a 2m-es ember még magasabbnak. Ettől fogva a 180 cm magasság részben alacsonyt is jelent. Az adatokhoz hozzárendelt igazságértékeket 0 és 1 közé szokás normalizálni:

\[Alacsony=[130_1, 140_{0.9}, 150_{0.7}, 160_{0.5}, 170_{0.3}, 180_{0.2}, 190_{0.1}, 200_0]\]

\[Magas=[130_0, 140_{0.1}, 150_{0.3}, 160_{0.5}, 170_{0.7}, 180_{0.8}, 190_{0.9}, 200_1]\]

A változóhoz hozzárendelt igazságértékek tehát a tagsági értékek, melyek szintén egy halmazt alkotnak. Ha $U$ a magasság halmaza és $A$ a tagsági értékek halmaza, akkor elmondható, hogy $A\subset U$. Legyen $x$ az $U$ halmazban lévő tulajdonság és $\mu_A$ az $A$ halmazban lévő tagsági érték, ami 0 és 1 között mozog ($\mu_A:A\rightarrow[0,1]$). Az $A$ fuzzy részhalmaz a következőképp írható fel:

\[A=\{{(x,\mu_A(x))|x\in U}\}\]

ahol $\mu_A(x)$ a tagsági függvény. Diszkrét esetben a fuzzy halmaz a következőképp írható fel:

\[A=\displaystyle\sum_{i=1}^{n}\frac{\mu_A(x_i)}{x_i}\]

Folytonos esetben pedig a következőképp:

\[A=\displaystyle\int_x\frac{\mu_A(x)}{x}\]

A klasszikus halmazban a tagsági függvénynek két értéke lehet:
\[\mu_A(x)=1\text{, ha } x\in U\] \[\mu_A(x)=0\text{, ha }x \notin U\]

\[Alacsony=[130_1, 140_1, 150_1, 160_1, 170_0, 180_0, 190_0, 200_0]\]

\[Magas=[130_0, 140_0, 150_0, 160_0, 170_1, 180_1, 190_1, 200_1]\]

A tagsági függvényre nincs szabály, akármilyen alakú lehet, hisz az mérési adatok alapján rajzolódik meg, nem pedig képletesen. Ennek ellenére megkülönböztethetünk 3 tagsági függvénytípust:

a) Trapéz típus

Lineárisan változó tagságértékek esetén. Trapéz, lépcsős és háromszögfüggvények alakíthatóak ki. Például:

b) Gauss típus

Nem lineárisan, de szimmetrikusan változó tagságértékek esetén. Ennél a középpont (c) és a szórás mértéke $\sigma$ a paraméter. A Bell függvény esetén a középpont (c), a kitöltés (a) és a meredekség (b). Például:

c) Szigmoid típus

Nem lineárisan és nem is szimmetrikusan változó változó tagságértékek esetén. A paraméterek: meredekség (a), központ (c). Például:

A tagsági függvény legtöbb esetben összerakható ebből a három típusból, de nem kötelező ezeket használni. Minden halmaznak egyedi tagsági függvénye is lehet, főleg ha nagyon eltérő tulajdonságokról van szó, ez azonban nem okoz különösebb problémát. Problémát az jelenthet, ha egy változónak egyforma tagsági értéke van különböző halmazokban. Például a 160cm testmagasság 50%-ban alacsonynak és 50%-ban magasnak számít. Ez egy olyan eset, amikor az adott változóra egyszerre két szabály érvényesül (például, az alacsonyak üljenek jobb oldalt, a magasak pedig bal oldalt). Ilyenkor valahogyan el kell dönteni, hogy mi legyen a 160cm magas személyekkel. Ezt a következtető (inference) rendszer oldja meg.

A következtető rendszer

A fuzzy halmaz nem más, mint egy tagságot jelölő számhalmazzal ellátot klasszikus halmaz. Ilyenkor újra kell értelmezni a halmazműveleteket (egyesítés, metszet, negáció), azonban a fuzzy halmazok tényeket szimbolizálnak, ezért logikai műveletekként kell ezeket értelmezni. Legyen $\mu_A(x)$ az $A$ fuzzy halmaz tagságfüggvénye, és $\mu_B(x)$ a $B$ fuzzy halmaz tagságfüggvénye.

Metszés (AND)

Ez a művelet $A$ és $B$ halmaz közös elemeit válogatja ki. A közös elemekből azok kerülnek az eredménybe, melyeknek kisebb a tagsági értékük.

\[\mu_{A\cap B}(x)=\textbf{min}(\mu_A(x),\mu_B(x))=\mu_A(x)\cdot\mu_B(x)\]

Például:

\[\mu_{A\cap B}(15)=\textbf{min} (\mu_A(15),\mu_B(15))=\textbf{min}(a,0)=0\]

\[\mu_{A\cap B}(22)=\textbf{min} (\mu_A(22),\mu_B(22))=\textbf{min}(0.75,0.13)=0.13 \Rightarrow B(22)\]

Egyesítés (OR)

Ez a művelet $A$ és $B$ halmaz elemeit egyesíti. A közös elemekből azok kerülnek az eredménybe, melyeknek nagyobb a tagsági értékük.

\[\mu_{A\cup B}(x)=\textbf{max} (\mu_A(x),\mu_B(x))=\mu_A(x)+\mu_B(x)-\mu_A(x)\cdot \mu_B(x)=\] \[=1-(1-\mu_A(x))(1-\mu_B(x))\]

Negáció (NOT)

Ez a művelet az $A$ halmaz komplementerét képzi le, azaz a halmaz fordítottját. Ez ugyanaz, mintha a halmaz legnagyobb eleméből kivonná az összes többit. A tagsági értékek halmazában a legnagyobb érték 1.

\[\mu_{\overline{A}}(x)=1-\mu_A(x)\]

Implikáció (IF...THEN...)

Legyen $P$ a hipotézis és $Q$ a konklúzió. Az implikáció formája: $P\rightarrow Q$

Az IF $P$ THEN $Q$ eredménye $P\rightarrow Q$. A $P$ implikálja $Q$-t azt jelenti, hogy $Q$ nem lehet hamis amikor $P$ igaz. Más minden egyéb lehetséges. Úgy is mindható, hogy $Q$ legalább annyira igaz mint $P$. Ha ezt boolean logikával ábrázoljuk (és a halmazok tagsági függvényeit vesszük), akkor:

*µ_P(x)*	*µ_Q(x)*	*µ_P-->Q(x)*
0	0	1
0	1	1
1	0	0
1	1	1

Az implikáció akkor igaz, ha $\mu_P(x)\leq\mu_Q(x)$, különben hamis. Ezt standard implikációnak hívják. Az implikációt sokféleképp lehet értelmezni:

Larsen: $P\rightarrow Q = PQ$
Lukasiewicz: $P\rightarrow Q=\textbf{min}(1,1-P+Q)$
Mamdani: $P\rightarrow Q =\textbf{min}(P,Q)$
Standard: $P\rightarrow Q = \begin{cases} 1 & \text{ha } P\leq Q \\ 0 & \text{különben} \\ \end{cases}$
Gödel: $P\rightarrow Q = \begin{cases} 1 & \text{ha } P\leq Q \\ Q & \text{különben} \\ \end{cases}$
Gaines: $P\rightarrow Q = \begin{cases} 1 & \text{ha } P\leq Q \\ Q/P & \text{különben} \\ \end{cases}$
Kleene-Dienes: $P\rightarrow Q=\textbf{max}(1-P,Q)$
Kleene-Dienes-Luk: $P\rightarrow Q = 1-P+PQ$

Leggyakrabban a Mamdani értelmezést alkalmazzák, mert ennek a legkevesebb a számításigénye. Mamdani a korrelációs-minimummal értelmezte az implikációt:

\[\mu_{P\rightarrow Q}(x)=\textbf{min}(\mu_P(x),\mu_Q(x))\]

Például vizsgáljuk meg az „IF x ϵ alacsony THEN y ϵ magas” implikációt. Legyen $P$ az alacsonyak és $Q$ a magasak halmaza. A két halmaznak nagyjából különbözik az értéktartománya $(x_P\neq y_Q)$.

Hogy x az alacsonyak halmazából legyen, 150-nél kisebbnek kell választani, például x=120.

\[\mu_{P\rightarrow Q}(120)=\textbf{min}(\mu_P(120),\mu_Q(y))=\textbf{min}(0.4, \mu_Q(y))\]

Az implikáció eredménye minden 0.4-nél kisebb tagságértékű adat a $Q$ halmazban (sárga választerület). Ez egy újabb halmaz, melynek más a tagsági függvénye is:

A halmazba beletartozik minden 145-170 és 270-300 közötti magasság, ami eléggé pontatlan. Az eredmény tehát fuzzy, nem konkrét, mert egyidejűleg több érték is helyes. Át kell konvertálni, deffuzifikálni.

A Mamdani módszeren kívül még a Sugeno módszert is gyakran használják. Ez nagyon hasonló a Mamdanihoz azzal a különbséggel, hogy a tagságfüggvények kimenete lineáris vagy konstans és ezért nincs szükség a fuzzy-konkrét átalakítóra. Például:

IF bemenet1 = x AND bemenet2 = y THEN z = ax+by+c

Mindenik szabály megsúlyozza a kimeneti szintjét, tehát a kimenet $w\cdot z$ lesz. Ha $N$ szabály van, akkor a végső kimenet:

\[kimenet=\frac{\displaystyle\sum_{i=1}^{N}w_i z_i}{\displaystyle\sum_{i=1}^{N}w_i}\]

A súlyt teljesítési mértéknek is nevezik, mert meghatározza, hogy egy fuzzy szabály előzménye milyen mértékben teljesülhet. A súlyozott átlagszámítás tulajdonképpen a deffuzifikálást helyettesíti, ami bár egyszerűsít a dolgokon (megkönnyítve a számításokat), de csökkenti a tagságfüggvények szókincsét.

A következtető rendszer

Minden rendszer feladata, hogy egy adott bemenetre előállítson valamilyen kimenetet, lehetőleg egyet és konkrétat. Amennyiben a rendszer szabályai nem konkrét, hanem fuzzy kimenetűek, akkor a kimenetet „élesíteni” kell, konkréttá tenni. Ezt ismét tagsági függvényekkel lehet elérni, azaz tapasztalati adatokból. Az előző példában olyasmi lehetett az eredeti probléma, hogy HA egy villanyszerelő x cm alacsony, AKKOR álljon egy y cm magas székre, hogy érje fel pl. a lámpát a szobában. Tapasztalatból tudjuk, hogy egy átlagos szoba magassága nem sokkal több 3m-nél, ezért a 145...170 érték közül kell választani. További körülmények alapján eldönthető hogy ennek az elejéről, közepéről vagy végéről kell választani. Olyan helyzetek is előfordulhatnak, ahol a szélsőértékek között (145...300) bármelyik jó. Nem számít, ha ezek tagsági értéke nulla, hisz az is 0.4 alatt van. Ilyenkor az ember a hasára csap és azt mondja, hogy legyen a középső, 220, de soha nem mond olyat, hogy „legyen a középső előtt 3-mal” mert annak már tényleg semmi értelme. Éppen ezért matematikai módszerekkel is fel lehet írni a az eljárásokat melyek közül választani kell. Néhány közülük:

a) Maximum módszerek

- Első maximum (FOM - First Of Maximum vagy SOM - Smallest Of Maximum): $SOM=c_1$

- Középső maximum (MOM - Middle Of Maximum vagy Mean Of Maximum): $MOM=\frac{c_1+c_2}{2}$

- Utolsó maximum (LOM - Last Of Maximum): $LOM=c_2$

- Maximum középérték módszer (COM - Center Of Maximum)

\[COM=\frac{\displaystyle\sum_{j=1}^{m}c_j\cdot\mu(c_j)}{\displaystyle\sum_{j=1}^{m}\mu(c_j)}\]

b) Súlypont vagy első momentum módszer (COG - Center of Gravirty, Centroid)

A súlypont módszer a választerületre mint tömegre tekint, melyet a gravitáció lefelé húz. Kiszámítjuk a párhuzamos erők eredőjét és az ahhoz a ponthoz tartozó adat lesz a keresett konkrét érték.

\[\mu_{er}(c)=\displaystyle\sum_{j=1}^{m}\mu_{B_j}(c)\] \[COG=\frac{\displaystyle\int c\displaystyle\sum_{j=1}^{m}\mu_{B_j}(c)dc}{\displaystyle\int\displaystyle\sum_{j=1}^{m}\mu_{B_j}(c)dc}=\frac{\displaystyle\sum_{j=1}^{m}\displaystyle\int c\mu_{B_j}(c)dc}{\displaystyle\sum_{j=1}^{m}\displaystyle\int \mu_{B_j}(c)dc}=\frac{\displaystyle\sum_{j=1}^{m} M_j}{\displaystyle\sum_{j=1}^{m} A_j}\]

ahol $M_j$ a momentum, $A_j$ a felület.

c) Felező módszer (COA - Center Of Area, Bisector)

A válaszfelületet két egyenlő területre bontja, és a felezési pontnál lesz a konkrét érték.

\[COA=\frac{\displaystyle\int_{c_1}^{c_2}c\cdot\mu(c)dc}{\displaystyle\int_{c_1}^{c_2}\mu(c)dc}\]

d) Magasság módszer (HM – Height Method)

Ez csak akkor működik, ha a kimenő tagsági függvények szimmetrikus függvények következményei. Ilyen például a Sugeno modell. A módszert két lépésre lehet bontani: először a kimenő tagsági függvényből ($F_i$) kihozzuk a konkrét értéket: $x=f_i$, ahol $f_i$ a súlyközéppontja $F_i$-nek. Ezután a konkrét értékekre alkalmazzuk a súlypont módszert:

\[HM=\frac{\displaystyle\sum_{i=1}^{M}w_i f_i}{\displaystyle\sum_{i=1}^{M}w_i}\]

ahol $w_i$ annak mértéke, miszerint az $i.$ szabály érvényes a bemenetre.

Példa - levezetve

Építsünk egy olyan fuzzy szakértői rendszert, mely segít ajánlatot tenni egy olajgyár fejlődési szükségére. Ehhez szükség van az olajárakra (mit jelent az olcsó, megfelelő, drága) és a gyár olajtartalék mennyiségére (mit jelent a kevés, elegendő, sok). A két bemeneti változó:

A megközelítő következtetést fuzzy szabályokkal állítsuk fel. Mivel két bemenő változó van és mindeniknek 3 fuzzy halmaza, ezért $3^2=9$ szabály lesz összesen:

IF olajár = drága AND olajtartalék = kevés THEN fejlesztés = kötelezően ajánlott (KA)
IF olajár = drága AND olajtartalék = elegendő THEN fejlesztés = szigorúan ajánlott (SzA)
IF olajár = drága AND olajtartalék = sok THEN fejlesztés = mérsékelten ajánlott (MA)
IF olajár = megfelelő AND olajtartalék = kevés THEN fejlesztés = mérsékelten ajánlott (MA)
IF olajár = megfelelő AND olajtartalék = elegendőTHEN fejlesztés = óvatosan ajánlott (OA)
IF olajár = megfelelő AND olajtartalék = sok THEN fejlesztés = óvatosan ajánlott (OA)
IF olajár = olcsó AND olajtartalék = kevés THEN fejlesztés = óvatosan ajánlott (OA)
IF olajár = olcsó AND olajtartalék = elegendő THEN fejlesztés = nem ajánlott (NA)
IF olajár = olcsó AND olajtartalék = sok THEN fejlesztés = nem ajánlott (NA)

Ezek a szabályok mátrixokba is rendezhetőek:

	Olajtartalék
Olajár	Kevés	Elegendő	Sok
Olcsó	1. KA	2.SzA	3. MA
Megfelelő	4. MA	5. OA	6. OA
Drága	7. OA	8. NA	9. NA

Mindenik szabály egy halmazt jelent a kimeneten, a kimeneti változó ezért 9 halmazból áll. A halmazok az erősségük szerint egymás után következnek.

Minden újabb bemeneti változó drasztikusan megemeli szabályok számát. A következtető rendszer dolgozza fel ezeket, ezért sokszor fuzzy inferenciamotornak is hívják. A szabályok alapján kapcsolatot teremt a halmazok között. A szabályokat egyszerre hajtja végre és nem sorra, ahogy a klasszikus rendszerek teszik, ami méginkább hasonlóvá teszi az emberi gondolkodáshoz. A feladatot a Mamdani inferencia módszerrel fogjuk megoldani. Tegyük fel, hogy az olajár 20 euró és a gyárnak 7 millió tartalékhordója van:

A tagságfüggvényekből leolvasható hogy milyen halmazokba sorolódik a két bemenő változó, ami alapján a következő szabályok érvényesek egyszerre:

1. IF olajár = drága AND olajtartalék = kevés THEN fejlesztés = kötelezően ajánlott (KA)

2. IF olajár = drága AND olajtartalék = elegendő THEN fejlesztés = szigorúan ajánlott (SzA)

4. IF olajár = megfelelő AND olajtartalék = kevés THEN fejlesztés = mérsékelten ajánlott (MA)

5. IF olajár = megfelelő AND olajtartalék = elegendő THEN fejlesztés = óvatosan ajánlott (OA)

Az AND művelet a két bemenő változó között a Mamdani módszer szerint a min halmazművelettel történik, azaz mindig az a halmaz győz, amelyben kisebb tagságértékű a változó. Minden szabálynak más a kimenete:

Az inferencia rendszer eredménye a kimenő változóhoz tartozó halmazok a gyűjteménye:

A konkrét értéket ebből a defuzzifikáló módszerek egyikével lehet megkapni, a leggyakrabban a súlypont módszert használják:

\[COG=\frac{\displaystyle\sum_{i=1}^{8} z_i\cdot\mu(z_i)}{\displaystyle\sum_{i=1}^{8}\mu(z_i)}=\] \[\large{=\frac{(0.15\cdot 25)+(0.15\cdot 47)+(0.1\cdot 48)+(0.1\cdot 64)+(0.65\cdot 72)+(0.65\cdot 82)+(0.1\cdot 89)+(0.1\cdot 100)}{0.15+0.15+0.1+0.1+0.65+0.65+0.1+0.1}}\]

Ezek szerint 70.5% az esélye, hogy az olajgyár fejlesztésre szorul, különben csődbe megy. A számítások megközelítőek, a pontosabb eredményért sűrűbben kellett volna venni az adatokat, $i$ legalább 100-ig kellett volna menjen.

Példa - Matlabban

Az egyszerűbb fuzzy inferencia rendszerek építése a "Fuzzy Logic Designer" alkalmazással gyorsabban megy mint forráskód írásával. Ez elindítható az App listából vagy a következő parancsokkal:

>> fuzzyLogicDesigner vagy >> fuzzy

A felugró ablakban egy Mamdani fuzzy inferenciarendszer jelenik meg. Lehet állítgatni a halmazműveleteket, valamint a defuzzifikáló eljárást. Ha nincs a listában olyan amit szeretnénk, akkor függvényt lehet írni neki és a Matlab jelenlegi munkaterületére elmenteni. Az olajgyáras példához minden szükséges elem megvan, csupán egy újabb változót kell az Edit menüben hozzáadni:

Ezek után minden változónak be kell állítani a tagsági függvény típusát és értéktartományát.

A szabályokat az Edit / Rules menüben lehet hozzáadni:

A szabályokat működés közben View / Rules menüponton lehet megnézni:

Az eredmény (64.4%) valamivel pontosabb, mert 101 ponton számolt összeget. A program megmutatja a ki- és bementi változók összefüggését egy kontrollfelületen.

Ha csak konkrét változókból történt volna a fejlesztés igényének megbecslése, akkor a fenti ábrán csak egy vonalgörbe lenne két dimenzióban.

Az egyensúlyozó kerekek (balancing scooter) a fordított inga elvén működnek, ami viszont fuzzy logikával van kitalálva. A következő videón olyan utasítások teljesülnek mint "kicsit jobbra" vagy "sokat balra".

Neuro-fuzzy rendszerek

A fuzzy logikával vagy genetikus algoritmusokkal működő neurális hálózatot hibrid intelligens rendszernek is nevezik. Két ellentmondó követelmény van: értelmezhetőség és pontosság. Ennek alapján két nagy kategóriába sorolják a neuro-fuzzy modelleket:

1. Nyelvi fuzzy modell, amely az értelmezhetőségre törekszik (Mamdani)

2. Konkrét kimenetelű fuzzy modell, amely a pontosságra törekszik (Takagi-Sugeno-Kang)

Fuzzy logikát sok helyen lehet alkalmazni egy neurális hálózatnál:

Transzferfüggvények kiválasztása

Tanítóminták kiválasztása

Hálózati struktúra kiválasztása vagy a hálózatépítés menete

A betanított hálózatból fuzzy függvények deriválhatóak le, melyekkel újabb hálózatot lehet betanítani.

Az előrecsatolt többrétegű hálózat rendelkezhet fuzzifikálóval a bemeneten, inferenciarendszerrel és defizzifikálóval a kimeneten.

A neurális és fuzzy rendszerek úgymond kiegészíthetik egymást:

a neurális hálózat az osztályozásban jó, de döntéseit nem tudja megindokolni

a fuzzy rendszer jó a döntései indoklásában, de a szabályokat nem tudja felállítani

Ezek alapján fordítva is segíthetik egymást:

a neurális hálózattal javíthatóak a fuzzy rendszer tagsági függvényi, vagy azok létrehozási menete

a neurális hálózattal meghatározhatóak a numerikus adatok fuzzy szabályai

A fuzzy megközelítés önmagában univerzális, minden folytonos függvényt meg tud becsülni egy kompakt halmazon tetszőleges pontossággal. A probléma ezzel az, hogy nem konstruktív és nem mondja meg, hogyan építsük fel a hálózatot. A neuro-fuzzy rendszer viszont konstruktív módon hozza létre az IF…THEN… szabályokat.

A fuzzy és neurális rendszerek nagyon hasonlóak:

a fuzzy tagságfüggvénye hasonló a neurális hálózat transzferfüggvényéhez

a neurális hálózat szorzatösszege hasonló a fuzzy min-max közelítéshez

A neuro-fuzzy rendszer neuronjai a fuzzy neuronok. A bemenetek fuzzy értékek és súlyozottak, de nem úgy mint a neurális hálózat neuronjai. Ezek az értékek ezután AND, OR vagy NOT műveleteken esnek át, a neuron kimenetén pedig az implikáció hajtódik végre. Íme néhány fuzzy neuron típus:

Az első modell IF...THEN... szabályokat valósít meg. A második bemenetei konkrét adatok, melyek súlyozásait a tagsági függvények végzik. A kimenet a tagsági érték, tehát egy 0 és 1 közötti szám. A harmadik modell egy nem-fuzzy neuron, aminek fuzzy bemeneti vannak. Ezeket súlyozva egy újabb fuzzy halmazt kapunk, ami egyben a kimenet is. A modelleket a megfelelő sorrendben rétegekbe helyezve felépíthető egy teljes fuzzy következtető rendszer. Egy ilyen hálózatot csak felügyelt tanítással lehet tanítani. Ne feledjük, hogy a tanulás közben megváltoznak a bázis szabályok, a halmazműveketek és a tagsági függvények, például egy háromszög alakú tagságfüggvény a szorzás után (OR / max) a következőképp alakul:

Akármilyen tanulási algoritmus nem működik a fuzzy neuronokkal, de a csökkenő gradiens módszert bátran lehet alkalmazni. A neurális hálózat formájában felépített fuzzy következtető (inferencia) rendszereket fuzzy kontrollereknek hívják. Az ilyen rendszerek tanítása például a Sugeno módszerből is indulhat, ahol a tagságfüggvények kimenete konkrét szám. Szokás ezt singleton-nak is hívni, ami egy olyan halmazt jelent aminek csak egy eleme van.

Legyen egy fuzzy kontroller $m$ bemenettel $(x_1 ... x_m)$ és egyetlen $y$ kimenettel, melyre $n$ szabály érvényes a következő formában:

IF $x_1=A_{i1}$ AND $x_2=A_{i2}$ AND ... AND $x_m=A_{im}$ THEN $y=w_i \text{ }i=1...n$

A szabály sorszáma $i$, $A_{i,j}$ pedig egy fuzzy halmaz az $i.$ szabályra és a $j.$ változóra. Az ebből következő valós számot $w_i$ képviseli. Ne feledjük, hogy a tagságfüggvények paraméterei mások minden szabálynál és bemenetnél. Minden tagságfüggvény szimmetrikus háromszögfüggvény és parciálisan differenciálható:

Ennek a tagságfüggvénynek a matematikai definíciója a következő:

\[\mu_{i,j}=\begin{cases} 1-\frac{2|x_j-a_{ij}|}{b_{i,j}} & \text{ha } a_{i,j}-\frac{b_{i,j}}{2} < x_j < a_{i,j} + \frac{b_{i,j}}{2} \\ 0 & \text{különben} \\ \end{cases} \text{ (1. egyenlet)}\]

Szükséges lesz egy következtető rendszer is, ami a szabályokat összekapcsolja. Ha egy bemenetre több szabály is érvényes, a szabályokhoz tartozó tagsági függvényeket összeszorozzuk:

\[\mu_i=\mu_{i1}\cdot\mu_{i2}\cdot\cdots\cdot\mu_{in} \text{ (2. egyenlet)}\]

A szorzás eredménye egy új szabály, új tagságfüggvény. Mivel a szabályok kimenete konkrét (crisp) szám, ennek az új szabálynak is az lesz. Több bemenet esetén azonban sok ilyen konkrét szám lesz és ez ismét fuzzy halmazat eredményez, amit defuzzifikálni kell, például a súlypont módszerrel:

\[y=\frac{\displaystyle\sum_{i=1}^{n}u_i w_i}{\displaystyle\sum_{i=1}^{n} w_i}=\displaystyle\sum_{i=1}^{n}\overline{u}_i w_i\text{ (3. egyenlet)}\]

Ha két bemenet van, akkor ez a következőképp fest:

A szorzás műveletét T-norm-nak is nevezik (Triangular norm), mert minden háromszögű tagságfüggvénynél érvényes a háromszög egyenlőtlenség (az átfogó mindig kisebb a befogók összegénél). Vegyük észre, hogy a fenti rajz nagyon hasonló az előrecsatolt neurális hálózathoz. A műveletek osztályozása (Fuzzifikálás, Szorzás, Normalizálás és Defuzzifikálás) pedig megfelel a neuronrétegeknek. Az első réteg fuzzifikálja a bemenetet a táblázatban lévő 1. modell alapján a szabályok segítségével. A kimenet a tagsági érték (1. egyenlet), ami a szorzó rétegbe kerül (2. egyenlet). Ennek kimenete a "tüzelő erő", amit a normalizáló függvény 1 és 0 közé skáláz. A normalizálás tulajdonképpen a kimenő tagsági függvényt helyettesíti. Az utolsó réteg pedig végrehajtja a súlyozott összegzését ezeknek (3. egyenlet).

Példa - Neuro-fuzzy (Matlabban)

Nézzük meg az olajgyáras példát neuro-fuzzy rendszerrel (vagy fuzzy kontrollerrel). Az olajár és az olajtartalék tagságfüggvényei nem változnak, sőt a szabályok is ugyanazok maradnak. Annyi változik, hogy nincsenek kimenő tagsági függvények, azaz helyettük normalizálni kell az adatokat 0 és 1 közé:

nem ajánlott (NA) = 0
óvatosan ajánlott (OA) = 0.25
mérsékelten ajánlott (MA) = 0.5
szigorúan ajánlott (SzA) = 0.75
kötelezően ajánlott (KA) = 1

A végeredmény a 20 euró olajárra és a 7 millió tartalékhordóra pedig:

Ahogy a Mamdani módszernél, itt is 4 kimenő tagságfüggvény teljesült egyszerre, de különböző mértékben. Ezeknek a súlyozott közepe 0.709, amit ha visszaskálázunk az eredeti mértékegységbe, akkor 70.9%-ot kapunk. Ez ugyan merészebb becslés, de a számítások mennyisége sokkal kevesebb. A Sugeno modell lehetőséget ad a neuro-fuzzy struktúra megtekintéséhez is:

A hálózatot be is lehetne tanítani, hogy a tagságfüggvényeket módosítsa a megfelelő kimenet érdekében, de az a feltétel, hogy a kimenő tagságfüggvények száma és a szabályok száma azonos legyen, valamint mindenik szabályhoz más tagságfüggvény kapcsolódjon. Ez ebben a példában nem teljesül.

A taníthatóság két részre osztja a fuzzy rendszerek defuzzifikálási folyamatát

Offline defuzzifikálás: az amiről idáig szó volt. Minden kimenő és bemenő tagságfüggvény és szabály a valódi mechanizmusból szerzett tapasztalat alapján készül. Ennek előnye, hogy a matematikailag levezethetetlen, vagy túl bonyolult számításokat igénylő feladatokat egyszerű becsléssé alakítja, ezért sokkal hamarabb eredményre vezet.
Online defuzzifikálás: a neurális hálózat elveinek alkalmazásával a fuzzy rendszer menet közben is alakítgathatja szabályait vagy tagsági függvényeit (csak az egyiket). Az eredmény sokkal pontosabb lesz, mint a z offline defuzzifikálásnál. Hátránya az időigényesebb számítás, de a mai processzorokon ez már nem jelent problémát.

Genetikus algoritmusok

Minél egyszerűbb egy élőlény, annál inkább érvényes rá a fuzzy logika, azaz annál inkább tapasztalat, és nem számítások alapján dönt. Az állatok általában tapasztalat nélkül is megéreznek, cselekszenek dolgokat, ösztönösen cselekszenek. Az ilyen tapasztalati tudást az élőlények öröklik, és az öröklés hogyanját pedig a genetikus algoritmusokkal lehet modellezni. Az öröklődő információ mennyisége a biológiában szorosan kötődik az élettartamhoz, például a pár napig vagy hónapig élő lényeknek nincs idejük mindent a saját tapasztalataikból megtanulni, ezért az ősöktől örökölt tudást születéskor megkapják, életükben bővítik, majd tovább adják az utódoknak. Ez segít abban például hogy az adott faj folyamatosan alkalmazkodjon a változó éghajlati viszonyokhoz.

Már régen felfedezték, hogy mikor megfestik a sejteket, akkor találnak benne olyan pici struktúrákat melyek egészen jól megfestődnek (magukba veszik a színeket). Ezeket kromoszómáknak nevezték el és vizsgálatok során rájöttek, hogy ezek hordozzák azokat az információkat amiket a sejt örököl. Ma már azt is tudják hogy a kromoszóma génekből áll és hogy melyik gén miért felelős, ugyanis mindenik egy bizonyos tulajdonságot rögzít. A gének DNS-ből állnak és a hozzáértők azt is megmondják, hogy mi van abba beleírva, ennek értelmezése viszont már nagyon bonyolult folyamat. Az informatikában a kromoszómára úgy lehet tekinteni mint egy karakterláncra, tehát a bennük lévő gének a karakterek. A karakterek értéke a gének jellemzőjének (allél) felel meg és itt van a vége, a géneket nem bontjuk tovább. Egyelőre nincs értelme, hisz ezzel a felbontással is rendkívüli dolgok valósíthatók meg. Amijük még van a karaktereknek az a pozíció a karakterláncban, amit a biológiában lókusznak neveznek. A karakterek paramétereinek készletét (ami ebben az esetben az érték és a pozíció) a biológiában fenotípusnak hívják, a karakterlánc szerkezetét pedig genotípusnak. Az élőlények génstruktúrája különbözik, keresztezni csak, a hasonló struktúrájúakat lehet. A fák génjeit nem lehet például az állatok génjeivel keresztezni, de a ló és a szamár génjeit már igen, mert hasonlóak (így lesz az öszvér). A paraméterkészlet olyan információkat tesz lehetővé, amelyek meghatározzák például hogy az ember szőke-e vagy barna, ázsiai-e vagy európai, fekete-e vagy fehér, stb.

A genetikus algoritmusok az öröklődés hogyanját írják le, amihez három feltételnek kell teljesülnie:

Legyen meg minden jellemző amivel az egyed rendelkezik, azaz legyen megépíthető a karakterlánc

Legyen egy reprezentatív populáció, hisz az egyed saját magától nem tud hatékonyan örökölni. Ha osztódna, akkor mindig ugyanaz a tulajdonság öröklődne, és az egyed nem tenne szert olyan tudásra amit nem ő szerzett. Minél nagyobb a populáció, annál több karakterláncot tartalmazhat egy generáció. A reprezentatív azt jelenti, hogy a populáció nagyjából arányosan oszlik el a keresési felületen, azaz a lehetséges életszituációk minden részéből van egy-egy példány a karakterláncok között és nem tömörülnek osztályokba. A populáció mérete attól függ, hogy mennyire bonyolultak az életkörülmények amikhez alkalmazkodni kell. Egyszerű környezetben kevés gén is meg tudja határozni, hogy mikor hogyan kell viselkedni. A feladat az, hogy meg kell keresni a populációból a legsikeresebb karakterláncokat (amelyek a legjobban boldogulnak a környezetben) és azokat örököltetni. Ehhez szükség van a harmadik feltételre.

Legyen egy tesztkörnyezet, ahol meg lehet mérni, hogy az adott egyed hogyan tud boldogulni. Ha ez megvan, akkor alkalmazható a genetikus algoritmus az öröklésre. A biológiában ezt a mérést úgy nevezik, hogy fitness, a technikában inkább a jóság szó a megfelelő. Ez két tulajdonsággal ruházza fel az egyedet. Az egyik az abszolút jóság, ami azt mondja meg, hogy mennyire teljesíti a követelményeket, és a relatív jóság, ami a többi egyedhez képes viszonyított jóságot adja.

A genetikus algoritmus feladata, hogy a kezdeti generációból létrehoz egy új generációt, átmásolva a karakterláncokat egyikből a másikba. A másolás közben módosítja is a karakterláncokat és minden generáció addig változik amíg meg nincs a jó megoldás. Ez viszonylagos, ugyanis az életben nincs megállás nincs olyan hogy kifejlett generáció, hisz az életkörülmények folyamatosan változnak. Ha meg tudjuk teremteni ezt a három feltételt, akkor a genetikus algoritmusokat nagyon sok mindenre fel lehet használni, hiszen az alany addig fogja fejleszteni magát míg teljesíteni nem tudja a feladatot.

A biológiában rengeteg módszer van az öröklődésre (dominancia, inverzió, törlődés, halkítás, konck-out, stb.), az informatikában viszont ezek közül három is elég ahhoz, hogy hihetetlen dolgokat lehessen alkotni. Ezek a módszerek tehát a karakterláncok átmásolása közbeni módosításokra vonatkoznak.

1. Kiválasztás

Ha egyszer tudjuk, hogy melyek a legjobb egyedek, akkor elindul a kiválasztó eljárás. Ez történhet úgy, hogy az egyedeket relatív jóságuk alapján sorba rendezzük és a legjobbaknak megadjuk a jogot az átmásolódásra. Aki alatta van az elvész, az a családág kihal, nem lesz benne a következő generációban. Ez túlságosan elitista, elnyomó módszer, lokális helyzetben beválhat, viszont kizárja az ismeretlen körülményekhez való alkalmazkodást.

A másik megoldás rulettkerék elve, ahol minden egyedet rárakunk egy rulettkerékre, megpörgetjük és amelyik egyednél megáll az fog átmásolódni. A nagyobb relatív jóságú egyedek szerencséje továbbra is nagyobb lesz, mert a keréken nagyobb cikkelyt kapnak, viszont a kevésbé sikeres egyedek kromoszómáinak is meg lesz az esélye.

Miután kiválasztottuk a legjobbat azt átmásoljuk a következő populációba változás nélkül, majd a elölről kezdjük a kiválasztást. Hogy összesen hányat viszünk át az attól függ, hogy a következő populációnak mekkora lesz a mérete. Ha N darab volt a populációban, akkor a rulett kereket N-szer kell megforgatni. Ez azt jelenti, hogy egy egyed akár többször is átmásolódhat, tehát az sikeresebbnek számít, mert több utódot hozott létre.

A rulettkerék algoritmus a következő:

Az egyedek abszolút jóságának (Fitness) meghatározása teszteléssel: $F_i=f(teszt)$

A populáció N tagjának összjósága: $S=\displaystyle\sum_{i=1}^{N} F_i$

Az egyedek relatív jóságának (Relative Fitness) kiszámítása: $RF_i=\frac{F_i}{S}$

A relatív jóságok normalizálása (pl. 1 és 100 közé)

M darab véletlenszám generálása (1 és 100 között), M az új populáció mérete

A véletlen számoknak megfelelő kromoszómák átmásolása az új generációba

2. Kereszteződés

Ebben az esetben megpróbáljuk összekombinálni az ősök tudását (ivaros szaporodás). Mivel minden leszármazottnak két őse lehet, kiválasztunk egy párost és keresztezzük tartalmukat. Fontos feltétel hogy a két szülő azonos génstruktúrájú legyen, tehát egymás mellé helyezhető legyen. A kereszteződés úgy történik, hogy először kijelölünk (véletlenszerűen) egy karakterpozíciót és addig a pontig felcseréljük a két karakterlánc tartalmát. A létrejött egyedek ezért a szülei keverékei lesznek.

Több helyen is lehet keresztezni, és ez is egy véletlen változó. A genetikus algoritmusok véletlenszerűek mind, a biológiában is. Káosz azért nem történhet, mert a tartalom, amivel véletlenszerűen bánik, nem lehet akármi. Van egy bizonyos értéktartomány, amiben mozogni lehet, például ha az egyik ős szőke, a másik barna hajszín információt hordoz, akkor az utóduknak nem lehet vörös haja.

3. Mutáció

Véletlenszerűen felveszünk néhány pontot a karakterláncban és megváltoztatjuk azokon a pontokon a karakterek értékeit. Nyilván itt sem lehet káoszt okozni, a hajszínnek is van például egy értéktartománya, amiben nincs benne a zöld, de benne lehet a vörös. A változás mértéke is véletlenszerű.

Az eddig leírt algoritmusok problémái ott kezdődnek, hogy a túlságosan nagy jóságú egyedek eluralhatják a populációt. Ha mindig ugyanazok választódnak ki, akkor előbb utóbb csak olyanok lesznek, és ennek az a hátránya az egyedek közötti minimális különbségek már nem lesznek elégségesek a további fejlődéshez. A biológiában ez az egymással rokon (családtag) gének kereszteződésekor alakul ki. Ezért a kiválasztás során meg kell akadályozni hogy csak a legjobbak kerüljenek ki. A jósági értéket át kell transzformálni különböző mértékben attól függően, hogy hol tartunk a generációkban. Ennek akkor van vége mikor az adott követelményeket már teljesíteni tudja. Az elején felgyorsíthatjuk a fejlődést azzal, hogy megnöveljük a jósági tényezőket, összehúzzuk őket, had választódjanak ki a legnagyobbak. Ez azt jelenti hogy elosszuk egy számmal, hogy a kis jóságúak minél közelebb kerüljenek nullához. Mikor kezd jól működni az egyed, akkor újra szét kell húzni a jóságokat beszorozva egy számmal, hogy megnőjön a kevésbé sikeres egyedek esélye is. Ezzel a fejlődés lelassul, de legalább nem fog elakadni.

Ezért is van az, hogy sokkal jobb a genetikus algoritmus a tanításra, mint például a gradiens módszer, mert nem akad el a lokális minimumokon vagy maximumokon, valahogy mindig kirázódik belőle. Emellett a keresésben is sokkal jobban megállja a helyét, mert párhuzamosan csinálja, minden egyed bejárja a maga keresési területét majd a szerzett információt átadja az utódainak, így azok nem kell újból bejárják azokat az utakat. A genetikus algoritmusok ezért az optimumok megoldásában nagyon jók, előnyei a következők:

Párhuzamos keresés: egyszerre több pontot is megvizsgál

Általános, mert nem nézi a változók értékeit, csakis azok pozícióját vagy relatív jóságát.

A lokális minimumokra kevésbé érzékeny, nem ragad le ha oda kerül

A nem determinisztikus (NP) problémákra is jó megoldást lehet vele találni

Tulajdonképpen itt kötődik össze a genetikus algoritmus a neurális hálózatokkal, ugyanis a neurális hálózatban is keresni kell az optimális súlytényezőt. Az már kiderült hogy a Back Error Propagation önmagában kevés, mert elakadhat a lokális minimumokban vagy maximumokban. Folyton kell őt finomítani akár menetközben is hogy el ne akadjon sehol.

A fuzzy logikába is bevezethető, hiszen ott is optimumkeresés zajlik az olyan szabályok kiválasztásakor, amelyek egyszerre érvényesek egy adott döntésnél. Ilyenkor a genetikus algoritmus a tagsági függvényeket finomhangolhatja megkönnyítve a választást.

Az intelligencia és az evolúció közvetlen kapcsolatban állnak egymással, ugyanis az intelligencia a felfogóképességet és az alkalmazkodóképességet jelenti. Egy egyed intelligens, ha a problémáját a környezetéhez való alkalmazkodása révén képes megoldani. A megoldás ilyen módú keresését intelligens keresésnek hívják, mert mindig fenntartja az egyensúlyt az örökölt és az újonnan felfedezett információ között. Nem hagyatkozik teljesen a „régi jól bevált” adatokra, de az ismeretlenben sem téved el. Az evolúciós fejlődéses keresés vagy problémamegoldás a következő lépésekben működik:

Létrehozza kezdeti populációt

Mindenik egyedet leteszteli (fitness, vagy a jóság meghatározása)

Rangsorolja az egyedeket a teszteredmények szerint

Kiválasztja az öröklődésre méltó egyedeket

Genetikus algoritmusokkal (kiválasztás, kereszteződés, mutáció) létrehozza az új populációt

Ismétli önmagát a 2. lépéstől, míg a probléma meg nem oldódik.

Az elvárásokat teljesítő egyed az optimum egyed, tehát gyakorlatilag optimum keresés zajlik. Az optimizálás célja általában minimum vagy maximum keresés. Minimizálni például a hibát lehet, maximizálni pedig a cég profitját. Minden egyes evolúció új optimumokkal szolgál, mely egy bizonyos célérték felé konvergál. A konvergencia kritériuma (vagy megállási feltétele) lehet egy küszöbérték, vagy lehet a generációk változatlansága is (amikor nem ismerjük a küszöbértéket, hanem a határokat próbáljuk meghatározni). Leginkább ez utóbbit alkalmazzák az algoritmusokban. A genetikus algoritmusokat korlátozni kell, hogy a létrejött egyedek mind legálisak legyenek. Ez azt jelenti, hogy megfeleljenek az alapkövetelményeknek, például egy gépjármű fejlesztésére használt algoritmus ne generáljon olyan egyedeket, melyeknél nincs mind a 4 kerék a földön.

Példák

Egy gép tervezése

Mikor egy gépet újítani kell, ami lehet akár mosógép, számítógép, hajtómű, rakéta vagy akármi más, akkor általában tervezőmérnökök, szakértők, menedzserek összeülnek és kigondolják hogy mit lehetne módosítani vagy újítani, hogy jobban működjön vagy hogy teljesítsen egy új követelményt. Ezután megtervezik, ha lehet szimulálják, és ha jobb lett akkor megépítik.

A genetikus algoritmushoz is ugyanezek a szakértők kellenek, plusz még egy informatikus. Az informatikus nem ért semmihez az informatikán kívül, csupán kikérdezi a szakértőket, hogy melyek a gép tulajdonságai amik nagyon fontosak. Nem kell minden részletet kitárgyalni, csak a lényeges dolgokat. Nem számít például hogy a mosógépet milyen színűre festik vagy milyen csavarok tartják össze. A csavarok talán számítanak de nem azon múlnak a fontosabb funkciók. Ezek a tulajdonságok lesznek a karakterek (gének), melyek egy hosszú karakterláncot, mesterséges kromoszómát alkotnak. Szükség van még értékekre is, pontosabban szélsőértékekre, hogy milyen tartomány között mozoghat például a gép áramfogyasztása, amennyiben elektromos. Minden tulajdonsághoz jár egy értéktartomány, melyben majd járkálni lehet a mutáció során. Az utolsó dolog amit az informatikus meg kell kérdezzen a szakértőktől a tesztelési eljárás. Miután azt is tudja hogyan tesztelje le, létrehoz több karakterláncot más-más kezdeti értékekkel, míg egy populációra való össze nem gyűl, aztán leteszteli őket szerre. Ha nem talált rögtön egy jót, akkor alkalmazza a genetikus algoritmust (örökölteti a paramétereket) és újból tesztel. Ezt addig ismételteti a programmal amíg a szimulátor tesztjének eleget tévő gépeket nem kap. A számítógép sokat dolgozik, akár napokig anélkül hogy az informatikus bármit is kéne tegyen, majd mikor megvannak a jól működő gépek, lejegyzi azok paramétereit és odaadja a szakértőknek had válasszák ki melyiket építik meg.

Legkönnyebben olyan egyszerű lényeket lehet fejleszteni, melyek izmokból (pl. rugókból) és csomópontokból (pl. golyókból) állnak. A következő videón ilyen elemekből felépített lények vannak, melyek dolga hogy vízszintes helyzetből függőleges helyzetbe kerüljenek. Vannak bizonyos tesztfeltételek, azaz tulajdonságok melyekkel a rugók és a golyók rendelkeznek. A golyók egyformák és mindig a föld irányába tartanak, húzza őket a gravitáció, a földdel ütközhetnek de egymással nem. A rugók erőssége viszont változó és az algoritmus feladata, hogy ezeket úgy rendezze a golyók között, és úgy örököltesse az erősségeket, hogy a 12 golyóból és 26 rugóból álló szerkezet végül talpra álljon. A lények belső (fekete) rugóinak erőssége konstans, így az nem változik a generációk során. Ahogyan a szerző állítja, csak a külső (szürke) rugóknak van "agya".

Látható, hogy a generációk során egyre ügyesebbek a lények, a 325. generációnál már meg is van a stabilan talpon maradó egyed. A következő 4 részes videóban hasonló lényekkel folyik a munka, viszont itt a lények tulajdonságai kevésbé korlátozottak. Éppen ezért több információval kell felrhuázni őket, különben káosz keletkezik. A rugóknak az erősségükön kívül van egy maximális és minimális feszülési távolságuk és változó rugózási időperiódusuk is. Az előző videón ez utóbbi konstans volt. A rugók száma 5, a golyók száma pedig 4, a feladat pedig hogy minél gyorsabban haladjanak jobbra. Hogy ez megtörténhessen, egyes golyók tapadósak, mások csúszósak kell legyenek. Ezeket a színük jelzi, a sötét piros a legtapadósabb, a fehér a legcsúszósabb.

A következő példa már egy neurális hálózat, ugyanis a teremtmények együttműködése fejlődik, nem pedig a struktúrája. Két csapatot alkotnak a lények, melyek célja hogy a labdát eljutassák a másik csapat kapujába. A két csapat minden generációban javul kicsit, tanul az előző hibákból.

Közeljövő

Az intelligenciát sokféleképp lehet osztályozni, és ezek az osztályok határozzák meg, hogy összehasonlítható-e két intelligencia szint. Nem hasonlítható össze például egy légy és egy ember intelligenciája. Ha az ember irányítaná a legyet, biztosan nem tudna olyan manővereket végrehajtani akadálykikerülésben mint a légy. Nem azért mert alacsonyabb az intelligenciája és nem képes a feladatot a légy hibahatárának megfelelően elvégezni, hanem mert az ember nem rendelkezik a szükséges szenzorokkal, receptorokkal, reflexekkel, tapasztalattal és szerkezeti felépítéssel. Ez egyértelmű, hiszen nagyok a különbségek, viszont ugyanez igaz a kisebb eltérések esetén is, mint például a gazdag és a szegény környezetben nevelkedett ember, a tanult vagy a tanulatlan ember között. Mivel két egyforma alany nem létezik, ezért az átlagszinthez viszonyítva mérik az emberek intelligenciáját. Ezzel az a baj, hogy ha a tesztből hiányzik az alapvető tényezők egyike is (szóértés, felfogási sebesség, következtetés, emlékezés, képkiegészítés, mennyiségi és analógiás gondolkodás, stb.), akkor már pontatlan az eredmény. Az pedig kizárt, hogy az összes tényező jelen legyen és teljesíthető legyen bárki számára, ezért az IQ eredmények mindig fuzzy értékűek, viszonylagosak.

A mesterséges intelligenciánál szerencsére nincs ilyen probléma, hisz két egyforma paraméterű gép bármikor megépíthető. Éppen ezért az intelligencia meghatározása is egyszerűsödik: intelligencia = hatékonyság, azaz a rendelkezésre álló adatok minél hatékonyabb felhasználása a probléma megoldása érdekében. A gépnél a hatékonyság két fő tényezőtől függ:

Mennyiség: minél kevesebb információból meg tudja oldani a feladatot, annál intelligensebb.

Gyorsaság: minél hamarabb képes jó döntést hozni, annál intelligensebb

Ezeknek egyszerre kell teljesülniük, hiszen összefüggnek (ha túl sok információra van szükség, akkor a döntéshozatal is tovább tart). A mai intelligens rendszereknek sajnos még rengeteg információra van szükségük, hogy valamit produkáljanak, sokkal többre mint az embernek. Jó példa erre a kézírás felismerő program, aminek közel az összes lehetséges írástípust ismernie kell, hogy működjön. Ezzel szemben az embernek sokkal kevesebb mintára van szükség, gyakorlatilag már a saját kézírásának ismerete elegendő ahhoz, hogy másokét olvasni tudja.

Közeljövő

2015. november 1., vasárnap

Intelligens rendszerek

A tanítási módszerek javítása

Példa - levezetve

Példa - Matlabban

A konkrét-fuzzy átalakító

A következtető rendszer

A következtető rendszer

Példa - levezetve

Példa - Matlabban

Neuro-fuzzy rendszerek

Példa - Neuro-fuzzy (Matlabban)

1. Kiválasztás

2. Kereszteződés

3. Mutáció

Példák

Közeljövő

Nincsenek megjegyzések:

Megjegyzés küldése