Discesa stocastica del gradiente

Da Wikipedia, l'enciclopedia libera.
Jump to navigation Jump to search

La discesa stocastica del gradiente (in lingua inglese stochastic gradient descent, SGD) è un metodo iterativo per l'ottimizzazione di funzioni differenziabili, approssimazione stocastica del metodo di discesa del gradiente (GD) quando la funzione costo ha la forma di una somma. SGD opera similmente a GD ma, ad ogni iterazione, sostituisce il valore esatto del gradiente della funzione costo con una stima ottenuta valutando il gradiente solo su un sottinsieme degli addendi. È ampiamente usato per l'allenamento di una varietà di modelli probabilistici e modelli di apprendimento automatico, come macchine a vettori di supporto, regressione logistica e modelli grafici.[1] In combinazione con il metodo di retropropagazione dell'errore, è lo standard de facto per l'allenamento delle reti neurali artificiali.[2]

Contesto[modifica | modifica wikitesto]

In molti problemi di statistica e di apprendimento automatico si ha la necessità di ottimizzare una funzione nei parametri[3] che ha la forma di una somma

dove ogni addendo rappresenta il costo calcolato sull'-esima osservazione in un dataset. Nel contesto della statistica classica, tale problema appare tipicamente in applicazioni del metodo dei minimi quadrati o del metodo della massima verosimiglianza, e gli stimatori ottenuti come soluzione di tali problemi sono chiamati stimatori M. Il metodo di discesa del gradiente esegue iterazioni nella forma

dove è un iperparametro che controlla l'ampiezza di ogni passo, e nel contesto dell'apprendimento automatico è chiamato tasso di apprendimento (learning rate). In molti casi, gli addendi hanno un'espressione sufficientemente semplice, che consente una valutazione rapida del gradiente ad ogni iterazione (ad esempio, in statistica, le funzioni della famiglia esponenziale). Tuttavia, in altri contesti, la valutazione dell'intera somma può essere particolarmente costosa, ad esempio quando il dataset è particolarmente ampio e non esiste un'espressione elementare per il costo, richiedendo la valutazione di tutti i singoli addendi, fatto che si verifica comunemente, ad esempio, nei problemi di apprendimento profondo. La discesa stocastica del gradiente affronta tale problema approssimando il gradiente dell'intera somma, valutandolo solo in un sottoinsieme casuale degli addendi ad ogni iterazione.[4]

Formulazione[modifica | modifica wikitesto]

Esempio di andamento della funzione costo nel corso delle iterazioni in un problema di ottimizzazione risolto tramite SGD

La discesa del gradiente classica viene anche chiamata batch GD, in quanto l'intero dataset viene valutato ad ogni iterazione. Quando il gradiente viene invece approssimato stocasticamente, è possibile costruire diversi metodi a seconda del numero di addendi usati ad ogni iterazione. Un possibile approccio è la discesa stocastica del gradiente in linea (on-line), che usa un solo elemento del dataset alla volta, ed è così chiamato perché può essere usato quando il dataset non è prefissato e nuovi dati vengono generati sul momento (on-line, o on-the-fly). Il gradiente di è approssimato ad ogni iterazione con il gradiente calcolato su un singolo addendo della funzione costo (corrispondente ad un elemento del dataset)

e i parametri vengono aggiornati dopo ogni valutazione. Il dataset può essere attraversato diverse volte, fino a quando il metodo converge. Tipicamente, l'ordine degli elementi è randomizzato ad ogni attraversamento del dataset, e il tasso di apprendimento può essere variato dinamicamente, tipicamente riducendolo con il procedere delle iterazioni (annealing).[5]

 1  
 2  
 3  until convergenza do:
 4      dataset := permutazione(dataset)
 5      for  do:
 6          
 7          

L'aggiornamento dei parametri in linea, con iterazione sui singoli elementi del dataset, implica generalmente un andamento molto irregolare della funzione costo (figura a lato). Una variante ampiamente utilizzata, che rappresenta un approccio intermedio tra SGD in linea e batch GD, è nota come mini-batch e prevede di calcolare il gradiente su un sottinsieme di elementi del dataset ad ogni iterazione, invece che su in singolo elemento. La dimensione di ogni mini-batch è generalmente dipendente dal contesto. Ciò rende l'evoluzione della funzione costo nel corso delle iterazioni meno rumorosa, in quanto il gradiente ad ogni iterazione diventa la media di ogni mini-batch, risultando in un effetto di smoothing, e riduce il costo computazionale, consentendo una migliore vettorizzazione del codice.[5]

