[PYTHON] [PyTorch Tutorial ⑦] Visualisieren von Modellen, Daten und Training mit Tensorboard

Einführung

Dies ist die 7. Ausgabe von PyTorch Official Tutorial nach Last time. Dieses Mal fahren wir mit [Visualisieren von Modellen, Daten und Schulungen mit TensorBoard] fort (https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html).

Visualizing Models, Data, And Training With Tensorboard

In 60 Minute Blitz haben wir gesehen, wie man ein grundlegendes neuronales Netzwerk aufbaut und mit Trainingsdaten trainiert. Lassen Sie uns diesmal sehen, wie Sie die Trainingssituation visualisieren und prüfen, ob das Training läuft. Die Visualisierung verwendet TensorBoard. PyTorch kann TensorBoard nutzen, ein Tool zum Trainieren neuronaler Netze und zum Visualisieren von Ergebnissen.

In diesem Tutorial werden Fashion-MNIST-Daten aus torchvision.datasets verwendet, um einige seiner Funktionen zu veranschaulichen. Lernen wie man:

1. Lesen Sie die Daten und führen Sie die entsprechenden Konvertierungen durch. (Fast das gleiche wie im vorherigen Tutorial)
2. Richten Sie TensorBoard ein.
3. Schreiben Sie an TensorBoard.
4. Verwenden Sie TensorBoard, um die Modellarchitektur zu visualisieren.
5. Verwenden Sie TensorBoard, um Vorhersagen und Genauigkeit während des Trainings zu visualisieren.

Insbesondere kann das Folgende aus den obigen fünf Punkten gesehen werden.

• So überprüfen Sie die Trainingsdaten
• So verfolgen Sie die Modellleistung während des Modelltrainings
• Wie bewertet man die Leistung eines Modells nach dem Training?

CIFAR-10 Beginnen Sie mit Code ähnlich dem Tutorial.

%matplotlib inline

# imports
import matplotlib.pyplot as plt
import numpy as np

import torch
import torchvision
import torchvision.transforms as transforms

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

#Definition der Transformation
transform = transforms.Compose(
    [transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))])

#Datensatz
trainset = torchvision.datasets.FashionMNIST('./data',
    download=True,
    train=True,
    transform=transform)
testset = torchvision.datasets.FashionMNIST('./data',
    download=True,
    train=False,
    transform=transform)

#Datenlader
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                        shuffle=True, num_workers=2)


testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                        shuffle=False, num_workers=2)

#Klassifizierungskonstante
classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
        'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')

#Hilfsfunktion für die Bildanzeige
# (unten`plot_classes_preds`Wird in Funktionen verwendet)
def matplotlib_imshow(img, one_channel=False):
    if one_channel:
        img = img.mean(dim=0)
    img = img / 2 + 0.5     #Denormalisiert
    npimg = img.numpy()
    if one_channel:
        plt.imshow(npimg, cmap="Greys")
    else:
        plt.imshow(np.transpose(npimg, (1, 2, 0)))

CIFAR-10 Definiert ein Modell ähnlich dem Lernprogramm, jedoch mit einem Kanal anstelle von drei Bildern und 28x28 anstelle von 32x32. Ich werde es ein wenig ändern, um es zu machen.

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 4 * 4, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

Definieren Sie dieselbe Optimierungs- und Verlustfunktion wie zuvor.

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

1.TensorBoard setup

Richten Sie als Nächstes das TensorBoard ein. Definieren Sie einen SummaryWriter, der ein Objekt zum Importieren von TensorBoard aus torch.utils und zum Schreiben in TensorBoard ist.

from torch.utils.tensorboard import SummaryWriter

#Das Standardprotokollverzeichnis ist"runs"Sie können es hier jedoch angeben.
writer = SummaryWriter('runs/fashion_mnist_experiment_1')

Führen Sie einfach diese Zeile aus und es wird das Verzeichnis "running / fashion_mnist_experiment_1" erstellt.

2.Writing to TensorBoard

Verwenden Sie dann make_grid, um das Bild in TensorBoard zu schreiben.

#Holen Sie sich ein zufälliges Trainingsbild
dataiter = iter(trainloader)
images, labels = dataiter.next()

#Erstellen Sie ein Raster mit Bildern
img_grid = torchvision.utils.make_grid(images)

#Bild anzeigen
matplotlib_imshow(img_grid, one_channel=True)

#Schreiben Sie an die Tensorplatine
writer.add_image('four_fashion_mnist_images', img_grid)

(In diesem Lernprogramm nicht erwähnt. Wenn Sie jedoch Tensorboard mit Google Colaboratory verwenden möchten, laden Sie die TensorBoard-Notebook-Erweiterung.)

%load_ext tensorboard

