[Tutoriel PyTorch ⑦] Visualisation des modèles, des données et de la formation avec Tensorboard

introduction

Ceci est le 7ème volet de PyTorch Tutoriel officiel après Dernière fois. Cette fois, nous allons procéder à la Visualisation des modèles, des données et de la formation avec TensorBoard.

Visualizing Models, Data, And Training With Tensorboard

Dans 60 Minute Blitz, nous avons vu comment construire un réseau neuronal de base et s'entraîner avec des données d'entraînement. Cette fois, voyons comment visualiser la situation d'entraînement et vérifier si l'entraînement est en cours. La visualisation utilise TensorBoard. PyTorch peut tirer parti de TensorBoard, un outil pour entraîner les réseaux de neurones et visualiser les résultats.

Ce tutoriel utilise les données Fashion-MNIST de torchvision.datasets pour illustrer certaines de ses fonctionnalités. Apprendre à:

1. Lisez les données et effectuez les conversions appropriées. (Presque le même que le tutoriel précédent)
2. Configurez TensorBoard.
3. Écrivez à TensorBoard.
4. Utilisez TensorBoard pour visualiser l'architecture du modèle.
5. Utilisez TensorBoard pour visualiser les prévisions et la précision pendant l'entraînement.

Plus précisément, ce qui suit peut être vu à partir des cinq points ci-dessus.

• Comment inspecter les données de formation
• Comment suivre les performances du modèle pendant la formation du modèle
• Comment évaluer les performances d'un modèle après l'entraînement.

CIFAR-10 Commencez avec un code similaire au tutoriel.

%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

#Définition de la transformation
transform = transforms.Compose(
    [transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))])

#base de données
trainset = torchvision.datasets.FashionMNIST('./data',
    download=True,
    train=True,
    transform=transform)
testset = torchvision.datasets.FashionMNIST('./data',
    download=True,
    train=False,
    transform=transform)

#Chargeur de données
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)

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

#Fonction d'aide à l'affichage d'image
# (au dessous de`plot_classes_preds`Utilisé dans les fonctions)
def matplotlib_imshow(img, one_channel=False):
    if one_channel:
        img = img.mean(dim=0)
    img = img / 2 + 0.5     #Dénormalisé
    npimg = img.numpy()
    if one_channel:
        plt.imshow(npimg, cmap="Greys")
    else:
        plt.imshow(np.transpose(npimg, (1, 2, 0)))

CIFAR-10 Définit un modèle similaire au tutoriel, mais avec un canal au lieu de trois images et 28x28 au lieu de 32x32. Je vais le changer un peu pour le faire.

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

Définissez le même optimiseur et la même fonction de perte qu'auparavant.

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

1.TensorBoard setup

Ensuite, configurez le TensorBoard. Définissez un SummaryWriter qui est un objet pour importer TensorBoard depuis torch.utils et écrire dans TensorBoard.

from torch.utils.tensorboard import SummaryWriter

#Le répertoire des journaux par défaut est"runs"Cependant, vous pouvez le spécifier ici.
writer = SummaryWriter('runs/fashion_mnist_experiment_1')

Exécutez simplement cette ligne et elle créera le répertoire "runs / fashion_mnist_experiment_1".

2.Writing to TensorBoard

Ensuite, utilisez make_grid pour écrire l'image dans TensorBoard.

#Obtenez une image d'entraînement aléatoire
dataiter = iter(trainloader)
images, labels = dataiter.next()

#Créer une grille d'images
img_grid = torchvision.utils.make_grid(images)

#Afficher l'image
matplotlib_imshow(img_grid, one_channel=True)

#Ecrire au tableau des tenseurs
writer.add_image('four_fashion_mnist_images', img_grid)

