Reconstruction d'images animées par Autoencoder en utilisant 3D-CNN

Aperçu

Comment va tout le monde. Je pense que l'épidémie de la nouvelle infection à coronavirus s'est un peu atténuée et que de nombreuses personnes retournent progressivement au travail ou à l'école. Maintenant, cette fois, je voudrais me concentrer sur la tâche de reconstruction qui utilise à nouveau le modèle de génération. En particulier, ** je vais essayer de reconstruire la "vidéo". ** ** (Ce que vous pouvez comprendre dans cet article, ce sont les résultats expérimentaux et la prise en compte de la méthode de reconstruction à l'aide de la ** convolution 3D basée sur un codeur-décodeur, qui peut être étendue pour détecter des anomalies dans les images en mouvement, et ** des théories telles que des formules mathématiques. Je ne suivrai pas l'arrière-plan.) ** Toute cette implémentation est disponible sur ici. ** Mis en œuvre par PyTorch.

Dans l'article précédent, Vérification et implémentation de la méthode de reconstruction vidéo à l'aide de GRU et Autoencoder, nous avons considéré le modèle suivant.

図4.png

La raison pour laquelle j'ai pensé à ce modèle est que les variables latentes peuvent être exprimées sous forme de données en série. En d'autres termes, 3d-conv encode une vidéo en une seule variable latente, mais c'est exagéré, n'est-ce pas? C'était la motivation. En fait, il est difficile de «reconstruire» la 3D-conv dans certains articles. Il y a une mention. (D'un autre côté, le CVPR récent devrait utiliser la conversion 3D lorsqu'une grande quantité de données est collectée dans la reconnaissance vidéo, mais comme il s'agit d'une histoire d'un modèle d'identification, ce sera un domaine différent de cette tâche de génération.)

Maintenant, cependant, je voulais * confirmer expérimentalement que la reconstruction de 3D-conv fonctionnerait. ** La reconnaissance vidéo fonctionne-t-elle, mais la reconstruction fonctionne-t-elle vraiment? Bien que je l'ai compris théoriquement, je me suis toujours demandé. C'est pourquoi je suis venu écrire cet article. Je vais commencer par l'explication du modèle immédiatement.

Modèle de reconstruction vidéo

Le modèle à mettre en œuvre cette fois est illustré ci-dessous.

40.png

$ \ boldsymbol {x_1, x_2, ..., x_T} $ signifie une vidéo d'une longueur de T, et $ \ boldsymbol {x_t} $ est chaque image. L'encodeur utilisant 3D-CNN reçoit l'image en mouvement et la mappe à un point de $ \ boldsymbol {z_T} $. En utilisant cela, la procédure consiste à cartographier l'espace d'observation avec le décodeur. En tant que tâche de reconstruction, les paramètres sont optimisés pour minimiser la différence entre l'entrée et la sortie.

Je pense que la méthode utilisant 3D-CNN est très simple et facile à comprendre. Il est possible d'extraire les caractéristiques du temps et de l'espace à la fois ** par convolution tridimensionnelle sans mordre le modèle de série temporelle. En ce qui concerne le traitement 3D-CNN, il y a d'autres articles de commentaires, donc je vais passer à ce lol

Apprentissage / vérification du modèle

** Le flux de reconstruction est le suivant. ** **

  1. Préparez un ensemble de données sur l'action humaine
  2. Apprenez le codeur automatique 3D-CNN
  3. Reconstruisez la vidéo en utilisant le modèle appris en 2.

1.human action dataset Utilisez le jeu de données familier sur l'action humaine. Ces données ont été utilisées pour la vérification dans un modèle de génération vidéo appelé MocoGAN, et comme son nom l'indique, elles montrent des gens marchant et agitant.

epoch_real_60.png epoch_real_30.png

Vous pouvez le télécharger depuis ici. (L'image ci-dessus est également tirée des données de ce lien.)

2. Apprentissage du codeur automatique 3D-CNN

Ensuite, nous entraînerons le modèle en utilisant les données ci-dessus. La fonction de perte est MSE, ce qui minimise naturellement l'erreur entre l'entrée et la sortie. Pour plus de détails sur le modèle, voir ici. Voici la mise en œuvre du modèle.

network.py



class ThreeD_conv(nn.Module):
    def __init__(self, opt, ndf=64, ngpu=1):
        super(ThreeD_conv, self).__init__()
        self.ngpu = ngpu
        self.ndf = ndf
        self.z_dim = opt.z_dim
        self.T = opt.T
        self.image_size = opt.image_size
        self.n_channels = opt.n_channels
        self.conv_size = int(opt.image_size/16)

        self.encoder = nn.Sequential(
            nn.Conv3d(opt.n_channels, ndf, 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf),
            nn.ReLU(inplace=True),
            nn.Conv3d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf * 2),
            nn.ReLU(inplace=True),
            nn.Conv3d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf * 4),
            nn.ReLU(inplace=True),
            nn.Conv3d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf * 8),
            nn.ReLU(inplace=True),
        )
        self.fc1 = nn.Sequential(
            nn.Linear(int((ndf*8)*(self.T/16)*self.conv_size*self.conv_size),self.z_dim ),#6*6
            nn.ReLU(inplace=True),
        )
        self.fc2 = nn.Sequential(
            nn.Linear(self.z_dim,int((ndf*8)*(self.T/16)*self.conv_size*self.conv_size)),#6*6
            nn.ReLU(inplace=True),
        )
        self.decoder = nn.Sequential(
            nn.ConvTranspose3d((ndf*8), ndf*4, 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf * 4),
            nn.ReLU(inplace=True),
            nn.ConvTranspose3d(ndf*4, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf * 2),
            nn.ReLU(inplace=True),
            nn.ConvTranspose3d(ndf * 2, ndf , 4, 2, 1, bias=False),
            nn.BatchNorm3d(ndf),
            nn.ReLU(inplace=True),
            nn.ConvTranspose3d(ndf , opt.n_channels, 4, 2, 1, bias=False),
            nn.Tanh(),
        )