#Wenn Sie Tensorboard mit Google Colaboratory verwenden, führen Sie Tensorboard mit magischen Befehlen aus.
#tensorboard --logdir=runs
%tensorboard --logdir=runs

Wenn in einer lokalen Umgebung ausgeführt https：//localhost:6006 Sie können die folgenden Tensorboard-Bildschirme mit durchsuchen. Ich konnte TensorBoard ausführen. Wir werden uns die Funktionen von TensorBoard unten ansehen.

3.Inspect the model using TensorBoard

Eine der Stärken von TensorBoard ist die Fähigkeit, komplexe Modellstrukturen zu visualisieren. Lassen Sie uns das erstellte Modell visualisieren.

writer.add_graph(net, images)
writer.close()

Nach dem Aktualisieren des TensorBoards wird eine Registerkarte "GRAFIKEN" angezeigt, die der folgenden ähnelt. Sie können auf Net doppelklicken, um es zu erweitern und die einzelnen Komponenten anzuzeigen, aus denen das Modell besteht. TensorBoard verfügt über eine sehr nützliche Funktion zur Visualisierung hochdimensionaler Daten wie Bilddaten im niedrigdimensionalen Raum. Es wird unten erklärt.

4.Adding a “Projector” to TensorBoard

Sie können die niedrigdimensionale Darstellung hochdimensionaler Daten über die Methode add_embedding visualisieren.

import tensorflow as tf
import tensorboard as tb
tf.io.gfile = tb.compat.tensorflow_stub.io.gfile

#Hilfsfunktion
def select_n_random(data, labels, n=100):
    '''
Wählen Sie n zufällige Datenpunkte und die entsprechenden Beschriftungen aus dem Datensatz aus
    '''
    assert len(data) == len(labels)

    perm = torch.randperm(len(data))
    return data[perm][:n], labels[perm][:n]

#Wählen Sie ein zufälliges Bild und seinen Zielindex aus
images, labels = select_n_random(trainset.data, trainset.targets)

#Holen Sie sich die Klassenbezeichnung für jedes Bild
class_labels = [classes[lab] for lab in labels]

#Protokolleinbettung
features = images.view(-1, 28 * 28)
writer.add_embedding(features,
                    metadata=class_labels,
                    label_img=images.unsqueeze(1))
writer.close()

Auf der Registerkarte PROJEKTOR von TensorBoard werden diese 100 Bilder angezeigt. Jedes Bild hat 784 Dimensionen, wird jedoch im dreidimensionalen Raum projiziert. Sie können die dreidimensionale Projektion durch Ziehen drehen. Wenn Sie oben links "Farbe: Beschriftung" auswählen und "Nachtmodus" aktivieren, wird der Hintergrund schwarz und das Bild wird besser sichtbar.

Jetzt wissen Sie, wie Sie mit TensorBoard Ihre Daten visualisieren. Als nächstes wollen wir sehen, wie TensorBoard Training und Bewertungen visualisiert.

5.Tracking model training with TensorBoard

