Pochylenie gradientowe (gradient descent) jest algorytmem minimalizującym funkcje. Biorąc pod uwagę funkcję zdefiniowaną przez zestaw parametrów, pochylenie gradientowe rozpoczyna się od początkowego zestawu wartości parametrów i iteracyjnie przesuwa się w kierunku zestawu wartości parametrów, które minimalizują tę funkcję. Zaczynamy od losowego punktu na funkcji i poruszamy się w kierunku ujemnym gradientu funkcji, aby osiągnąć minima lokalne / globalne.
Gradient Descent wymaga funkcji kosztu (najczęściej występuje funkcja kosztu błędu średniego kwadratów) ponieważ chcemy ją zminimalizować. Oznacza to, że wybór funkcji kosztowej wpłynie na obliczenie gradientu każdej wagi. Minimalizacja jakiejkolwiek funkcji oznacza znalezienie najgłębszej doliny (minimum) w tej funkcji. Należy pamiętać, że funkcja kosztu służy do monitorowania błędu w przewidywaniach modelu. Minimalizowanie tego, w zasadzie oznacza osiągnięcie najniższej możliwej wartości błędu lub zwiększenie dokładności modelu.
from IPython.display import Image
Image(filename="img/grad.png")
Mamy teraz wszystkie narzędzia potrzebne do uruchomienia spadku gradientu. Możemy zainicjować nasze wyszukiwanie, aby rozpocząć od dowolnej pary wartości (m i b) i pozwolić algorytmowi zejść w dół po naszej funkcji błędu w kierunku najlepszej linii. Każda iteracja zaktualizuje m i b do wiersza, który daje nieco mniejszy błąd niż poprzednia iteracja. Zasadniczo funkcja kosztu służy jedynie do monitorowania błędu przy każdym przykładzie szkoleniowym, podczas gdy pochodna funkcji kosztu w odniesieniu do jednej wagi jest tam, gdzie musimy przesunąć tę wagę, aby zminimalizować błąd dla tego przykładu szkoleniowego. Istnieją dwa parametry (współczynniki) w naszej funkcji kosztowej, którą możemy kontrolować: waga m i odchylenie b (bias). Ponieważ musimy wziąć pod uwagę wpływ każdego z nich na ostateczną prognozę, używamy pochodnych cząstkowych.
Wnew = W – learning rate * dW (weights)
Bnew = b – learning rate * db (bias)
Loss error = ½ (predicted value – actual value)2
To tak jakby szukać dna doliny gdy stoimy na stoku i nic nie widzimy. Intuicyjnie idziemy w dół ale dokładnie nie wiemy jakie kroki musimy dać aby nie przeoczyć dna a przy okazji nie zajęło nam to za dużo czasu.
Przykład jak działa gradient descent, nasz algorytm zaczyna się od 2 (current x), precision – to dokładność jakąchcemy uzyskać przy minimum – czyli kiedy zatrzymamy algorytm a nasza funkcja to: y = x + 2
cur_x = 2
rate = 0.01
precision = 0.000001
previous_step = 1
max_iters = 10000
iters = 0
df = lambda x: 2*(x+2)
while previous_step > precision and iters < max_iters:
prev_x = cur_x
cur_x = cur_x - rate * df(prev_x)
previous_step = abs(cur_x - prev_x)
iters = iters+1
print('Lokalne minimum', cur_x)
Nasze lokalne minimum to ok. -2 i to się zgadza bo gdy podstawimy do naszej funkcji y= -2 + 2 otrzymamy y=0
Zmienna – learning Rate – kontroluje, jak dużego kroku użyjemy aby zejść w dół podczas każdej iteracji. Jeśli podejmiemy zbyt duży krok, możemy przekroczyć minimum. Jeśli jednak podejmiemy małe kroki, będzie wymagało wielu iteracji, aby osiągnąć minimum.
Wartości te ustalamy głównie metodą prób i błędów.
from IPython.display import Image
Image(filename="img/rate.png")
Inny przykład:
import pandas as pd
from scipy import linspace, randn
n = 50
X = linspace(-5,5,n)
y= randn(n)
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
%matplotlib inline
lin_reg = LinearRegression()
lin_reg.fit(X.reshape(-1,1), y)
plt.scatter(X.reshape(-1,1), y, color = 'g')
plt.plot(X.reshape(-1,1), lin_reg.predict(X.reshape(-1,1)), color = 'r')
plt.title('Linear Regression')
plt.show()
Użyjemy funkcji stats.linregress aby otrzymać slope i intercept otrzymane z modelu:
from scipy import stats
slope, intercept, r_value, p_value, std_err = stats.linregress(X,y)
print('slope:', slope, 'intercept:', intercept)
Podążając logiką gradient descent możemy obliczyć optymalne wartości W (wagi) i b (bias):
import numpy as np
costs = []
W = 0.5
b = 1
for i in range(1, 50):
Y_pred = np.multiply(W, X) + b
Loss_error = 0.5 * (Y_pred - y)**2
cost = np.sum(Loss_error)/10
db = np.sum((Y_pred - y))
dw = np.dot((Y_pred - y), X)
costs.append(cost)
W = W - 0.01*dw
b = b - 0.01*db
print("W = ", W, "b = ",b)
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('iterations')
plt.show()
Była to funkcja kosztu wykreślona dla tylko jednej wagi. W prawdziwym modelu robimy wszystkie powyższe, dla wszystkich wag, podczas iteracji nad wszystkimi przykładami szkolenia. Nawet w stosunkowo niewielkim modelu ML będziesz miał więcej niż 1 lub 2 wagi.
Prediction = Weight * (independent variable) + Bias
Jest kilka rodzai Gradient Descent:
- Mini – Batch – GD: Tutaj, zamiast powtarzania wszystkich przykładów treningowych i przy każdej iteracji wykonuje się tylko obliczenia na jednym przykładzie szkoleniowym, przetwarzamy n przykładów treningu naraz.
- Stochastic – GD: Zamiast tego używać i zapętlać każdy przykład szkolenia, używamy JUST USE ONE.
- Podstawowy – GD: Zapętlanie nad każdym przykładem szkolenia.
