[PYTHON] Tutorial zum neuronalen Netz von Pytorch (CNN) 1.3.1.

Angenommener Leser

Ich bin ein Anfänger von Pytorch. Nachdem Sie das Tutorial 1.3.1 zu Pytorchs Neural Network (CNN) verstanden haben, werfen wir einen Blick darauf.

――Ich verstehe den Mechanismus von CNN sehr gut

• Ich habe Python irgendwie berührt ――Ich habe zum ersten Mal versucht, Pytorch zu lernen, aber ich verstehe das offizielle Tutorial nicht.

Es ist ein Artikel für diejenigen, die sagen. Deshalb schreibe ich es ziemlich sorgfältig. Bitte lesen Sie nur dort, wo Sie es brauchen. Außerdem konzentrieren wir uns diesmal darauf, das offizielle Tutorial zu verstehen, und wir werden die Argumente, die nicht im Tutorial enthalten sind, nicht erläutern. Dieser Artikel beschreibt Pytorch Tutorial 1.3.1 ist.

Was ist in diesem Tutorial zu tun?

In diesem Tutorial fügt "Pytorch ein zweidimensionales Bild in ein neuronales Netzwerk ein, gibt es an die Zielfunktion aus (Vorwärtsausbreitung) und aktualisiert dann jeden Parameterwert (Fehlerrückausbreitungsmethode: Rückausbreitung). Möchtest Du das tun? "

Bildquelle: [Pytorch Tutorial 1.3.1] (https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#backprop )

Um einen detaillierteren Überblick zu geben, wie oben gezeigt, ist das Bild, dass Bildfaltung → Pooling → Faltung → Pooling → Konvertierung in ein eindimensionales Array → mit einem vollständig verbundenen Netzwerk (jeweils danach) zur Ausgabeschicht (10 Knoten) bringt Ich werde es erklären). Danach wird der Wert der Zielfunktion (in diesem Fall der durchschnittliche quadratische Fehler) berechnet, indem dieses Ausgabeergebnis mit der Antwort verglichen wird, die Sie im Voraus haben, und der Wert des Parameters wird aktualisiert, obwohl dies im obigen Bild nicht geschrieben ist.

