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

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