Implémentation simple d'un réseau de neurones à l'aide de Chainer ~ Définition d'un algorithme d'optimisation ~

Depuis la dernière fois, j'écris un article pour créer un réseau de neurones en utilisant Chainer, qui est un cadre d'apprentissage en profondeur. Cette fois

  1. Préparation des données

  2. Description du modèle

  3. Optimisation des paramètres d'algorithme

  4. Apprentissage

  5. Sortie de résultat De

  6. Optimisation des paramètres d'algorithme Je vais écrire sur.

Aussi, comme il est 4. J'écrirai également sur l'apprentissage.

Calcul des paramètres optimaux

Le modèle Iris que j'ai écrit la dernière fois était le code suivant.

class IrisChain(Chain):
    def __init__():
        super(IrisChain, self).__init__(
             l1 = L.Linear(4, 6),
             l2 = L.Linear(6, 3),
    )

    def __call__(self, x, y):
        return F.mean_squared_error(self.fwd(x), y)

    def fwd(self, x):
        h1 = F.sigmoid(self.l1(x))
        h2 = self.l2(h1)
        return h2

Le flux de ce que nous faisons est

  1. Définition de linéaire dans le constructeur
  2. Utilisez fwd pour déterminer s'il faut déclencher d'un nœud à l'autre
  3. Erreur entre la sortie et les données de l'enseignant par appel

Irisニューラルネット_4.png

Conversion de la couche d'entrée en couche intermédiaire

v = w_1x + b_1 ...(1)

Conversion de la couche intermédiaire à la couche de sortie

y = w_2v + b_2 ...(2)

Cependant, ce sont ces paramètres, w et b, que nous voulons enfin trouver.

Cette fois ici Utilise l'algorithme d'optimisation de la méthode de descente de gradient stochastique (SGD).

Et apprendre. Le nombre de répétitions d'apprentissage est de 10 000 cette fois.

>>> model = IrisChain()
>>> optimizer = optimizers.SGD()
>>> optimizer.setup(model)
>>> for i range(10000):
...     x = Variable(xtrain)
...     y = Variable(ytrain)
...     model = zerograds()
...     loss = model(x, y)
...     loss.backward()
...     optimizer.update()

En dessous de 4 lignes

model = zerograds()
loss = model(x, y)
loss.backward()
optimizer.update()

Est ici Ceci est l'état de propagation des erreurs. C'est presque un modèle promis. Vous avez maintenant les paramètres appropriés w et b, et vous avez un classificateur. La prochaine fois, j'essaierai ce classificateur.

référence

Takayoshi Yamashita Apprentissage profond du Kodansha visible sur l'illustration Hiroyuki Shinno Apprentissage en profondeur pratique avec Chainer-Comment implémenter des NN-Ohm complexes

Recommended Posts

Implémentation simple d'un réseau de neurones à l'aide de Chainer ~ Définition d'un algorithme d'optimisation ~
Implémentation simple d'un réseau neuronal à l'aide de Chainer
Implémentation de réseau neuronal simple à l'aide de la préparation Chainer-Data-
Implémentation de réseau neuronal simple à l'aide de la description du modèle Chainer-
Théorie et implémentation simples des réseaux neuronaux
Implémentation de réseaux neuronaux "flous" avec Chainer
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
Implémentation de réseau neuronal en python
Implémentation de réseau neuronal (NumPy uniquement)
Apprentissage des classements à l'aide d'un réseau neuronal (implémentation RankNet par Chainer)
Implémentation d'un réseau de neurones à deux couches 2
PRML Chapitre 5 Implémentation Python du réseau neuronal
Modèle de classification simple avec réseau neuronal
Prédiction des survivants à l'aide du réseau neuronal titanesque de Kaggle [80,8%]
Implémentation d'un réseau neuronal à 3 couches (pas d'apprentissage)
Essayez d'utiliser TensorFlow-Part 2-Convolution Neural Network (MNIST)
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Une autre méthode de conversion de style utilisant le réseau neuronal convolutif
Réseau neuronal paramétrique
Estimation de l'auteur à l'aide du réseau neuronal et de Doc2Vec (Aozora Bunko)
Modèle utilisant un réseau neuronal convolutif dans le traitement du langage naturel
Mise en œuvre de l'optimisation bayésienne des hyper paramètres du réseau de neurones (Chainer + GPyOpt)