(Übrigens, als CNN 1998 zum ersten Mal als ideal für die einfache Objekterkennung wie handgeschriebene Zeichen erwähnt wurde, [Objekterkennung mit gradientenbasiertem Lernen](http: //yann.lecun.). Es handelt sich um ein 5-Schicht-LeNet, das in der Veröffentlichung com / exdb / publis / pdf / lecun-99.pdf) vorgestellt wurde.

Schauen wir uns nun beim Schreiben des Codes weitere Details an.

Mach ein Modell

qiita.python

import torch
import torch.nn as nn
import torch.nn.functional as F

Importieren Sie zuerst die Taschenlampe. nn ist ein Modul, das Ebenen mit Parametern enthält, und F ist ein Modul, das Ebenen ohne Parameter enthält.

qiita.python

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 3x3 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

Nun wird hier das Netzwerk definiert. Pytorch erstellt eine Klasse, die von nn.Module (in diesem Fall NET) erbt, und das Netzwerk wird in dieser Klasse definiert. Ich werde jede der drei Methoden erklären, während ich den obigen Code teile.

__Init__ mit Ebenen mit Parametern

    def __init__(self):
        super(Net, self).__init__()

Das erste ist, wie man in Schichten mit Parametern verarbeitet. Grundsätzlich wird die Ebene mit den Parametern in den Konstruktor __init __ eingefügt. Erstens erbt super (Net, self) .__ init__ () den Konstruktor der übergeordneten Klasse. Wenn Sie einen Konstruktor in einer untergeordneten Klasse erstellen, wird dieser überschrieben. Es ist also so, als würden Sie den Konstruktor der übergeordneten Klasse übernehmen und die Teile hinzufügen, die dieses Mal hinzugefügt werden müssen. Übrigens kann "super (Net, self) .__ init __ ()" als "super () .__ init __ ()" abgekürzt werden.

Faltschicht

        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)

"conv2D" ist eine Klasse, die für die zweidimensionale Faltung verwendet wird. Mit anderen Worten, hier ist das Bild so, dass die Höhe und Breite des Bildes komprimiert werden. Die Argumente sind (die Tiefe des Eingabebildes (In-Channel), die Tiefe des Ausgabebildes (Out-Channel) und die Größe des Filters).

Was sind Kanäle (Tiefe, Tiefe)?

Bilder haben zusätzlich zu vertikal und horizontal eine Tiefe (manchmal auch als Tiefe übersetzt), und diese Tiefe wird als Kanal bezeichnet. Die Tiefe entspricht der Farbe im Fall des Bildes, die Anzahl der Kanäle beträgt 3 im Fall von RGB und 1 im Fall von Monochrom. Wir falten einen Filter hinein, der automatisch so eingestellt wird, dass er die gleiche Anzahl von Kanälen wie die Eingangsschicht hat. Wenn beispielsweise die Anzahl der Eingangskanäle 3 beträgt, beträgt die Anzahl der Filterkanäle automatisch 3.

Zum Beispiel Bildquelle: https://axa.biopapyrus.jp/deep-learning/cnn.html

Auf diese Weise beträgt die Anzahl der Kanäle im Filter ebenfalls 3, wenn die Anzahl der Kanäle im Eingabebild 3 beträgt. Mit anderen Worten, jeder Kanal des Filters wird in R, G und B gefaltet, und eine Merkmalskarte wird als Summe erstellt.

Die Anzahl der Ausgänge hängt davon ab, wie viele Filter Sie vorbereiten. Bildquelle: https://qiita.com/icoxfog417/items/5aa1b3f87bb294f84bac

Betrachtet man das erste "conv1" -Argument, so sind die Eingangsdaten 1 Kanal = Monochrom, die Ausgabe 6 Kanäle und die Filtergröße 3x3. Mit anderen Worten, 6 Feature-Maps wurden ausgegeben, indem 6 Filter mit der gleichen Tiefe von 1 wie die Eingabedaten vorbereitet und gefaltet wurden. Das nächste "conv2" hat 6 Kanäle mit Eingangsdaten und 16 Kanäle mit Ausgang, so dass 16 Filter mit einer Tiefe von 6 gefaltet sind. Die Anzahl der Kanäle im Bild zum Zeitpunkt der Ausgabe entspricht immer der Anzahl der Filter.

Vollständig verbundene Schicht

Als nächstes ist nn.Linear eine Klasse, die eine lineare Transformation auf die Eingabedaten anwendet, und die Argumente sind (Anzahl der Eingabeeinheiten, Anzahl der Ausgabeeinheiten). Ein vollständig verbundenes Netzwerk, in dem alle Einheiten (auch Knoten genannt) verbunden sind.

        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

Übrigens erscheint hier plötzlich die Zahl 16 * 6 * 6 (= 576), aber dies ist eine eindimensionale Version der vorherigen dreidimensionalen Daten.

Die Bilddaten waren 16 Kanäle in der Faltungsschicht, bevor sie zu dieser vollständig verbundenen Schicht kamen. Daher sind Daten 3D-Daten von (Anzahl der Kanäle, vertikal, horizontal) = (16, vertikal, horizontal). Um diese Daten auf die vollständig verbundene Schicht zu bringen, ist es notwendig, die dreidimensionalen Daten eindimensional zu machen. In diesem Modell wird festgelegt, dass hier Bilder mit einer Länge und Breite von 6 eingehen, und 16 * 6 * 6 = 576 ist die Anzahl der Knoten in der ersten Eingabeebene der vollständig verbundenen Ebene. Wenn die in dieses Modell aufzunehmenden Bilddaten beispielsweise nicht vertikal und horizontal 6 * 6 vor der vollständig verbundenen Ebene sind, ist vor dieser Ebene eine Ebene erforderlich, die auf 6 * 6 geändert werden soll.

"vorwärts", um die Vorwärtsausbreitung zu beschreiben

Als nächstes folgt die Methode "forward". Hier wird das Netzwerk beschrieben, das Daten (x) als Argument empfängt und den Wert der Ausgabeschicht ausgibt.

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

Hier, input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d -> view -> linear -> relu -> linear -> relu -> linear Der Fluss der Vorwärtsausbreitung wird beschrieben. Wir haben die Ebenen bereits mit Parametern erklärt, daher werden wir die anderen Ebenen erklären.

Die "F.relu" -Funktion ist eine Rampenfunktion, die eine der Aktivierungsfunktionen ist, die eine nichtlineare Verarbeitung der gewundenen Daten durchführt. ReLU (x) = max (x, 0), und wenn die Daten größer als 0 sind, wird der Wert ausgegeben, und wenn er kleiner als 0 ist, wird 0 ausgegeben.

Die Funktion max_pool2d führt ein zweidimensionales Maximalwert-Pooling durch. Hier verwenden wir ein 2 * 2-Fenster. Die Figur ist wie folgt. Der Maximalwert im Fenster wird in der Reihenfolge von oben links ausgegeben. Das Pooling wird so berechnet, dass der Rand nicht abgedeckt wird, ohne den Schritt festzulegen. Diesmal ist es 2 * 2, daher werden die vertikalen und horizontalen Größen hier halbiert.

Schauen wir uns die Ansichtsfunktion genauer an. view ist eine Funktion, die eine Liste von Zahlen zurückgibt, die mit den Eingabedaten eines neuen Tensors mit einer anderen Form identisch sind. Dies wird verwendet, wenn Bilddaten vor der vollständig verbundenen Schicht in eindimensionale Daten konvertiert werden. Zum Beispiel

>>>x = torch.randn(2,2)
>>>x
tensor([[-0.2834, -0.3660],
        [-0.1678, -0.3034]])
>>>x.view(4)
tensor([-0.2834, -0.3660, -0.1678, -0.3034])

Sie können die Form der Daten wie gesagt ändern. Dieses Mal steht am Anfang des Arguments ein -1. Dadurch wird die Größe der ersten Dimension ordnungsgemäß an die anderen (in diesem Fall zweiten) Argumente angepasst. Zum Beispiel

>>>x = torch.randn(4,3)
>>>x
tensor([[-1.2163,  1.6905,  0.1850],
        [-0.2123,  0.5995,  0.7282],
        [-0.5564, -0.1090, -0.8454],
        [-0.5643,  1.2565, -0.5475]])
>>>x.view(-1,6)
tensor([[-1.2163,  1.6905,  0.1850, -0.2123,  0.5995,  0.7282],
        [-0.5564, -0.1090, -0.8454, -0.5643,  1.2565, -0.5475]])

Es ist so. Wenn Sie "4 * 3 in x * 6 ändern" sagen, wird automatisch das optimale 2 * 6 geändert.

Betrachten Sie diese Zeit "x = x.view (-1, self.num_flat_features (x))".

Wenn die ursprünglichen Bilddaten (16,6,6) sind, scheint "x.view (576)" gut zu sein, aber tatsächlich hat der ursprüngliche Eingangstensor vier Dimensionen (Anzahl der Abtastwerte, Anzahl der Kanäle, Länge, Breite). Es ist ein Tensor von. Bisher habe ich die Anzahl der Proben nicht erwähnt, weil ich dachte, die Eingabedaten seien ein Bild, aber beim maschinellen Lernen, weil die Parameter nach der Verarbeitung mehrerer Bilder in einem Mini-Batch (Pytorch's'torch 'aktualisiert werden). .nn'ist unter der Annahme, dass eine Mini-Charge verwendet wird), und die Eingabedaten enthalten auch Informationen wie die Anzahl der Proben. Daher wird hier die Form der Ausgabe auf (Anzahl der Abtastwerte, Anzahl der Kanäle x Länge x Breite) eingestellt, und der Merkmalsbetrag für jeden Abtastwert ist ein eindimensionales Array, so dass der Merkmalsbetrag für jeden Abtastwert die vollständig verbundene Schicht ist. Ich möchte, dass es der Startknoten ist.

"x = x.view (-1, self.num_flat_features (x))" ist diesmal "x = x.view (-1, 576)". Diese "self.num_flat_features (x)" wird als Methode zur Berechnung der Anzahl der Features pro Stichprobe erstellt, sodass das mit dieser Methode berechnete Ergebnis hier einfach ersetzt wird. (Ich werde später über self.num_flat_features (x) sprechen.)

Durch Erstellen eines Vorwärtsausbreitungsmodells mit dieser Vorwärtsmethode wird auch die Rückwärtsfunktion definiert. Die Rückwärtsfunktion kehrt nur den Pfad um, der von der Vorwärtsausbreitung stammt, und ermittelt den Gradienten für die Zielfunktion. Wenn also ein Vorwärtsausbreitungsnetzwerk erstellt wird, wird diese Formel ebenfalls automatisch erstellt.

Num_flat_features (x) zählt die Anzahl der Features

Hier wird nur die Anzahl der Kanäle x Länge x Breite verwendet, um die Merkmalsmenge anders als die Anzahl der Abtastwerte eindimensional zu machen.

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

Es werden nur die anderen Dimensionen als die erste Anzahl von Abtastwerten der Eingabedaten multipliziert. "[1:]" bedeutet, 16 oder höher (= Index [1] oder später) von (0,16,6, ...) zu extrahieren. num_features * = s =num_features = num_features * s.

Mit anderen Worten, hier (Anzahl der Abtastwerte, 16,6,6), so dass nach dem Wechsel zu (16,6,6) 16 * 6 * 6 pro Bild verwendet werden, um die Anzahl der Merkmale zu berechnen.

Nun ist die Konstruktionszeichnung des Modells fertig. Lassen Sie es uns instanziieren.

>>>net = Net()
>>>print(net)
Net(
  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))
  (fc1): Linear(in_features=576, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

Im maschinellen Lernprozess wird das Lernen mit einem Objekt durchgeführt, das eine von sich selbst definierte Klasse instanziiert (hier die Net () -Klasse).

Bildgröße organisieren

Lassen Sie uns für alle Fälle herausfinden, welche Bildgröße dieses Modell haben soll und welche Änderungen die Bildgröße bisher vorgenommen hat.

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d -> view -> linear -> relu -> linear -> relu -> linear

Dieses Mal wird "Die Eingabedaten von LeNet werden mit 32 * 32 angenommen" im offiziellen Tutorial von pytorch geschrieben, aber ich denke, dass 30 das Optimum für diesen Parameter ist. Geben Sie 30 × 30 Daten ein → Die Größe des Faltfilters beträgt (3 * 3,1 Schritt), also 28 * 28 → Das Pooling (2 * 2) beträgt 14 * 14 → Falten (3 * 3,1 Schritt), also 12 * 12 → Pooling (2 * 2) → 6 * 6, um es in die vollständig verbundene Ebene einzufügen, nicht wahr? Im Originalpapier verwendet die erste Faltungsschicht eine Filtergröße von 5 * 5, daher ist 32 * 32 die beste Wahl dafür. (Pytorchs 'nn.MaxPool2d'-Pooling wird nach dem Dezimalpunkt abgeschnitten, sodass auch mit diesem Parameter 32 * 32 eingegeben werden kann.)

Überprüfen Sie die Parameter

Lassen Sie uns nun die Parameter überprüfen. Die zu lernenden Parameter finden Sie mit net.parameter ().

>>>params = list(net.parameters())
>>>print(len(params))
>>>print(params[0].size())  # conv1's .weight
>>>print(params[1].size())

10
torch.Size([6, 1, 3, 3])
torch.Size([6])

Diesmal gibt es 10 Parameter. Die erste Faltungsschicht hat die Parameter [6, 1, 3, 3] und [6]. Der Parameter in der Faltungsschicht ist der Wert des Filters. Da der Wert dieses Filters ein Parameter ist und durch Lernen aktualisiert wird, beträgt er 6 (Anzahl der Ausgangskanäle) x 1 (Anzahl der Eingangskanäle) x 3 (vertikal) x 3 (horizontal) + 6 (Vorspannung). Die nächste Faltungsschicht ist [16,6,3,3] und [16] mit derselben Begründung. Wenn Sie dies bisher verstanden haben, können Sie die anderen sechs vollständig verbundenen Schichten verstehen. Sie sind [120, 576], [120], [84, 120], [84], [10, 84], [10].

Daten eingeben

Versuchen wir nun, eine geeignete Nummer einzugeben, als hätten wir die Bilddaten im vorherigen Modell eingegeben.

>>>input = torch.randn(1, 1, 32, 32)
>>>out = net(input)
>>>print(out)
tensor([[-0.0843,  0.0283,  0.0677,  0.0639, -0.0076, -0.0293,  0.1049,  0.2183,
         -0.1275, -0.1151]], grad_fn=<AddmmBackward>)

10 Stück werden fest ausgegeben. Übrigens ist die erste der 4D-Daten zum Zeitpunkt der Eingabe die Anzahl der Bilder pro Stapel.

Verlustberechnung

Die Zielfunktion verwendet ein Paar (Ausgabewert, Ziel (Antwort)) als Eingabe und berechnet, wie weit das Ausgabeergebnis von der gewünschten Antwort entfernt ist. Es gibt mehrere Verlustfunktionen im nn-Paket, aber dieses Mal werden wir nn.MSELoss verwenden, um den durchschnittlichen quadratischen Fehler zwischen dem Ausgabeergebnis und dem Ziel zu berechnen.

>>>output = net(input)
>>>target = torch.randn(10)  # a dummy target, for example
>>>target = target.view(1, -1)  # make it the same shape as output
>>>criterion = nn.MSELoss()

>>>loss = criterion(output, target)
>>>print(loss)
tensor(0.6110, grad_fn=<MseLossBackward>)

Setzen Sie das Ausgabeergebnis des Modells in die Ausgabe ein und geben Sie diesmal eine geeignete Zahl in das Ziel ein, um die Form mit dem Ausgabeergebnis des Modells abzugleichen (da das Ausgabeergebnis des Modells auch die Anzahl der Stapel enthält (1,10). ) ist). Die Verlustfunktion wird instanziiert und verwendet.