La convergenza del metodo è stata studiata nel contesto dell'ottimizzazione convessa e dell'approssimazione stocastica. In sintesi, se il tasso di apprendimento decresce nel corso delle iterazioni secondo una funzione opportuna del tempo, e la funzione obiettivo è convessa o pseudoconvessa e soddisfa alcune ipotesi deboli, la discesa del gradiente stocastica converge quasi certamente ad un punto di ottimo locale.[6][7][8]

Estensioni e varianti[modifica | modifica wikitesto]

Molte estensioni del metodo sono state proposte, soprattutto nel contesto dell'apprendimento automatico, dove la discesa stocastica del gradiente è un metodo indispensabile per l'addestramento delle reti neurali artificiali profonde. In tale contesto la funzione obiettivo ha tipicamente decine di milioni di parametri da ottimizzare, il che rende difficile sfuggire dai punti di sella.[9]

Uno degli aspetti importanti nella formulazione dei metodi è la presenza di iperparametri che necessitano di essere a loro volta ottimizzati, e la capacità di un algoritmo di non dipendere da iperparametri espliciti è generalmente un aspetto positivo. Un iperparametro fondamentale in molti metodi è il tasso di apprendimento, che riveste un ruolo cruciale in quanto un valore troppo elevato comporta scarsa capacità di convergenza, mentre un valore troppo basso implica una convergenza molto lenta. Un'estensione elementare prevede di usare un tasso di apprendimento dinamico con una funzione decrescente nel numero di iterazioni, concetto già studiato in precedenza in altri algoritmi come simulated annealing o nell'estensione adattiva dell'algoritmo k-means.[10]

Diversi metodi con tasso di apprendimento adattivo, regolato automaticamente nel corso delle iterazioni, sono stati sviluppati e hanno raggiunto grande diffusione nelle applicazioni pratiche. Tuttavia in alcuni problemi di apprendimento automatico, come riconoscimento di oggetti o traduzione automatica, tali metodi mostrano scarsa capacità di generalizzazione e sono meno robusti rispetto a una semplice SGD con momento.[11][12] Questo è legato al fatto che tali metodi usano una media mobile con memoria a breve termine, soggetta a decadimento esponenziale, e poiché alcune mini-batch sono più ricche di contenuto informativo ma allo stesso tempo più rare, la loro influenza risulta limitata, indebolendo la robustezza del metodo.[13]

Momento[modifica | modifica wikitesto]

Il momento è un termine dipendente dalle iterazioni precedenti, che viene sommato al gradiente nel tentativo di regolarizzare il movimento nello spazio dei parametri. È stato descritto da Rumelhart, Hinton e Williams nel loro articolo seminale del 1986 sulla retropropagazione dell'errore.[14] L'aggiornamento dei parametri usa una combinazione lineare del gradiente nell'iterazione corrente e dell'aggiornamento nell'iterazione precedente[15][16]

che risulta in

Questo metodo introduce un secondo iperparametro per controllare l'effetto del momento, ovvero l'importanza dell'iterazione passata. Un valore empirico per tale parametro è solitamente fissato intorno a .[17]

Il metodo è stato usato a lungo nell'addestramento delle reti neurali[18] e il nome deriva da un'analogia non del tutto accurata con il momento lineare in fisica, in quanto il vettore dei parametri può essere visto come una particella che si muove nello spazio dei parametri, soggetta ad accelerazione da parte di una forza il cui potenziale è espresso dalla funzione costo.

NAG[modifica | modifica wikitesto]

NAG (Nesterov accelerated gradient), introdotto da Jurij Nesterov nel 1983, è un'estensione del metodo del momento che approssima la posizione futura dei parametri, introducendo una espressione corretta che tiene conto del movimento.[19]

Questa correzione previene movimenti eccessivi nello spazio dei parametri, e la sua introduzione ha portato significativi miglioramenti nella performance delle reti neurali ricorsive.[20]

AdaGrad[modifica | modifica wikitesto]

AdaGrad (adaptive gradient) è un metodo pubblicato nel 2011[21][22] che usa un tasso di apprendimento indipendente per ogni parametro. Intuitivamente, questo metodo usa tassi di apprendimento più elevati per parametri con una distribuzione più sparsa, e più lenti per i parametri con distribuzione più densa. AdaGrad spesso converge più rapidamente rispetto a SGD ordinaria, soprattutto quando la distribuzione dei dati è sparsa e i parametri sparsi hanno maggior contenuto informativo, che si verifica ad esempio in problemi di elaborazione del linguaggio naturale o riconoscimento automatico del contenuto di immagini.[21]

