Matrycowa forma propagacji wstecznej z normalizacją partii

Normalizacji partii przypisano znaczną poprawę wydajności w głębokich sieciach neuronowych. Wiele materiałów w Internecie pokazuje, jak wdrożyć je na zasadzie aktywacja po aktywacji. Zaimplementowałem już backprop za pomocą algebry macierzy i biorąc pod uwagę, że pracuję w językach wysokiego poziomu (polegając na Rcpp(i ewentualnie GPU) na gęstym mnożeniu macierzy), zgrywanie wszystkiego i uciekanie się do forpętli prawdopodobnie spowolniłoby mój kod zasadniczo, oprócz tego, że jest ogromnym bólem.

Funkcja normalizacji partii to gdzie

$$b(x_p) = \gamma \left(x_p - \mu_{x_p}\right) \sigma^{-1}_{x_p} + \beta$$

• $x_p$ jest tym węzłem, zanim zostanie aktywowany$p$
• $\gamma$ i są parametrami skalarnymi$\beta$
• σ x p x $\mu_{x_p}$ i są średnią i SD . (Zauważ, że zwykle stosowany jest pierwiastek kwadratowy wariancji plus współczynnik krówki - załóżmy, że elementy są niezerowe).$\sigma_{x_p}$$x_p$

W postaci macierzowej normalizacja partii dla całej warstwy to gdzie

$$b(\mathbf{X}) = \left(\gamma\otimes\mathbf{1}_p\right)\odot \left(\mathbf{X} - \mu_{\mathbf{X}}\right) \odot\sigma^{-1}_{\mathbf{X}} + \left(\beta\otimes\mathbf{1}_p\right)$$

• N × $\mathbf{X}$ to$N\times p$
• $\mathbf{1}_N$ jest wektorem kolumnowym jedności
• β $\gamma$ i są teraz wierszami wektorów parametrów normalizacji dla poszczególnych warstw$\beta$$p$
• σ X N × p $\mu_{\mathbf{X}}$ i są macierzami , gdzie każda kolumna jest wektorem wektorów średnich i odchyleń standardowych$\sigma_{\mathbf{X}}$$N \times p$$N$
• $\otimes$ to produkt Kronecker, a to produkt elementowy (Hadamard)$\odot$

Bardzo prosta jednowarstwowa sieć neuronowa bez normalizacji partii i ciągłym wynikiem jest

$$y = a\left(\mathbf{X\Gamma}_1\right)\Gamma_2 + \epsilon$$

gdzie

• $\Gamma_1$ to$p_1 \times p_2$
• p 2 × $\Gamma_2$ to$p_2 \times 1$
• $a(.)$ to funkcja aktywacji

Jeśli utrata wynosi , wówczas gradienty to ∂ $R = N^{-1}\displaystyle\sum\left(y - \hat{y}\right)^2$