(Non mentionné dans ce didacticiel, mais si vous souhaitez utiliser Tensorboard avec Google Colaboratory, chargez l'extension de bloc-notes TensorBoard.)

%load_ext tensorboard

#Lorsque vous utilisez Tensorboard avec Google Colaboratory, exécutez Tensorboard avec des commandes magiques.
#tensorboard --logdir=runs
%tensorboard --logdir=runs

Lorsqu'il est exécuté dans un environnement local https：//localhost:6006 Vous pouvez parcourir les écrans de tensorboard suivants avec. J'ai pu exécuter TensorBoard. Nous examinerons les fonctionnalités de TensorBoard ci-dessous.

3.Inspect the model using TensorBoard

L'une des forces de TensorBoard est la possibilité de visualiser des structures de modèles complexes. Visualisons le modèle créé.

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

Après avoir mis à jour le TensorBoard, vous verrez un onglet «GRAPHIQUES» semblable au suivant. Vous pouvez double-cliquer sur Net pour le développer et voir les composants individuels qui composent le modèle. TensorBoard a une fonction très utile pour visualiser des données de grande dimension telles que des données d'image dans un espace de faible dimension. Cela sera expliqué ci-dessous.

4.Adding a “Projector” to TensorBoard

Vous pouvez visualiser la représentation en basse dimension des données en haute dimension via la méthode add_embedding.

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

#Fonction d'assistance
def select_n_random(data, labels, n=100):
    '''
Sélectionnez n points de données aléatoires et leurs étiquettes correspondantes dans l'ensemble de données
    '''
    assert len(data) == len(labels)

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

#Sélectionnez une image aléatoire et son index cible
images, labels = select_n_random(trainset.data, trainset.targets)

#Obtenez l'étiquette de classe pour chaque image
class_labels = [classes[lab] for lab in labels]

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

L'onglet PROJECTEUR de TensorBoard affiche ces 100 images. Chaque image a 784 dimensions, mais elle est projetée dans un espace à 3 dimensions. Vous pouvez faire pivoter la projection tridimensionnelle en la faisant glisser. Si vous sélectionnez «Couleur: Étiquette» en haut à gauche et activez «Mode nuit», l'arrière-plan sera noir et l'image sera plus facile à voir.

Vous savez maintenant comment utiliser TensorBoard pour visualiser vos données. Voyons ensuite comment visualiser la formation et l'évaluation avec TensorBoard.

5.Tracking model training with TensorBoard

Dans le didacticiel précédent (https://qiita.com/sudominoru/items/61f57946799e67cedd47), nous avons simplement imprimé la valeur de perte du modèle toutes les 2000 itérations. Dans ce didacticiel, nous enregistrerons la valeur de perte dans TensorBoard et afficherons la valeur prédite avec la fonction plot_classes_preds.

#Fonction d'assistance
def images_to_probs(net, images):
    '''
Renvoie la valeur prédite et sa probabilité avec le modèle entraîné et l'image comme arguments
    '''
    output = net(images)
    #Convertir la probabilité de sortie en classe de prédiction
    _, 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):
    '''
Génère un diagramme matplotlib avec le modèle entraîné, l'image et les données de l'enseignant comme arguments.
Il affiche l'étiquette la plus probable que le modèle a prédit et si la prédiction est correcte.
Coloriez le.
    「images_to_Utilisez la fonction "probs".
    '''
    preds, probs = images_to_probs(net, images)
    #Tracez l'image par lots avec les étiquettes prévues et réelles.
    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

Apprenez à utiliser le même modèle que dans le didacticiel précédent (https://qiita.com/sudominoru/items/61f57946799e67cedd47), mais écrivez dans TensorBoard tous les 1000 lots au lieu d'imprimer sur la console. (Fonction Add_scalar) De plus, la valeur prédite pendant l'apprentissage et l'image prédite sont émises. (Fonction Add_figure)

running_loss = 0.0
for epoch in range(1):  #Boucle le jeu de données plusieurs fois

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

        #Obtenez les commentaires. Les données sont[inputs, labels]Est une liste de
        inputs, labels = data

        #Initialiser le dégradé
        optimizer.zero_grad()

        #Propagation vers l'avant+Rétropropagation+optimisation
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 1000 == 999:    #Tous les 1000 lots

            # ...Enregistrez la valeur de la perte tous les 1000 lots
            writer.add_scalar('training loss',
                            running_loss / 1000,
                            epoch * len(trainloader) + i)

            # ...Consigner les prédictions du modèle dans des diagrammes Matplotlib dans un mini-lot aléatoire
            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

Sur l'onglet SCALARS, vous pouvez voir la valeur de la perte pendant l'entraînement. En outre, vous pouvez voir les prédictions du modèle effectuées tous les 1000 lots. Accédez à l'onglet IMAGES et faites défiler sous la visualisation prédictions vs réelles. En regardant cela, après seulement 3000 séances d'entraînement, le modèle a déjà classé des chemises, des baskets, des manteaux et plus encore. Cependant, la probabilité n'est pas aussi élevée que dans la seconde moitié de la formation. Dans le tutoriel précédent (https://qiita.com/sudominoru/items/61f57946799e67cedd47), nous avons vérifié le taux de précision de chaque étiquette après l'entraînement. Ici, nous utilisons TensorBoard pour tracer la courbe PR pour chaque classe.

6.Assessing trained models with TensorBoard

# 1. test_size x num_Obtenez une prédiction de probabilité avec Tensor of Class
# 2. test_Obtenez des prédictions avec Tensor of Size
#Prend jusqu'à 10 secondes pour fonctionner
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)

#Fonction d'assistance
def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0):
    '''
"Classe" de 0 à 9_Prenez "index" et tracez la courbe PR correspondante
    '''
    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()

#Tracer la courbe PR
for i in range(len(classes)):
    add_pr_curve_tensorboard(i, test_probs, test_preds)

L'onglet PR CURVES s'affiche. Ouvrons la courbe PR de chaque étiquette et vérifions-la. Vous pouvez voir que certaines étiquettes ont presque 100% de «surface sous la courbe», tandis que certaines étiquettes ont moins de cette surface. Ce tutoriel vous a présenté l'intégration de TensorBoard avec PyTorch. Bien sûr, le Jupyter Notebook seul peut faire la même chose que le TensorBoard, mais avec le TensorBoard, vous pouvez le voir visuellement.

7. Enfin

Ce qui précède est "Visualisation des modèles, des données et de la formation avec Tensorboard". J'ai appris à utiliser Tensorboard avec PyTorch. La prochaine fois, j'aimerais continuer avec le "Tutoriel de réglage fin de détection d'objets V Torch Vision".

Histoire

2020/10/15 Première édition publiée