[PYTHON] Sinuswellenvorhersage (Rückkehr) mit Pytorch

Überblick

Hallo. Ich bin ein neuer Mitarbeiter eines bestimmten IT-Unternehmens. Hier habe ich Pytorch, eine Open-Source-Bibliothek für maschinelles Lernen, verwendet, um ein Regressionsmodell-Lernprogramm für die Vorhersage von Sinuswellen als Beispiel zu beschreiben. (Es ist keine Zeitreihenprognose ... Ich möchte bald eine Zeitreihenprognose erstellen.)

Wenn sich der Kettenhändler zu Pytorch bewegt, Es war spät, aber ich habe es geschrieben, weil ich diesmal aufholen wollte. Es beschreibt auch die Punkte, an denen ich mich anders gefühlt habe.

Es ist wie die Pytorch-Migration des folgenden Artikels, den ich zuvor geschrieben habe. [Jetzt lasst uns mit Sinter sorgfältig Sündenwellen lernen] 1

Wenn Sie Vorschläge oder Fragen haben, zögern Sie bitte nicht, diese im Kommentarbereich zu hinterlassen.

Ganzer Code

Der Code befindet sich auf dem GitHub unten. kazu-ojisan/NN-pytorch_PredictSinWave

Umgebung

macOS Catalina 10.15.3 conda 4.7.12 Python 3.7.6 (Erstellen Sie eine virtuelle Umgebung mit Conda) pytorch 1.4.0

Die Installation von Pytorch ist in Sekunden erledigt. Wenn Sie Ihre eigene Umgebung auf der offiziellen Website unten auswählen, Es wird der Installationsbefehl angezeigt. [Pytorch -Official Site-] 3

Jeder Parameter

• Input ：0〜2π
• Output ：sin⁡(Input)
• Anzahl der Lernenden: 200
• Chargengröße: 10 (Mini-Chargenmethode)
• Anzahl der Trainingsdaten: 1000
• Anzahl der Testdaten: 200

Modellstruktur

• Zwischenschicht: 2 Schichten (Anzahl der Einheiten: 10) --Aktivierungsfunktion: ReLU

Implementierung

Unten sind die URLs aufgeführt, auf die ich mich bei der Implementierung bezogen habe.

• [Pytorch üben] 4
• [Lösen von Regressionsproblemen mit einem in PyTroch implementierten neuronalen Netzwerk] 5

Modul verwendet

Das Pytorch-Modul ist in Ordnung, solange mindestens Folgendes importiert wird.

test.py

import numpy as np      #Array
import time             #Zeit
from matplotlib import pyplot as plt #Graph
import os               #So erstellen Sie einen Ordner

# pytorch
import torch as T
import torch.nn as nn           #Schichtkonfiguration
import torch.nn.functional as F #Aktivierungsfunktion
from torch import optim         #Optimierungsfunktion

Datensatz

Ein einfacher y = sin (x) -Datensatz (x, y).

python

# y=sin(x)Erstellen Sie N Datensätze
def get_data(N, Nte):
    x = np.linspace(0, 2 * np.pi, N+Nte)
    #Teilen Sie in Trainingsdaten und Testdaten
    ram = np.random.permutation(N+Nte)
    x_train = np.sort(x[ram[:N]])
    x_test = np.sort(x[ram[N:]])

    t_train = np.sin(x_train)
    t_test = np.sin(x_test)

    return x_train, t_train, x_test, t_test

Struktur des neuronalen Netzes, Vorwärtsausbreitung usw.

Der einzige Unterschied zum Chainer besteht darin, dass er das Modul ohne besonderen Unterschied ersetzt. Der von pytorch verarbeitete Datentyp ist "Tensortyp", daher ist eine Konvertierung erforderlich. (Wertvoller Typ in Chainer)

.py

class SIN_NN(nn.Module):
    def __init__(self, h_units, act):
        super(SIN_NN, self).__init__()
        self.l1=nn.Linear(1, h_units[0])
        self.l2=nn.Linear(h_units[0], h_units[1])
        self.l3=nn.Linear(h_units[1], 1)

        if act == "relu":
            self.act = F.relu
        elif act == "sig":
            self.act = F.sigmoid

    def __call__(self, x, t):
        x = T.from_numpy(x.astype(np.float32).reshape(x.shape[0],1))
        t = T.from_numpy(t.astype(np.float32).reshape(t.shape[0],1))
        y = self.forward(x)
        return y, t

    def forward(self, x):
        h = self.act(self.l1(x))
        h = self.act(self.l2(h))
        h = self.l3(h)

        return h

Lernen

Ich fühlte den Unterschied zu Chainer (mehr Details später) (1) model.parameter () wird als erstes Argument der Optimierungsfunktion benötigt (2) Da MSE in Class definiert ist, kann es nur verwendet werden, wenn eine Instanz erstellt wurde. ③ Umschalten zwischen Lernmodus und Testmodus mit "model.train ()" und "model.eval ()" (Es gibt kein Problem, auch wenn es diesmal nicht ist.) ④ Die Erweiterung des Modells lautet ".pt" oder ".pth".

