Regresja liniowa

Aby przeprowadzić uczenie z nadzorem musimy zdecydować się jak będziemy reprezentować funkcję \(h\) w komputerze. Na początek załóżmy, że będzie to funkcja liniowa:

\(h_{\theta }(x) = \theta_0 + \theta_1 x_1 + \theta_2 x_2\)

Parametry \(\theta _i\) (zwane także wagami) parametryzują przestrzeń funkcji liniowych \(X \rightarrow Y\). Tam gdzie nie będzie to powodować niejednoznaczności zamiast \(h_\theta (x)\) będziemy pisać \(h(x)\). Dla uproszczenia notacji wprowadzimy też “sztuczne” wejście \(x_0 =1\), zaś parametr \(\theta _0\) nazywać będziemy obciążeniem (bias).

Stosując powyższą konwencję możemy napisać:

\(h(x) = \sum _{i=0}^n \theta _i x_i\)

Niektóre rachunki uproszczą się nam jeśli zastosujemy notację wektorową. Oznaczmy:

\(\mathbf {\theta } = [\theta _0, \dots , \theta _n]^T\) ,

\(\mathbf {x} = [x_0, \dots ,x_n]^T\)

(zapisaliśmy oba wektory jako transponowane bo \(\mathbf {\theta }\) i \(\mathbf {x}\) są wektorami kolumnowymi). Wówczas:

\(h(x) = \sum _{i=0}^n \theta _i x_i = \mathbf {\theta }^T \mathbf {x}\)

Problem uczenia maszynowego polega na tym: jak mając zbiór uczący znaleźć “dobre” parametry? Aby sformalizować ten problem wyprowadzimy funkcję kosztu

\(J(\mathbf {\theta }) = \frac{1}{2} \sum _{i=1}^{m} \left( h_\theta (x^{(i)}) - y^{(i)} \right)^2\)

Teraz możemy powiedzieć, że “dobre” parametry to takie, które minimalizują funkcję kosztu.

Regresja liniowa - gotowy model

Zbiór danych zawierających maksymalną prędkość samochodu oraz jego drogę hamowania:

summary(cars)
##      speed           dist       
##  Min.   : 4.0   Min.   :  2.00  
##  1st Qu.:12.0   1st Qu.: 26.00  
##  Median :15.0   Median : 36.00  
##  Mean   :15.4   Mean   : 42.98  
##  3rd Qu.:19.0   3rd Qu.: 56.00  
##  Max.   :25.0   Max.   :120.00
plot(cars$speed,cars$dist)

Wywołanie funkcji budującej model regresji liniowej:

reg<-lm(dist~speed, cars)
summary(reg)
## 
## Call:
## lm(formula = dist ~ speed, data = cars)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -29.069  -9.525  -2.272   9.215  43.201 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept) -17.5791     6.7584  -2.601   0.0123 *  
## speed         3.9324     0.4155   9.464 1.49e-12 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 15.38 on 48 degrees of freedom
## Multiple R-squared:  0.6511, Adjusted R-squared:  0.6438 
## F-statistic: 89.57 on 1 and 48 DF,  p-value: 1.49e-12
plot(cars$speed,cars$dist)
abline(reg$coefficients[1], reg$coefficients[2],col='red')

Regresja liniowa - jak znaleźć parametry ?