Parameteraktualisierung

Das Modul enthält verschiedene Methoden zur Parameteraktualisierung, die als Optim of Pytorch bezeichnet werden, und Sie können die Fehlerrückvermehrungsmethode zum Aktualisieren der Parameter problemlos ausführen.

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

"optim.SGD (net.parameters (), lr = 0.01)" bedeutet, den angegebenen Parameterwert ("net.parameters ()") mit einer Lernrate von 0,01 unter Verwendung der probabilistischen Gradientenabstiegsmethode zu aktualisieren. ist.

optimizer.zero_grad() Dies bedeutet, dass der Gradient der Zielfunktion 0 sein sollte. Dies kann für diejenigen erforderlich sein, die mit Definitions- und Ausführungsframeworks wie Transflow vertraut sind, aber Pytorch und Chainer schreiben den Backpropagation-Berechnungsprozess im Voraus vor. Es ist nicht erforderlich, und die Parameter können flexibel aktualisiert werden, indem der gesamte für die Gradientenverarbeitung erforderliche Berechnungsverlauf gespeichert wird. Umgekehrt, wann ist der Berechnungsprozess für diesen Gradienten abgeschlossen? Unbestimmt. Wenn dies an der erforderlichen Stelle nicht auf 0 gesetzt ist, wird der Gradient der neuen Daten in Bezug auf den Gradienten akkumuliert, der zuvor aus den Eingabedaten berechnet wurde, und der korrekte Gradient kann nicht berechnet werden. Mit anderen Worten, der Prozess des Initialisierens dieses Gradienten muss jedes Mal ausgeführt werden, wenn der Fehler zurückpropagiert wird (= jedes Mal, wenn ein Stapel erstellt wird).

