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

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]

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

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.

sin_hybrid_order.png

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.

Recommended Posts

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.
Un diagramme de réseau a été créé avec les données du COVID-19.
Visualisez la couche interne du réseau neuronal
Entraînez les données MNIST avec PyTorch en utilisant un réseau neuronal
L'histoire de la création d'un réseau neuronal de génération musicale
Ce à quoi j'étais accro lorsque j'ai construit mon propre réseau de neurones en utilisant les poids et les biais que j'ai obtenus avec le classificateur MLP de scikit-learn.
Mesurer l'importance des entités avec un outil de forêt aléatoire
À la suite du montage et du réglage avec POH! Lite
Une collection de méthodes utilisées lors de l'agrégation de données avec des pandas
Gérez le chevauchement lors du dessin d'un diagramme de dispersion avec une grande quantité de données (Matplotlib, Pandas, Datashader)
Une histoire et sa mise en œuvre selon laquelle des données arbitraires a1 * a2 peuvent être représentées par un réseau de neurones ReLU à 3 couches avec des neurones intermédiaires a1 et a2 sans erreur.
[Application TF2.0] Un cas où l'augmentation de données à usage général a été parallélisée et réalisée à grande vitesse avec la fonction de jeu de données fort de l'exemple TF.
Compter la partie concaténée maximale d'un graphe aléatoire avec NetworkX
Créez un programme de jugement de compatibilité avec le module aléatoire de python.
Comprendre le nombre de paramètres d'entrée / sortie du réseau neuronal convolutif
Quand j'ai gratté le pouce de BOOTH et détecté le visage avec OpenCV, la précision était trop bonne et j'avais peur
Mettez à jour les données en les téléchargeant sur s3 d'aws avec une commande, et supprimez les données utilisées (en chemin)