Założmy dla uproszczenia, że szukamy wartości tylko drugiego parametru (wartość pierwszego “magicznie” poznaliśmy" )

w0 = -17.57909

w1 = 10  # przypuszczenie

Ile wynosi funkcja kosztów dla takich wartości parametrów ?

TPredict<-function(theta, x){
  x<-cbind(rep(1,nrow(x)), x)
  return (x %*% theta)
}

TCost<-function(theta, x, y){
  y_pred<-TPredict(theta, x)
  err=(y_pred - y)^2
  return (sum(err))
}


theta<-as.matrix(c(w0, w1), 2,1)
theta
##           [,1]
## [1,] -17.57909
## [2,]  10.00000
y = as.matrix(cars$dist, length(cars$dist),1)
x = as.matrix(cars$speed, length(cars$speed),1)
x
##       [,1]
##  [1,]    4
##  [2,]    4
##  [3,]    7
##  [4,]    7
##  [5,]    8
##  [6,]    9
##  [7,]   10
##  [8,]   10
##  [9,]   10
## [10,]   11
## [11,]   11
## [12,]   12
## [13,]   12
## [14,]   12
## [15,]   12
## [16,]   13
## [17,]   13
## [18,]   13
## [19,]   13
## [20,]   14
## [21,]   14
## [22,]   14
## [23,]   14
## [24,]   15
## [25,]   15
## [26,]   15
## [27,]   16
## [28,]   16
## [29,]   17
## [30,]   17
## [31,]   17
## [32,]   18
## [33,]   18
## [34,]   18
## [35,]   18
## [36,]   19
## [37,]   19
## [38,]   19
## [39,]   20
## [40,]   20
## [41,]   20
## [42,]   20
## [43,]   20
## [44,]   22
## [45,]   23
## [46,]   24
## [47,]   24
## [48,]   24
## [49,]   24
## [50,]   25
y_pred<-TPredict(theta, x)
y_pred
##            [,1]
##  [1,]  22.42091
##  [2,]  22.42091
##  [3,]  52.42091
##  [4,]  52.42091
##  [5,]  62.42091
##  [6,]  72.42091
##  [7,]  82.42091
##  [8,]  82.42091
##  [9,]  82.42091
## [10,]  92.42091
## [11,]  92.42091
## [12,] 102.42091
## [13,] 102.42091
## [14,] 102.42091
## [15,] 102.42091
## [16,] 112.42091
## [17,] 112.42091
## [18,] 112.42091
## [19,] 112.42091
## [20,] 122.42091
## [21,] 122.42091
## [22,] 122.42091
## [23,] 122.42091
## [24,] 132.42091
## [25,] 132.42091
## [26,] 132.42091
## [27,] 142.42091
## [28,] 142.42091
## [29,] 152.42091
## [30,] 152.42091
## [31,] 152.42091
## [32,] 162.42091
## [33,] 162.42091
## [34,] 162.42091
## [35,] 162.42091
## [36,] 172.42091
## [37,] 172.42091
## [38,] 172.42091
## [39,] 182.42091
## [40,] 182.42091
## [41,] 182.42091
## [42,] 182.42091
## [43,] 182.42091
## [44,] 202.42091
## [45,] 212.42091
## [46,] 222.42091
## [47,] 222.42091
## [48,] 222.42091
## [49,] 222.42091
## [50,] 232.42091

Wykres funkcji kosztu w zależności od wartości parametru:

theta
##           [,1]
## [1,] -17.57909
## [2,]  10.00000

Dla innej wartości parametetru błąd wynosi:

w1 = 5
theta<-as.matrix(c(w0, w1), 2,1)

err<-TCost(theta, x, y)
err
## [1] 26430.16

Wykres wartości błędu od wartości parametru:

w1<- seq(-1,6, length.out = 50)

theta=as.matrix(cbind(rep(w0,length(w1)),w1), 2, length(w1))
error= apply(theta, 1, TCost, x,y)
y_pred= apply(theta, 1, TPredict, x)
plot(w1, error)

Batch Gradient Descent

Chcemy znaleźć takie parametry aby zminimalizować funkcję kosztów. Zobaczmy czy zadziała następujący pomysł:

Zacznijmy od pewniej “odgadniętej” wartości początkowej. Następnie zmieniamy ją zgodnie z kierunkiem przeciwnym do gradientu funkcji kosztu.

Warto tu przypomnieć, że gradient funkcji to wektor, którego kierunek pokrywa się z kierunkiem, w którym funkcja zmienia się najszybciej, a zwrot wskazuje kierunek, w którym funkcja rośnie. Zatem jeśli wyobrazimy sobie funkcję jako pofałdowany teren, to poruszając się w kierunku przeciwnym do gradientu powinniśmy dotrzeć do niżej położonych partii terenu. Formalnie jeden krok algorytmu minimalizacji gradientowej możemy zapisać:

dla każdego \(j\) : \(\theta _{j} := \theta _j - \alpha \frac{\partial }{\partial \theta _j } J(\theta )\)

gdzie parametr \(\alpha\) to szybkość uczenia.

Przyjrzyjmy się pochodnej cząstkowej \(\frac{\partial }{\partial \theta _j } J(\theta )\):

\[\begin{matrix} \frac{\partial }{\partial \theta _j } J(\theta ) &=&\frac{\partial }{\partial \theta _j } \frac{1}{2} \sum _{i=1}^{m} \left( h_\theta (x^{(i)}) - y^{(i)} \right)^2 \\ &=&\frac{1}{2} \sum _{i=1}^{m} \frac{\partial }{\partial \theta _j } \left( h_\theta (x^{(i)}) - y^{(i)} \right)^2\\ &=&\frac{1}{2} \sum _{i=1}^{m} 2 \left( h_\theta (x^{(i)}) - y^{(i)} \right)\frac{\partial }{\partial \theta _j }h_\theta (x^{(i)})\\ &=& \sum _{i=1}^{m} \left( h_\theta (x^{(i)}) - y^{(i)} \right)\frac{\partial }{\partial \theta _j } \sum _{j=0}^n \theta _j x_j^{(i)}\\ &=& \sum _{i=1}^{m} \left( h_\theta (x^{(i)}) - y^{(i)} \right) \sum _{j=0}^n \frac{\partial }{\partial \theta _j }\theta _j x_j^{(i)} \end{matrix}\]

\(\frac{\partial }{\partial \theta _j } J(\theta ) = \sum _{i=1}^{m} \left( h_\theta (x^{(i)}) - y^{(i)} \right) x_j^{(i)}\)

Uwzględniając powyższe mamy algorytm:

  • Zainicjuj \(\theta _{j}\)
  • powtarzaj, aż zbiegniesz:
    • dla każdego \(j\) : \(\theta _{j} := \theta _j - \alpha \sum _{i=1}^{m} \left( h_\theta (x^{(i)}) - y^{(i)} \right) x_j^{(i)}\)

Algorytm najmniejszych kwadratów ma kilka cech, które są intuicyjne i naturalne. Wartość zmiany jest proporcjonalna do błędu. Gdy mamy przykład uczący, dla którego przewidywanie prawie zgadza się z \(y\) to wprowadzane zmiany parametrów są małe. Większa zmiana parametrów będzie dla przykładu, który generuje większy błąd.

Powyższe obliczenia dotyczą sytuacji gdy ciąg uczący zawierają wiele przykładów i poprawki obliczamy biorąc pod uwagę wszystkie przykłady. Jest to tak zwany algorytm gradientowy zbiorczy (ang. batch gradient descent).

Implementacja algorytmu:

\(\theta := \theta - \eta \frac{1}{N}(y^{T} - \theta X^{T})X\)

GradD <- function(x, y, alpha = 0.005, epsilon = 10^-10){
  iter <- 0
  i <- 0
  x_ext <- cbind(rep(1,nrow(x)), x)
  
  theta <- matrix(c(1,1),ncol(x)+1,1)
  cost <- TCost(theta,x,y) 
  delta <- 1
  while(delta > epsilon){
    
    i <- i + 1
 
    #####
    grad <- t(x_ext) %*%  (TPredict(theta, x) - y)
    theta <- theta - (alpha / nrow(x)) * grad 
    ####
    
    cval <- TCost(theta,x,y) 
    cost <- append(cost, cval)
    delta <- abs(cost[i+1] - cost[i])
    
    if((cost[i+1] - cost[i]) > 0){
      print("The cost is increasing.  Try reducing alpha.")
      return()
    }
    iter <- append(iter, i)
  }
  print(sprintf("Completed in %i iterations.", i))
  return(theta)
}

GradD(x,y)
## [1] "Completed in 22909 iterations."
##            [,1]
## [1,] -17.578958
## [2,]   3.932401

Wpływ skalowania zmiennych

x <- as.matrix(cars$speed)
y <- as.matrix(cars$dist)
stheta <- GradD(scale(x), y, alpha = 0.06, epsilon = 10^-10)
## [1] "Completed in 265 iterations."
stheta
##          [,1]
## [1,] 42.98000
## [2,] 20.79318

\(x^{'}=\frac{x-\overline{x}}{\delta_x}\)

\(y=\theta^{'}_{0} + \theta^{'}_{1} \frac{x-\overline{x}}{\delta_x}\)

\(y=\theta^{'}_{0} -\theta^{'}_{1} \cdot \frac{\overline{x}}{\delta_x} + \frac {\theta^{'}_{1}}{\delta_x}\cdot x\)

Stąd:

\(\theta_{0} = \theta^{'}_{0} -\theta^{'}_{1} \cdot \frac{\overline{x}}{\delta_x}\)

\(\theta_{1} = \frac {\theta^{'}_{1}}{\delta_x}\)

ctheta <- stheta[c(2:nrow(stheta)),] / t(t(apply(x,2,sd)))
cthetazero <- stheta[1,1] - sum(stheta[c(2:nrow(stheta)),] / t(t(apply(x,2,sd))) * t(t(apply(x,2,mean))))

ctheta <- matrix(c(cthetazero, ctheta))
ctheta
##            [,1]
## [1,] -17.579092
## [2,]   3.932408

Stochastic Gradient Descent

Uaktualnianie parametrów funkcji kosztu można też prowadzić po każdej prezentacji elementu ciągu uczącego. Zauważmy, że w pierwszej linijce naszych przekształceń występuje suma po przyczynkach pochodzących od pojedynczych przykładów. Każdy przykład daje przyczynek dodatni. Zatem minimalizując każdy z przyczynków niezależnie również zminimalizujemy funkcję kosztu. Wersja algorytmu, w której zmiany parametrów obliczane są i dla pojedynczych przykładów z ciągu uczącego podawanych w losowej kolejności nosi nazwę stochastycznego algorytmu minimalizacji gradientowej. Ta wersja algorytmu jest zwykle bardziej wydajna obliczeniowo.

Otrzymujemy algorytm:

  • Zainicjuj \(\theta _{j}\)

  • powtarzaj, aż zbiegniesz:

    • wylosuj przykład \(i\)

    • dla każdego \(j\) : \(\theta _{j} := \theta _j - \alpha \left( h_\theta (x^{(i)}) - y^{(i)} \right) x_j^{(i)}\)

Warto w tym miejscu zauważyć, że algorytm gradientowy jest wrażliwy na minima lokalne, tzn. że z danego punktu w przestrzeni parametrów prowadzi do najbliższego minimum lokalnego. Na szczęście w przypadku regresji linowej istnieje tylko jedno minimum i jest to minimum globalne.

Równania normalne

W pewnych sytuacjach można wykorzystać nieco bardziej narzędzia algebry i analizy matematycznej i znaleźć optymalne parametry analitycznie. W tym celu trzeba znaleźć pochodna funkcji kosztu po parametrach i przyrównać ją do zera.

Rachunki macierzowe

Dla danej funkcji \(f: \mathcal {R}^{n \times m} \rightarrow \mathcal {R}\) mapującej macierze \(n \times m\) na liczby rzeczywiste definiujemy pochodną \(f\) względem \(A\) jako:

\(\nabla _A f(A) = \left[ \begin{array}{ccc} \frac{\partial f}{\partial A_{1,1}} \dots \frac{\partial f }{\partial A_{1,n}}\\ \vdots \vdots \\ \frac{\partial f}{\partial A_{n,1}} \dots \frac{\partial f}{\partial A_{n,n}} \end{array}\right]\)

Zatem gradient \(\nabla _A f(A)\) jest macierzą \(n \times m\), której element \((i,j)\) to pochodna cząstkowa \(\frac{\partial f}{\partial A_{i,j}}\).

Jako przykład weźmy macierz

\(A =\left[ \begin{array}{cc} A_{1,1} & A_{1,2} \\ A_{2,1} & A_{2,2} \end{array} \right]\)

i funkcję \(f: \mathcal {R}^{n \times m} \rightarrow \mathcal {R}\):

\(f(A) = \frac{3}{2} A_{1,1} + 5 A_{1,2}^2 + A_{2,1} A_{2,2}\)

W tym przypadku otrzymujemy:

\(\nabla _A f(A) = \left[ \begin{array}{ccc} \frac{3}{2} & 10 A_{1,2} \\ A_{2,2} & A_{2,1} \end{array} \right]\)

Dla przypomnienia operator śladu macierzy kwadratowej \(A\) to suma elementów diagonalnych:

\(\textrm {tr}A = \sum _{i=1}^{n}A_{i,i}\)

Operator śladu jest przemienny, tzn.

\(\textrm {tr}AB = \textrm {tr}BA\)

Zachodzi również:

\(\textrm {tr}A =\textrm {tr}A^T\)

\(\textrm {tr}(A+B) =\textrm {tr}A + \textrm {tr}B\)

\(\textrm {tr}(aA) = a\textrm {tr}A\)

Dla pochodnych macierzowych zachodzi:

\(\nabla _A \textrm {tr}AB = B^T\)

\(\nabla _{A^T} f(A) = (\nabla _A f(A))^T\)

\(\nabla _A \textrm {tr} ABA^TC = CAB +C^TAB^T\)

\(\nabla _A |A| = |A| (A^{-1})^T\)

gdzie \(|A|\) to wyznacznik macierzy A.

Minimalizacja funkcji kosztu

Zbudujmy macierz wejść \(X\) w taki sposób, że wejścia z poszczególnych przykładów są jej wierszami.

\(X = \left[ \begin{array}{ccc} -& ( x^{(1)})^T&- \\ & \vdots & \\ - &(x^{(m)})^T &- \end{array} \right]\)

Z wartości wyjściowych zbudujemy wektor kolumnowy

\(\mathbf {y} = \left[ \begin{array}{c} y^{(1) }\\ \vdots \\ y^{(m)} \end{array} \right]\)

Ponieważ \(h_\theta (x^{(i)} ) = (x^{(i)})^T \theta\) możemy zapisać:

\(X \theta - \mathbf {y} = \left[ \begin{array}{c} ( x^{(1)})^T \theta \\ \vdots \\ (x^{(m)})^T \theta \end{array} \right] - \left[ \begin{array}{c} y^{(1) }\\ \vdots \\ y^{(m)} \end{array} \right] = \left[ \begin{array}{c} h_\theta (x^{(1)}) - y^{(1) }\\ \vdots \\ h_\theta (x^{(m)}) - y^{(m)} \end{array} \right]\)

Korzystając z faktu, że dla wektora \(\mathbf {z}\) mamy \(\mathbf {z}^T\mathbf {z}=\sum _i z_i^2\) możemy zapisać funkcję kosztu w następujący sposób:

\(J(\theta ) = \frac{1}{2} \sum _{i=1}^m \left( h_\theta (x^{(i)} ) - y^{(i)}\right)^2 = \frac{1}{2} (X \theta - \mathbf {y})^T (X \theta - \mathbf {y})\)

Teraz aby zminimalizować funkcję kosztu \(J\) znajdzmy jej pochodną względem \(\theta\).

\(\begin{matrix} \nabla _\theta J(\theta ) &=& \nabla _\theta \frac{1}{2} (X \theta - \mathbf {y})^T (X \theta - \mathbf {y}) \\ &=& \frac{1}{2} \nabla _\theta ( \theta ^T X ^T X \theta -\theta ^T X^T \mathbf {y} - \mathbf {y}^T X \theta + \mathbf {y}^T \mathbf {y}) \end{matrix}\)

Ślad liczby jest tą samą liczbą, a \(\textrm {tr}A = \textrm {tr}A^T\) stąd:

\(\begin{matrix} \nabla _\theta J(\theta ) &=& \frac{1}{2} \nabla _\theta \textrm {tr}( \theta ^T X ^T X \theta -\theta ^T X^T \mathbf {y} - \mathbf {y}^T X \theta + \mathbf {y}^T \mathbf {y}) \\ &=& \frac{1}{2} \nabla _\theta (\textrm {tr} \theta ^T X ^T X \theta - 2 \textrm {tr} \mathbf {y}^T X \theta ) \end{matrix}\)

Ponieważ zachodzi:

\(\nabla _{A^T} \textrm {tr}ABA^TC = B^T A^T C^T + B A^T C\)

to przy podstawieniu:

\(A^T = \theta\),

\(B = B^T = X^TX\) i

\(C = I\)

otrzymujemy:

\(\begin{matrix} \nabla _\theta J(\theta ) &=& \frac{1}{2} ( X ^T X \theta +X^T X \theta - 2 X^T \mathbf {y}) \\ &=& X^T X \theta - X^T \mathbf {y} \end{matrix}\)

Aby zminimalizować funkcję kosztu kładziemy jej pochodną równą 0 i otrzymujemy równanie normalne:

\(X^T X \theta = X^T \mathbf {y}\)

Z niego możemy obliczyć parametry minimalizujące funkcję kosztu:

\(\theta = (X^T X )^{-1} X^T \mathbf {y}\)

Interpretacja probabilistyczna

Uzasadnienie funkcji kosztu \(J\) w postaci sumy kwadratów błędów dla problemu regresji - założenia probailistyczne, które prowadzą do przyjętej funkcji błędu.

Załóżmy, że zmienne wejściowe i wyjściowe powiązane są zależnością:

\(y^{(i)} = \theta ^T x^{(i)} + \epsilon ^{(i)}\)

gdzie \(\epsilon ^{(i)}\) jest błędem, który albo pochodzi od pewnych nieuwzględnionych w modelu regresji czynników lub czynnikiem losowym. Załóżmy, że \(\epsilon ^{(i)}\) to zmienne niezależne i podlegające temu samemu rozkładowi (ang. IID - independent and identically distributed) normalnemu o średniej zero i wariancji \(\sigma ^2\) . To założenie zapisujemy krótko: \(\epsilon ^{(i)} \sim \mathcal {N}(0, \sigma ^2)\). Zatem funkcja gęstości prawdopodobieństwa \(\epsilon ^{(i)}\) dana jest wzorem:

\(p(\epsilon ^{(i)}) = \frac{1}{\sqrt{2 \pi} \sigma } \exp \left( - \frac{ \left(\epsilon ^{(i)} \right)^2}{2 \sigma ^2} \right)\)

Z tego wynika, że:

\(p(y^{(i)}| x^{(i)}; \theta ) = \frac{1}{\sqrt{2 \pi} \sigma } \exp \left( - \frac{ \left(y^{(i)} - \theta ^Tx^{(i)} \right)^2}{2 \sigma ^2} \right)\)

Notacja \(p(y^{(i)}| x^{(i)}; \theta )\) oznacza funkcję gęstości prawdopodobieństwa zmiennej \(y^{(i)}\) mając daną zmienną \(x^{(i)}\) sparametryzowaną przez \(\theta\). Nie mówimy “mając dane \(\theta\)” bo \(\theta\) nie jest zmienną losową. Prawdopodobieństwo danych (całego ciągu uczącego) określone jest przez rozkład \(p(\mathbf {y}|X;\theta )\). Ten rozkład zazwyczaj rozumiany jest jako funkcja \(\mathbf {y}\) i \(X\) przy ustalonym \(\theta\). Możemy jednak spojrzeć na niego inaczej, tzn. jako funkcję \(\theta\) przy ustalonych \(X\) i \(\mathbf {y}\). Funkcję tą nazywamy funkcją wiarygodności:

\(L(\theta ) = L(\theta ;X,\mathbf {y}) = p(\mathbf {y}|X;\theta )\)

Zauważmy, że dzięki założeniu o niezależności \(\epsilon ^{(i)}\) możemy tą funkcję zapisać jako:

\(\begin{matrix} L(\theta ) &=& \prod _{i=1}^m p(y^{(i)} | x^{(i)};\theta )\\ &=& \prod _{i=1}^m \frac{1}{\sqrt{2 \pi} \sigma } \exp \left( - \frac{ \left(y^{(i)} - \theta ^Tx^{(i)} \right)^2}{2 \sigma ^2} \right) \end{matrix}\)

Teraz, mając nasz model probabilistyczny możemy się zapytać: jakie \(\theta\) są sensowne? Chcielibyśmy, aby były to takie parametry, dla których zaobserwowanie naszego ciągu uczącego jest najbardziej prawdopodobne. Jest to zasada największej wiarygodności. A zatem w myśl tej zasady trzeba znaleźć \(\theta\), które maksymalizuje funkcję wiarygodności \(L(\theta )\). Tak naprawdę wystarczy jeśli zmaksymalizujemy dowolną ściśle rosnącą funkcję funkcji wiarygodności. Rachunki znacznie się uproszczą jeśli jako tą funkcję wybierzemy \(\log\) (wówczas iloczyn przejdzie w sumę). Ostatecznie chcemy zmaksymalizować:

\(\begin{matrix} l(\theta ) &=& \log (L(\theta )) \\ &=& \log \prod _{i=1}^m \frac{1}{\sqrt{2 \pi} \sigma } \exp \left( - \frac{ \left(y^{(i)} - \theta ^Tx^{(i)} \right)^2}{2 \sigma ^2} \right)\\ &=& \sum _{i=1}^m \log \frac{1}{\sqrt{2 \pi} \sigma } \exp \left( - \frac{ \left(y^{(i)} - \theta ^Tx^{(i)} \right)^2}{2 \sigma ^2} \right) \\ &=& m \log \frac{1}{\sqrt{2 \pi }\sigma } - \frac{1}{\sigma ^2} \cdot \frac{1}{2} \sum _{i=1}^m \left( y^{(i)} - \theta ^Tx^{(i)} \right)^2 \end{matrix}\)

Zauważmy, że aby zmaksymalizować funkcję wiarygodności musimy zminimalizować wyrażenie \(\frac{1}{2} \sum _{i=1}^m \left( y^{(i)} - \theta ^Tx^{(i)} \right)^2\), czyli wprowadzoną w poprzednim rozdziale funkcję kosztu \(J(\theta )\).

Podsumowując: zakładając konkretny model probabilistyczny ciągu uczącego udało nam się pokazać, że minimalizacja funkcji kosztu jest konsekwencją zastosowania zasady największej wiarygodności. Warto jednak pamiętać, że procedura minimalizacji średniego błędu kwadratowego daje sensowne wyniki dla znacznie szerszej klasy modeli danych.