Expérimentez avec divers algorithmes d'optimisation sur le réseau neuronal

L'implémentation peut être trouvée dans dnn / optimizers.py de ** this GitHub repository **.

introduction

J'ai essayé d'utiliser l'optimisation des coefficients d'apprentissage suivante avec un simple réseau de neurones en utilisant MNIST comme référence. Comparons la précision de chaque ensemble de données d'évaluation.

la mise en oeuvre

L'implémentation utilisée Theano. Cette fois, j'ai téléchargé le code source dans My GitHub Repository.

Je l'ai utilisé comme référence pour optimiser le coefficient d'apprentissage. https://gist.github.com/SnippyHolloW/67effa81dd1cd5a488b4 https://gist.github.com/skaae/ae7225263ca8806868cb http://chainer.readthedocs.org/en/stable/reference/optimizers.html?highlight=optimizers http://qiita.com/skitaoka/items/e6afbe238cd69c899b2a

Dans le code ci-dessous, params '' (ou self.params '') détient le poids et le biais de l'ensemble du réseau. Puisqu'elle est apprise par la méthode de descente de gradient probabiliste, la valeur obtenue en différenciant la valeur de la fonction d'erreur loss``` par params est requise, mais `` gparams (ou .gparams '') correspond à cela. (Différencié par T.grad (loss, param) ''.) La classe Optimizer est au point où le gradient est obtenu en le différenciant et en l'héritant, en implémentant SGD, Momentum SGD, etc. Je vais.

optimizers.py


class Optimizer(object):
	def __init__(self, params=None):
		if params is None:
			return NotImplementedError()
		self.params = params

	def updates(self, loss=None):
		if loss is None:
			return NotImplementedError()

		self.updates = OrderedDict()
		self.gparams = [T.grad(loss, param) for param in self.params]

À propos, `` self.updates '' ici est utilisé pour mettre à jour les poids, etc.

SGD

optimizers.py


class SGD(Optimizer):
	def __init__(self, learning_rate=0.01, params=None):
		super(SGD, self).__init__(params=params)
		self.learning_rate = 0.01

	def updates(self, loss=None):
		super(SGD, self).updates(loss=loss)

		for param, gparam in zip(self.params, self.gparams):
			self.updates[param] = param - self.learning_rate * gparam

		return self.updates	

Momentum SGD

optimizers.py


class MomentumSGD(Optimizer):
	def __init__(self, learning_rate=0.01, momentum=0.9, params=None):
		super(MomentumSGD, self).__init__(params=params)
		self.learning_rate = learning_rate
		self.momentum = momentum
		self.vs = [build_shared_zeros(t.shape.eval(), 'v') for t in self.params]

	def updates(self, loss=None):
		super(MomentumSGD, self).updates(loss=loss)

		for v, param, gparam in zip(self.vs, self.params, self.gparams):
			_v = v * self.momentum
			_v = _v - self.learning_rate * gparam
			self.updates[param] = param + _v
			self.updates[v] = _v

		return self.updates

AdaGrad

optimizers.py


class AdaGrad(Optimizer):
	def __init__(self, learning_rate=0.01, eps=1e-6, params=None):
		super(AdaGrad, self).__init__(params=params)

		self.learning_rate = learning_rate
		self.eps = eps
		self.accugrads = [build_shared_zeros(t.shape.eval(),'accugrad') for t in self.params]

	def updates(self, loss=None):
		super(AdaGrad, self).updates(loss=loss)

		for accugrad, param, gparam\
		in zip(self.accugrads, self.params, self.gparams):
			agrad = accugrad + gparam * gparam
			dx = - (self.learning_rate / T.sqrt(agrad + self.eps)) * gparam
			self.updates[param] = param + dx
			self.updates[accugrad] = agrad

		return self.updates

RMSprop

optimizers.py


class RMSprop(Optimizer):
	def __init__(self, learning_rate=0.001, alpha=0.99, eps=1e-8, params=None):
		super(RMSprop, self).__init__(params=params)

		self.learning_rate = learning_rate
		self.alpha = alpha
		self.eps = eps

		self.mss = [build_shared_zeros(t.shape.eval(),'ms') for t in self.params]

	def updates(self, loss=None):
		super(RMSprop, self).updates(loss=loss)

		for ms, param, gparam in zip(self.mss, self.params, self.gparams):
			_ms = ms*self.alpha
			_ms += (1 - self.alpha) * gparam * gparam
			self.updates[ms] = _ms
			self.updates[param] = param - self.learning_rate * gparam / T.sqrt(_ms + self.eps)

		return self.updates

AdaDelta

optimizers.py


