Qual è la complessità temporale per l'addestramento di una rete neurale usando la propagazione posteriore?

Supponiamo che un NN contenga $n$ livelli nascosti, $m$ esempi di allenamento, $x$ funzioni e $n_i$ nodi in ogni strato. Qual è la complessità temporale per addestrare questo NN usando la propagazione di ritorno?

Ho un'idea di base su come trovano la complessità temporale degli algoritmi, ma qui ci sono 4 diversi fattori da considerare qui, ad esempio iterazioni, layer, nodi in ogni layer, esempi di training e forse più fattori. Ho trovato una risposta qui, ma non era abbastanza chiaro.

Esistono altri fattori, oltre a quelli che ho menzionato sopra, che influenzano la complessità temporale dell'algoritmo di training di una NN?

Non ho visto una risposta da una fonte attendibile, ma proverò a rispondere da solo, con un semplice esempio (con le mie conoscenze attuali).

In generale, si noti che l'addestramento di un MLP usando la propagazione di ritorno è di solito implementato con matrici.

Complessità temporale della moltiplicazione matriciale

La complessità temporale della moltiplicazione della matrice per $M_{ij} * M_{jk}$ è semplicemente $\mathcal{O}(i*j*k)$ .

Si noti che stiamo assumendo l'algoritmo di moltiplicazione più semplice qui: esistono altri algoritmi con una complessità temporale leggermente migliore.

Algoritmo di feedforward pass

L'algoritmo di propagazione feedforward è il seguente.

Innanzitutto, per passare dallo strato da $i$ a $j$ , lo fai

$$S_j = W_{ji}*Z_i$$

Quindi si applica la funzione di attivazione

$$Z_j = f(S_j)$$

Se abbiamo $N$ layer (inclusi layer input e output), questo verrà eseguito $N-1$ volte.

Esempio

Come esempio, consentono di calcolare la complessità temporale dell'algoritmo in avanti per un MLP con $4$ strati, in cui $i$ indica il numero di nodi dello strato di input, $j$ il numero di nodi nel secondo strato, $k$ il numero di nodi nel terzo strato e $l$ il numero di nodi nello strato di output.

Poiché ci sono $4$ livelli, sono necessarie $3$ matrici per rappresentare i pesi tra questi livelli. Poniamo li indichiamo con $W_{ji}$ , $W_{kj}$ e $W_{lk}$ , dove $W_{ji}$ è una matrice con $j$ righe e $i$ colonne ( $W_{ji}$ contiene quindi i pesi che vanno dal livello $i$ al livello $j$ ).

Si supponga di avere $t$ esempi di addestramento. Per la propagazione dallo strato da $i$ a $j$ , abbiamo prima

$$S_{jt} = W_{ji} * Z_{it}$$

e questa operazione (cioè la multiplazione di matrici) ha una complessità temporale di $\mathcal{O}(j*i*t)$ . Quindi applichiamo la funzione di attivazione

$$Z_{jt} = f(S_{jt})$$

e questo ha una complessità temporale $\mathcal{O}(j*t)$ , perché è un'operazione saggia da elemento.

Quindi, in totale, abbiamo

$$\mathcal{O}(j*i*t + j*t) = \mathcal{O}(j*t*(t + 1)) = \mathcal{O}(j*i*t)$$

Usando la stessa logica, per andare $j \to k$ , abbiamo $\mathcal{O}(k*j*t)$ , e, per $k \to l$ , abbiamo $\mathcal{O}(l*k*t)$ .

In totale, la complessità temporale per la propagazione feedforward sarà

$$\mathcal{O}(j*i*t + k*j*t + l*k*t) = \mathcal{O}(t*(ij + jk + kl))$$

Non sono sicuro se questo possa essere ulteriormente semplificato o meno. Forse è solo $\mathcal{O}(t*i*j*k*l)$ , ma non ne sono sicuro.

Algoritmo di propagazione inversa

L'algoritmo di retro-propagazione procede come segue. A partire dal livello di output $l \to k$ , calcoliamo il segnale di errore, $E_{lt}$ , una matrice contenente i segnali di errore per i nodi al livello $l$

$$E_{lt} = f'(S_{lt}) \odot {(Z_{lt} - O_{lt})}$$