$$\begin{array}{lr} \frac{\partial R}{\partial \Gamma_1} = -2\mathbf{V}^T \hat\epsilon\\ \frac{\partial R}{\partial \Gamma_2} = \mathbf{X}^T \left(a'(\mathbf{X}\mathbf{\Gamma}_1) \odot -2\hat\epsilon \mathbf{\Gamma}_2^T\right) \\ \end{array}$$

gdzie

• $\mathbf{V} = a\left(\mathbf{X}\Gamma_1\right)$
• $\hat{\epsilon} = y-\hat{y}$

W ramach normalizacji partii siatka staje się lub Nie mam pojęcia, jak obliczyć pochodne produktów Hadamarda i Kroneckera. Literatura na temat produktów Kronecker jest dość tajemnicza. y = a ( ( γ ⊗ 1

$$y = a\left(b\left(\mathbf{X}\Gamma_1\right)\right)\Gamma_2$$ $$y = a\Big(\left(\gamma\otimes\mathbf{1}_N\right)\odot \left(\mathbf{X\Gamma_1} - \mu_{\mathbf{X\Gamma_1}}\right) \odot\sigma^{-1}_{\mathbf{X\Gamma_1}} + \left(\beta\otimes\mathbf{1}_N\right)\Big)\mathbf{\Gamma_2}$$

Czy istnieje praktyczny sposób obliczania , i w ramach matrycy? Proste wyrażenie bez uciekania się do obliczeń węzeł-węzeł?∂ R / ∂ β ∂ R / ∂ Γ $\partial R/\partial \gamma$$\partial R/\partial \beta$$\partial R/\partial \mathbf{\Gamma_1}$

Aktualizacja 1:

Odkryłem - w pewnym sensie. Jest to: Niektóre kody R pokazują, że jest to równoważne z zapętleniem. Najpierw skonfiguruj fałszywe dane:$\partial R/\partial \beta$

$$\mathbf{1}_{N}^T \left(a'(\mathbf{X}\mathbf{\Gamma}_1) \odot -2\hat\epsilon \mathbf{\Gamma}_2^T\right)$$

set.seed(1)
library(dplyr)
library(foreach)

#numbers of obs, variables, and hidden layers
N <- 10
p1 <- 7
p2 <- 4
a <- function (v) {
  v[v < 0] <- 0
  v
}
ap <- function (v) {
  v[v < 0] <- 0
  v[v >= 0] <- 1
  v
}

# parameters
G1 <- matrix(rnorm(p1*p2), nrow = p1)
G2 <- rnorm(p2)
gamma <- 1:p2+1
beta <- (1:p2+1)*-1
# error
u <- rnorm(10)

# matrix batch norm function
b <- function(x, bet = beta, gam = gamma){
  xs <- scale(x)
  gk <- t(matrix(gam)) %x% matrix(rep(1, N))
  bk <- t(matrix(bet)) %x% matrix(rep(1, N))
  gk*xs+bk
}
# activation-wise batch norm function
bi <- function(x, i){
  xs <- scale(x)
  gk <- t(matrix(gamma[i]))
  bk <- t(matrix(beta[i]))
  suppressWarnings(gk*xs[,i]+bk)
}

X <- round(runif(N*p1, -5, 5)) %>% matrix(nrow = N)
# the neural net
y <- a(b(X %*% G1)) %*% G2 + u

Następnie oblicz pochodne:

# drdbeta -- the matrix way
drdb <- matrix(rep(1, N*1), nrow = 1) %*% (-2*u %*% t(G2) * ap(b(X%*%G1)))
drdb
           [,1]      [,2]    [,3]        [,4]
[1,] -0.4460901 0.3899186 1.26758 -0.09589582
# the looping way
foreach(i = 1:4, .combine = c) %do%{
  sum(-2*u*matrix(ap(bi(X[,i, drop = FALSE]%*%G1[i,], i)))*G2[i])
}
[1] -0.44609015  0.38991862  1.26758024 -0.09589582

Pasują do siebie. Ale nadal jestem zdezorientowany, ponieważ tak naprawdę nie wiem, dlaczego to działa. Notatki MatCalc, do których odwołuje się @ Mark L. Stone, mówią, że pochodna powinna być$\beta \otimes \mathbf{1}_N$

$$\frac{\partial A \otimes B}{\partial A} = \left(I_{nq} \otimes T_{mp}\right)\left(I_n\otimes vec(B) \otimes I_m\right)$$ gdzie indeksy , i , są wymiary i . jest macierzą komutacji, która jest tutaj tylko 1, ponieważ oba wejścia są wektorami. Próbuję tego i otrzymuję wynik, który nie wydaje się pomocny:$m$$n$$p$$q$$A$$B$$T$

# playing with the kroneker derivative rule
A <- t(matrix(beta)) 
B <- matrix(rep(1, N))
diag(rep(1, ncol(A) *ncol(B))) %*% diag(rep(1, ncol(A))) %x% (B) %x% diag(nrow(A))
     [,1] [,2] [,3] [,4]
 [1,]    1    0    0    0
 [2,]    1    0    0    0
 snip
[13,]    0    1    0    0
[14,]    0    1    0    0
snip
[28,]    0    0    1    0
[29,]    0    0    1    0
[snip
[39,]    0    0    0    1
[40,]    0    0    0    1

To nie jest zgodne. Najwyraźniej nie rozumiem tych reguł pochodnych Kroneckera. Pomoc z nimi byłaby świetna. Nadal całkowicie utknąłem w innych pochodnych, dla i - są one trudniejsze, ponieważ nie wchodzą w addytywne, jak .$\gamma$$\mathbf{\Gamma_1}$$\beta \otimes \mathbf{1}$

Aktualizacja 2

Czytając podręczniki, jestem całkiem pewien, że i będą wymagały użycia operatora. Ale najwyraźniej nie jestem w stanie śledzić pochodnych w stopniu wystarczającym, aby móc je przetłumaczyć na kod. Na przykład, będzie wzięcia pochodnej w odniesieniu do , gdzie (które w tej chwili możemy traktować jako stałą macierz). ∂ R / ∂ $\partial R/\partial \Gamma_1$$\partial R/\partial \gamma$vec()$\partial R/\partial \Gamma_1$$w\odot\mathbf{X\Gamma_1}$$\mathbf{\Gamma_1}$$w \equiv (\gamma \otimes \mathbf{1}) \odot \sigma_{\mathbf{X\Gamma_1}}^{-1}$

Instynktownie mówię „odpowiedź brzmi ”, ale to oczywiście nie działa, ponieważ nie jest zgodne z .$w\odot\mathbf{X}$$w$$\mathbf{X}$

Wiem, że

$$\partial(A \odot B) = \partial A \odot B + A \odot \partial B$$

i z tego , że

$$\frac{\partial vec(w \odot \mathbf{X\Gamma_1})}{\partial vec(\mathbf{\Gamma_1})^T} = vec(\mathbf{X\Gamma_1})I\frac{\partial vec(w)}{\partial vec(\mathbf{\Gamma_1})^T} + vec(w)I\frac{\partial vec(\mathbf{X\Gamma_1})}{\partial vec(\mathbf{\Gamma_1})^T}$$ Ale nie jestem pewien, jak to ocenić, a co dopiero kodować.

Aktualizacja 3

Robię postępy tutaj. Obudziłem się wczoraj o 2 nad ranem z tym pomysłem. Matematyka nie jest dobra na sen.

Oto , po cukru notacyjnego:$\partial R/\partial \mathbf{\Gamma_1}$

• $w \equiv (\gamma \otimes \mathbf{1}) \odot \sigma_{\mathbf{X\Gamma_1}}^{-1}$
• $\text{"stub"} \equiv a'(b(\mathbf{X\Gamma}_1)) \odot -2\hat\epsilon \mathbf{\Gamma}_2^T$

Oto, co masz po do końca reguły łańcucha: Zacznij od zrobienia tego w pętli - i subskrybują kolumny, a jest zgodną matrycą tożsamości:

$$\frac{\partial R}{\partial \Gamma_1} = \frac{\partial w \odot \mathbf{X\Gamma}_1}{\partial \Gamma_1}\left(\text{"stub"}\right)$$ $i$$j$$\mathbf{I}$ $$\frac{\partial R}{\partial \Gamma_{ij}} = \left(w_i \odot \mathbf{X_i}\right)^T\left(\text{"stub"}_j\right)$$ $$\frac{\partial R}{\partial \Gamma_{ij}} = \left(\mathbf{I} w_i \mathbf{X_i}\right)^T\left(\text{"stub"}_j\right)$$ $$\frac{\partial R}{\partial \Gamma_{ij}} = \mathbf{X_i}^T\mathbf{I} w_i\left(\text{"stub"}_j\right)$$ tl; dr to w zasadzie wstępne pomnożenie kodu pośredniczącego przez czynniki skali wsadowej. Powinno to być równoważne z: $$\frac{\partial R}{\partial \Gamma} = \mathbf{X}^T\left(\text{"stub"}\odot w\right)$$

I w rzeczywistości jest to:

stub <- (-2*u %*% t(G2) * ap(b(X%*%G1)))
w <- t(matrix(gamma)) %x% matrix(rep(1, N)) * (apply(X%*%G1, 2, sd) %>% t %x% matrix(rep(1, N)))
drdG1 <- t(X) %*% (stub*w)

loop_drdG1 <- drdG1*NA
for (i in 1:7){
  for (j in 1:4){
    loop_drdG1[i,j] <- t(X[,i]) %*% diag(w[,j]) %*% (stub[,j])
  }
}

> loop_drdG1
           [,1]       [,2]       [,3]       [,4]
[1,] -61.531877  122.66157  360.08132 -51.666215
[2,]   7.047767  -14.04947  -41.24316   5.917769
[3,] 124.157678 -247.50384 -726.56422 104.250961
[4,]  44.151682  -88.01478 -258.37333  37.072659
[5,]  22.478082  -44.80924 -131.54056  18.874078
[6,]  22.098857  -44.05327 -129.32135  18.555655
[7,]  79.617345 -158.71430 -465.91653  66.851965
> drdG1
           [,1]       [,2]       [,3]       [,4]
[1,] -61.531877  122.66157  360.08132 -51.666215
[2,]   7.047767  -14.04947  -41.24316   5.917769
[3,] 124.157678 -247.50384 -726.56422 104.250961
[4,]  44.151682  -88.01478 -258.37333  37.072659
[5,]  22.478082  -44.80924 -131.54056  18.874078
[6,]  22.098857  -44.05327 -129.32135  18.555655
[7,]  79.617345 -158.71430 -465.91653  66.851965

Aktualizacja 4

Myślę, że tutaj jest . Pierwszy$\partial R / \partial \gamma$

• $\widetilde{\mathbf{X\Gamma}} \equiv \left(\mathbf{X\Gamma} - \mu_{\mathbf{X\Gamma}}\right)\odot \sigma^{-1}_\mathbf{X\Gamma}$
• $\tilde\gamma \equiv \gamma \otimes\mathbf{1}_N$

Podobnie jak poprzednio, reguła łańcuchowa prowadzi cię do Pętla daje Co, podobnie jak poprzednio, jest w zasadzie wstępnym pomnożeniem kodu pośredniczącego. Powinien zatem być równoważny z:

$$\frac{\partial R}{\partial \tilde\gamma} = \frac{\partial \tilde\gamma \odot \widetilde{\mathbf{X\Gamma}}}{\partial \tilde\gamma}\left(\text{"stub"}\right)$$ $$\frac{\partial R}{\partial \tilde\gamma_i} = (\widetilde{\mathbf{X\Gamma}})_i^T \mathbf{I}\tilde\gamma_i \left(\text{"stub"}_i\right)$$ $$\frac{\partial R}{\partial \tilde\gamma} = (\widetilde{\mathbf{X\Gamma}})^T \left(\text{"stub"} \odot \tilde\gamma \right)$$

To rodzaj dopasowań:

drdg <- t(scale(X %*% G1)) %*% (stub * t(matrix(gamma)) %x% matrix(rep(1, N)))

loop_drdg <- foreach(i = 1:4, .combine = c) %do% {
  t(scale(X %*% G1)[,i]) %*% (stub[,i, drop = F] * gamma[i])  
}

> drdg
           [,1]      [,2]       [,3]       [,4]
[1,]  0.8580574 -1.125017  -4.876398  0.4611406
[2,] -4.5463304  5.960787  25.837103 -2.4433071
[3,]  2.0706860 -2.714919 -11.767849  1.1128364
[4,] -8.5641868 11.228681  48.670853 -4.6025996
> loop_drdg
[1]   0.8580574   5.9607870 -11.7678486  -4.6025996

Przekątna na pierwszym jest taka sama jak wektor na drugim. Ale tak naprawdę, ponieważ pochodna dotyczy macierzy - aczkolwiek o określonej strukturze, wynik powinien być podobną macierzą o tej samej strukturze. Czy powinienem wziąć przekątną matrycy i po prostu przyjąć, że jest to ? Nie jestem pewny.$\gamma$

Wygląda na to, że odpowiedziałem na własne pytanie, ale nie jestem pewien, czy mam rację. W tym momencie zaakceptuję odpowiedź, która rygorystycznie udowodni (lub obali) to, co razem zhackowałem.

while(not_answered){
  print("Bueller?")
  Sys.sleep(1)
}

Nie jest to kompletna odpowiedź, ale w celu zademonstrowania tego, co zasugerowałem w moim komentarzu, jeśli gdzie , i jest wektorem jedności, a następnie według reguły łańcuchowej Zwracając uwagę, że and , widzimy, że

$$b(X)=(X−e_N\mu_X^T)ΓΣ_X^{-1/2}+e_N\beta^T$$ $\Gamma=\mathop{\mathrm{diag}}(\gamma)$$\Sigma_X^{-1/2}=\mathop{\mathrm{diag}}(\sigma_{X_1}^{-1},\sigma_{X_2}^{-1},\dots)$$e_N$ $$\nabla_\beta R=[-2\hat{\epsilon}(\Gamma_2^T\otimes I)J_X(a)(I\otimes e_N)]^T$$ $-2\hat{\epsilon}(\Gamma_2^T\otimes I)=\mathop{\mathrm{vec}}(-2\hat{\epsilon}\Gamma_2^T)^T$$J_X(a)=\mathop{\mathrm{diag}}(\mathop{\mathrm{vec}}(a^\prime(b(X\Gamma_1))))$ $$\nabla_\beta R=(I\otimes e_N^T)\mathop{\mathrm{vec}}(a^\prime(b(X\Gamma_1))\odot-2\hat{\epsilon}\Gamma_2^T)=e_N^T(a^\prime(b(X\Gamma_1))\odot-2\hat{\epsilon}\Gamma_2^T)$$ poprzez tożsamość . Podobnie, gdzie („stub”), a to$\mathop{\mathrm{vec}}(AXB)=(B^T\otimes A)\mathop{\mathrm{vec}}(X)$ W='(b(XΓ1))⊙- $$\begin{align}\nabla_\gamma R&=[-2\hat{\epsilon}(\Gamma_2^T\otimes I)J_X(a)(\Sigma_{X\Gamma_1}^{-1/2}\otimes (X\Gamma_1-e_N\mu_{X\Gamma_1}^T))K]^T\\&=K^T\mathop{\mathrm{vec}}((X\Gamma_1-e_N\mu_{X\Gamma_1}^T)^TW\Sigma^{-1/2}_{X\Gamma_1})\\&=\mathop{\mathrm{diag}}((X\Gamma_1-e_N\mu_{X\Gamma_1}^T)^TW\Sigma^{-1/2}_{X\Gamma_1})\end{align}$$ $W=a^\prime(b(X\Gamma_1))\odot-2\hat{\epsilon}\Gamma_2^T$$K$$Np\times p$macierz binarna, która wybiera kolumny produktu Kroneckera odpowiadające elementom ukośnym macierzy kwadratowej. Wynika to z faktu, że . W przeciwieństwie do pierwszego gradientu, to wyrażenie nie jest równoważne z wyrażeniem, które wyprowadziłeś. Biorąc pod uwagę, że jest funkcją liniową wrt , nie powinno być współczynnika w gradiencie. Gradient OP, ale powiem, że dla wyprowadzenia ze stałym tworzy „wybuch”, którego autorzy artykułu starają się uniknąć. W praktyce musisz także znaleźć jakobianów z i wrtb γ i γ i Γ 1 w Σ X μ X$d\Gamma_{i\neq j}=0$$b$$\gamma_i$$\gamma_i$$\Gamma_1$$w$$\Sigma_X$$\mu_X$$X$ i użyj reguły produktu.