A Newton és Gauss-Newton módszerek alkalmazása egyenletrszerek megoldására és nemlineáris optimalizálásra Veress Krisztián veresskrisztian@gmail.com 2007. július 10. 1
Tartalomjegyzék 1. Bevezetés 3 1.1. Motiváció és háttér........................................ 3 1.2. Egy példa a gyökkeresésre.................................... 3 1.3. Az egyenletrszerek fontossága................................ 4 1.4. Egy optimalizálási példa..................................... 4 2. A Newton-módszer 5 2.1. A klasszikus módszer ismertetése................................ 5 2.2. A szelőmódszer.......................................... 6 2.3. A csillapított Newton-módszer................................. 7 2.4. A többdimenziós Newton-módszer............................... 8 2.4.1. A Jacobi mátrix definíciója............................... 8 2.4.2. A Jacobi-mátrix számítása............................... 9 2.5. A módszerek hibája és konvergenciája............................. 10 3. A Gauss-Newton módszer 11 3.1. Alul és túlhatározott egyenletrszerek............................ 11 3.2. A minimalizálási alapfeladat................................... 11 3.3. A módszer elméleti háttere................................... 12 3.4. Egyéb algoritmusok....................................... 13 3.4.1. A Hesse mátrix definíciója................................ 13 4. Nemlineáris optimalizálási problémák 15 4.1. Megvalósítás MATLAB-ban................................... 15 4.2. A módszerek implementációja.................................. 15 4.3. Az elemzésre használt MATLAB kód.............................. 16 4.4. Zérushelykeresés és analízis................................... 17 4.5. A Gauss-Newton módszerek tesztelése............................. 24 4.5.1. Az Optimization Toolbox alkalmazása nemlineáris optimalizálásra......... 24 5. Egyenletrszerek iterációs megoldása 27 5.1. A Newton-módszer........................................ 27 5.2. Az fsolve eljárás......................................... 29 5.3. A módszerek összehasonlítása.................................. 32 5.4. Összegzés............................................. 35 6. Függelék 36 6.1. Prezentációs MATLAB kódok.................................. 36 6.1.1. newton convergence.m.................................. 36 6.1.2. secant convergence.m.................................. 36 6.2. MATLAB algoritmusok..................................... 37 6.2.1. newton method.m.................................... 37 6.2.2. secant method.m..................................... 39 6.2.3. newton method2.m.................................... 40 6.2.4. analyze.m......................................... 41 6.2.5. analyze2.m........................................ 43 6.3. Tesztfüggvények......................................... 44 6.3.1. f1.m............................................ 44 6.3.2. f2.m............................................ 44 6.3.3. f3.m............................................ 44 6.3.4. f4.m............................................ 45 6.3.5. equationf1.m....................................... 45 6.3.6. equationf2.m....................................... 45 6.3.7. gnlmf1.m......................................... 45 6.3.8. gnlmf2.m......................................... 45 6.3.9. fsolvef1.m......................................... 45 1
6.3.10. fsolvef2.m......................................... 45 6.3.11. fsolvef3.m......................................... 46 6.3.12. fngnlm.m......................................... 46 6.4. Segédfüggvények......................................... 46 6.4.1. outfunc.m......................................... 46 2
1. Bevezetés Ezen dokumentum a Szegedi Tudományegyetemen a 2006-2007/2 -es tanévben tartott Nemlineáris programozás és Közelítő és szimbólikus számítások II. című kurzusokra készített esszé dolgozatok egyesített változata. Az esszé tematikája az egyenletrszerek megoldására és a nemlineáris optimalizálás területén alkalmazott gyökkereső eljárások ismertetése, tesztelése és példákon keresztüli bemutatása. Az ismertetett algoritmusokat MATLAB környezetben példaprogramokkal mutatom be, melyek elérhetőek a Függelékben. 1.1. Motiváció és háttér A matematikai számításaink során sokszor futunk olyan problémába, hogy adott egy f függvény (mely leír bizonyos viselkedést), és meg kell határoznunk, hogy milyen feltételek mellett lesz az adott függvény nulla. Azaz keresnünk kell egy x-t úgy, hogy f(x) = 0, ahol az f függvény ismert. Minden ilyen x-t az f függvény gyökének nevezünk. A fenti problémát numerikusan szeretnénk megoldani és tekintettel arra, hogy az f függvényre semmilyen feltételt nem kötöttünk ki (folytonos-e, differenciálható-e, lineáris/nemlineáris-e, stb.), egy általánosan használható algoritmust keresünk. Az optimum megtalálásához közelítő eljárásokat alkalmazunk, melyek iterációt használva olyan számsorozatokat számítanak ki, amelyek (remélhetőleg) egy pontba kovergálnak, s ez a pont lesz a keresett gyök. Az iterációt azonban el kell indítanunk valahonnan, ezért meg kell sejtenünk egy kiindulási pontot, majd a módszer a sorozat következő elemét az előző elem és az f függvényből kiszámítja. 1.2. Egy példa a gyökkeresésre A műszaki alkalmazások területén sokszor találkozhatunk Laplace-transzformált függvényekkel. Esetenként szükség lehet arra, hogy az adott Laplace-transzformált hol vesz fel nullát, azaz szeretnénk megkeresni a függvény zérushelyét. 1. ábra. Egy Laplace transzformált, és annak pár zérushelye 3
1.3. Az egyenletrszerek fontossága A műszaki alkalmazások területén (Robotika, Optimalizálás, Irányítástechnika, stb) sokszor futunk olyan problémába, hogy több ismeretlenünk van, és ezen változók között több összefüggés is fennáll. Ha az összefüggések (továbbiakban egyenletek) olyanok, hogy a változóink legfeljebb az első hatványon szerepelnek, lineáris egyenletrszerről beszélhetünk, melyet a következő alakban írhatunk fel: Ax = b ahol A R n m az együtthatómátrix, x R m a kereső vektor, b R n konstansokból álló vektor. Az ilyen típusú egyenletrszereket Gauss-eliminációval, LU felbontással vagy éppen QR transzformációval numerikusan megoldhatjuk. A probléma ott kezdődik, amikor az egyenletrszerben szereplő változóink fokszáma nincs 1-re maximalizálva, azaz nemlineáris egyenletrszerhez jutunk, melynek általános alakja: h i (x) = 0 (i = 1,..., m) ahol h 1,..., h m olyan R n -ből R-be képező függvények, amelyek közül legalább az egyik nemlineáris. Az ilyen típusú egyenletrszerek megoldására szinte kizárólag a többváltozós Newton-módszerek használatosak. Ennek magyarázata az, hogy már az első deriváltak megszerzése sem problémamentes, ugyanakkor a magasabb rű módszerek még az egydimenziós esetben sem feltétlenül hatékonyabbak. 1.4. Egy optimalizálási példa Gazdasági, fizikai vagy paraméter-meghatározási problémákból sokszor erednek szélsőérték-feladatok (minimalizálni kell a költségfüggvényt, maximalizálni a profitot, stb), így elmondhatjuk, hogy szoros kapcsolat van a szélsőérték feladatok és az egyenletrszerek megoldása között. Tekintsünk most egy olyan optimalizálási feladatot, melyben a célfüggvény egy f : R n R az n dimenziós Euklideszi térből a valós számokra képező függvény. Ekkor f minden szélsőértékére igaz, hogy az adott pontban a gradiensvektor eltűnik, azaz: ( ) f f f(x) =,..., = 0 T x 1 x n Láthatjuk, hogy a gradiensvektor elemei is nemlineárisak lehetnek, így egy n ismeretlenes n egyenletből álló nemlineáris egyenletrszerhez jutottunk. Ezen egyenletrszer megoldásai azok a pontok - másnéven stacionárius pontok -, ahol az f függvénynek szélsőértéke lehet. A továbbiakban közelítő numerikus eljárást adunk a nemlineáris egyenletrszerek megoldására, amely azt jelenti, hogy a megoldást legtöbb esetben csak megközelítjük. (Természetesen ez az eljárás használható lesz lineáris egyenletrszerek megoldására is, de nem feltétlenül hatékonyabb, mint a már említett módszerek.) 4
2. A Newton-módszer 2.1. A klasszikus módszer ismertetése A Newton-módszer valós, folytonos és differenciálható függvények zérushelyeinek meghatározására használható iteratív eljárás. Az eljárást használhatjuk függvények minimumának/maximumának meghatározására abban az esetben, ha létezik vagy meghatározható a függvény második deriváltja, ugyanis az első derivált zérushelyei azonosítják a függvény szélsőértékeit. A Newton-módszer alapötlete a következő: vegyünk egy olyan pontot, mely relatíve közel van a tényleges zérushelyhez (ez a sejtésünk ), ez lesz az iteráció kiindulási pontja: x i,i=0. Ezekután számítsuk ki az f függvény ismeretében f(x i )-t. Az (x i, f(x i )) pontban húzott érintő zérushelye általában jobb közelítése a függvény zérushelyének, mint x i. Egy adott (x 0, y 0 ) ponton áthaladó, m meredekségű egyenes egyenlete a következő: (y y 0 ) = m(x x 0 ) Tudjuk, hogy egy x i pontban az f (x i ) deriváltfüggvény megadja az adott pontban húzott érintő meredekségét, így m = f (x i ). Mostmár nincs más dolgunk, mint felírni az (x i, f(x i )) ponton áthaladó f függvényhez húzott érintő egyenletét, és meghatározni, hogy az hol metszi az abszcissza-tengelyt: f(x) f(x i ) = f (x i )(x x i ) f(x) = 0 A fenti egyenletrszerből algebrai átalakítások után megkapjuk az iterációt leíró egyenletet: x i+1 = x i f(x i) f (x i ) (1) 2. ábra. A Newton módszer illusztrálása ( newton convergence.m ) Láthatjuk, hogy az f(x i ) pontban húzott érintő és az abszcissza-tengely metszéspontja egy jobb közelítése a gyöknek. A klasszikus Newton-módszert ezen trükk használata miatt érintőmódszernek is szokták nevezni. 5
2.2. A szelőmódszer A most ismertetésre kerülő közelítő gyökkereső eljárás a Newton-módszer egy speciális változata. A Newton-módszer igényelte a kiindulási függvényünk első deriváltjának expliciten történő megadását, ezt szeretnénk valahogy kiküszöbölni. Ennek nagy jelentősége van, hiszen olyan eset is elképzelhető, mikor a deriváltfüggvényünk nem áll relkezésre, nem tudjuk kiszámolni, vagy legrosszabb esetben még az f függvényünk is ún. black-box 1 függvény. A feladatunk tehát nem más, mint a Newton-módszer iterációs képletében szereplő f (x i ) tagot kiküszöböljük, és annak valamilyen közelítésével helyettesítsük. Kalkulusból ismeretes, hogy egy f függvény x i helyen vett deriváltja (differenciálhányadosa) : f (x i ) = lim h 0 f(x i + h) f(x i ) h Ez a határérték kellően kicsi h-k esetén helyettesíthető a differenciahányadossal: f (x i ) f(x i + h) f(x i ) h Ha a h = x i 1 x i helyettesítést alkalmazzuk, megkapjuk, hogy: f (x i ) f(x i + x i 1 x i ) f(x i ) x i 1 x i = f(x i 1) f(x i ) x i 1 x i = f(x i) f(x i 1 ) x i x i 1 Ezt behelyettesítve az iterációs képletbe kapjuk, hogy: x i x i 1 x i+1 = x i f(x i ) f(x i ) f(x i 1 ) (2) 3. ábra. A szelőmódszer illusztrálása ( secant convergence.m ) A szelőmódszer geometriai jelentése a következő: az iteráció elkezdéséhez két pontra lesz szükségünk ( x 0, x 1 ) úgy, hogy f(x 0 ) = f(x 1 ). Ezekután egyenest húzunk az (x 0, f(x 0 ) és (x 1, f(x 1 )) pontokra. Ez az f egy szelője lesz, és ha a kezdeti x 0, x 1 pontjainkat közel választottuk az x zérushelyhez, ez a szelő metszeni fogja az abszcissza-tengelyt, legyen ez a pont (x 2, 0). Az eljárást ezekután folytatjuk (x 1, x 2 ) pontokra. A 3.ábrán az f(x) = x 3 + 3x 2 10x függvényt, és annak gyökének közelítését láthatjuk. Az ábrát a következőképpen rajzolhatjuk ki MATLAB-ban: 1 black-box függvény: egy függvényt black-box függvénynek nevezünk, ha a viselkedését csak bemenet-kimeneti párokkal tudjuk leírni és zárt képlete nem ismert 6
>> f=inline( x.^3+3*x.^2-10*x ); >> subplot(2,2,1) >> secant_convergence(x,f,4.7,-5.2,4) >> axis([-6 5-100 400]) >> subplot(2,2,2) >> secant_convergence(x,f,4.7,-5.2,4) >> axis([-6 5-50 130]) >> subplot(2,2,3) >> secant_convergence(x,f,4.7,-5.2,4) >> axis([-6-4 -50 50]) >> subplot(2,2,4) >> secant_convergence(x,f,4.7,-5.2,4) >> axis([-5.1-4.9-2 2]) Vegyük észre, hogy itt csak egyetlen függvénykiértékelésre van szükségünk egy iterációban (az f(x i 1 ) -t az előző iterációban már kiszámoltuk ) szemben a hagyományos Newton-módszerrel, és ez már szélesebb körben használható eljárás, hiszen nincs szükségünk a deriváltra. Ha feltételezzük, hogy ugyanannyi költség kiértékelni f-t és f -t, és minden más járulékos költséget elhagyunk, ugyanannyi költségbe kerül két lépést végrehajtani a szelőmódszerrel, mint egyet a Newton-módszerrel. A differenciálhányados helyettesítése a differenciahányadossal megfelelően kicsi h érték esetén alkalmazható. Mivel h = x i 1 x i, ezért azt mondhatjuk, hogy a most kapott iterációs eljárásunk olyan esetekben fog a Newton-módszer-hez hasonló konvergenciát mutatni, amikor már a tényleges x gyök közelében vagyunk. A fent ismertetett eljárásokat használják megbízható számítású rszerekben is, ez általában intervallumos számítást jelent (lásd [5] Vinkó). 2.3. A csillapított Newton-módszer Az imént ismertetett eljárások nagy hátránya, hogy csak lokálisan konvergensek (a konvergenciát részletesebben később vizsgáljuk), azaz egy x gyökhöz akkor és csakis akkor tart az iterációs sorozat, ha az iterációt egy, az x gyökhöz közeli pontból indítottuk. A célunk tehát nem más, mint elérni, hogy minél,,távolabbi kezdősejtéssel is elérhessük a konvergenciát, esetleg a teljes abszcisszatengelyre kiterjesszük a konvergencia-intervallumot, így globális konvergenciát érjünk el. Ehhez módosítsuk a (1) iterációs képletet a következőképpen: x i+1 = x i t i f(x i ) f (x i ) ahol a t i paraméter az ún. csillapítási paraméter. Nyilvánvaló, hogy az iteráció elindításához szükségünk van t 0 értékére. Ezt meghatározhatjuk a következő összefüggés segítségével: (3) ln f(x) t 0 = lim x x 0 ln f(x)f (x) ahol x 0 D f Hasonlóan, minden egyes iterációban a t i származtatva könnyen megtehetjük: paramétert frissítenünk kell, ezt az előbbi összefüggésből ln f(x) t i = lim x x i ln f(x)f (x) ahol x i az aktuális közelítésünk. Ha t értékét maximáljuk, akkor a konvergencia sebessége nő, azonban a konvergencia-intervallum szélessége csökken. Ellenkező esetben pedig a konvergencia sebessége csökken, a konvergencia-intervallum szélessége nő. Ha t < 1, akkor csillapított Newton-módszerről beszélünk. Ekkor a klasszikus Newton-módszer lokális konvergenciáját globális konvergenciává terjesztettük ki (ugyanakkor a konvergencia sebessége csökkent!). A gyakorlatban a csillapított módszer általában eléri azt a gyök-közelítést, amelyet a klasszikus Newtonmódszernek adtunk meg kezdősejtésnek, és ettől kezdve t = 1 teljesül, azaz a klasszikus Newton-módszer hajtódik végre. 7
2.4. A többdimenziós Newton-módszer Az eddig tárgyalt módszereket egyváltozós függvényekre definiáltuk. Lehetőség van a fenti iterációs eljárások használatára többváltozós függvények esetében is. Egyenletrszerek megoldására sem igazán használhatók az előbb ismertetett egydimenziós iterációs eljárások, hiszen ezeket csak akkor használhatjuk, ha egyetlen változónk és egyetlen egyenletünk van. Legyen most f : R n R leképezés az n-dimenziós Euklideszi térből a valós számokra. Ekkor minden dimenzióban kell venni a (1) egyenletet, de mivel a függvényünk többváltozós, a deriváltfüggvény helyét átveszik a parciális deriváltak : vagy átírva mátrix-alakra: f(x i ). = f(x i ) f(x i ) = f (x i )(x 1 x i,1 ) x 1.. f(x i ) = f (x i )(x n x i,n ) x n f (x i ) 0 0 x 1. 0.. 0 f 0 0 (x i ) x n x 1 x i,1.. x m x i,n A fenti egyenletből a gradiensvektort tartalmazó diagonális mátrix inverzével balról beszorozva, majd az x i vektort hozzáadva mindkét oldalhoz kapjuk, hogy: x i+1,1 = x i,1 f(x i) f x 1 (x i ). x i+1,m = x i,m f(x i) f x m (x i ) Láthatjuk, hogy az f függvény n-változós, így jelen esetben egy n-változós, egy egyenletből álló egyenletrszerhez készítettünk iterációs eljárást, mely az f(x) = 0 egyenlet megoldásának egy közelítését állítja elő. Legyen most f : R n R m az n dimenziós térből az m dimenziós térbe képező függvény. Ebben az esetben a derivált-függvényt a Jacobi-mátrixszal kell helyettesítenünk. A Jacobi-mátrix segítségével felírhatjuk az f függvényünk x i ponton áthaladó érintő hipersíkját: f(x i ) = J f (x i )(x x i ) A többdimenziós esetben használható iterációs algoritmusunk iterációs képletet pedig úgy kaphatjuk meg, ha a fenti egyenletet x -ra rezzük: 2.4.1. A Jacobi mátrix definíciója x i+1 = x i J f (x i ) 1 f(x i ) (4) A Jacobi-mátrix megadja egy p R n pontban a p pontban differenciálható f : R n R m függvény deriváltját, mely a legjobb lineáris approximációja f-nek a p pont körül. Egy f : R n R m függvényt felfoghatunk m darab y i : R n R i = (1,..., m) függvényként, y 1 (x 1,..., x n )... y m (x 1,..., x n ). Ez utóbbi függvények parciális deriváltjait (feltéve, hogy azok léteznek) egy m n-es mátrixba rezhetjük, mely az f függvény ún. Jacobi-mátrixa : y 1 y 1... x 1 x n J f (x) =.. y m... x 1 8..... y m x n
Vegyük észre, hogy a Jacobi mátrix i-edik sora pontosan az y i függvény gradiensének transzponáltja. 2.4.2. A Jacobi-mátrix számítása A (4) iterációs egyenletben szereplő Jacobi-mátrix invertálása kapcsán kétségeink merülhetnek fel. A numerikus matematikából ismeretes (lásd Cses [6]), hogy egy mátrix invertálása egyrészt nehéz feladat, másrészt igencsak költséges. Ezért szükség lenne a Jacobi-mátrix inverzének egy hatékony kiszámítási módjára, nos erre több lehetőség is felmerül: A Jacobi-mátrix kiszámításának problémáját át lehet ruházni a majdani felhasználóra (programozza le ő maga a deriváltakat). Egy jobb megoldás az, ha a deriváltakat az eljáráson belül formulamanipulációval (pl szimbólikus számításokkal) számítjuk ki, ami elvileg és gyakorlatilag is megoldott feladat, bár nem egészen problémamentes. Speciális, f i (x) = a ij x j + b ijl x j x l = 0 j 1 a ij = c ij e dij/x1 j l>1 alakú egyenletek (Hik [12]) esetén hasznos ezt a megoldást választani. Ha a deriváltak pontos értékei relkezésünkre állnak, akkor érdemes figyelni a Jacobi-mátrix tárolására is. Ugyanis nagy n-re a nemlineáris egyenletrszerek Jacobi-mátrixai tipikusan ritkák, azaz a nemzérus elemek száma N jóval kisebb a mátrix méretéhez viszonyítva (N n). A ritka mátrix tárolása azért ennyire fontos, mert szeretnénk elkerülni a sok 0-val való szorzást és 0-val való összeadást. Egy járható út az is, ha a parciális deriváltakat a differenciaképlettel helyettesítjük (lásd a szelőmódszer esetében is). A többdimenziós esetben diszkretizált Newton-módszerről beszélünk, ha minden k iterációs lépésre a J f (x k ) Jacobi-mátrix elemeit a J f (x k ) = J ij = f i x j f i(x k + h ij x j ) f i (x k ) h ij, i, j = 1,..., n elsőrű közelítéssel számítjuk, ahol e j a j-edik koordináta menti egységvektor és h ij -k nemnulla valós számok. Egy numerikusan is könnyen számítható eljárás az, ha a J f (x i )s i = f(x i ) linearizált egyenletrszert s i -re megoldjuk, és így az x i+1 = x i + s i relációval egy, a (4) rekurzív összefüggéssel ekvivalens alakot kapunk, amely egyben a kiindulási nemlináris egyenletrszerünk megoldásának egy újabb közelítése lesz. 9
2.5. A módszerek hibája és konvergenciája Felmerül a kérdés, hogy vajon bármilyen x 0 pontból kiindulva megtalálhatjuk a zérushelyet? A válasz nemleges, a módszer csak lokálisan, de nem globálisan konvergens. Általában a konvergencia sebessége kvadratikus, azaz minden iterációs lépés után a közelítő megoldás pontos jegyeinek száma megduplázódik. Azonban a Newton-módszer nagy hátrányai, hogy az f függvény deriváltját expliciten meg kell adnunk, illetve ha a tényleges x gyöktől távoli x 0 pontot sejtünk meg, a módszer nem konvergál. A konvergencia részletesebb vizsgálatához vezessük be az osztott differenciák fogalmát: 2.5.1. Definíció. Elsőrű osztott differencia : 2.5.2. Definíció. Másodrű osztott differencia : f [x i, x i+1 ] = f(x i+1) f(x i ) x i+1 x i f [x i, x i+1, x i+2 ] = f [x i+1, x i+2 ] f [x i, x i+1 ] x i+2 x i Ezekután vizsgáljuk meg a szelőmódszer hibáját az n + 1-edik lépésben : ε n+1 = x n+1 x x n x n 1 = x n f(x n ) f(x n ) f(x n 1 ) x Ha felhasználjuk az f(x ) = 0 tényt, és a fenti egyenlet jobboldalának középső tagját bővítjük x n x -al, akkor a következőhöz jutunk: ε n+1 = x n (f(x n ) f(x x n x n 1 x n x )) f(x n ) f(x n 1 ) x n x x = x n x f [x, x n ] f [x n 1, x n ] (x n x ) ( = ε n 1 f ) [x, x n ] f [x n 1, x n ] ( f [xn 1, x n ] f [x ), x n ] ε n 1 = ε n f [x n 1, x n ] x n 1 x f [x, x n 1, x n ] = ε n ε n 1 f [x n 1, x n ] x n x Használjuk fel az osztott differenciák és a deriváltak közötti összefüggést ([3] Hegedűs), mely szerint ha f n + 1-szer folytonosan differenciálható [a, b]-n, x [a, b], x x i, akkor létezik olyan ξ x [a, b], melyre: f [x, x 0, x 1,..., x n ] = f n+1 (ξ x ) (n + 1!) és ha alkalmazzuk az x n 1 x n határátmenetet, azt kapjuk, hogy: ε n+1 = ε 2 f (ξ) n 2f (x n ), ξ [x n, x ] amelyből már könnyen leolvasható, hogy a módszer konvergenciagyorsasága kvadratikus. Természetesen a kvadratikus konvergenciagyorsaság igaz a többdimenziós esetben is, ott a tényleges gyök egy δ sugarú hipergömb környezetében kell lennünk a konvergencia eléréséhez (lásd [11] HIK). A bizonyítást nyomon lehet követni a [6] Cses, [7] Mathworld, [9] HIK forrásokban is. 10
3. A Gauss-Newton módszer A természettudományi területeken végzett kutatások, mérések során illetve az iparban nagyon sokszor ütközünk paraméter-meghatározási problémákba. Tegyük fel, hogy egy összetett ipari robot dinamikai modelljét vizsgáljuk, amely egy m = g(t, x 1,..., x n ) alakban írható fel, ahol az m mennyiség egy mérhető érték (pl. az aktuátor által a munkadarabra kifejtett erő), x i -k pedig a modell belső változói, a robot paraméterei (forgatónyomatékok, elfordulási szögek, stb.), míg t az időt szimbolizálja. Ha különböző t j időpontokban k-szor megmérjük az m mennyiséget, megkapjuk az m k értékeket. Ezekután az a feladatunk, hogy a f i = g(t i, x 1,..., x n ) m i, i = 1,..., k függvényekkel megfogalmazott feladatot megoldjuk, azaz meghatározzuk a modell x 1,..., x k paramétereit, oly módon, hogy a lehető legkevesebbet tévedjünk. A most ismertető eljárásokat többek között paraméter-becslési feladatok és egyenletrszerek megoldására illetve többváltozós nemlineáris vektorfüggvények minimalizálására használhatjuk. Először vezessünk be pár fogalmat. 3.1. Alul és túlhatározott egyenletrszerek Meg kell említenünk azokat a speciális eseteket, mikor olyan egyenletrszerrel állunk szemben, mely alul vagy túlhatározott. 3.1.1. Definíció. Egy egyenletrszer túlhatározott, ha a benne szereplő független változók száma kevesebb, mint a változók között fennálló ekvivalenciák száma, azaz több egyenletünk van, mint változónk. Ezt megfeleltethetjük egy f : R n R m, n < m vektorfüggvénnyel. 3.1.2. Definíció. Egy egyenletrszert alulhatározottnak tekintünk, ha a benne szereplő független változók száma nagyobb, mint a változók között fennálló ekvivalenciák száma, azaz kevesebb egyenletünk van, mint változónk. Ezt megfeleltethetjük egy f : R n R m, n > m vektorfüggvénnyel. Nyilvánvaló, hogy a túlhatározottság jelentheti az egyenletrszer megoldásának hiányát, az alulhatározottság pedig végtelen sok megoldást. Ekkor mondhatnánk azt, hogy megállunk, hiszen nincs megoldás, vagy végtelen sok megoldás van, azonban a valós rszerekben (pl. ipari alkalmazások területén) ilyen viselkedés elkerülő. Értelmezhetjük tehát az alulhatározott egyenletrszerünk megoldását oly módon, hogy a lehetséges megoldások közül melyik tér el a legkevésbé az igazi megoldástól, míg a túlhatározott esetben is adhatunk olyan megoldást, mely ugyan nem elégíti ki az egyenletrszerünket, de legkisebb a hibája. A következő eljárásokat ilyen típusú egyenletrszerek esetén vethetjük be. Ahhoz, hogy egyenletrszerünkhöz ilyen megoldásokat keressünk, át kell azt transzformálni egy azzal ekvivalens minimalizálási feladatra. 3.2. A minimalizálási alapfeladat Tekintsük a következő minimalizálási feladatot: Adott f : R n R m, m > n függvényhez keressük az f(x) = 0 nemlineráris egyenletrszer megoldását legkisebb négyzetek értelmében, azaz f(x) = ( f 1 (x),..., f m (x)) T, f(x) 2 min x R n! (5) ahol a. az Euklideszi normát jelenti. A normát ilyenkor legtöbbször 11
m ( 2 f(x) 2 = f i (x)) vagy f(x) 2 = i=1 m i=1 ) 2 w i (f i (x) alapján szokták definiálni. A példaként említett paraméter-becslési feladatra a második definíció lenne a megfelelőbb választás, hiszen a w i súlyokkal jellemezhetjük az m i értékek mérési pontosságait. Jól látható, hogy a minimalizálási alapfeladatunkat és az egyenletrszert oda-vissza transzformálhatjuk egymásba. Azaz, ha egy egyenletrszert kell megoldanunk, megoldhatjuk azt minimalizálási feladatként is, és fordítva. 3.2.0.1. Példa. Oldjuk meg a következő egyenletrszert: x 1 2x 2 = 0 x 1 4 = 0 3x 1 + x 1 x 2 2 = 0 Felfoghatjuk az egyenletrszerünket egy f : R 2 R 3 vektorfüggvényként, és így társíthatjuk a következő minimalizálási feladatot: f(x) = (x 1 2x 2 ) 2 + (x 1 4) 2 + (3x 1 + x 1 x 2 2) 2 min! Mivel f(x) teljes négyzetek összegeként áll elő, így minimumát akkor veszi fel, ha minden egyes négyzetes tag zérus. Azaz a társított minimalizálási feladat optimális megoldása egyben megoldása az egyenletrszerünknek is. Ha nincs optimális megoldás, az azt jelenti, hogy az egyenletrszerünk nem elégíthető ki, végtelen sok optimális megoldás esetén pedig végtelen sok megoldása van az egyenletrszerünknek is. Tekintettel arra, hogy az abszolút optimális megoldás (jelen esetünkben az x úgy, hogy f(x ) = 0) hiánya esetén is tudjuk minimalizálni a célfüggvényünket, így tudunk legkisebb négyzetes értelemben megoldást adni az egyenletrszerünkre. Levonhatjuk tehát azt a következtetést, hogy egyenletrszerek megoldása általában transzformálható olyan optimalizálási feladatra, amely optimális megoldása megegyezik az egyenletrszer megoldásával. Felismervén az alul és túlhatározott egyeletrszerek és a legkisebb négyzetes közelítési probléma közötti szoros kapcsolatot, a továbbiakban csak ilyen feladatokat vizsgálunk. 3.3. A módszer elméleti háttere A Gauss-Newton módszer egy iteratív közelítő eljárás, az optimumnak mindig csak egy közelítését állítja elő, azt nem feltétlenül éri el, minden egyes lépés után annak egy (várhatóan) jobb közelítését kapjuk, és támaszkodik az optimum egy kezdeti sejtésére. Az eljárás a megoldandó nemlineáris legkisebb négyzetes probléma (továbbiakban NLLS) megoldását visszavezeti a lineáris legkisebb négyzetes probléma (továbbiakban LS) megoldására. Minden egyes iterációban az adott x i közelítésnél linearizálni próbáljuk a minimalizálandó célfüggvényt, mégpedig a következő módon: f(x) f(x i ) + J f (x i )(x x i ) ahol J a Jacobi mátrix (6) Ezekután írjuk fel a lineáris közelítést a következőképpen: f(x i ) + J f (x i )(x x i ) = A i x b i ahol A i = J f (x i ) és b i = J f (x i )x i f(x i ) (7) Ilyen módon felírva az NLLS problémánkat, az A i és b i által leírt LS probléma megoldása egy közelítése lesz a kiindulási nemlináris problémánknak, azaz A fenti LS probléma megoldása az f(x) 2 = A i x b i 2 x i+1 = (A T i A i ) 1 A T i b i (8) 12
vektor. A (7) és (3.3) egyenletekből felírhatjuk a Gauss-Newton módszer iterációs képletét: mely leegyszerűsítve a következő alakban írható: x i+1 = (J f (x i ) T J f (x i )) 1 J f (x i ) T (J f (x i )x i f(x i )) x i+1 = x i (J f (x i ) T J f (x i )) 1 J f (x i ) T f(x i ) (9) A gyakorlatban az (9) iterációs egyenletben szereplő mátrixinverzet sosem invertálással számítjuk. Ehelyett az ezzel ekvivalens x i+1 = x i + δ i helyettesítéssel élve megoldjuk a következő lineáris egyenletrszert: J f (x i ) T J f (x i )δ i = J f (x i ) T f(x i ) A fenti helyettesítésre egy jobb megoldás, ha egyenesmenti keresést alkalmazunk, azaz a helyettesítésünket most x i+1 = x i + α i δ i alakban írjuk, ahol α i valamely értelemben optimális számunkra. Így lehetőségünk nyílik arra is, hogy az eljárást gyorsítsuk (pl. a függvénykiértékelések számát minimalizáljuk, vagy a futásidőt, tárigényt csökkentsük, stb.). 3.4. Egyéb algoritmusok Klasszikus Newton-módszer A (5) probléma megoldására használhatjuk a klasszikus többváltozós Newton-módszert is, ha a célfüggvény deriváltjának keressük zérushelyeit. Ekkor szükségünk van a célfüggvény Jacobi és Hessemátrixára is. Egyenletrszerek vizsgálata esetén jusson eszünkbe, hogy most az alul- illetve túlhatározott esetre keresünk megoldást, így a kiindulási egyenletrszerünkre hiába alkalmaznánk a klasszikus többváltozós Newton-módszert, az nem konvergálna. 3.4.1. A Hesse mátrix definíciója A Hesse-mátrix megadja egy p R n pontban a p pontban differenciálható f : R n R m függvény második deriváltját a p pont körül. 2 f(x) 2 f(x) 2 f(x) x 2... 1 x 1 x 2 x 1 x n 2 f(x) 2 f(x) 2 f(x) H f (x) = x 2 x 1 x 2... 2 x 2 x n...... 2 f(x) 2 f(x) 2 f(x)... x m x 1 x m x 2 x m x n A Hesse-mátrix (i, j) eleme megadja az f függvény i-edik változó szerinti elsőrű parciális deriváltjának a j -edik változó szerinti parciális deriváltját, azaz 2 f(x) x i x j = x j ( ) f(x) A Young-tétel értelmében pedig ha az f függvény másodrű parciális deriváltjai folytonosak egy nyílt tarományon (lásd még [4] Szabó), akkor x i 2 f(x) x i x j = 2 f(x) x j x i A Hesse-mátrix ismeretében felírhatjuk a Newton-iterációs egyenletet: 13
m ( 2 x i+1 = x i (H S (x i )x i ) 1 J S (x i ) ahol S(x) = f i (x)) azaz x i+1 = x i ( J f (x i ) T J f (x i ) + m i=1 i=1 ( ) 1 f i (x i ) H fi (x i )) J f (x i ) T f(x i ) Meg kell továbbá említenünk a DFP (Davidon-Fletcher-Powell) és a BFGS (Broyden-Fletcher - Goldfarb-Shanno) két igen hatékony kvázi-newton eljárást is. (A kvázi-newton eljárások olyan közelítő Newton eljárások, amelyekben nem használjuk a célfüggvény Hesse-mátrixát, hanem azt csak alkalmas módon közelítjük.) Ezekről több információt lehet találni az irodalomjegyzék elemei közt (lásd [4] Szabo, [10] Hik, [1] Wikipedia, [2] Mathworld ). Levenberg-Marquardt eljárás Egy jól használható algoritmus még az ún. Levenberg-Marquardt féle iterációs eljárás, mely ötvözi a Gauss-Newton módszer és a gradiensmódszer előnyeit. Ezt az eljárást a legkisebb négyzetes függvényközelítési probléma megoldására használják, így használható nemlináris függvények gyökösszegének minimalizálására is, azaz az feladat megoldására. F (x) = 1 2 m i=1 ( f i (x)) 2 min! (10) A Levenberg és Marguardt által javasolt iterációs eljárás egy p vektor által adott irány mentén keresi a minimumot ([1] Wikipedia,[2] Mathworld ): Először választanunk kell egy sejtést p-re, általában megfelelő választás a p T = (1, 1,..., 1). Minden iterációban a p irányt megpróbáljuk javítani p + q -ra, ahol p-t úgy számítjuk, hogy az f i (p + q) függvényeket helyettesítjük azok linearizált megfelelőikkel, azaz f i (p + q) f(p) + J f (q) ahol J f az f Jacobi-mátrixa Tudjuk, hogy ott lehet minimális F (x), ahol q F (x) = 0. Így kapjuk q-ra, hogy (J T f i (x i )J fi (x i ))q = J T f i (x i )f i (x i ) amelyből q-t a (J T f i J fi ) mátrix invertálásával megkaphatjuk. A Levenberg-Marquardt eljárás azonban a fenti egyenletet helyettesíti annak egy skálázott alakjával: (J T (x i )J(x i ) + λ i I)q i = J T (x i )F (x i ) ahol λ i -k skalárok, az I pedig az identikus mátrix. A λ -k ily módon való bevezetésével elérték azt, hogy teszőlegesen mozoghassunk a Gauss-Newtonmódszer és a gradiensmódszer között. Ha ugyanis azt tapasztaljuk, hogy F (x) minimumára adott közelítésünk gyorsan csökken, kis λ -t választva a Gauss-Newton módszer felé terelhetjük algoritmusunkat, míg lassú csökkenés esetén nagy λ-t választunk, így a gradiensmódszerhez hasonló algoritmust kapunk. A Gauss-Newton és Levenberg-Marquardt eljárások működését interaktívan meg lehet tekinteni a következő webcímeken: http://www.cse.uiuc.edu/eot/modules/optimization/gaussnewton/ http://www.cse.uiuc.edu/eot/modules/optimization/levenbergmarquardt/ 14
4. Nemlineáris optimalizálási problémák 4.1. Megvalósítás MATLAB-ban Az előző fejezetben ismertetett gyökkeresési eljárásokra most implementációt adunk MATLAB környezetben. A klasszikus Newton-módszerhez szükségünk van a deriváltfüggvényre, amelyet az INTLAB Toolbox-ban megtalálható eljárásokkal fogunk számítani. A Toolbox-t le lehet tölteni a http://www.ti3.tu-harburg.de/rump/intlab/ webcímen. A MATLAB-ban be kell állítani a File Set Path menüpontban a letöltött Toolbox elérési útvonalát, s ezekután elérhetőek lesznek a Toolbox által definiált függvények. 4.2. A módszerek implementációja A Függelékben megadott newton method.m MATLAB függvény tartalmazza a klasszikus Newtonmódszer míg a secant method.m a szelőmódszer implementálását a f : R R és f : R m R függvénycsaládokra. Mindkét függvény 4 paramétert vár : azt a függvényt, amelynek egy zérushelyét keressük (ezt külön MATLAB.m fájlban kell megvalósítani) a gyök egy sejtését (a szelőmódszer esetében két pontot) a maximális iterációk számát (ezzel tudjuk biztosítani az algoritmus végességét) egy kívánt pontosságot A két algoritmus keretrszere megegyezik, először megvizsgáljuk a függvények által kapott argumentumokat, és beállítjuk az iterációhoz szükséges értékeket (max iteration, epsilon változók). Ezekután megállapítjuk a gyök sejtéséből a feladat dimenzióját, és létrehozunk egy D (M + 1) méretű mátrixot (xv mátrix) (D (M + 2) méretűt a szelőmódszer esetében), ahol D a feladat dimenziója, M pedig a maximális iterációk száma. Ez a mátrix fogja tartalmazni az iteráció során előállított közelítéseket. A létrehozott mátrix első sorát beállítjuk a gyök sejtésére (szelőmódszer esetén az első két sorát). Az algoritmusok következő lépése az (1) illetve a (2) egyenletek által leírt iterációk megvalósítása. Az iteráció legfeljebb M lépésben megáll, ha azonban egy i M iterációs lépésben az xv mátrixra teljesül, hogy xv(i) xv(i 1) < epsilon, akkor az iteráció leáll, hiszen elértük a kívánt pontosságot. A függvények ezekután visszatérnek az iteráció során előállított közelítések mátrixával (xv) illetve az elért legjobb közelítéssel (xv mátrix legutolsó nem nulla sora). Az eljárásokhoz MATLAB segítséget is írtam, ezt megtekinthetjük a következő parancs kiadásával: >> help newton_method Függvények zérushelyének megtalálása Newton-iterációval NEWTON_METHOD(func_handle, initial_guess, max_iteration, epsilon) a func_handle függvény initial_guess pont közelében található zérushelyét közelíti meg epsilon pontossággal, legfeljebb max_iteration iterációt végrehajtva. func_handle : vektorizált függvény, pl (y = (x(1)-2.345).^2 + (x(2)-5.678).^2;) initial_guess : sorvektor, dimenziója megegyezik a func_handle dimenziójával max_iteration : egész szám, ha nem adjuk meg, alapértelmezetten 100 epsilon : lebeg}opontos szám, ha az eltérés két közelítés között kisebb, mint epsilon, az iteráció megáll. az alapértelmezés 1e-10 visszatérési érték : [ xv approxroot ]... 15
4.3. Az elemzésre használt MATLAB kód Ahhoz hogy a klasszikus Newton-módszer illetve a szelőmódszer viselkedését könnyen elemezhessük több függvényen és több dimenzióban, elkészítettem egy olyan MATLAB függvényt (analyze.m), mely az eljárások által visszaadott xv gyök-közelítéseket tartalmazó mátrixot elemzi, és grafikonon ábrázolja az abszolút hibát abszolút relatív hibát abszolút közelítési hibát illetve az abszolút relatív közelítési hibát. Abszolút hiba Legyen x az f függvény tényleges gyöke, x i pedig annak egy közelítése. Ekkor a x x i értéket az x i közelítés abszolút hibájának nevezzük. Ez az érték kifejezi a közelítés jóságát, megmondja, milyen távol vagyunk a tényleges gyöktől. Ha az abszolút hibát az iterációk függvényében ábrázoljuk grafikonon, akkor ha azt látjuk, hogy az abszolút hiba csökken, akkor egy re jobb közelítéseket állítunk elő nő, akkor egyre rosszabb közelítéseket állítunk elő oszcillál, akkor nem konvergens az iterációnk Abszolút relatív hiba Legyen x az f függvény tényleges gyöke, x i pedig annak egy közelítése. Ekkor a x x i x vagy x x i x 100 értéket a x i közelítés relatív hibájának nevezzük. A relatív hiba az eltérésnek a pontos érték nagyságrjéhez való viszonyát mondja meg. Ez már sokkal jobban jellemzi a közelítés pontosságát, mint az abszolút hiba. Minél kisebb ez az érték, annál közelebb vagyunk a pontos megoldáshoz. Ha a második százalékosan kifejezett abszolút relatív hiba 5% alá megy, azt mondhatjuk, hogy az aktuális közelítés 95%-os pontosságú. Abszolút közelítési hiba Legyen x az f függvény tényleges gyöke, x i illetve x i+1 pedig annak két egymás utáni közelítése. Ekkor az x i+1 x i értéket a közelítő eljárás abszolút közelítési hibájának nevezzük. Látjuk, hogy ez az érték két egymás utáni közelítés közötti különbséget adja meg, azaz ha ez az érték kicsi, feltételezhetjük, hogy a legutolsó közelítések már jól megközelítettek egy gyököt. Abszolút relatív közelítési hiba Legyen x az f függvény tényleges gyöke, x i illetve x i+1 pedig annak két egymás utáni közelítése. Ekkor a x i+1 x i x i+1 vagy x i+1 x i x i+1 100 értéket a közelítő eljárás abszolút relatív approximációs (közelítési) hibájának nevezzük. A kifejezésekből láthatjuk, hogy ennek a hibafajtának a százalékos értékét is minimalizálni szeretnénk. Ehhez a függvényhez is készítettem MATLAB help-t (lásd help analyze). 16
4.4. Zérushelykeresés és analízis 4.4.0.1. Példa. Keressük meg az alábbi függvény egy zérushelyét! f(x) = (x 2.3450) 2 1 Megoldás. Készítsünk egy f1.m nevű MATLAB függvényt, melynek tartalma legyen a következő: f1.m function z = f1(x) z = (x-2.345)^2-1; Most futtassuk a klasszikus Newton-módszert, majd az analizáló függvényt (tudjuk, hogy a fenti függvény két zérushelye a 3.3450 illetve 1.3450 ): >> [xr r] = newton_method(@f1,10); performed_iteration = 8 approxroot = 3.3450 >> analyze(3.3450,xr); Láthatjuk, hogy 8 iteráció után elértük az alapértelmezett 1 10 pontosságot, és megtaláltuk a nagyobbik gyököt. 4. ábra. A klasszikus Newton-módszer hiba-karakterisztikája a (x 2.3450) 2 1 függvényen Ha a kisebbik gyököt szeretnénk megtalálni, egy olyan kezdőpontot kell választanunk, mely közelebb van ez utóbbihoz. Ennek vizsgálata során állítsunk be hosszú formázást, és maximalizáljuk az iterációk számát először 4-re, majd 10-re: >> format long >> [xr r] = newton_method(@f1,-2.045,4); performed_iteration = 4 approxroot = 17
1.34380032018164 >> [xr r] = newton_method(@f1,-2.045,10); performed_iteration = 7 approxroot = 1.34500000000000 Látható, hogy az első 4 iteráció után még nem kaptunk pontos megoldást, ugyanakkor nem is kellett 10 iteráció a gyök 10 jegyre pontos értékének meghatározásához. 4.4.0.2. Példa. Adjuk meg az alábbi függvény egy zérushelyét! f(x) = e x 10 x2 Megoldás. A vizsgált függvény zérushelyeit keressük meg a MATLAB beépített solve függvényével: >> solve( exp(x)-10^(x^2) ) ans = 0 1/log(10) >> 1/log(10) ans = 0.43429448190325 >> 5. ábra. Az e x 10 x2 függvény grafikonja Most a szelőmódszert alkalmazzuk a második gyök megtalálására. Ehhez szükségünk lesz két olyan x 1 és x 2 értékre, mely helyeken az e x 10 x2 függvény ellentétes előjelű értékeket vesz fel. Legyen ez a két pont x 1 = 0.25 és x 2 = 0.73. Ellenőrizzük a kezdeti sejtésünket: >> [f2(0.25) f2(0.73)] ans = 0.12924343199828-1.33606297327459 Látjuk, hogy ez a két inicializáló pont megfelel a szelőmódszernek. Indítsuk el az algoritmust, és kérjünk 5 jegy pontosságot, maximálisan 20 iterációval: >> [xr r] = secant_method(@f2,[0.25;0.73],20,1e-5); performed_iteration = 10 approxroot = 0.43429449877644 18
Most vizsgáljuk meg az imént futtatott algoritmus közelítési hibáit az egyes iterációk során! Ha megnézzük a 6.ábrán az abszolút hiba grafikonját, látjuk, hogy nem monoton csökken. Ez egy fontos tulajdonsága a szelőmódszernek, de emlékezzünk arra, hogy a szelőmódszer esetében nem volt szükségünk a deriváltfüggvényre! >> analyze(1/log(10),xr) 6. ábra. Az approximációs hibák alakulása a szelőmódszer alkalmazása során 4.4.0.3. Példa. Határozzunk meg egy olyan x vektort, mely zérushelye a következő vektorfüggvénynek! f(x) = (x 1 2.345) 2 + x 2 2 + (x 3 + 10.11) 2 + (x 4 4.567) 2 + x 2 5; Megoldás. A most vizsgálandó függvény az 5 dimenziós Euklideszi térből képez a valós számokra. Egy triviális gyökét könnyen leolvashatjuk, ezt próbáljuk meg megtalálni a klasszikus Newton-módszerrel: >> [xr r] = newton_method(@f3,[4.4 8.7 6.7 10 10],20); performed_iteration = 20 approxroot = Columns 1 through 3 2.35137106831725 0.00127856525746-10.10771255271272 Columns 4 through 5 4.55625264200140 0.00326598776801 >> analyze([2.3450 0.0000-10.1100 4.5670 0.0000],xr); >> Az analyze függvény meghívása után a kapott grafikonokról szépen leolvasható, hogy a Newton-eljárásunk minden egyes lépésben egy adott dimenzióban,,lép egyet a megoldás felé. Az abszolút közelítési hiba is folyamatosan csökken az egyes dimenziókban, és 15 iteráció után már jól közelíti a nullát. Ez azt jelenti, hogy az iterációnk konvergens volt, tehát egy valódi gyökhöz közelítettünk. A grafikonokon a kvadratikus konvergencia is jól látható, az abszolút hiba diszkrét pontjaira egy 1 x 2 -es függvény illeszkedne. 19
7. ábra. Az abszolút (relatív) hibák alakulása az egyes dimenziókban 8. ábra. A közelítési hibák csökkenése többdimenziós gyökkeresés esetén 4.4.0.4. Példa. Határozzunk meg legalább egy gyököt, ha a függvényünk a következő : f(x) = (x + ln20 + sin(x))e x2 2x Megoldás. A most megvizsgálandó függvény tartalmaz egy periodikus tagot, mely komoly ellensége lehet a Newton-módszereknek. 9. ábra. A (x + ln20 + sin(x))e x2 2x függvény grafikonja és egyetlen zérushelye Ha ugyanis a tényleges gyökhöz nem megfelelően közel választjuk az iteráció kezdőpontját, a közelítés divergálhat. Ha a gyök sejtésének x 0 = 1.4000 -t választunk, a klasszikus Newton-módszer divergens lesz. >> solve( (x + log(20) + sin(x))*exp(-x^2/(2*x)) ) ans = 20
-2.1698791015827486253136751239048 >> [xr r] = newton_method(@f4,1.4000,100); performed_iteration = 100 approxroot = 2.101282697874923e+02 >> >> analyze(-2.1698791015827486253136751239048,xr) 10. ábra. A (x + ln(20) + sin(x))e x2 2x függvény zérushelyének megtalálásakor kudarcot vallunk Ha megnézzük a 10.ábrán található abszolút hiba grafikont, látjuk, hogy az lineárisan nő az iterációk előrehaladtával, ebből kifolyólag a relatív hiba is nő, tehát kijelenthetjük, hogy az x 0 = 1.4000 gyöksejtés nem vezethet minket helyes eredményhez. A konvergenciasebesség tárgyalásakor említettük, hogy a Newton-módszerek konvergenciasebessége a gyök közvetlen közelében a legjobb. Példának okáért az intervallumos globális optimalizálási feladatok esetében is csak kis szélességű intervallumok esetén hajtunk végre Newton-lépéseket. Széles intervallumok esetén nem érünk el szignifikáns eredményeket, míg a kis intervallumok esetén a pontos jegyek számát megduplázhatjuk. Ha a most vizsgált függvény egy valódi probléma leírása lenne, a gyök megkereséséhez más módszerekkel kellene keresni egy jobb gyök-sejtést. Tegyük fel, hogy ilyen módszerek relkezésünkre állnak, és találtunk egy jobb közelítést : x 0 = 2.16. Ez már közel van a valódi gyökhöz, de a 2 tizedesjegyre pontos értékből 13 jegyre pontos értéket szeretnénk kapni. Ilyenkor igazán hatékony a Newton-módszer: >> [xr r] = newton_method(@f4,-2.1600,1000,1e-13); performed_iteration = 4 approxroot = -2.16987910158275 >> Ha mégsem állna relkezésünkre más gyök-közelítési módszer, használhatjuk a szelőmódszert felismervén azt, hogy a függvénynek egy zérushelye van, monoton nő, és az értékkészlete a valós számok halmaza: 21
>> [xr r] = secant_method(@f4,[-1.4000;1.4000],100,1e-13); performed_iteration = 9 approxroot = -2.16987910158275 >> r ans = -2.16987910158275 >> 4.4.0.5. Példa. Keressük iterációs eljárással egy zérushelyét az függvénynek! f(x) = cos(x) Megoldás. Az cos függvény elég egyszerűnek néz ki ahhoz, hogy elfeledkezzünk arról, hogy a Newtonmódszerek nem globálisan konvergensek. Az előző függvény esetében láttuk, hogy a Newton-módszer divergálhat, ebben az esetben viszont egy újabb jelenséget tapasztalhatunk! Keressük meg a cos függvény zérushelyét klasszikus Newton-módszerrel, s legyen a kiindulási sejtésünk speciálisan 0.166506331901513860! >> [xr r] = newton_method(@cos,0.166506331901513860,10,1e-30); performed_iteration = 10 approxroot = 0.22611484477995 >> analyze(3/2*pi,xr) >> 11. ábra. A cos(x) függvényen a Newton-módszer oszcillációja Most az iterációk számát ne 10-re, hanem 30-ra maximalizáljuk: 22
>> [xr r] = newton_method(@cos,0.166506331901513860,30,1e-30); performed_iteration = 15 approxroot = 4.7124 >> analyze(3/2*pi,xr) >> A 12.ábrán látható abszolút és abszolút relatív hiba grafikonjáról szépen leolvashatjuk, hogy egy szerencsétlenül választott sejtéssel elindított Newton-féle gyökkeresési eljárás az első pár lépésben oszcillál, majd 11 iterációs lépés megtétele után kezd konvergálni a függvény zérushelyéhez. 12. ábra. A cos(x) függvényen a Newton-módszer csak 10 lépés után konvergál Ez a megállapítás azért fontos, mert például az intervallumos globális optimalizálás területén alkalmazott ún. intervallumos Branch and Bound (Korlátozás és Szétválasztás) módszer is alkalmazza a Newton-módszert abból a célból, hogy a keresési teret szűkítse (esetünkben egy intervallum szélességét csökkentse). Tekintettel arra, hogy a módszer költségessége miatt csak egyetlen iteációs lépést hajt végre a B&B algoritmus, sokszor előfodulhat, hogy a keresési tér egyáltalán nem szűkül. Az előző függvényeken végzett tesztek alapján megállapíthatjuk, hogy a gyökkeresési problémák megoldására használt Newton-módszer igenis hatékonyan alkalmazható a valódi gyök közelében, ugyanakkor a globális konvergencia hiánya miatt fellépő divergencia és/vagy oszcilláció jelenségét is figyelembe kell vennünk. 23
4.5. A Gauss-Newton módszerek tesztelése Az esszé második részében ismertetett többdimenziós, feltétel nélküli optimalizáló eljárásokat a MAT- LAB kiegészítéseként elérhető Optimization Toolbox-al fogom bemutatni. Ez a Toolbox kiegészíti a MAT- LAB numerikus rszerét olyan optimalizáló eljárásokkal, melyek hatékonyan alkalmazhatóak többek között feltétel nélküli nemlineáris optimalizálásra lineáris és kvadratikus programozási feladatok megoldására nemlineáris egyenletrszerek megoldására legkisebb négyzetes függvényközelítésre Az Optimization Toolbox függvényeit nagyméretű optimalizálási feladatokra (Large Scale Optimization Problem) is felkészítették, és ez az alapértelmezett. Ha ezt ki szeretnénk kapcsolni (a tesztelés során nem ilyen feladatokat választottam), akkor a Toolbox által elérhető eljárások mindegyikének megadható LargeScale mezőt off -ra kell állítanunk a következőképpen: options = optimset( LargeScale, off ); majd a használni kívánt optimalizáló függvénynek paraméterül kell adnunk az options vektort. 4.5.1. Az Optimization Toolbox alkalmazása nemlineáris optimalizálásra A Gauss-Newton és Levenberg-Marquardt módszereket az lsqnonlin függvényben valósították meg. Ha a függvény LargeScale változatát használjuk, akkor egy prekondícionált konjugált gradiens- és ún. Trust-Region módszert használ a nagyméretű feladatunk megoldására. Ha a LargeScale opciót kikapcsoljuk a fent említett módon, akkor Levenberg-Marguardt és Gauss- Newton módszereket használ megfelelő egyenesmenti kereső algoritmusokkal egyetemben. Az alapértelmezett a Levenberg-Marquardt, ha azonban a Gauss-Newton módszer lenne számunkra optimális, a Levenberg-Marquardt opciót kell off -ra állítanunk. 4.5.1.1. Példa. Oldjuk meg a következő egyenletrszert közelítő eljárással (Gauss-Newton): x 2 1 4x 2 = 0 6x 1 x 2 2 = 4 3x 1 x 2 = 0 Megoldás. Ehhez a feladathoz társítsuk a következő, vele ekvivalens feladatot: F (x) = 1 ( (x 2 2 1 4x 2 ) 2 + (6x 1 x 2 2 4) 2 + (3x 1 x 2 ) 2) min! (11) amely feladat legkisebb négyzetes értelemben vett megoldását keressük. Nyilvánvaló, hogy a (11) feladat optimális megoldása egyben megoldása a kiindulási feladatunknak is. Nagyon fontos, hogy az lsqnonlin függvénynek nem f i (x) 2 alakú célfüggvényt kell megadnunk! A célfüggvényünket vektor-függvényként kell megadni, azaz el kell készíteni egy olyan MATLAB függvényt, mely az f 1 (x) f 2 (x) F (x) =. f n (x) vektor-függvényt számítja ki. A (11) feladathoz így a következő MATLAB függvényt kell elkészítenünk: gnlmf1.m function y = gnlmf1(x) y(1) = x(1).^2-4*x(2); y(2) = 6*x(1) - x(2).^2-4; y(3) = 3*x(1).*x(2); Ezekután futtassuk le a Gauss-Newton módszert a most definiált függvényünkön: 24
>> x0 = [-2.6-2.7] x0 = -2.6000-2.7000 >> options = optimset( LargeScale, off, LevenbergMarquardt, off ); >> [r,resnorm,residual,exitflag,output] = lsqnonlin(@gnlmf1,x0,[],[],options) Optimization terminated: directional derivative along search direction less than TolFun and infinity-norm of gradient less than 10*(TolFun+TolX). r = 0.6634 0.0880 resnorm = 0.0392 residual = 0.0883-0.0272 0.1751 exitflag = 1 output = iterations: 8 funccount: 47 stepsize: 0.9847 cgiterations: [] firstorderopt: [] algorithm: medium-scale: Gauss-Newton, line-search message: [1x147 char] >> >> gnlmf1(r) ans = 0.0883-0.0272 0.1751 Láthatjuk, hogy az r vektorban megkapott minimum-közelítés elég jó közelítése a 0 vektornak, amely a valódi megoldás. Ezt megkaptuk 8 iterációból, és mindössze 47 függvénykiértékeléssel. 13. ábra. A Gauss-Newton módszer kezdő- és vég-közelítésének helyzete a célfüggvény felületén 25
4.5.1.2. Példa. Oldjuk meg az alábbi gyökkeresési feladatot! F (x) = x 2 1 12x 1 x 2 + 8y 2 2 + 40e (x1 4)2 + 40e x2 2 sin(x1 ) + e x1x2 = 0! Megoldás. A következő három MATLAB utasítással kirajzolhatjuk a kétváltozós függvény által a térben kifeszített kifejezetten szép felületet: >> [x,y] = meshgrid(linspace(-2.3,2.3,60)); >> surf(x,y,x.^2-12.*x.*y+8.*y.^2+40.*exp(-(x-.4).^2)+40.*exp(-y.^2).*sin(x)+exp(x.*y)) >> colormap hot 14. ábra. Az x 2 1 12x 1 x 2 + 8y 2 2 + 40e (x1 4)2 + 40e x2 2 sin(x1 ) + e x1x2 függvény grafikonja. Ahhoz, hogy F (x) egy gyökét megtaláljuk, minimalizálnunk kell az F (x) 2 függvényt. Válasszuk a minimum sejtésének az x 0 = ( 2.1, 2.1) pontot. >> x0=[-2.1 2.1]; Kapcsoljuk ki a LargeScale módot, viszont használjuk a Gauss-Newton módszer helyett a Levenberg- Marquardt algoritmust. >> options = optimset( LargeScale, off, LevenbergMarquardt, on ); És indítsuk el az optimalizálást: >> [r,resnorm,residual,exitflag,output] = lsqnonlin(@gnlmf2,x0,[],[],options); Optimization terminated: directional derivative along search direction less than TolFun and infinity-norm of gradient less than 10*(TolFun+TolX). >> r r = -1.3255 0.7749 >> gnlmf2(r) ans = 3.8371e-06 Azaz 6 jegyre pontos megoldást kaptunk 8 iterációs lépés, és 56 függvénykiértékelés elvégzésével (ezeket az információkat az output.iterations és output.funccount mezőkből tudhatjuk meg). Az előző két tesztünkből levonhatjuk azt a következtetést, hogy még nagyon bonyolult függvények esetén sem reménytelen a gyökkeresési probléma megoldása, hiszen többdimenziós közelítő eljárásaink vannak a megoldás megtalálására, és az Optimization Toolbox függvényei igencsak hatékonyak. 26
5. Egyenletrszerek iterációs megoldása Egyenletrszerek vizsgálatát is a már megismert Optimization Toolbox, és a Symbolix Math Toolbox használatával fogom bemutatni. Ezen Toolboxok kiegészítik a MATLAB numerikus rszerét olyan optimalizáló eljárásokkal és szimbólikus számítási lehetőségekkel, melyek hatékonyan alkalmazhatóak többek között feltétel nélküli nemlineáris optimalizálásra lineáris és kvadratikus programozási feladatok megoldására nemlineáris egyenletrszerek megoldására legkisebb négyzetes függvényközelítésre automatikus differenciálásra egyenletrszerek algebrai megoldására 5.1. A Newton-módszer A klasszikus Newton-módszer bemutatására elkészítettem a Függelékben elérhető newton_method2.m MATLAB kódot. Ez a függvény a klasszikus Newton-iterációt hajtja végre. Paraméteréül meg kell adni a célfüggvényt, egy kezdeti sejtést (x 0 ), a kért pontosságot (ɛ), illetve az iterációk maximális számát. A célfüggvényt egy külön.m fájlban kell megvalósítani úgy, hogy egy adott x i helyen felvett függvényértéket, és az adott helyen vett Jacobi-mátrixot is kiszámítja. (Itt tehát nem az INTLAB automatikus differenciáló eljárásával számolunk!) 5.1.0.3. Példa. Oldjuk meg az alábbi egyszerű egyenletrszert! 3x 1 4x 2 + x 3 = 7 5x 1 + x 2 = 4 x 1 x 2 3x 3 = 5 Az egyenletrszerünket most egy F : R 3 R 3 vektorfüggvényként kell kezelnünk. Ezen vektorfüggvény Jacobi mátrixa a következő lesz: [ Fi (x) J F (x) = x j ] 3 i,j=1 = 3 4 1 5 1 0 1 1 3 Így a következőképpen kell egy MATLAB kóddal megvalósítanunk célfüggvényünket, és annak Jacobimátrixának kiszámítását: equationf1.m function [y,j] = equationf1(x) y(1) = 3*x(1)-4*x(2)+x(3)-7; y(2) = 5*x(1)+x(2)-4; y(3) = x(1)-x(2)-3*x(3)+5; J = [3-4 1; 5 1 0; 1-1 -3]; Az első három sorral már megbarátkoztunk, az számítja ki a vektorfüggvényt, míg a függvény negyedik sora a Jacobi-mátrixot adja. Most alkalmazzuk a Newton-módszert, és rajzoltassuk ki az abszolút közelítési és abszolút relatív közelítési hiba grafikonját: >> [xv r] = newton_method2(@equationf1,[1 4 5],1e-14,100); performed_iteration = 2 27
approxroot = 0.9067-0.5333 2.1467 >> equationf1(r) ans = 0 0 0 >> analyze2(xv) Láthatjuk, hogy mindössze két iteráció elvégzése után megtaláltuk a pontos gyököt (onnan tudjuk, hogy pontos, hogy az ans vektor elemei 0-k, és nem 0.0000-k!). Nyilvánvaló, hogy az előbbi egyenletrszerünk túl egyszerű volt, és ezért kaptunk ilyen gyorsan pontos megoldást. Most nézzünk egy nehezebb feladatot! 5.1.0.4. Példa. Adjunk közelítő megoldást az alábbi egyenletrszerre! 3x 2 1 5x 1 x 2 x 2 3 + 1 3 x2 2x 3 = 0 sin(x 1 )x 2 + sin(x 2 )x 3 cos(x 3 )x 1 x 2 = 1 2 x 1 x 2 + (x 3 2x 1 ) 2 = 20 Az egyenletrszerünket most is F : R 3 R 3 vektorfüggvényként kezeljük. A Jacobi-mátrix a következő lesz: J F (x) = 6x 1 5x 2 x 2 3 5x 1 x 2 3 + 2 3 x 2x 3 10x 1 x 2 x 3 + 1 3 x2 2 x 2 cos(x 1 ) cos(x 3 )x 2 sin(x 1 ) + x 3 cos(x 2 ) cos(x 3 )x 1 sin(x 2 ) + sin(x 3 )x 1 x 2 x 2 + 4(x 3 2x 1 ) x 1 2(x 3 2x 1 ) Az ehhez tartozó MATLAB függvény a következőképpen kell, hogy kinézzen: equationf2.m function [F,J] = equationf2(x) y = x(2); z = x(3); x = x(1); F = zeros(1,3); F(1) = 3*x^2-5*x*y.*z^2 + 1/3*y^2*z; F(2) = sin(x)*y + sin(y)*z - cos(z)*x*y+.5; F(3) = x*y+(z-2*x).^2-20; j1 = [(6*x - 5*y*z^2) (-5*x*z^2 + 2/3*y*z) (-10*x*y*z+1/3*y^2)]; j2 = [(y.*cos(x)-cos(z)*y) (sin(x)+ z*cos(y)-cos(z)*x) (sin(y)+sin(z)*x*y)]; j3 = [(y+4*(z-2*x)) (x) (2*(z-2*x))]; J = [j1;j2;j3]; Az első sorral (x,y és z változók bevezetésével) csak az olvashatóságot javítjuk. A következő három sorral kiszámítjuk az adott x helyen felvett függvényértéket, majd pedig a j1,j2 és j3 változók segítségével felépítjük a Jacobi-mátrixot az utolsó sorban. Keressünk közelítő megoldást az egyenletrszerünkre: 28
>> [xv r] = newton_method2(@equationf2,[1 4 5],1e-14,100); performed_iteration = 21 approxroot = -0.1064-6.6680 4.1792 >> equationf2(r) ans = 1.0e-14 * 0 0.0333 0.3553 >> analyze2(xv) >> Azt kaptuk, hogy 21 iteráció elvégzése után 14 jegyre pontos eredményt kaptunk. A grafikonokról szépen leolvasható, hogy az első 4-5 iteráció során még ténylegesen csak kerestük a gyököt, majd 7-8 iteráció után a megtalált közelítést csak finomítottuk. Azaz a gyök egy jó közelítését már 5-6 iteráció után megkaphattuk volna. 5.2. Az fsolve eljárás Az fsolve eljárás az Optimization Toolbox egyik fontos függvénye, nemlineáris egyenletrszert old meg közelítő eljárásokkal. Alapértelemezzen az ún. Trust-Region Dogleg módszer alkalmazza, azonban rá tudjuk bírni a Gauss-Newton és Levenberg-Marquardt módszerekre is a NonlEqnAlgorithm kapcsolóval. Teknikailag az F (x) = 0 egyenletet oldja meg x-re, ahol x egy vektor, míg F (x) egy vektorfüggvény, melynek visszatérési értéke is egy vektor. 5.2.0.5. Példa. Oldjuk meg a következő nemlineáris egyenletrszert: 4x 1 x 2 = e 2x1 x 1 + 2x 2 = e 1 2 x2 Rezzük át az egyenletrszert úgy, hogy minden egyenletet nullára redukálunk: 4x 1 x 2 e 2x1 = 0 x 1 + 2x 2 e 1 2 x2 = 0 Ezt az egyenletrszert szeretnénk megoldani az fsolve eljárással, mégpedig az x 0 = [ 5, 5] sejtésből kiindulva. Ehhez el kell készítenünk az F (x) vektorfüggvényt egy külön.m fájlban: fsolvef1.m function F = fsolvef1(x) F = [4*x(1) - x(2) - exp(-2*x(1)); -x(1) + 2*x(2) - exp(-.5*x(2))]; Ezekután hívjuk meg az optimalizálási eljárásukat: 29
>> global xv; >> x0 = [-5; -5]; % Kezd}opont beállítása >> options=optimset( Display, iter, NonlEqnAlgorithm, gn, OutputFcn,@outfunc); >> [x,fval] = fsolve(@fsolvef1,x0,options) Directional Iteration Func-count Residual Step-size derivative 0 3 4.85827e+08 1 12 1238.02 8.03-128 2 18 1238.02 1.61e-07-2.48e+03 3 25 13.4477 1.01-34 4 32 0.122666 1.29-0.198 5 38 1.21015e-06 0.999-9.83e-06 6 44 9.39938e-16 1-3.83e-15 7 45 3.04514e-24 1-1.88e-15 Optimization terminated: directional derivative along search direction less than TolFun and infinity-norm of gradient less than 10*(TolFun+TolX). x = 0.2749 0.5225 fval = 1.0e-11 * 0.1072-0.1377 >> analyze2(xv) 45 függvénykiértékelés után egy gyököt talált az eljárás, amely egyben az egyenletrszerünk közelítő megoldását is adja. Az fval vektor mutatja a redukált egyenletrszerünk baloldalának helyettesítési értékét a közelítésnél. Láthatjuk, hogy a hiba 1 11 -enes nagyságrű. A grafikonokról leolvashatjuk, hogy az fsolve eljárásnak főleg az második dimenzióval ( piros értékek a grafikonon, és x 2 változó az egyenlerszerben) gyűlt meg a baja, hiszen ott volt az abszolút közelítési hiba lényegesen magasabb. 5.2.0.6. Példa. Oldjuk meg az alábbi egyenletrszert! x 2 1 + x 3 x 4 = 20 x 1 x 3 + x 2 x 3 = 14 x 1 x 4 + x 2 x 4 = 8 x 3 x 4 + x 2 2 = 6 30