dove $\odot$ significa moltiplicazione degli elementi. Si noti che $E_{lt}$ ha $l$ righe e colonne $t$ : significa semplicemente che ogni colonna è il segnale di errore per l'esempio di allenamento $t$ .

We then compute the "delta weights", $D_{lk} \in \mathbb{R}^{l \times k}$ (between layer $l$ and layer $k$)

$$D_{lk} = E_{lt} * Z_{tk}$$

where $Z_{tk}$ is the transpose of $Z_{kt}$.

We then adjust the weights

$$W_{lk} = W_{lk} - D_{lk}$$

For $l \to k$, we thus have the time complexity $\mathcal{O}(lt + lt + ltk + lk) = \mathcal{O}(l*t*k)$.

Now, going back from $k \to j$. We first have

$$E_{kt} = f'(S_{kt}) \odot (W_{kl} * E_{lt})$$

Then

$$D_{kj} = E_{kt} * Z_{tj}$$

And then

$$W_{kj} = W_{kj} - D_{kj}$$

$W_{kl}$$W_{lk}$$k \to j$$\mathcal{O}(kt + klt + ktj + kj) = \mathcal{O}(k*t(l+j))$.

$j \to i$, we have $\mathcal{O}(j*t(k+i))$. In total, we have

$$\mathcal{O}(ltk + tk(l + j) + tj (k + i)) = \mathcal{O}(t*(lk + kj + ji))$$

which is same as feedforward pass algorithm. Since they are same, the total time complexity for one epoch will be

$$O(t*(ij + jk + kl)).$$

This time complexity is then multiplied by number of iterations (epochs). So, we have

$$O(n*t*(ij + jk + kl)),$$ where $n$ is number of iterations.

Notes

Note that these matrix operations can greatly be paralelized by GPUs.

Conclusion

We tried to find the time complexity for training a neural network that has 4 layers with respectively $i$, $j$, $k$ and $l$ nodes, with $t$ training examples and $n$ epochs. The result was $\mathcal{O}(nt*(ij + jk + kl))$.

We assumed the simplest form of matrix multiplication that has cubic time complexity. We used batch gradient descent algorithm. The results for stochastic and mini-batch gradient descent should be same. (Let me know if you think the otherwise: note that batch gradient descent is the general form, with little modification, it becomes stochastic or mini-batch)

Also, if you use momentum optimization, you will have same time complexity, because the extra matrix operations required are all element-wise operations, hence they will not affect the time complexity of the algorithm.

I'm not sure what the results would be using other optimizers such as RMSprop.

Sources

The following article http://briandolhansky.com/blog/2014/10/30/artificial-neural-networks-matrix-form-part-5 describes an implementation using matrices. Although this implementation is using "row major", the time complexity is not affected by this.

If you're not familiar with back-propagation, check this article:

http://briandolhansky.com/blog/2013/9/27/artificial-neural-networks-backpropagation-part-4

For the evaluation of a single pattern, you need to process all weights and all neurons. Given that every neuron has at least one weight, we can ignore them, and have $\mathcal{O}(w)$ where $w$ is the number of weights, i.e., $n * n_i$, assuming full connectivity between your layers.

The back-propagation has the same complexity as the forward evaluation (just look at the formula).

So, the complexity for learning $m$ examples, where each gets repeated $e$ times, is $\mathcal{O}(w*m*e)$.

The bad news is that there's no formula telling you what number of epochs $e$ you need.

A potential disadvantage of gradient-based methods is that they head for the nearest minimum, which is usually not the global minimum.

This means that the only difference between these search methods is the speed with which solutions are obtained, and not the nature of those solutions.

An important consideration is time complexity, which is the rate at which the time required to find a solution increases with the number of parameters (weights). In short, the time complexities of a range of different gradient-based methods (including second-order methods) seem to be similar.

Six different error functions exhibit a median run-time order of approximately O(N to the power 4) on the N-2-N encoder in this paper:

Lister, R and Stone J "An Empirical Study of the Time Complexity of Various Error Functions with Conjugate Gradient Back Propagation" , IEEE International Conference on Artificial Neural Networks (ICNN95), Perth, Australia, Nov 27-Dec 1, 1995.

Summarised from my book: Artificial Intelligence Engines: A Tutorial Introduction to the Mathematics of Deep Learning.