Sztuczna inteligencja/SI Moduł 12

Sieci neuronowe - wprowadzenie

Sieci neuronowe są jedną z wielu możliwych realizacji aproksymatora regresyjnego. Swoją popularność zawdzięczają w pewnej mierze analogiom biologicznym – można w nich upatrywać niezwykle uproszczonych modeli naturalnych struktur neuronowych. Przykładem sieci neuronowych, chyba najbardziej rozpowszechnionym, jest perceptron wielowarstwowy, któremu poświęcimy tę lekcję. Inne rozpowszechnione struktury sieci neuronowych to architektury ze sprzężeniem zwrotnym (tzw. sieci Hopfielda), realizujące układy dynamiczne, oraz architektury samoorganizujące (tzw. sieci Kohonena), realizujące algorytm grupowania. Tematyka sieci neuronowych jest dość dobrze opisana w literaturze uzupełniającej, do której odsyłamy bardziej zainteresowanych. Poniżej naszkicujemy podstawowe zagadnienia związane z wykorzystaniem perceptronu jako metody regresji oraz z metodami uczenia się stosowanymi dla tej sieci.

Definicja perceptronu wielowarstwowego

Perceptron wielowarstwowy jest aproksymatorem nieliniowym $R^n\to R^m$. Graficzna postać sieci jest następująca:

Węzeł grafu sieci odpowiada pojedynczemu neuronowi. Krawędź odpowiada połączeniu między neuronami (tzw. połączenie synaptyczne) – jest skierowana od wyjścia jednego do wejścia drugiego neuronu, co odpowiada jednokierunkowemu przepływowi danych.

Neuron działa w taki sposób, że dokonuje się ważonego sumowania wartości wejść, obliczając wartość, zwaną pobudzeniem Parser nie mógł rozpoznać (błąd składni): {\displaystyle h_i\} ,:

Parser nie mógł rozpoznać (błąd składni): {\displaystyle h_i = \sum_{j=1..n} w_{ij} x_j + w_{i0}\} ,

Wygodnie jest założyć, że neuron otrzymuje jeszcze jedno wejście Parser nie mógł rozpoznać (błąd składni): {\displaystyle x_0\} , o wartości równej stale jedynce. Przy takim założeniu, pobudzenie da się zapisać prościej jako

Parser nie mógł rozpoznać (błąd składni): {\displaystyle h_i = \sum_{j=0..n} w_{ij} x_j\} ,

Wyjście neuronu powstaje w wyniku podania pobudzenia na funkcję aktywacji Parser nie mógł rozpoznać (błąd składni): {\displaystyle g\} ,:

Parser nie mógł rozpoznać (błąd składni): {\displaystyle y_i = g(h_i)\} ,

W przypadku sieci neuronowych, funkcja aktywacji ma kształt litery „s” – jest monotonicznie rosnąca z asymptotami poziomymi w nieskończonościach. Najczęściej przyjmuje się funkcję tangens hiperboliczny:

$g(x)=\tanh (x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$

przyjmującą wartość z zakresu Parser nie mógł rozpoznać (błąd składni): {\displaystyle \bf [–1,1]} , względnie funkcję logistyczną:

$g(x)=\frac{1}{1+e^{-x}}$

o wartościach z zakresu $\mathbf{[}\mathbf{𝟎},\mathbf{𝟏}\mathbf{]}$.

Neurony zgrupowane są w warstwy w taki sposób, że między neuronami tej samej warstwy nie ma połączeń, a połączenia występują jedynie między neuronami sąsiadujących warstw.

Wyróżnia się warstwę neuronów wyjściowych (zwaną krótko warstwą wyjściową), których wyjście jest jednocześnie wyjściem z sieci. Pozostałe warstwy są nazywane ukrytymi, gdyż wyjścia neuronów w nich się znajdujących nie są „widoczne” na wyjściu sieci.

Dla neuronów wyjściowych można przyjąć, że funkcja aktywacji jest funkcją liniową.

Tak więc sieć neuronowa jest w swojej istocie pewnym wzorem, który da się przedstawić w formie graficznej. Wzór ten brzmi (w nieco nieformalnym zapisie):

$y_i=\sum w_{ij}g\left(\sum _k{w}_{jk}g(...\left(\sum _t{w}_{st}{x}_t\right))\right)$

Wielokrotne ważone sumowanie i przekształcanie funkcją aktywacji ma miejsce tyle razy, ile jest warstw neuronów w sieci, dlatego w powyższym wzorze pojawiają się trzy kropki. Jak więc widać, wyjście sieci neuronowej jest funkcją jej wejścia, przy czym funkcja ta jest parametryzowana zestawem parametrów $\mathbf{𝐰}$.

Interpretacja znaczenia parametrów sieci

Spróbujmy zrozumieć znaczenie poszczególnych parametrów, analizując przykładowe sieci zawierające jeden neuron wyjściowy z liniową funkcją aktywacji oraz jedną warstwę nieliniowych neuronów.

Na początek skoncentrujmy się na najprostszej sieci, mających jedno wejście i jedno wyjście (a zatem aproksymowana jest funkcja $R\to R$). Rozważmy sieć o dwóch neuronach ukrytych i jednym wyjściu liniowym. Opisuje ją wzór:

Parser nie mógł rozpoznać (błąd składni): {\displaystyle y=w_{10} + w_{11} g(w_{20} + w_{21} x) + w_{12} g(w_{30} + w_{31} x)\} ,

Znaczenie parametrów pojedynczego neuronu warstwy ukrytej jest następujące. Wartości proporcji Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{20}/w_{21}\} ,, Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{30}/w_{31}\} , służą do przesuwania wykresu funkcji Parser nie mógł rozpoznać (błąd składni): {\displaystyle g\} , wzdłuż osi OX. Z kolei parametry Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{21}, w_{31}\} , wpływają na „stromość” wykresu funkcji Parser nie mógł rozpoznać (błąd składni): {\displaystyle g(h_2)\} ,, Parser nie mógł rozpoznać (błąd składni): {\displaystyle g(h_3)\} ,. Tak więc, manipulując oboma parametrami, jesteśmy w stanie uzyskać funkcję o różnej „stromości”, różnie położoną na osi OX.

Parametry warstwy wyjściowej służą określeniu stopnia „wymieszania” wyjść neuronów ukrytych. Im większa wartość wagi Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{1i}\} ,, tym większy mnożnik użyty do wykresu wyjścia neuronu i-tego (dodajmy, że przyjęcie ujemnej wagi Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{1i}\} , powoduje odbicie wykresu funkcji wyjścia neuronu względem osi OX).

Z kolei w przypadku sieci o dwóch wejściach, aproksymującej funkcję $R^2\to R$, z dwoma neuronami ukrytymi i jednym liniowym wyjściowym, mamy wzór:

Parser nie mógł rozpoznać (błąd składni): {\displaystyle y=w_{10} + w_{11} g(w_{20}+w_{21} x_1 + w_{22} x_2) + w_{12} g(w_{30} + w_{31} x_1 + w_{32} x_2)\} ,

Wagi Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{20}, w_{21}, w_{22}\} , odpowiadają za sposób ułożenia w przestrzeni powierzchni, odpowiadającej funkcji Parser nie mógł rozpoznać (błąd składni): {\displaystyle g(w_{20} + w_{21} x_1 + w_{22} x_2)\} , – powierzchnia ta ma poziomice ułożone wzdłuż prostej o równaniu Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_{20} + w_{21} x_1 + w_{22} x_2 = 0\} ,, a w przekroju poprzecznym do poziomic ma kształt funkcji Parser nie mógł rozpoznać (błąd składni): {\displaystyle g\} ,. Zmieniając współczynniki wagowe, dokonujemy obrotów i przemieszczeń tej powierzchni, nie zmieniając jednak jej zasadniczego kształtu.

Wpływ wag perceptronu na jakość aproksymacji

Rzecz jasna wielce niepraktyczne byłoby dobieranie wartości współczynników wagowych sieci neuronowej „na oko” poprzez ręczne manipulacje tymi wartościami. Dlatego można zastosować to samo podejście, z którym mieliśmy już do czynienia w regresji liniowej i przeprowadzić regresję nieliniową.

Zasada jest podobna. Zakładamy, że sieć neuronowa ma jedno wyjście i wiele wejść. Oznaczymy aproksymowaną funkcję przez $y(\mathbf{𝐱})$, natomiast wyjście sieci przez $\hat{y}(\mathbf{𝐱})$. Dysponujemy pewnym zbiorem $T=\{(\mathbf{𝐱},y(\mathbf{𝐱}))\}$, zwanym zbiorem uczącym. Zdefiniujmy funkcję reszt $r(\mathbf{𝐱})=\hat{y}(\mathbf{𝐱})-y(\mathbf{𝐱})$. Zauważmy, że zarówno $\hat{y}(\mathbf{𝐱})$, jak i $r(\mathbf{𝐱})$ są funkcjami nie tylko wektora argumentów $\mathbf{𝐱}$, ale i wektora wag $\mathbf{𝐰}$.

