[PYTHON] 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.
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.
- Pour comparaison avec la méthode utilisant GRU, il y a des chevauchements avec l'article précédent, mais pardonnez-moi s'il vous plaît.
Modèle de reconstruction vidéo
Le modèle à mettre en œuvre cette fois est illustré ci-dessous.
$ \ 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. ** **
- Préparez un ensemble de données sur l'action humaine
- Apprenez le codeur automatique 3D-CNN
- 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.
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é.
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.
--1 000 itrth
Bien qu'il soit flou, il a une forme humaine.
--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.
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?
―― 1500 yeux
Oh. C'est une bonne idée.
--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
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