Il tasso di apprendimento è moltiplicato per un vettore i cui elementi rappresentano i fattori di scala per ogni parametro. Tale vettore è la diagonale della matrice ottenuta come prodotto esterno

dove è il gradiente all'iterazione . La diagonale ha la forma

.

Tale vettore è aggiornato ad ogni iterazione, e l'espressione di aggiornamento dei parametri diventa

dove è il prodotto di Hadamard e è un termine di smoothing, solitamente con un valore dell'ordine di , aggiunto per migliorare la stabilità numerica.[17]

Ogni elemento è un fattore di scala del learning rate per un singolo parametro da ottimizzare, e è la norma 2 di una quantità che incorpora le derivate alle iterazioni precedenti, per cui tale fattore attenua il learning rate di parametri soggetti ad aggiornamenti bruschi, e fornisce maggiore importanza al learning rate di parametri con aggiornamenti piccoli o infrequenti.[18] Esprimendo l'aggiornamento per ogni singolo parametro, la formula diventa

Benché ideato per problemi di ottimizzazione convessa, AdaGrad è usato anche per problemi di ottimizzazione nonconvessa.[23] Uno dei vantaggi principali di AdaGrad è la sua capacità di adattare automaticamente il tasso di apprendimento, che ne fa in pratica un metodo senza iperparametri, in quanto molte implementazioni usano un valore iniziale predefinito (intorno a ). Il principale svantaggio è la tendenza del metodo a cancellare il learning rate nel corso delle iterazioni, portando ad un arresto dell'apprendimento, poiché i termini della somma sono positivi e il valore del denominatore è strettamente crescente in funzione delle iterazioni.[17]

RMSProp[modifica | modifica wikitesto]

RMSProp (Root Mean Square Propagation) è un metodo con tasso di apprendimento adattivo che affronta il problema della cancellazione del tasso di apprendimento in AdaGrad. L'algoritmo non è stato pubblicato su una rivista peer-reviewed dall'autore Geoffrey Hinton, ma è stato proposto originariamente nelle sue slide per il corso Neural Networks for Machine Learning, tenutosi su Coursera,[24] che vengono comunemente citate come fonte originale per tale metodo.[17] Data la media mobile della norma del gradiente ad ogni iterazione, calcolata in una finestra di iterazioni precedenti

dove è un fattore di decadimento esponenziale, solitamente con valore empiricamente fissato intorno a (suggerito anche da Hinton), il parametro determina l'importanza della memoria delle passate iterazioni nel calcolo della media mobile: un valore pari a zero significa che le iterazioni passate sono ignorate e solo il gradiente all'iterazione corrente è usato, e all'aumentare di la memoria delle passate iterazioni assume importanza sempre maggiore, a discapito del valore corrente del gradiente.

Definendo la media quadratica (root mean square) come

l'aggiornamento dei parametri è definito come

In questo modo, il tasso di apprendimento è controllato dinamicamente della media quadratica della norma del gradiente.[25]

AdaDelta[modifica | modifica wikitesto]

AdaDelta, come RMSProp, è una variante di AdaGrad che contrasta la cancellazione del tasso di apprendimento. È stato sviluppato indipendentemente da RMSProp, di cui può essere considerato una estensione. Ad ogni iterazione viene calcolata una media mobile del quadrato della norma del gradiente nel corso delle iterazioni

e una media mobile del vettore di cambiamento dei parametri

Il vettore di aggiornamento dei parametri è definito come[26]

Il tasso di apprendimento è completamente automatico, e l'unico iperparametro di AdaDelta è il decadimento .

Adam[modifica | modifica wikitesto]

Adam (Adaptive moment estimation) è un'estensione di RMSProp che tiene conto della media mobile dei momenti primo () e secondo () del gradiente, usando degli stimatori corretti e , in quanto e sono distorti verso valori prossimi allo zero, fenomeno evidente soprattutto nelle prime iterazioni. Indicando con i parametri all'iterazione , e con la funzione costo da ottimizzare, si ha

dove è un termine di smoothing aggiunto ai fini della stabilità numerica, mentre e sono iperparametri che controllano il decadimento esponenziale. Gli autori suggeriscono , e .[27]

AdaMax[modifica | modifica wikitesto]

AdaMax è una variante di Adam che usa la norma del massimo del gradiente invece della norma 2 nella stima del momento secondo