Załóżmy, że miarą błędu jest błąd średniokwadratowy:

$\Vert e(x)\Vert =\int r^2(x)dx$

W praktyce nie jesteśmy w stanie obliczyć powyższej całki, gdyż nie dysponujemy wartościami $y(\mathbf{𝐱})$ dla dowolnej wartość argumentu, lecz tylko dla zbioru uczącego. Dlatego zamiast całką posługujemy się wartością błędu średniokwadratowego, obliczanego na zbiorze trenującym:

$V(\mathbf{𝐰})=\frac{1}{n_T}\sum _T{r}^2(x)$

gdzie Parser nie mógł rozpoznać (błąd składni): {\displaystyle n_T\} , jest liczbą elementów zbioru trenującego. Jeśli nie będzie to budzić wątpliwości, wartość $V(\mathbf{𝐰})$ będziemy dalej nazywać błędem sieci.

Teraz możemy już sformułować zadanie przeszukiwania, które leży u podstaw algorytmu uczenia sieci neuronowej. Przestrzeń przeszukiwań jest przestrzenią wektorów $\mathbf{𝐰}$, a zatem jest to przestrzeń kartezjańska Parser nie mógł rozpoznać (błąd składni): {\displaystyle R^{n_w}\} ,, gdzie Parser nie mógł rozpoznać (błąd składni): {\displaystyle n_w\} , jest liczbą wag sieci. W przykładach rozważanych powyżej wartość Parser nie mógł rozpoznać (błąd składni): {\displaystyle n_w\} , jest równa odpowiednio: siedem (dla sieci z jednym wejściem) i dziewięć (dla sieci z dwoma wejściami). W nieco bardziej realistycznych przypadkach wartość Parser nie mógł rozpoznać (błąd składni): {\displaystyle n_w\} , może się wahać od kilkudziesięciu do nawet kilkuset.

W przestrzeni przeszukiwań jest zdefiniowany funkcja, przyporządkowująca wektorowi wag $\mathbf{𝐰}$ wartość błędu $V(\mathbf{𝐰})$. Przeszukiwanie ma na celu znalezienie takiego punktu (czyli wektora wag $\mathbf{𝐰}$), dla którego wartość błędu $V(\mathbf{𝐰})$ jest minimalna – uczenie sieci jest więc zadaniem minimalizacji błędu w przestrzeni wag aproksymatora.

Powstaje pytanie – jak stwierdzić, że dla konkretnego wektora wag w przypada minimum błędu $V(\mathbf{𝐰})$? Jeśli wiemy, że jest dokładnie jedno takie minimum, a tak jest przy aproksymatorach liniowych, można obliczyć wartość gradientu błędu – będzie się on zerować w minimum. W przypadku aproksymatorów nieliniowych może być wiele minimów lokalnych, jednak zerowanie gradientu błędu jest warunkiem koniecznym istnienia minimum funkcji w punkcie.

Przystąpmy zatem do obliczenia gradientu. Dla neuronu wyjściowego (patrz rysunek) mamy:

$\frac{\partial V}{\partial w_i}=\frac{1}{n_T}\sum _{T}2e(\mathbf{𝐱})\frac{\partial e(\mathbf{𝐱})}{\partial w_i}=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})\frac{\partial \hat{y}(\mathbf{𝐱})}{\partial w_i}$

a ponieważ dla każdego neuronu:

$\frac{\partial y_i}{\partial w_{ij}}=g^{\prime }(h_i)\frac{\partial h_i}{\partial w_{ij}}=g^{\prime }(h_i)y_i$

dostaniemy zatem:

$\frac{\partial V}{\partial w_i}=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})g^{\prime }(h)y_i$

Dla neuronu warstwy ukrytej, którego wyjście jest dostarczane do neuronu wyjściowego (patrz rysunek), mamy:

$\frac{\partial V}{\partial w_{ij}}=\frac{1}{n_T}\sum _{T}2e(\mathbf{𝐱})\frac{\partial e(\mathbf{𝐱})}{\partial w_{ij}}=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})\frac{\partial e(\mathbf{𝐱})}{\partial y_i}\frac{\partial y_i}{\partial w_{ij}}=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})\frac{\partial \hat{y}(\mathbf{𝐱})}{\partial y_i}\frac{\partial y_i}{\partial w_{ij}}$

a ponieważ dla każdego neuronu:

$\frac{\partial y_i}{\partial y_j}=g^{\prime }(h_i)\frac{\partial h_i}{\partial y_j}=g^{\prime }(h_i)w_{ij}$

dostaniemy zatem:

$\frac{\partial V}{\partial w_{ij}}=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})w_i{g}^{\prime }(h)g^{\prime }(h_i)y_i$

Dla neuronu znajdującego się warstwę głębiej mamy:

$\frac{\partial V}{\partial w_{jk}}=\frac{1}{n_T}\sum _{T}2e(\mathbf{𝐱})\frac{\partial e(\mathbf{𝐱})}{\partial w_{jk}}=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})\frac{\partial e(\mathbf{𝐱})}{\partial y_i}\sum _j\frac{\partial y_i}{\partial y_j}\frac{\partial y_j}{\partial w_{jk}}=$

$=\frac{2}{n_T}\sum _{T}e(\mathbf{𝐱})w_i{g}^{\prime }(h)\sum _j{w}_{ij}{g}^{\prime }(h_i)g^{\prime }(h_j)y_k$

Oznaczmy:

$\delta (\hat{y})=e(\mathbf{𝐱})g^{\prime }(h)$
$\delta (y_i)=w_i\delta (\hat{y})g^{\prime }(h)$
Parser nie mógł rozpoznać (błąd składni): {\displaystyle \delta(y_j) = \sum_j w_{ij} \delta{y_i} g'(h_j)\} ,

Możemy zatem zapisać:

$\frac{\partial V}{\partial w_i}=\frac{2}{n_T}\sum _T\delta (\hat{y})y_i$ $\frac{\partial V}{\partial w_i}=\frac{2}{n_T}\sum _T\delta (y_i)y_j$ $\frac{\partial V}{\partial w_i}=\frac{2}{n_T}\sum _T\delta (y_j)y_k$

O swoistej urodzie gradientu funkcji błędu względem wag sieci świadczy fakt, że do obliczenia gradientu względem wag warstwy ukrytej wystarczy informacja o gradiencie wag warstwy, która po niej następuje. Z tej przyczyny sposób obliczania gradientu jest nazywany algorytmem wstecznej propagacji błędu – błąd propaguje wzdłuż wag sieci w kierunku od wyjścia do wejścia.

Spełnienie warunku koniecznego istnienia minimum funkcji w punkcie nie daje oszacowania wartości funkcji błędu w tym punkcie. Powstaje zatem pytanie – czy dla dowolnej aproksymowanej funkcji istnieje sieć neuronowa, której błąd aproksymacji będzie nie większy niż pewien założony limit. Odpowiedzi na to pytanie udziela poniższe twierdzenie.

Twierdzenie o uniwersalnych właściwościach aproksymacyjnych

Załóżmy, że:

$D\subset R^n$ jest zbiorem otwartym, skończonej miary

$f:R^n\to R$ jest funkcją ciągłą, taką że dla każdego $\mathbf{𝐞}\in D|f(\mathbf{𝐱})|<\mathrm{\infty }$

$\hat{y}(\mathbf{𝐱})$ jest funkcją postaci:

$\hat{y}(\mathbf{𝐱})=\sum _{i=1..N}g({\mathbf{𝐰}}_i^T\mathbf{𝐱})$

gdzie $g(\mathbf{𝐱})$ jest funkcją ciągłą, ograniczoną i monotoniczną.

Wówczas:

dla każdego $ϵ>0$ istnieje taki zbiór wektorów wag $\{{\mathbf{𝐰}}_1,...,{\mathbf{𝐰}}_N\}$, że dla każdego $x\in D$

$|\hat{y}(\mathbf{𝐱})-f(\mathbf{𝐱})|<ϵ$

Tak więc na mocy powyższego twierdzenia wiemy, że istnieje taka struktura sieci neuronowej, w której da się zrealizować aproksymację z dowolnie małym błędem. Analizując gradient, umiemy także stwierdzić, czy zestaw wag sieci jest minimum lokalnym funkcji błędu. Pozostaje rzecz najtrudniejsza – wyznaczyć taki zestaw wag, który jest nie tylko minimum lokalnym, lecz globalnym funkcji błędu.

Uczenie sieci

Jedną z najpowszechniej chyba stosowanych metod minimalizacji błędu sieci neuronowej jest przeszukiwanie przestrzeni wag według algorytmu wzrostu. Algorytm wychodzi z ustalonego arbitralnie wektora wag, po czym oblicza wektor gradientu funkcji błędu i jako nowy wektor wag przyjmuje wektor znajdujący się na półprostej wyprowadzonej w kierunku minus gradientu. Taką metodę nazywa się często metodą wstecznej propagacji błędu, a jej algorytm jest podany poniżej.

Algorytm uczenia perceptronu

Parser nie mógł rozpoznać (błąd składni): {\displaystyle t=0\} ,

inicjuj ${\mathbf{𝐰}}^{(0)}$

powtarzaj

${\mathbf{𝐰}}^{(t+1)}={\mathbf{𝐰}}^{(t)}-\eta \mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})$

