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.