[PYTHON] Das Ergebnis war besser, als die Trainingsdaten des Mini-Batches als Hybrid aus fest und zufällig mit einem neuronalen Netzwerk erstellt wurden.

Einführung

Letztes Mal Ich möchte zufällig ein gutes Ergebnis bei der Erstellung eines Artikels einbringen.

Das Lernergebnis, wenn die Lerndaten des Mini-Batch randomisiert wurden, war besser als das letzte Mal. Wenn ich also die Ursache untersuchte, war das Lernergebnis zum festgelegten Zeitpunkt im Vergleich zum zufälligen Zeitpunkt Es stellte sich heraus, dass die Absicht des Vergleichs darin besteht, die Lernergebnisse zum Zeitpunkt von fest gegen fest + zufällig zu vergleichen. (Letztes Mal Artikel ist ein Vergleich zwischen fester Zeit und zufälliger Zeit)

Umgebung

• python: 2.7.6
• chainer: 1.8.0

Inhalt des Studiums

Wir werden den Unterschied zwischen dem Fall, in dem die Trainingsdaten des Mini-Batch für jede allgemeine Epoche zufällig gemischt werden, und dem Fall, in dem es sich um eine Mischung aus festem und zufälligem Mischen handelt, überprüfen. Wie üblich wird die Sündenfunktion trainiert.

[training data]

• Eingabe: Theta (0 ~ 2π, 1000 Teilungen)
• output: sin(theta)

Implementierung

Modell zweimal erstellen

Diese Entdeckung ist darauf zurückzuführen, dass vergessen wurde, das Trainingsergebnis des Modells vor dem Training zu einem zufälligen Zeitpunkt zurückzusetzen. Ich wusste nicht, wie ich es zurücksetzen sollte, und es war mühsam, den Modellnamen usw. zu ändern, also habe ich den gleichen Vorgang zweimal codiert. (Bitte sagen Sie mir, wie ich zurücksetzen soll ...)

Modell zweimal erstellen

#Modellieren
model = MyChain(n_units)
optimizer = optimizers.Adam()
optimizer.setup(model)

'''
Kürzung(Allgemeines zufälliges Lernen nur)
'''

#Modellieren(Ich weiß nicht, wie ich das Trainingsergebnis des Modells zurücksetzen soll. Erstellen Sie das Modell daher erneut)
model = MyChain(n_units)
optimizer = optimizers.Adam()
optimizer.setup(model)

Lernparameter

• Mini-Chargengröße: 20
• Epoche (n_epoch): 500
• Anzahl der versteckten Ebenen: 2
• Anzahl der versteckten Ebeneneinheiten (n_Einheiten): 100
• Aktivierungsfunktion: Normalisierte lineare Funktion (relu)
• Schulabbrecher: Keine (0%)
• Optimierung: Adam
• Verlustfehlerfunktion: Mittlere quadratische Fehlerfunktion (mean_squared_error)

Alle Parameter sind angemessen.

Die Epoche zum Zeitpunkt des Hybrids ist jeweils 250 Mal fest und zufällig.

Ganzer Code

Es ist ein schmutziger gekritzelter Code, aber er funktioniert, also bin ich okay.

Das ganze

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

#Vorerst von einem Ende importieren
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

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

#neurales Netzwerk
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)) #In variables Objekt konvertieren
        y = Variable(y_data.astype(np.float32).reshape(len(y_data),1)) #In variables Objekt konvertieren
        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__":

    #Trainingsdaten
    N = 1000
    x_train, y_train = get_dataset(N)

    #Lernparameter
    batchsize = 10
    n_epoch = 500
    n_units = 100

    #Modellieren
    model = MyChain(n_units)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    #Lernschleife(Nur allgemein zufällig)
    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)

        #Lernprozess ausgeben
        if epoch % 10 == 0:
            print "(normal) epoch: {}/{} normal loss: {}".format(epoch, n_epoch, average_loss)

    interval = int(time.time() - start_time)
    print "Ausführungszeit(normal): {}sec".format(interval)

    #Modellieren(Ich weiß nicht, wie ich das Trainingsergebnis des Modells zurücksetzen soll. Erstellen Sie das Modell daher erneut)
    model = MyChain(n_units)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    #Lernschleife(Hybrid)
    #Feste und zufällige Mischung von Mini-Batch-Trainingsdaten
    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": #Die Reihenfolge des Lernens ist festgelegt
                    x_batch = x_train[i:i + batchsize]
                    y_batch = y_train[i:i + batchsize]
                elif order == "random": #Zufällige Reihenfolge des Lernens
                    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)

            #Lernprozess ausgeben
            if epoch % 10 == 0:
                print "(hybrid) epoch: {}/{} {} loss: {}".format(epoch, n_epoch, order, average_loss)

        interval = int(time.time() - start_time)
        print "Ausführungszeit(hybrid {}): {}sec".format(order, interval)

    print "end"

    #Fehlergrafik
    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()

Ausführungsergebnis

Error

Im Vergleich zur allgemeinen Methode (normal) weist die feste und zufällige Hybridmethode (Hybrid) einen um eine Größenordnung besseren Fehler auf. Beim Wechsel von fest zu zufällig nimmt hybrid_loss in der Mitte der horizontalen Achse stark ab.

Wenn die Anzahl der Epochen gleich ist, scheint es besser zu sein, weniger fest und zufälliger zu sein.

Zusammenfassung

Ich kenne die akademische Ursache nicht, aber bei diesem Trainingsziel (Sinusfunktion von 0 bis 2π) ist der Fehler um eine Größenordnung besser als bei der allgemeinen Nur-Zufalls-Methode, wenn die Trainingsdaten des Mini-Batch eine Mischung aus fest und zufällig sind. wurde.

Ich dachte, dies sei ein gemunkeltes Überlernen, also habe ich es getestet, aber das Ergebnis war das gleiche wie beim Lernen.

Ich hatte das Gefühl, dass die Anhäufung detaillierter Ideen wie diese zur Schaffung eines hochpräzisen neuronalen Netzwerks führte.