Bisher haben wir den Ablauf der Modellerstellung -> Vorwärtsausbreitung -> Berechnung der Verlustfunktion -> Fehlerrückausbreitung zur Aktualisierung von Parametern mit Pytorch erläutert. Als nächstes gibt es ein Tutorial zum Verschieben des Modells unter Verwendung der tatsächlichen Daten. Probieren Sie es also aus.

abschließend

Dieses Mal habe ich zu meinem Verständnis auf verschiedene URLs verwiesen, daher möchte ich sie vorstellen. Alle werden empfohlen.

Bildquelle

• Implementierung eines Faltungs-Neuronalen Netzes
  https://qiita.com/icoxfog417/items/5aa1b3f87bb294f84bac
• Faltungsneurales Netzwerk
  https://axa.biopapyrus.jp/deep-learning/cnn.html
• Object Recognition with Gradient-Based Learning
  http://yann.lecun.com/exdb/publis/pdf/lecun-99.pdf

Als nächstes folgt die Referenz-URL

• Folding Neural Network_CNN (Vol.16)
  https://products.sint.co.jp/aisia/blog/vol1-16#toc-3
• Neueste Forschungstrends von Faltungs-Neuronalen Netzen (~ 2017)
  https://qiita.com/yu4u/items/7e93c454c9410c4b5427#fn3 --Medical AI Specialized Course Online-Vorlesungsmaterialien
  https://japan-medical-ai.github.io/medical-ai-course-materials/index.html
• Convolutional Neural Networks (CNNs / ConvNets)
  http://cs231n.github.io/convolutional-networks/
• Why do we need to call zero_grad() in PyTorch?
  https://discuss.pytorch.org/t/why-do-we-need-to-set-the-gradients-manually-to-zero-in-pytorch/4903