Essayez Auto Encoder avec Pytorch

en premier

AutoEncoder est un type d'apprentissage non supervisé dans l'apprentissage automatique. La détection d'anomalies est connue comme un exemple d'application. Cette fois, je voudrais essayer AutoEncoedr pour mnist en utilisant CNN (réseau de neurones convolutifs). Je ne sais pas quel numéro brasser, mais c'est un mémorandum d'étude de Pytorch. Cette fois, je me suis référé à ici

À propos d'AutoEncoder

Voici une compréhension approximative d'AutoEncoder: オートエンコーダ.png Ajustez l'encodeur et le décodeur de sorte que le contenu des données d'entrée et de sortie soit égal. Si les données d'entrée sont différentes des données habituelles, il n'est pas possible de créer des données de sortie égales aux données d'entrée. Par conséquent, s'il y a une grande différence entre les données d'entrée et les données de sortie, cela peut être jugé anormal (il semble).

Entraine toi

L'environnement est python ver3.6.9 pytorch ver1.3.1 numpy ver1.17.4

Tout d'abord, chargez mnist. Dans le code (en tant que passe-temps personnel), l'apprentissage scicit est utilisé pour lire les données au format ndarray, mais la vision de la torche est utilisée pour les lire au format Tensor. 7 000 images de données d'image à 0 numéro sont extraites, et 6 000 d'entre elles sont utilisées pour l'apprentissage.


import numpy as np
import matplotlib.pyplot as plt
import torch
from torch import nn, optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.datasets import fetch_openml

#Télécharger les données mnist
mnist =  fetch_openml('mnist_784', version=1, data_home='data/src/download/')  
X, y = mnist["data"], mnist["target"]
X_0 = X[np.int32(y) == 0]        #Extraire uniquement lorsque la donnée cible est 0
X_0 = (2 *X_0) / 255.0 - 1.0     #max 1.0 min -1.Convertir en 0

X_0 = X_0.reshape([X_0.shape[0], 1, 28, 28])
X_0 = torch.tensor(X_0, dtype = torch.float32)
X_0_train, X_0_test = X_0[:6000, :, :, :], X_0[6000:, :, :, :]
train_loader = DataLoader(X_0_train, batch_size = 50)

Ensuite, créez un réseau à l'aide de Pytorch. L'encodeur utilise nn.Conv2d pour la convolution normale. L'image d'entrée était de 1x28x28 avec 784 dimensions, mais après avoir traversé l'encodeur, elle est dimensionnellement compressée à 4x7x7 avec 196 dimensions. Le décodeur utilise nn.ConvTranspose2d, qui est l'inverse de la convolution normale (?). Ensuite, il revient finalement à 784 dimensions de 1x28x28.

class ConvAutoencoder(nn.Module):
    def __init__(self):
        super(ConvAutoencoder, self).__init__()
        #Encoder Layers
        self.conv1 = nn.Conv2d(in_channels = 1, out_channels = 16,
                               kernel_size = 3, padding = 1)
        self.conv2 = nn.Conv2d(in_channels = 16, out_channels = 4,
                               kernel_size = 3, padding = 1)
        #Decoder Layers
        self.t_conv1 = nn.ConvTranspose2d(in_channels = 4, out_channels = 16,
                                          kernel_size = 2, stride = 2)
        self.t_conv2 = nn.ConvTranspose2d(in_channels = 16, out_channels = 1,
                                          kernel_size = 2, stride = 2)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, 2)
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        #Affiche la dimension lorsque i feuilles d'images monochromes 28x28 sont entrées dans le commentaire
        #encode#                          #in  [i, 1, 28, 28] 
        x = self.relu(self.conv1(x))      #out [i, 16, 28, 28]  
        x = self.pool(x)                  #out [i, 16, 14, 14]
        x = self.relu(self.conv2(x))      #out [i, 4, 14, 14]
        x = self.pool(x)                  #out [i ,4, 7, 7]
        #decode#
        x = self.relu(self.t_conv1(x))    #out [i, 16, 14, 14]
        x = self.sigmoid(self.t_conv2(x)) #out [i, 1, 28, 28]
        return x

Maintenant que nous avons un réseau, apprenons. Le calcul loss_fn compare l'image d'entrée avec l'image de sortie du réseau.

def train_net(n_epochs, train_loader, net, optimizer_cls = optim.Adam,
              loss_fn = nn.MSELoss(), device = "cpu"):
    """
    n_époques… Nombre de formations
net… réseau
    device … "cpu" or "cuda:0"
    """
    losses = []         #loss_Enregistrer la transition de fonction
    optimizer = optimizer_cls(net.parameters(), lr = 0.001)
    net.to(device)
    
    for epoch in range(n_epochs):
        running_loss = 0.0  
        net.train()         #Mode réseau d'entraînement
    
        for i, XX in enumerate(train_loader):
            XX.to(device)
            optimizer.zero_grad()
            XX_pred = net(XX)             #Prédire sur le réseau
            loss = loss_fn(XX, XX_pred)   #Données de prédiction et prédiction des données originales
            loss.backward()
            optimizer.step()              #Mise à jour du dégradé
            running_loss += loss.item()
        
        losses.append(running_loss / i)
        print("epoch", epoch, ": ", running_loss / i)
        
    return losses