Parser nie mógł rozpoznać (błąd składni): {\displaystyle t = t + 1\} ,

dopóki $\Vert \mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})\Vert >ϵ$

Gradient funkcji błędu $\mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})$ można obliczyć, korzystając z zasady wstecznej propagacji błędu, sumując iloczyny Parser nie mógł rozpoznać (błąd składni): {\displaystyle \delta(y_j)y_k\} , po wszystkich elementach zbioru trenującego Parser nie mógł rozpoznać (błąd składni): {\displaystyle T\} ,. Taki sposób uczenia nazywa się „trybem blokowym”. Istnieje jednak inna możliwość – zamiast wykorzystywać cały zbiór trenujący, można wziąć jedynie jego podzbiór $T^{\prime }\subset T$ (np. losowowybrany podzbiór, w szczególności podzbiór jednoelementowy), w każdej iteracji algorytmu uczenia wybierany na nowo, i obliczać gradient $\mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})$ dla elementów zbioru Parser nie mógł rozpoznać (błąd składni): {\displaystyle T'\} ,. Jeśli ponumerujemy elementy zbioru Parser nie mógł rozpoznać (błąd składni): {\displaystyle T\} ,, a podzbiór Parser nie mógł rozpoznać (błąd składni): {\displaystyle T'\} , będzie jednoelementowy i będzie zawierać za każdym razem element z Parser nie mógł rozpoznać (błąd składni): {\displaystyle T\} , o kolejnym numerze porządkowym, to taki tryb uczenia nazywa się uczeniem sekwencyjnym.