class AdaDelta(Optimizer):
	def __init__(self, rho=0.95, eps=1e-6, params=None):
		super(AdaDelta, self).__init__(params=params)

		self.rho = rho
		self.eps = eps
		self.accugrads = [build_shared_zeros(t.shape.eval(),'accugrad') for t in self.params]
		self.accudeltas = [build_shared_zeros(t.shape.eval(),'accudelta') for t in self.params]

	def updates(self, loss=None):
		super(AdaDelta, self).updates(loss=loss)

		for accugrad, accudelta, param, gparam\
		in zip(self.accugrads, self.accudeltas, self.params, self.gparams):
			agrad = self.rho * accugrad + (1 - self.rho) * gparam * gparam
			dx = - T.sqrt((accudelta + self.eps)/(agrad + self.eps)) * gparam
			self.updates[accudelta] = (self.rho*accudelta + (1 - self.rho) * dx * dx)
			self.updates[param] = param + dx
			self.updates[accugrad] = agrad

		return self.updates

Adam

optimizers.py


class Adam(Optimizer):
	def __init__(self, alpha=0.001, beta1=0.9, beta2=0.999, eps=1e-8, gamma=1-1e-8, params=None):
		super(Adam, self).__init__(params=params)

		self.alpha = alpha
		self.b1 = beta1
		self.b2 = beta2
		self.gamma = gamma
		self.t = theano.shared(np.float32(1))
		self.eps = eps

		self.ms = [build_shared_zeros(t.shape.eval(), 'm') for t in self.params]
		self.vs = [build_shared_zeros(t.shape.eval(), 'v') for t in self.params]

	def updates(self, loss=None):
		super(Adam, self).updates(loss=loss)
		self.b1_t = self.b1 * self.gamma ** (self.t - 1)

		for m, v, param, gparam \
		in zip(self.ms, self.vs, self.params, self.gparams):
			_m = self.b1_t * m + (1 - self.b1_t) * gparam
			_v = self.b2 * v + (1 - self.b2) * gparam ** 2

			m_hat = _m / (1 - self.b1 ** self.t)
			v_hat = _v / (1 - self.b2 ** self.t)

			self.updates[param] = param - self.alpha*m_hat / (T.sqrt(v_hat) + self.eps)
			self.updates[m] = _m
			self.updates[v] = _v
		self.updates[self.t] = self.t + 1.0

		return self.updates

Expérience

En utilisant MNIST, 30 graines ont été moyennées par 20 époques. Veuillez vous référer à My GitHub Repository pour les paramètres détaillés des coefficients d'apprentissage et des réseaux neuronaux.

résultat

Eh bien, je ne sais pas parce que celui du haut est en désordre, développons.

SGD a disparu.

en conclusion

J'aurais dû prendre la valeur de la fonction d'erreur. .. .. ..

Nous prévoyons d'ajouter à l'avenir des réseaux de neurones convolutifs, des autoencodeurs de réduction du bruit empilés, etc. à ce référentiel GitHub.

Je vous serais reconnaissant si vous pouviez souligner des points étranges.

Recommended Posts

Expérimentez avec divers algorithmes d'optimisation sur le réseau neuronal
Composez avec un réseau neuronal! Run Magenta
Entraînez les données MNIST avec PyTorch en utilisant un réseau neuronal
Implémenter un réseau neuronal à 3 couches
Réseau de neurones avec Python (scikit-learn)
3. Distribution normale avec un réseau neuronal!
Réseau de neurones commençant par Chainer
4. Entourez les paramètres avec un réseau neuronal!
Créez une application Web qui reconnaît les nombres avec un réseau neuronal
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Réseau neuronal avec OpenCV 3 et Python 3
Implémentation d'un réseau de neurones à deux couches 2
Modèle de classification simple avec réseau neuronal
Qu'est-ce que le réseau neuronal convolutif?
Ecrire un réseau résiduel avec TFLearn
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
J'ai essayé de mettre en œuvre un réseau de neurones à deux couches
Prédire les données de séries chronologiques avec un réseau neuronal
Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow
Persister le réseau de neurones construit avec PyBrain
2. Écart moyen et standard avec le réseau neuronal!
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Visualisez la couche interne du réseau neuronal
Vérification de la normalisation des lots avec un réseau neuronal multicouche
Créez un tableau de bord pour les appareils réseau avec Django!
Réseau neuronal paramétrique
L'histoire de la création d'un réseau neuronal de génération musicale
environnement en ligne de serveur de code (2) Créer un réseau virtuel avec Boto3
Mise en œuvre de l'optimisation bayésienne des hyper paramètres du réseau de neurones (Chainer + GPyOpt)
J'ai essayé de résumer quatre méthodes d'optimisation de réseau neuronal
Bases de PyTorch (2) -Comment créer un réseau de neurones-
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
J'ai essayé un réseau de neurones convolutifs (CNN) avec un tutoriel TensorFlow sur Cloud9-Classification des images manuscrites-