losses = train_net(n_epochs = 30,
                   train_loader = train_loader,
                   net = net)

Représentez graphiquement la perte de sortie avec matplotlib. loss.png

Prédisez sur le net en utilisant des données qui ne sont pas utilisées pour la formation. Quand 0 images sont entrées dans le net

img_num = 4
pred = net(X_0_test[img_num:(img_num + 1)])
pred = pred.detach().numpy()
pred = pred[0, 0, :, :]

origin = X_0_test[img_num:(img_num + 1)].numpy()
origin = origin[0, 0, :, :]

plt.subplot(211)
plt.imshow(origin, cmap = "gray")
plt.xticks([])
plt.yticks([])
plt.text(x = 3, y = 2, s = "original image", c = "red")

plt.subplot(212)
plt.imshow(pred, cmap = "gray")
plt.text(x = 3, y = 2, s = "output image", c = "red")
plt.xticks([])
plt.yticks([])
plt.savefig("0_auto_encoder")
plt.show()

0_auto_encoder.png Le haut est l'image d'entrée et le bas est l'image de sortie. 0 est bien reproduit.

Lorsque j'ai entré l'image de 6, je ne pouvais pas bien reproduire 6. Si vous ne parvenez pas à bien reproduire les données, vous pouvez juger qu'elles sont anormales (probablement). 6_auto_encoder.png

À propos, ce modèle a été capable d'apprendre relativement rapidement, même sur un ordinateur portable, alors j'aimerais l'essayer même dans une couche plus profonde.

Recommended Posts

Essayez Auto Encoder avec Pytorch
Essayez d'implémenter XOR avec PyTorch
Jouez avec PyTorch
Validation croisée avec PyTorch
À partir de PyTorch
Essayez de générer une image avec aliénation
Essayez de monter votre visage avec le test AB
Essayez de créer un environnement pour MayaPython avec VisualStudioCode
Essayez de gratter avec Python.
Utilisez RTX 3090 avec PyTorch
Essayez la segmentation sémantique (Pytorch)
Essayez SNN avec BindsNET
Installer la diffusion de la torche avec PyTorch 1.7
Essayez la régression avec TensorFlow
J'ai eu une erreur lors de l'utilisation de Tensorboard avec Pytorch
Essayez de défier le sol par récursif
Essayez l'optimisation des fonctions avec Optuna
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez d'utiliser PythonTex avec Texpad.
Créer un environnement avec virtualenv
Essayez la détection des bords avec OpenCV
Créer une API avec Django
Essayez d'implémenter RBM avec chainer.
Essayez Google Mock avec C
Essayez d'utiliser matplotlib avec PyCharm
Essayez de programmer avec un shell!
Essayez la programmation GUI avec Hy
Essayez la sortie Python avec Haxe 3.2
Essayez l'opération matricielle avec NumPy
Créer un œuf avec python
Essayez d'exécuter CNN avec ChainerRL
Essayez différentes choses avec PhantomJS
Essayez le Deep Learning avec FPGA
Implémenter le GPU PyTorch + avec Docker
Prédiction de la moyenne Nikkei avec Pytorch 2
Démineur d'apprentissage automatique avec PyTorch
PyTorch avec AWS Lambda [importation Lambda]
Essayez d'exécuter Python avec Try Jupyter
Essayez d'implémenter le parfum avec Go
Prédiction de la moyenne Nikkei avec Pytorch
Essayez Selenium Grid avec Docker
Effectuer un fractionnement stratifié avec PyTorch
Essayez la reconnaissance faciale avec Python
Essayez OpenCV avec Google Colaboratory
J'ai créé Word2Vec avec Pytorch
Essayez le machine learning à la légère avec Kaggle
Essayez TensorFlow MNIST avec RNN
Essayez de créer Jupyter Hub avec Docker
Essayez d'utiliser le folium avec anaconda
Essayez d'implémenter la régression linéaire à l'aide de Pytorch avec Google Colaboratory
Essayez de créer un visualiseur de différence de chemin d'exécution avec angr + bingraphvis
Essayez d'extraire une chaîne de caractères d'une image avec Python3
Essayez le Deep Learning avec les concombres FPGA-Select
Essayez de gratter avec Python + Beautiful Soup
Découpez une image avec python
Renforcer l'apprentissage 13 Essayez Mountain_car avec ChainerRL.
Charger les modules Django avec un interpréteur
[Tutoriel PyTorch ⑤] Apprentissage de PyTorch avec des exemples (Partie 2)
Paramètre de fonction uniquement pour l'astérisque '*'
Apprenez avec les réseaux convolutifs PyTorch Graph
Essayez d'exploiter Facebook avec Python