Przyjęcie trybu blokowego powoduje, że możliwie najdokładniej przybliżana jest wartość gradientu funkcji błędu. Jeśli funkcja błędu obliczana dla zbioru Parser nie mógł rozpoznać (błąd składni): {\displaystyle T\} , ma „wąskie” minima lokalne – takie, których stwierdzenie nie jest możliwe po usunięciu choć jednego elementu zbioru Parser nie mógł rozpoznać (błąd składni): {\displaystyle T\} , – to przypuszczalnie nie odpowiadają one minimum globalnemu. Posłużenie się jedynie podzbiorem Parser nie mógł rozpoznać (błąd składni): {\displaystyle T'\} ,, w dodatku zmieniającym się z iteracji na iterację, pozwala algorytmowi skoncentrować się na „szerokich” minimach funkcji błędu, co czyni metodę uczenia nieco odporniejszą na minima lokalne. Wtedy jednak należy się liczyć z faktem, że warunek zatrzymania – spadek normy gradientu błędu poniżej założonego poziomu – może nie być spełniony. Można ten problem ominąć, zwiększając wartość Parser nie mógł rozpoznać (błąd składni): {\displaystyle \epsilon\} ,, albo ustalić apriori liczbę iteracji algorytmu.

Powyższy algorytm wykonuje krok w kierunku minus gradientu; szerokość tego kroku jest stałą krotnością gradientu (reguluje to współczynnik uczenia Parser nie mógł rozpoznać (błąd składni): {\displaystyle \eta\} ,). Takie postępowanie może prowadzić do bardzo długotrwałego procesu uczenia, jeśli gradient funkcji błędu ma małą „długość” (norma gradientu jest niewielką liczbą). Małe wartości gradientu z kolei występują w dwóch sytuacjach: gdy neurony są bliskie nasyceniu (tzn. wartości gradientu funkcji aktywacji Parser nie mógł rozpoznać (błąd składni): {\displaystyle g'(h_i)\} , są małe) albo gdy mamy do czynienia z minimum funkcji błędu (patrz poniższy rysunek).

W tym pierwszym przypadku, po wykonaniu ruchu w kierunku minus gradientu, znajdujemy się w nowym punkcie, w którym gradient ma najczęściej ten sam kierunek (a nierzadko i tę samą wartość) co poprzednio. Z tą sytuacją mamy do czynienia dla punktu Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_1\} ,. W tym drugim przypadku, po wykonaniu podobnego kroku mamy najczęściej do czynienia ze zmianą kierunku i wartości gradientu (tak jest przykładowo dla punktu Parser nie mógł rozpoznać (błąd składni): {\displaystyle w_2\} ,). Obserwacje te stanowią motywację metody przyspieszenia algorytmu uczenia perceptronu, polegającej na dodaniu „momentu bezwładności”. Algorytm wygląda następująco:

Algorytm uczenia perceptronu z momentem bezwładności

inicjuj ${\mathbf{𝐰}}^{(0)}$

$\mathrm{\Delta }{\mathbf{𝐰}}^{(0)}=\eta \mathrm{\nabla }V({\mathbf{𝐰}}^{(0)})$

${\mathbf{𝐰}}^{(1)}={\mathbf{𝐰}}^{(0)}-\mathrm{\Delta }{\mathbf{𝐰}}^{(0)}$

Parser nie mógł rozpoznać (błąd składni): {\displaystyle t = 1\} ,

powtarzaj

$\mathrm{\Delta }{\mathbf{𝐰}}^{(t)}=\eta \mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})+\alpha \mathrm{\Delta }{\mathbf{𝐰}}^{(t-1)}$

${\mathbf{𝐰}}^{(t+1)}={\mathbf{𝐰}}^{(t)}-\mathrm{\Delta }{\mathbf{𝐰}}^{(t)}$

Parser nie mógł rozpoznać (błąd składni): {\displaystyle t = t + 1\} ,

dopóki $\Vert \mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})\Vert >ϵ$

Współczynnik $\alpha$ jest momentem bezwładności i spełnia warunek Parser nie mógł rozpoznać (błąd składni): {\displaystyle 0 < \alpha < 1\} ,.

Jeśli zachodzi pierwszy z omawianych wcześniej przypadków (gradient w przybliżeniu niezmienny wzdłuż kierunku swoich zmian), wówczas efektywny współczynnik uczenia wynosi w przybliżeniu Parser nie mógł rozpoznać (błąd składni): {\displaystyle \eta (1 + \alpha)^k\} ,, gdzie Parser nie mógł rozpoznać (błąd składni): {\displaystyle k\} , jest liczbą kroków, w których gradient jest w przybliżeniu niezmienny. A zatem w kolejnych iteracjach algorytm uczenia wykonuje coraz większy krok, co pozwala przyspieszyć jego działanie. Z kolei gdy w kolejnych krokach gradient różni się, krok się zmniejsza. Przykładowo, dla $\mathrm{\nabla }V({\mathbf{𝐰}}^{(t)})=-\mathrm{\nabla }V({\mathbf{𝐰}}^{(t-1)})$, efektywny współczynnik uczenia wyniesie Parser nie mógł rozpoznać (błąd składni): {\displaystyle \eta (1 - \alpha)\} ,, co pozwala na dokładniejszą lokalizację minimum lokalnego funkcji błędu.

Omawiane algorytmy uczenia sieci korzystają z warunku koniecznego istnienia minimum funkcji w punkcie. Oznacza to, że wektor wag ${\mathbf{𝐰}}^{(t)}$ będzie zdążać do takiego wektora, dla którego przypada minimum lokalne funkcji błędu, niekoniecznie będące minimum globalnym. Nie jest znany algorytm dający gwarancję znalezienia minimum globalnego dowolnej funkcji w Parser nie mógł rozpoznać (błąd składni): {\displaystyle R^n\} ,, a zatem nie możemy liczyć na gwarancję wyznaczenia optymalnego wektora wag. Można jednak zwiększyć prawdopodobieństwo wyznaczenia minimum globalnego, stosując np. techniki omawiane we wcześniejszej lekcji poświęconej metodom przeszukiwania wykorzystującym losowość.