Forma matrice di backpropagation con normalizzazione batch

La normalizzazione in lotti è stata accreditata con sostanziali miglioramenti delle prestazioni nelle reti neurali profonde. Un sacco di materiale su Internet mostra come implementarlo su una base di attivazione per attivazione. Ho già implementato il backprop usando l'algebra della matrice e dato che sto lavorando in linguaggi di alto livello (facendo affidamento su Rcpp(e infine sulle GPU) per la densa moltiplicazione della matrice), strappando tutto e ricorrendo a for-loops probabilmente rallenterei il mio codice sostanzialmente, oltre ad essere un enorme dolore.

La funzione di normalizzazione batch è dove

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

• $x_p$ è il nodo , prima che venga attivato$p$
• $\gamma$ e sono parametri scalari$\beta$
• $\mu_{x_p}$ e sono la media e la SD di . (Si noti che viene normalmente utilizzata la radice quadrata della varianza più un fattore di fudge - supponiamo che elementi non zero per la compattezza)$\sigma_{x_p}$$x_p$

In forma di matrice, la normalizzazione batch per un intero livello sarebbe dove

$$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}$ è$N\times p$
• $\mathbf{1}_N$ è un vettore colonna di quelli
• β $\gamma$ e sono ora riga vettori dei parametri di normalizzazione per livello$\beta$$p$
• σ X N × p $\mu_{\mathbf{X}}$ e sono matrici , dove ogni colonna è un vettore di medie a colonna e deviazioni standard$\sigma_{\mathbf{X}}$$N \times p$$N$
• $\otimes$ è il prodotto Kronecker e è il prodotto elementwise (Hadamard)$\odot$

Una rete neurale a uno strato molto semplice senza normalizzazione batch e un risultato continuo è

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

dove

• p 1 × p $\Gamma_1$ è$p_1 \times p_2$
• p 2 × $\Gamma_2$ è$p_2 \times 1$
• $a(.)$ è la funzione di attivazione

Se la perdita è , i gradienti sono ∂ $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}$$

dove

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

Sotto la normalizzazione batch, la rete diventa o Non ho idea di come calcolare i derivati ​​dei prodotti Hadamard e Kronecker. Per quanto riguarda i prodotti Kronecker, la letteratura diventa piuttosto arcana. y = a ( ( γ ⊗ 1 N ) ⊙ ( X Γ 1 - μ X Γ 1 ) ⊙ σ - 1 X Γ 1 + ( β ⊗ 1 N ) ) Γ

$$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}$$

Esiste un modo pratico di calcolare , e all'interno del framework matriciale? Un'espressione semplice, senza ricorrere al calcolo nodo per nodo?∂ R / ∂ β ∂ R / ∂ Γ $\partial R/\partial \gamma$$\partial R/\partial \beta$$\partial R/\partial \mathbf{\Gamma_1}$

Aggiornamento 1:

Ho capito - sorta di. È: Alcuni codici R dimostrano che ciò equivale al modo di fare il looping. Innanzitutto imposta i dati falsi:$\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

Quindi calcolare i derivati:

# 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

Si abbinano. Ma sono ancora confuso, perché non so davvero perché funzioni. Le note MatCalc a cui fa riferimento @Mark L. Stone affermano che la derivata di dovrebbe essere$\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)$$ dove il indici , , e , sono le dimensioni di e . è la matrice di commutazione, che è solo 1 qui perché entrambi gli ingressi sono vettori. Provo questo e ottengo un risultato che non sembra utile:$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

Questo non è conforme. Chiaramente non capisco quelle regole derivate di Kronecker. Aiutare con quelli sarebbe fantastico. Sono ancora totalmente bloccato sugli altri derivati, per e - quelli sono più difficili perché non entrano in modo additivo come .$\gamma$$\mathbf{\Gamma_1}$$\beta \otimes \mathbf{1}$

Aggiornamento 2

Leggendo i libri di testo, sono abbastanza sicuro che e richiederanno l'uso dell'operatore. Ma a quanto pare non sono in grado di seguire sufficientemente le derivazioni da riuscire a tradurle in codice. Ad esempio, implicherà il prendere la derivata di rispetto a , dove (che possiamo considerare come una matrice costante per il momento). $\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}$

Il mio istinto è semplicemente dire "la risposta è ", ma ovviamente non funziona perché non è conforme a .$w\odot\mathbf{X}$$w$$\mathbf{X}$

So che

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

e da questo , quello

$$\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}$$ Ma non sono sicuro di come valutarlo, figuriamoci nel codificarlo.

Aggiornamento 3

Fare progressi qui. Questa notte mi sono svegliato alle 2 del mattino con questa idea. La matematica non fa bene al sonno.

Ecco , dopo un po 'di zucchero notazionale:$\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$

Ecco cosa hai dopo che sei arrivato alla fine della regola della catena: Inizia in questo modo la strada loop - e sarà pedice colonne e è una matrice identità conforme:

$$\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 stai praticamente pre-moltiplicando lo stub per i fattori di scala batchnorm. Questo dovrebbe essere equivalente a: $$\frac{\partial R}{\partial \Gamma} = \mathbf{X}^T\left(\text{"stub"}\odot w\right)$$

E infatti è:

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

Aggiornamento 4

Qui, penso, è . Primo$\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$

Simile a prima, la regola della catena arriva fino a looping ti dà Che, come prima, sta praticamente pre-moltiplicando lo stub. Dovrebbe quindi essere equivalente a:

$$\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)$$

In un certo senso corrisponde:

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

La diagonale sul primo è uguale al vettore sul secondo. Ma proprio dal momento che la derivata è rispetto a una matrice - sebbene con una certa struttura, l'output dovrebbe essere una matrice simile con la stessa struttura. Dovrei prendere la diagonale dell'approccio matrix e semplicemente prenderla come ? Non ne sono sicuro.$\gamma$

Sembra che io abbia risposto alla mia domanda ma non sono sicuro di aver ragione. A questo punto accetterò una risposta che dimostri rigorosamente (o smentisca) ciò che ho hackerato insieme.

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

Non una risposta completa, ma per dimostrare ciò che ho suggerito nel mio commento se dove , ed è un vettore di quelli, quindi secondo la regola della catena Notando che e , vediamo che

$$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)$$ tramite l'identità . Allo stesso modo, dove (lo "stub") e è un$\mathop{\mathrm{vec}}(AXB)=(B^T\otimes A)\mathop{\mathrm{vec}}(X)$ $$\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$matrice binaria che seleziona le colonne del prodotto Kronecker corrispondenti agli elementi diagonali di una matrice quadrata. Ciò deriva dal fatto che . A differenza del primo gradiente, questa espressione non è equivalente all'espressione che hai derivato. Considerando che è una funzione lineare , non dovrebbe esserci un fattore di nel gradiente. Lascio il gradiente di , ma dirò che per derivazione con fisso crea l '"esplosione" che gli scrittori dell'articolo cercano di evitare. In pratica, si dovrà anche trovare le Jacobiani di e 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$ e usa la regola del prodotto.