ottenendo la formula di aggiornamento

dove non richiede correzione né smoothing. Gli autori suggeriscono , e .[27]

Nadam[modifica | modifica wikitesto]

Nadam (Nesterov-accelerated Adaptive Moment Estimation) è un metodo che incorpora NAG in Adam. Espandendo la formula di aggiornamento dei parametri di Adam, sostituendo con la sua definizione,[28] si ha

Si può quindi applicare la correzione di Nesterov sostituendo lo stimatore corretto del momento all'iterazione precedente con la stima all'iterazione corrente , ottenendo la formula di aggiornamento dei parametri di Nadam[29]

AMSGrad[modifica | modifica wikitesto]

AMSGrad è una variante di Adam che sostituisce la media mobile del quadrato della norma del gradiente nelle passate iterazioni con il massimo, nel tentativo di ridurre l'effetto di memoria a breve termine che, in alcuni problemi, limità la robustezza di molti metodi con tasso di apprendimento adattivo[13]

kSGD[modifica | modifica wikitesto]

kSGD (Kalman-based Stochastic Gradient Descent)[30] è un metodo per l'apprendimento di parametri in modelli di quasi-verosimiglianza, includendo come casi particolari modelli di regressione lineare e non lineare, modelli lineari generalizzati e reti neurali con errore quadratico medio come funzione costo. Per l'apprendimento in linea, kSGD è un caso particolare di filtro di Kalman nel caso di problemi di regressione lineare, o un caso particolare di filtro di Kalman esteso per problemi di regressione non lineare, e costituisce un'estensione formalmente rigorosa della discesa del gradiente.[31][32]

kSGD non è sensibile al numero di condizionamento del problema,[33] ha una condizione di arresto e una scelta robusta degli iperparametri. Tra gli svantaggi, vi sono il fatto che kSGD richiede di memorizzare una matrice densa di covarianza, e richiede il calcolo di un prodotto matrice-vettore ad ogni iterazione.

Sia data la funzione costo , dove i parametri sono definiti da un'osservazione in maniera tale che

dove è il valore atteso di dato e è la varianza di dato ). Gli aggiornamenti dei parametri e della matrice di covarianza sono dati da

dove sono iperparametri del metodo. L'aggiornamento di può risultare in una matrice di covarianza non definita, e questo può essere evitato al costo di calcolare un prodotto di matrici aggiuntivo. può essere una qualsiasi matrice simmetrica definita positiva, ed è tipicamente inizializzata con l'identità. In un metodo correlato di regressione non-lineare, un fattore di decadimento è usato nell'aggiornamento della matrice di covarianza allo scopo di dimostrare la convergenza.[34]

Implementazione parallela[modifica | modifica wikitesto]

Benché l'algoritmo di discesa stocastica del gradiente sia inerentemente sequenziale, è possibile parallelizzarlo per l'esecuzione su sistemi distribuiti, generalmente operando su diversi mini-batch in parallelo e usando un array di parametri condiviso che viene aggiornato combinando i risultati.[35][36][37] Se i dati sono sufficientemente sparsi, ovvero ogni elemento del dataset influenza solo un numero limitato di parametri, è possibile implementare SGD in parallelo condividendo i parametri senza sincronizzazione, evitando il costo aggiuntivo di quest'ultima, in quanto la probabilità di incorrere in corse critiche è molto bassa e le stesse, pur introducendo rumore nel processo, risultano avere un effetto trascurabile sulla convergenza dell'algoritmo.[38]

Alcuni framework fanno uso di un processo server che memorizza i parametri, e una collezione di processi worker che calcolano i gradienti e manipolano i parametri tramite primitive di sincronizzazione. TensorFlow dalla versione 0.8 fornisce nativamente l'allenamento dei modelli con ottimizzazione distribuita su più GPU.[39]

Ottimizzazioni[modifica | modifica wikitesto]

In problemi complessi, ad esempio nell'ottimizzazione dei parametri di reti neurali molto profonde, può essere utile introdurre del rumore ad ogni iterazione, sommando al gradiente una componente di rumore gaussiano con media nulla e varianza , soggetta ad annealing in funzione del numero di iterazioni . Questo approccio rende il processo meno dipendente dal valore iniziale dei parametri da ottimizzare, e aumenta la capacità dell'algoritmo di sfuggire da minimi locali sub-ottimali.[40]