Im vorherigen Tutorial (https://qiita.com/sudominoru/items/61f57946799e67cedd47) geben wir einfach den Verlustwert des Modells nach jeweils 2000 Iterationen aus. In diesem Lernprogramm wird der Verlustwert in TensorBoard aufgezeichnet und der vorhergesagte Wert wird von der Funktion plot_classes_preds angezeigt.

#Hilfsfunktion
def images_to_probs(net, images):
    '''
Gibt den vorhergesagten Wert und seine Wahrscheinlichkeit mit dem trainierten Modell und Bild als Argumente zurück
    '''
    output = net(images)
    #Konvertieren Sie die Ausgabewahrscheinlichkeit in eine Vorhersageklasse
    _, preds_tensor = torch.max(output, 1)
    preds = np.squeeze(preds_tensor.numpy())
    return preds, [F.softmax(el, dim=0)[i].item() for i, el in zip(preds, output)]


def plot_classes_preds(net, images, labels):
    '''
Erzeugt ein Matplotlib-Diagramm mit den trainierten Modell-, Bild- und Lehrerdaten als Argumenten.
Es zeigt die wahrscheinlichste Bezeichnung an, die das Modell vorhergesagt hat, und ob die Vorhersage korrekt ist.
Färbe es.
    「images_to_Verwenden Sie die Funktion "Probs".
    '''
    preds, probs = images_to_probs(net, images)
    #Zeichnen Sie das Bild stapelweise mit den vorhergesagten und tatsächlichen Beschriftungen.
    fig = plt.figure(figsize=(12, 48))
    for idx in np.arange(4):
        ax = fig.add_subplot(1, 4, idx+1, xticks=[], yticks=[])
        matplotlib_imshow(images[idx], one_channel=True)
        ax.set_title("{0}, {1:.1f}%\n(label: {2})".format(
            classes[preds[idx]],
            probs[idx] * 100.0,
            classes[labels[idx]]),
                    color=("green" if preds[idx]==labels[idx].item() else "red"))
    return fig

Lernen Sie, dasselbe Modell wie im vorherigen Lernprogramm zu verwenden (https://qiita.com/sudominoru/items/61f57946799e67cedd47), schreiben Sie jedoch alle 1000 Stapel in TensorBoard, anstatt auf der Konsole zu drucken. (Add_scalar Funktion) Zusätzlich werden der vorhergesagte Wert während des Trainings und das vorhergesagte Bild ausgegeben. (Add_figure Funktion)

running_loss = 0.0
for epoch in range(1):  #Schleifen Sie den Datensatz mehrmals

    for i, data in enumerate(trainloader, 0):

        #Holen Sie sich die Eingabe. Daten sind[inputs, labels]Ist eine Liste von
        inputs, labels = data

        #Initialisieren Sie den Farbverlauf
        optimizer.zero_grad()

        #Vorwärtsausbreitung+Backpropagation+Optimierung
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 1000 == 999:    #Alle 1000 Chargen

            # ...Notieren Sie den Verlustwert alle 1000 Chargen
            writer.add_scalar('training loss',
                            running_loss / 1000,
                            epoch * len(trainloader) + i)

            # ...Protokollieren Sie Modellvorhersagen in Matplotlib-Diagrammen in einem zufälligen Mini-Batch
            writer.add_figure('predictions vs. actuals',
                            plot_classes_preds(net, inputs, labels),
                            global_step=epoch * len(trainloader) + i)
            running_loss = 0.0
print('Finished Training')

out

Finished Training

Auf der Registerkarte SCALARS können Sie den Verlustwert während des Trainings sehen. Darüber hinaus können Sie die Modellvorhersagen anzeigen, die alle 1000 Chargen erstellt wurden. Gehen Sie zur Registerkarte BILDER und scrollen Sie unter der Visualisierung Vorhersagen vs. Ist. Nach nur 3.000 Trainingseinheiten hat das Modell bereits Hemden, Turnschuhe, Mäntel und mehr klassifiziert. Die Wahrscheinlichkeit ist jedoch nicht so hoch wie in der zweiten Trainingshälfte. Im vorherigen Tutorial (https://qiita.com/sudominoru/items/61f57946799e67cedd47) haben wir nach dem Training die Genauigkeitsrate für jedes Etikett überprüft. Hier verwenden wir TensorBoard, um die PR-Kurve für jede Klasse zu zeichnen.

6.Assessing trained models with TensorBoard

# 1. test_size x num_Holen Sie sich eine Wahrscheinlichkeitsvorhersage mit Tensor of Classes
# 2. test_Holen Sie sich Preds mit Tensor der Größe
#Die Ausführung dauert bis zu 10 Sekunden
class_probs = []
class_preds = []
with torch.no_grad():
    for data in testloader:
        images, labels = data
        output = net(images)
        class_probs_batch = [F.softmax(el, dim=0) for el in output]
        _, class_preds_batch = torch.max(output, 1)

        class_probs.append(class_probs_batch)
        class_preds.append(class_preds_batch)

test_probs = torch.cat([torch.stack(batch) for batch in class_probs])
test_preds = torch.cat(class_preds)

#Hilfsfunktion
def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0):
    '''
"Klasse" von 0 bis 9_Nehmen Sie "Index" auf und zeichnen Sie die entsprechende PR-Kurve
    '''
    tensorboard_preds = test_preds == class_index
    tensorboard_probs = test_probs[:, class_index]

    writer.add_pr_curve(classes[class_index],
                        tensorboard_preds,
                        tensorboard_probs,
                        global_step=global_step)
    writer.close()

#Zeichnen Sie die PR-Kurve
for i in range(len(classes)):
    add_pr_curve_tensorboard(i, test_probs, test_preds)

Die Registerkarte PR CURVES wird angezeigt. Öffnen wir die PR-Kurve jedes Etiketts und überprüfen Sie sie. Sie können sehen, dass einige Beschriftungen fast 100% "Fläche unter der Kurve" haben, während einige Beschriftungen weniger von dieser Fläche haben. Dieses Tutorial führte Sie in die Integration von TensorBoard in PyTorch ein. Natürlich kann das Jupyter-Notebook allein dasselbe tun wie das TensorBoard, aber mit dem TensorBoard können Sie es visuell sehen.

7. Schließlich

Das Obige ist "Visualisieren von Modellen, Daten und Training mit Tensorboard". Ich habe gelernt, wie man Tensorboard mit PyTorch benutzt. Das nächste Mal möchte ich mit dem "V Torch Vision Object Detection Finetuning Tutorial" fortfahren.

Geschichte

2020/10/15 Erste Ausgabe veröffentlicht