.py

def training(N, Nte, bs, n_epoch, h_units, act):

    #Holen Sie sich den Datensatz
    x_train, t_train, x_test, t_test = get_data(N, Nte)
    x_test_torch = T.from_numpy(x_test.astype(np.float32).reshape(x_test.shape[0],1))
    t_test_torch = T.from_numpy(t_test.astype(np.float32).reshape(t_test.shape[0],1))

    #Modelleinrichtung
    model = SIN_NN(h_units, act)
    optimizer = optim.Adam(model.parameters())
    MSE = nn.MSELoss()

    #Verlustspeicher-Array
    tr_loss = []
    te_loss = []

    #Erstellen Sie ein Verzeichnis
    if os.path.exists("Results/{}/Pred".format(act)) == False:
        os.makedirs("Results/{}/Pred".format(act))

    #Messzeit
    start_time = time.time()
    print("START")

    #Schleife für die Anzahl der Lernvorgänge
    for epoch in range(1, n_epoch + 1):
        model.train()
        perm = np.random.permutation(N)
        sum_loss = 0
        for i in range(0, N, bs):
            x_batch = x_train[perm[i:i + bs]]
            t_batch = t_train[perm[i:i + bs]]

            optimizer.zero_grad()
            y_batch, t_batch = model(x_batch, t_batch)
            loss = MSE(y_batch, t_batch)
            loss.backward()
            optimizer.step()
            sum_loss += loss.data * bs

        #Berechnen Sie den Durchschnitt der Lernfehler
        ave_loss = sum_loss / N
        tr_loss.append(ave_loss)

        #Testfehler
        model.eval()
        y_test_torch = model.forward(x_test_torch)
        loss = MSE(y_test_torch, t_test_torch)
        te_loss.append(loss.data)

    #Speichern Sie das trainierte Modell
    T.save(model, "Results/model.pt")

Details: Was ich fühlte, war anders als Chainer

(1) model.parameters () wird als erstes Argument der Optimierungsfunktion benötigt

model.parameters () speichert Gewichte und die Anzahl der Einheiten, die Modellinformationen sind. Offizielles Dokument: [model.parameters ()] 9 Wenn Sie versuchen, gemäß dem Dokument auszugeben, wird dies wie folgt ausgegeben.

$ python exportModelParam.py 
<class 'torch.Tensor'> torch.Size([10, 1])
<class 'torch.Tensor'> torch.Size([10])
<class 'torch.Tensor'> torch.Size([10, 10])
<class 'torch.Tensor'> torch.Size([10])
<class 'torch.Tensor'> torch.Size([1, 10])
<class 'torch.Tensor'> torch.Size([1])

(2) Da MSE in Class definiert ist, kann es nur verwendet werden, wenn eine Instanz erstellt wurde.

Die offizielle Dokumentation zu Pytorchs "MSE Loss" und Chainers "mean_squared_error" ist sinnvoll. Pytorch:Pytorch -SOURCE CODE FOR TORCH.NN.MODULES.LOSS-

MSELoss.py

class MSELoss(_Loss):

Chainer:Chainer -mean_squared_error.py-

mean_squared_error.py

def mean_squared_error(x0, x1):

③ Umschalten zwischen Lernmodus und Testmodus mit "model.train ()" und "model.eval ()"

Wenn Sie es mit .eval in den Testmodus versetzen, werden Dropout- und Batch-Normalisierung deaktiviert und es handelt sich um eine Testspezifikation. Dieser Code verwendet weder Dropout noch Batch-Normalisierung, daher funktioniert er auch ohne Dropout. Wenn Sie jedoch in Zukunft Pytorch verwenden möchten, ist es meiner Meinung nach besser, eine Gewohnheit des Schreibens hinzuzufügen.

④ Die Erweiterung des Modells lautet ".pt" oder ".pth".

Siehe unten. Tutorials > Saving and Loading Models

Ergebnis

Fehlerdiagramm

Diagramm zur Vorhersage der Testdaten epoch:20 epoch:200

Trouble Shooting

• Lernst du nicht?
• Ich habe vergessen, den Farbverlauf zu initialisieren (optimizer.zero_grad ())
• Sie können nur lernen, wenn Sie den Farbverlauf für jeden Mini-Batch initialisieren.

Referenz-URL

• [Pytorch -Official Site-] 3
• [Pytorch üben] 4
• [Lösen von Regressionsproblemen mit einem in PyTroch implementierten neuronalen Netzwerk] 5
• [Jetzt lasst uns mit Sinter sorgfältig Sündenwellen lernen] 1

Ganzer Code

Der Code befindet sich auf dem GitHub unten. kazu-ojisan/NN-pytorch_PredictSinWave

Am Ende

Den Informationen zufolge war es dem Kettenhändler ziemlich ähnlich. Ich fand, dass Pytorch gut ausgerüstet war. Wenn Sie Vorschläge haben, zögern Sie bitte nicht, diese im Kommentarbereich zu belassen, da sie immer noch nicht verstanden werden.