Le résultat était meilleur lorsque les données d'apprentissage du mini-lot ont été faites un hybride de fixe et aléatoire avec un réseau de neurones.

introduction

La dernière fois J'ai obtenu de bons résultats dans le processus de création de l'article, je vais donc le présenter.

Le résultat d'apprentissage lorsque les données d'apprentissage du mini-lot ont été randomisées était meilleur que la dernière fois, donc si j'étudiais la cause, le résultat d'apprentissage au moment de la fixation par rapport au moment de l'aléatoire Il s'est avéré que j'avais l'intention de comparer les résultats d'apprentissage lorsqu'ils étaient fixes vs fixes + aléatoires. (Dernière fois l'article est une comparaison entre l'heure fixe et l'heure aléatoire)

environnement

• python: 2.7.6
• chainer: 1.8.0

contenu de l'étude

Nous allons vérifier la différence entre le cas où les données d'apprentissage du mini-lot sont mélangées aléatoirement pour chaque époque générale et le cas où il s'agit d'un hybride de mélange fixe et aléatoire. Comme d'habitude, c'est la fonction péché qui est entraînée.

[training data]

• entrée: thêta (0 ~ 2π, 1000 divisions)
• output: sin(theta)

la mise en oeuvre

Créer un modèle deux fois

Cette découverte est due à l'oubli de réinitialiser le résultat de l'entraînement du modèle avant l'entraînement à un moment aléatoire. Je ne savais pas comment le réinitialiser et il était difficile de changer le nom du modèle, etc., j'ai donc codé le même processus deux fois. (Veuillez me dire comment réinitialiser ...)

Créer un modèle deux fois

#La modélisation
model = MyChain(n_units)
optimizer = optimizers.Adam()
optimizer.setup(model)

'''
réduction(Apprentissage aléatoire général uniquement)
'''

#La modélisation(Je ne sais pas comment réinitialiser le résultat de l'entraînement du modèle, alors créez à nouveau le modèle)
model = MyChain(n_units)
optimizer = optimizers.Adam()
optimizer.setup(model)

Paramètres d'apprentissage

• Mini taille de lot: 20
• Époque (n_epoch): 500
• Nombre de couches cachées: 2
• Nombre d'unités de couche cachées (n_units): 100
• Fonction d'activation: fonction linéaire normalisée (relu)
• Abandon: Aucun (0%)
• Optimisation: Adam
• Fonction d'erreur de perte: fonction d'erreur quadratique moyenne (mean_squared_error)

Tous les paramètres sont appropriés.

L'époque au moment de l'hybride est fixe et aléatoire 250 fois chacune.

Code entier

C'est un code griffonné sale, mais ça marche, donc ça va.

L'ensemble

# -*- coding: utf-8 -*-

#Importer depuis une extrémité pour le moment
import numpy as np
import chainer
from chainer import cuda, Function, gradient_check, Variable, optimizers, serializers, utils
from chainer import Link, Chain, ChainList
import chainer.functions as F
import chainer.links as L
import time
from matplotlib import pyplot as plt

#Les données
def get_dataset(N):
    x = np.linspace(0, 2 * np.pi, N)
    y = np.sin(x)
    return x, y

#réseau neuronal
class MyChain(Chain):
    def __init__(self, n_units=10):
        super(MyChain, self).__init__(
             l1=L.Linear(1, n_units),
             l2=L.Linear(n_units, n_units),
             l3=L.Linear(n_units, 1))

    def __call__(self, x_data, y_data):
        x = Variable(x_data.astype(np.float32).reshape(len(x_data),1)) #Convertir en objet variable
        y = Variable(y_data.astype(np.float32).reshape(len(y_data),1)) #Convertir en objet variable
        return F.mean_squared_error(self.predict(x), y)

    def  predict(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        h3 = self.l3(h2)
        return h3

    def get_predata(self, x):
        return self.predict(Variable(x.astype(np.float32).reshape(len(x),1))).data

# main
if __name__ == "__main__":

    #Données d'entraînement
    N = 1000
    x_train, y_train = get_dataset(N)

    #Paramètres d'apprentissage
    batchsize = 10
    n_epoch = 500
    n_units = 100

    #La modélisation
    model = MyChain(n_units)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    #Boucle d'apprentissage(Aléatoire général uniquement)
    print "start..."
    normal_losses =[]
    start_time = time.time()
    for epoch in range(1, n_epoch + 1):

        # training
        perm = np.random.permutation(N)
        sum_loss = 0
        for i in range(0, N, batchsize):
            x_batch = x_train[perm[i:i + batchsize]]
            y_batch = y_train[perm[i:i + batchsize]]
            model.zerograds()
            loss = model(x_batch,y_batch)
            sum_loss += loss.data * batchsize
            loss.backward()
            optimizer.update()

        average_loss = sum_loss / N
        normal_losses.append(average_loss)

        #Processus d'apprentissage des extrants
        if epoch % 10 == 0:
            print "(normal) epoch: {}/{} normal loss: {}".format(epoch, n_epoch, average_loss)

    interval = int(time.time() - start_time)
    print "Temps d'exécution(normal): {}sec".format(interval)

    #La modélisation(Je ne sais pas comment réinitialiser le résultat de l'entraînement du modèle, alors créez à nouveau le modèle)
    model = MyChain(n_units)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    #Boucle d'apprentissage(hybride)
    #Hybride fixe et aléatoire de données d'entraînement mini-batch
    hybrid_losses =[]
    for order in ["fixed", "random"]:
        start_time = time.time()
        for epoch in range(1, (n_epoch + 1) / 2):

            # training
            perm = np.random.permutation(N)
            sum_loss = 0
            for i in range(0, N, batchsize):
                if order == "fixed": #L'ordre d'apprentissage est fixe
                    x_batch = x_train[i:i + batchsize]
                    y_batch = y_train[i:i + batchsize]
                elif order == "random": #Ordre aléatoire d'apprentissage
                    x_batch = x_train[perm[i:i + batchsize]]
                    y_batch = y_train[perm[i:i + batchsize]]

                model.zerograds()
                loss = model(x_batch,y_batch)
                sum_loss += loss.data * batchsize
                loss.backward()
                optimizer.update()

            average_loss = sum_loss / N
            hybrid_losses.append(average_loss)

            #Processus d'apprentissage des extrants
            if epoch % 10 == 0:
                print "(hybrid) epoch: {}/{} {} loss: {}".format(epoch, n_epoch, order, average_loss)

        interval = int(time.time() - start_time)
        print "Temps d'exécution(hybrid {}): {}sec".format(order, interval)

    print "end"

    #Graphique d'erreur
    plt.plot(normal_losses, label = "normal_loss")
    plt.plot(hybrid_losses, label = "hybrid_loss")
    plt.yscale('log')
    plt.legend()
    plt.grid(True)
    plt.title("loss")
    plt.xlabel("epoch")
    plt.ylabel("loss")
    plt.show()

Résultat d'exécution

Erreur

Par rapport à la méthode générale (normale), la méthode hybride fixe et aléatoire (hybride) a une erreur d'un ordre de grandeur meilleure. Le passage de fixe à aléatoire est l'endroit où hybrid_loss diminue fortement au centre de l'axe horizontal.

Si le nombre d'époques est le même, il semble qu'il vaut mieux avoir moins fixe et plus aléatoire.

Résumé

Je ne connais pas la cause académique, mais dans cet objectif d'entraînement (fonction sin de 0 à 2π), si les données d'apprentissage du mini-lot sont un hybride de fixe et aléatoire, l'erreur est d'un ordre de grandeur meilleure que la méthode générale aléatoire uniquement. devenu.

Je pensais que c'était une rumeur sur l'apprentissage, alors je l'ai testé, mais le résultat était le même que lorsque j'apprenais.

J'ai senti que l'accumulation d'idées détaillées comme celle-ci a conduit à la création d'un réseau de neurones très précis.