L'apprentissage a atteint 5 000 itr et la perte a changé comme suit. Il est devenu presque 0 en seconde période, et je ne vois pas beaucoup de changement, mais j'ai l'impression qu'il a convergé en toute sécurité.

image.png

3. Reconstruction de la vidéo par modèle

Faites des inférences à l'aide du modèle. Dans l'implémentation ci-dessus, le résultat de la reconstruction est enregistré dans generated_videos dans le dossier logs pour chaque point de contrôle spécifié par l'argument. Comme nous l'avons appris, nous avons montré le comportement suivant. La ligne supérieure de chaque itr est l'entrée et la ligne inférieure est la sortie.

--0 ses yeux Bien sûr, il ne peut pas du tout être reconstruit. real_itr0_no1.png recon_itr0_no1.png

--1 000 itrth Bien qu'il soit flou, il a une forme humaine. real_itr1000_no0.png recon_itr1000_no0.png

--4000 yeux C'est un peu clair, mais il semble que le flou et le flou se soient produits, et les détails tels que les mains humaines n'ont pas été reproduits. real_itr4000_no1.png recon_itr4000_no1.png De plus, comparons les résultats avec GRU-AE. Ce qui suit est le résultat de la reconstruction par GRU-AE. Il s'agit d'une comparaison des méthodes de l'article précédent dans les mêmes conditions que ci-dessus. L'œil 0 itr est omis.

-500 yeux itr Impression que ce n'est pas trop terrible. Ça va bien? real_itr500_no0.png recon_itr500_no0.png

―― 1500 yeux Oh. C'est une bonne idée. real_itr1500_no2.png recon_itr1500_no2.png

--4000 yeux Il est devenu indiscernable pendant un moment qui était le vrai. Si vous regardez de près, cela peut être flou, mais lol real_itr4000_no2.png recon_itr4000_no2.png

Résumé

Cette fois, j'ai essayé de reconstruire une image en mouvement en utilisant 3DCNN-AE. En conséquence, c'est comme prévu, mais la vidéo générée n'est pas bonne. Ce n'est pas que le mouvement ne puisse pas être reproduit, mais il est inférieur à GRU-AE en termes de netteté de chaque image. Dans les articles sur le système de détection des anomalies, de nombreuses voix considèrent le 3D-CNN comme un problème, et cette fois j'ai pu le comprendre expérimentalement. D'autre part, ** 3D-CNN est une star prometteuse dans les tâches de reconnaissance. ** Dans un environnement où une grande quantité de données peut être collectée, il semble que la reconnaissance vidéo soit traitée comme un favori plutôt qu'une approche 2D comme GRU. Cependant, la tâche de génération est différente. Il y a peu de données, et il semble que nous ne pouvons pas acquérir de «fonctionnalités fortes» comme celles avec les enseignants. Il semble que le jour où la 3D-conv sera utilisée comme favori pour la détection d'anomalies vidéo est toujours à venir. .. .. Merci d'avoir regardé jusqu'à la fin.

Recommended Posts

Reconstruction d'images animées par Autoencoder en utilisant 3D-CNN
Vérification et mise en œuvre de la méthode de reconstruction vidéo en utilisant GRU et Autoencoder
Approximation de bas rang des images par HOSVD étape par étape
Approximation de bas rang de l'image par décomposition de Tucker
Détection de visage en collectant des images d'Angers.
Détection d'anomalies à l'aide de MNIST par Autoencoder (PyTorch)
Classification des images de guitare par apprentissage automatique Partie 1
Approximation de bas rang des images par décomposition de singularité
Approximation de bas rang des images par HOSVD et HOOI
Téléchargement anonyme d'images à l'aide de l'API Imgur (à l'aide de Python)
Classification des images de guitare par apprentissage automatique, partie 2
Reconstruction de l'affiche de propagande soviétique par PyTorch x VAEGAN
Optical Flow, l'image dynamique capturée par OpenCV
Essayez de projeter la conversion d'image en utilisant OpenCV avec Python
J'ai comparé l'identité des images par moment Hu
Collecte et automatisation d'images érotiques à l'aide du deep learning