In generale, è utile randomizzare l'ordine del dataset ad ogni attraversamento, per evitare di introdurre un bias. Tuttavia in alcuni casi, ad esempio in problemi di apprendimento automatico, può essere invece utile attraversare il dataset in ordine di difficoltà crescente dei record, dove la difficoltà dipende dalla natura del problema (ad esempio, difficoltà di classificazione di un record in un problema di classificazione). Tale approccio è chiamato curriculum learning,[41] e diverse strategie di ordinamento sono state studiate.[42]

Note[modifica | modifica wikitesto]

  1. ^ Jenny Rose Finkel, Alex Kleeman, Christopher D. Manning (2008). Efficient, Feature-based, Conditional Random Field Parsing. Proc. Annual Meeting of the ACL.
  2. ^ LeCun, Yann A., et al. "Efficient backprop." Neural networks: Tricks of the trade. Springer Berlin Heidelberg, 2012. 9-48
  3. ^ In questo contesto, i parametri del modello statistico sono le variabili libere da ottimizzare, mentre i parametri del metodo di ottimizzazione sono chiamati iperparametri.
  4. ^ Léon Bottou e Olivier Bousquet, The Tradeoffs of Large Scale Learning, Advances in Neural Information Processing Systems, vol. 20, 2008, pp. 161–168.
  5. ^ a b Ruder, p. 3.
  6. ^ Léon Bottou, Online Algorithms and Stochastic Approximations, in Online Learning and Neural Networks, Cambridge University Press, 1998, ISBN 978-0-521-65263-6.
  7. ^ Krzysztof C. Kiwiel, Convergence and efficiency of subgradient methods for quasiconvex minimization, in Mathematical Programming (Series A), vol. 90, nº 1, Berlin, Heidelberg, Springer, 2001, pp. 1–25, DOI:10.1007/PL00011414, ISSN 0025-5610 (WC · ACNP), MR 1819784.
  8. ^ Herbert Robbins e David O. Siegmund, A convergence theorem for non negative almost supermartingales and some applications, in Jagdish S. Rustagi (a cura di), Optimizing Methods in Statistics, Academic Press, 1971.
  9. ^ Yann Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli e Yoshua Bengio, Identifying and attacking the saddle point problem in high-dimensional non-convex optimization.
  10. ^ Cited by Christian Darken e John Moody, Fast adaptive k-means clustering: some empirical results, Int'l Joint Conf. on Neural Networks (IJCNN), IEEE, 1990.
  11. ^ G. Huang, Z. Liu, K. Q. Weinberger e L. van der Maaten, Densely Connected Convolutional Networks, in Proceedings of CVPR, 2017.
  12. ^ T. Dozat, Incorporating Nesterov Momentum into Adam, in ICLR Workshop, 2016.
  13. ^ a b Sashank J. Reddi, Satyen Kale e Sanjiv Kumar, On the Convergence of Adam and Beyond, in Proceedings of ICLR, 2018.
  14. ^ David E. Rumelhart, Hinton, Geoffrey E. e Williams, Ronald J., Learning representations by back-propagating errors, in Nature, vol. 323, nº 6088, 8 ottobre 1986, pp. 533–536, DOI:10.1038/323533a0.
  15. ^ Ilya Sutskever, Martens, James, Dahl, George e Hinton, Geoffrey E., On the importance of initialization and momentum in deep learning (PDF), a cura di Sanjoy Dasgupta and David Mcallester, In Proceedings of the 30th international conference on machine learning (ICML-13), vol. 28, Atlanta, GA, giugno 2013, pp. 1139–1147. URL consultato il 14 gennaio 2016.
  16. ^ Ilya Sutskever, Training recurrent neural networks (PDF) (Ph.D.), University of Toronto, 2013, p. 74.
  17. ^ a b c d An overview of gradient descent optimization algorithms, su ruder.io.
  18. ^ a b Matthew D. Zeiler, ADADELTA: An adaptive learning rate method, 2012.
  19. ^ Nesterov, Yuri (1983). A method for unconstrained convex minimization problem with the rate of convergence o(1/k2). ANSSSR vol. 269, pp. 543– 547.
  20. ^ Bengio, Y., Boulanger-Lewandowski, N. e Pascanu, R, Advances in Optimizing Recurrent Networks, 2012.
  21. ^ a b John Duchi, Elad Hazan e Yoram Singer, Adaptive subgradient methods for online learning and stochastic optimization (PDF), in JMLR, vol. 12, 2011, pp. 2121–2159.
  22. ^ Joseph Perla, Notes on AdaGrad (PDF), su seed.ucsd.edu, 2014 (archiviato dall'url originale il 30 marzo 2015).
  23. ^ Maya R. Gupta, Samy Bengio e Jason Weston, Training highly multiclass classifiers (PDF), in JMLR, vol. 15, nº 1, 2014, pp. 1461–1492.
  24. ^ Tieleman, Tijmen and Hinton, Geoffrey (2012). Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning
  25. ^ Geoffrey Hinton, Overview of mini-batch gradient descent (PDF), su cs.toronto.edu, pp. 27–29. URL consultato il 27 settembre 2016.
  26. ^ Zeiler, M. D., ADADELTA: An Adaptive Learning Rate Method, 2012.
  27. ^ a b Kingma Diederik e Jimmy Ba, Adam: A method for stochastic optimization, 2014.
  28. ^ Per semplicità, nel sostituire si ignora la differenza tra e .
  29. ^ Timothy Dozat, Incorporating Nesterov Momentum into Adam, 18 febbraio 2016.
  30. ^ V. Patel, Kalman-Based Stochastic Gradient Method with Stop Condition and Insensitivity to Conditioning, in SIAM Journal on Optimization, vol. 26, nº 4, 1º gennaio 2016, pp. 2620–2648, DOI:10.1137/15M1048239, ISSN 1052-6234 (WC · ACNP), arXiv:1512.01139.
  31. ^ A Cichocki, T Chen e S Amari, Stability Analysis of Learning Algorithms for Blind Source Separation., in Neural networks : the official journal of the International Neural Network Society, vol. 10, nº 8, novembre 1997, pp. 1345–1351, PMID 12662478.
  32. ^ (EN) Ollivier Yann, Online Natural Gradient as a Kalman Filter, 1º marzo 2017, arXiv:1703.00209.
  33. ^ Nel problema di regressione lineare la discrepanza della funzione obiettivo di kSGD (somma di bias e varianza) all'iterazione è data da con probabilità convergente a 1 ad un tasso dipendente da , dove è la varianza dei residui. Inoltre, per valori opportuni di , si può dimostrare che il bias della funzione obiettivo all'iterazione è dato da con probabilità convergente a 1 ad un tasso dipendente da , dove è il parametro ottimale.
  34. ^ D. Bertsekas, Incremental Least Squares Methods and the Extended Kalman Filter, in SIAM Journal on Optimization, vol. 6, nº 3, 1º agosto 1996, pp. 807–822, DOI:10.1137/S1052623494268522, ISSN 1052-6234 (WC · ACNP).
  35. ^ Zinkevich, Martin, Markus Weimer, Lihong Li, and Alex J. Smola. "Parallelized stochastic gradient descent." In Advances in neural information processing systems, pp. 2595-2603. 2010
  36. ^ Dekel, Ofer, Ran Gilad-Bachrach, Ohad Shamir, and Lin Xiao. "Optimal distributed online prediction using mini-batches." Journal of Machine Learning Research 13, no. Jan (2012): 165-202.
  37. ^ Chen, J., Pan, X., Monga, R., Bengio, S., & Jozefowicz, R. (2016). Revisiting distributed synchronous SGD. arXiv preprint arXiv:1604.00981.
  38. ^ Recht, Benjamin, Christopher Re, Stephen Wright, and Feng Niu. "Hogwild: A lock-free approach to parallelizing stochastic gradient descent." In Advances in neural information processing systems, pp. 693-701. 2011.
  39. ^ Derek Murray, Announcing TensorFlow 0.8 – now with distributed computing support!, su ai.googleblog.com, 13 aprile 2016.
  40. ^ Arvind Neelakantan, Luke Vilnis, Quoc V. Le, Ilya Sutskever, Lukasz Kaiser, Karol Kurach e James Martens, Adding Gradient Noise Improves Learning for Very Deep Networks, in arXiv:1511.06807 [cs, stat], 20 novembre 2015.
  41. ^ Yoshua Bengio, Jérôme Louradour, Ronan Collobert e Jason Weston, Curriculum learning, ACM, 14 giugno 2009, pp. 41–48, DOI:10.1145/1553374.1553380, ISBN 978-1-60558-516-1.
  42. ^ Wojciech Zaremba e Ilya Sutskever, Learning to Execute, in arXiv:1410.4615 [cs], 16 ottobre 2014.

Bibliografia[modifica | modifica wikitesto]

Matematica Portale Matematica: accedi alle voci di Wikipedia che trattano di matematica