Színátmenet a Java-ban
1. Bemutatkozás
Ebben az oktatóanyagban megismerhetjük a Gradient Descent algoritmust. Megvalósítjuk az algoritmust a Java-ban, és lépésről lépésre bemutatjuk.
2. Mi az a gradiens süllyedés?
A Gradient Descent egy optimalizáló algoritmus, amelyet egy adott függvény helyi minimumának megtalálásához használnak. Széles körben használják a magas szintű gépi tanulási algoritmusokban a veszteségfüggvények minimalizálása érdekében.
A színátmenet a lejtő másik jelentése, az ereszkedés pedig lefelé haladást jelent. Ahogy a neve is sugallja, a Gradient Descent a függvény lejtőjén halad lefelé, amíg el nem éri a végét.
3. A gradiens süllyedés tulajdonságai
A gradiens süllyedés talál egy helyi minimumot, amely eltérhet a globális minimumtól. A kiinduló helyi pontot az algoritmus paramétereként adják meg.
Ez egy iteratív algoritmus, és minden lépésben megpróbál lefelé haladni a lejtőn és közelebb kerülni a helyi minimumhoz.
A gyakorlatban az algoritmus visszalépés. Ebben az oktatóanyagban szemléltetjük és megvalósítjuk a visszalépéses gradiens süllyedést.
4. Lépésenkénti illusztráció
A gradiens süllyedésnek függvényre és kiindulópontra van szüksége bemenetként. Definiáljuk és ábrázoljuk a függvényt:
Bármelyik kívánt ponton indulhatunk. Kezdjük x=1:
Az első lépésben a Gradient Descent előre meghatározott lépésmérettel megy le a lejtőn:
Ezután ugyanazzal a lépésmérettel tovább megy. Ezúttal azonban nagyobbra jut y mint az utolsó lépés:
Ez azt jelzi, hogy az algoritmus túllépte a helyi minimumot, tehát csökkentett lépésmérettel visszafelé halad:
Ezt követően, amikor az áram y nagyobb, mint az előző y, a lépcsőméretet csökkentik és tagadják. Az iteráció a kívánt pontosság eléréséig tart.
Mint láthatjuk, a Gradient Descent itt talált egy helyi minimumot, de ez nem a globális minimum. Ha itt kezdjük x= -1 helyett x= 1, a globális minimum megtalálható.
5. Megvalósítás Java-ban
A Gradient Descent megvalósításának számos módja van. Itt nem a függvény deriváltját számoljuk ki a meredekség irányának megkeresésére, így megvalósításunk nem differenciálható függvényekre is működik.
Határozzuk meg pontosság és stepCoefficient és adja meg nekik a kezdeti értékeket:
kettős pontosság = 0,000001; kettős lépésKoefficiens = 0,1;
Első lépésben nincs előzőnk y Összehasonlításképp. Vagy növelhetjük, vagy csökkenthetjük az értékét x hátha y csökkenti vagy emeli. Egy pozitív stepCoefficient azt jelenti, hogy növeljük a x.
Most hajtsuk végre az első lépést:
dupla előzőX = kezdőX; dupla előzőY = f.alkalmazás (előzőX); currentX + = stepCoefficient * előzőY;
A fenti kódban f egy Funkció, és kezdőX egy kettős, mindkettő bemenetként biztosított.
Egy másik fontos szempont, hogy a Színátmenet süllyedése nem garantáltan közeledik egymáshoz. Annak elkerülése érdekében, hogy elakadjon a ciklusban, korlátozzuk az iterációk számát:
int iter = 100;
Később csökkenteni fogjuk iter minden iterációnként egyet. Következésképpen legfeljebb 100 iterációval lépünk ki a ciklusból.
Most, hogy van egy előzőX, beállíthatjuk a hurokunkat:
while (előzőStep> precíziós && iter> 0) {iter--; kettős áram Y = f.alkalmazás (áramX); if (currentY> előzőY) {stepCoefficient = -stepCoefficient / 2; } előzőX = aktuálisX; currentX + = stepCoefficient * előzőY; előzőY = aktuálisY; előzőStep = StrictMath.abs (currentX - előzőX); }
Minden iterációban kiszámoljuk az újat y és hasonlítsa össze az előzővel y. Ha aktuálisY nagyobb, mint előzőY, megváltoztatjuk az irányunkat és csökkentjük a lépés méretét.
A hurok addig folytatódik, amíg a lépésméretünk kisebb lesz, mint a kívánt pontosság. Végül visszatérhetünk currentX mint helyi minimum:
visszatérő áramX;
6. Következtetés
Ebben a cikkben lépésről lépésre szemléltettük a Gradient Descent algoritmust.
A Gradient Descent programot Java-ban is megvalósítottuk. A kód elérhető a GitHubon.