Détection d'anomalies à l'aide de MNIST par Autoencoder (PyTorch)

Aperçu

Bonjour à tous. La déclaration d'urgence a finalement été levée, mais la situation est toujours imprévisible. .. Il semble que je vais continuer à rester à la maison.

Maintenant, cette fois, je voudrais implémenter et vérifier un programme de détection d'anomalies pour MNIST en utilisant un simple Autoencoder. Plus précisément, le modèle est le suivant.

(Ce que vous pouvez comprendre dans cet article est le flux de base de l'Autoencoder et de la détection d'anomalies, le flux de détection d'anomalies MNIST à l'aide de PyTorch et ses résultats de vérification.)

Qiita a déjà publié plusieurs articles sur la détection d'anomalies à l'aide de MNIST. Alors, où est la demande pour cet article? En fait, je pense que le point mis en œuvre par *** PyTorch est différent des autres ***.

Quand je google, c'est un exemple d'implémentation utilisant Keras, mais depuis que je suis récemment passé à PyTorch, je me demandais si je pouvais implémenter PyTorch, mais je ne pouvais pas le trouver, alors je l'ai implémenté moi-même. .. Ensuite, je viendrai à l'explication.

*** Tout le code implémenté cette fois-ci est disponible sur ici. *** ***

Autoencoder et détection des anomalies

Jetons un rapide coup d'œil à la façon dont Autoencoder est appliqué aux tâches de détection d'anomalies. (Si vous savez, voir le chapitre après la mise en œuvre)

À propos d'Autoencoder

La structure du modèle est illustrée ci-dessous.

L'idée d'Autoencoder est très simple, c'est un modèle qui encode des données de grande dimension avec des images, etc. en variables latentes à l'aide d'un encodeur et décode l'image à l'aide d'un décodeur. Quels sont les avantages du mappage vers un espace latent? Ceci est basé sur l'hypothèse de la diversité. Voir la distribution ci-dessous.

Source: [ici](https://blog.albert2005.co.jp/2014/12/11/%E9%AB%98%E6%AC%A1%E5%85%83%E3%83%87% E3% 83% BC% E3% 82% BF% E3% 81% AE% E5% 8F% AF% E8% A6% 96% E5% 8C% 96% E3% 81% AE% E6% 89% 8B% E6% B3% 95% E3% 82% 92 rouleau suisse% E3% 82% 92% E4% BE% 8B% E3% 81% AB% E8% A6% 8B% E3% 81% A6% E3% 81% BF% E3% 82% 88 /)

Ce qui précède est appelé la distribution des rouleaux suisses. L'image est en trois dimensions, mais considérez-la comme un exemple de données de grande dimension. Si vous regardez de près, vous pouvez voir qu'il y a certaines parties où les données sont assez rares. Si cela peut être mappé en deux dimensions (une image qui s'étend sur un plan), on peut en déduire que la distribution d'origine peut être exprimée dans un espace de faible dimension. Plus généralement, les données qui existent dans l'espace dimensionnel supérieur sont considérées comme une multidimensionnelle de faible dimension, ce que l'on appelle l'hypothèse multidimensionnelle.

Revenant à l'histoire d'Autoencoder, l'encodeur a mappé d'un espace de grande dimension à un espace latent de faible dimension. En d'autres termes, les «caractéristiques» des données de grande dimension telles que les images sont extraites et traitées comme des variables latentes. Les données originales sont décodées à partir de cette "caractéristique" de faible dimension.

Application à la détection d'anomalies

Ce framework Autoencoder est souvent appliqué dans la détection d'anomalies [1]. Le but de la détection d'anomalies est de reconnaître si le modèle est "normal" ou "anormal" pour les données d'entrée. Ce paramètre de problème est un cadre pour la reconnaissance de formes dans l'apprentissage supervisé qui est souvent utilisé, mais malheureusement, dans de nombreuses usines où la détection d'anomalies est réellement appliquée (inspection visuelle), les données d'anomalies ne sont généralement pas collectées. Par conséquent, une approche supervisée telle que la reconnaissance de formes ne peut pas être appliquée. Cependant, en général, une grande quantité de données «normales» peut être obtenue sur des sites tels que les usines. Un autoencoder sera introduit pour profiter de cela et l'intégrer dans la "détection d'anomalies". Comme expliqué ci-dessus, Autoencoder peut extraire des caractéristiques de la distribution de données de grande dimension et les mapper à un espace latent de faible dimension.

En d'autres termes, *** Vous pouvez acquérir les caractéristiques des données normales en entraînant le modèle à l'aide d'une grande quantité de données normales. *** A partir de là, si vous saisissez des données "normales" dans le modèle, le décodeur pourra bien entendu décoder l'entrée d'origine. Cependant, lorsque des données "anormales" sont entrées, elles ne peuvent pas être correctement décryptées car elles n'acquièrent pas la fonction qui peut exprimer les données anormales. La détection d'anomalies est effectuée à l'aide de cette astuce. Plus précisément, les anomalies peuvent être détectées en prenant une différence entre *** entrée et sortie et en la calculant comme le degré d'anomalie. *** *** De plus, la plupart des exemples d'application pour la détection d'anomalie réelle sont «sans enseignant» ou «avec semi-enseignant» qui utilise une petite quantité de données d'anomalie.

Ensuite, j'espère que vous approfondirez votre compréhension en vérifiant réellement la mise en œuvre et les expériences de MNIST.

Implémentation / partie de chargement MNIST

La détection d'anomalies est effectuée à l'aide de MNIST (ensemble de données de nombres manuscrits). Cette fois, sur 0 à 9 possédés par MNIST, ceux étiquetés avec *** "1" seront appris comme des données normales. *** *** Ensuite, nous utiliserons les données étiquetées «9» comme données anormales et vérifierons si elles peuvent être détectées.

Tout d'abord, vous pouvez facilement charger des données MNIST en utilisant le module MNIST de la classe de jeu de données de PyTorch. Cependant, comme tel est le cas, toutes les données de 0 à 9 existent, il est donc nécessaire de restreindre cela à seulement celles avec des étiquettes arbitraires. J'ai défini les classes suivantes.

main.py

class Mnisttox(Dataset):
    def __init__(self, datasets ,labels:list):
        self.dataset = [datasets[i][0] for i in range(len(datasets))
                        if datasets[i][1] in labels ]
        self.labels = labels
        self.len_oneclass = int(len(self.dataset)/10)

    def __len__(self):
        return int(len(self.dataset))

    def __getitem__(self, index):
        img = self.dataset[index]
        return img,[]

Dans la méthode d'initialisation, seules les données correspondant à la liste de toute étiquette donnée en argument sont passées en tant que variable dans la classe. Le reste est le même comportement que la classe Dataset normale.

L'autoencoder essentiel est défini comme suit.

main.py

class Autoencoder(nn.Module):
    def __init__(self,z_dim):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(28 * 28, 256),
            nn.ReLU(True),
            nn.Linear(256, 128),
            nn.ReLU(True),
            nn.Linear(128, z_dim))

        self.decoder = nn.Sequential(
            nn.Linear(z_dim, 128),
            nn.ReLU(True),
            nn.Linear(128, 256),
            nn.ReLU(True),
            nn.Linear(256, 28 * 28),
            nn.Tanh()
        )

    def forward(self, x):
        z = self.encoder(x)
        xhat = self.decoder(z)
        return xhat

Chacun est un simple à trois couches. L'apprentissage prend un MSE entre l'entrée et la sortie, et en minimisant cela, il est appris à reconstruire l'entrée. Maintenant, commençons l'expérience.

Expérience / discussion

Comme mentionné ci-dessus, les données d'apprentissage ne sont que l'image de "1", et environ 6 000 données d'image sont entraînées. Pour les données de test, mélangez les données de «1» et «9» et vérifiez si «9» peut être correctement identifié comme une anomalie. La valeur absolue de la différence entre l'entrée et la sortie est utilisée pour définir le degré d'anomalie.

La transition de la perte est illustrée ci-dessous.

L'entrée du modèle (en haut), sa sortie (au milieu) et son image de différence (en bas) sont indiquées ci-dessous.

Comme prévu, vous pouvez voir que l'image apprise de "1" a été reconstruite avec succès, mais que les données de "9" mélangées en tant que données anormales n'ont pas été correctement reconstruites. Cette fois, c'était un modèle avec seulement une simple couche entièrement connectée, mais cela semble avoir fonctionné.

De plus, si vous faites attention au score de la ligne inférieure, vous pouvez voir que la valeur devient grande lorsque des données anormales sont entrées. En fait, la détection d'anomalie est effectuée en définissant un seuil pour le degré d'anomalie. Dans la plupart des cas, la fixation du seuil est basée sur l'actualité conçue par un expert.

Résumé

Cette fois, nous avons implémenté et vérifié la détection d'anomalies non supervisée par MNIST à l'aide de PyTorch. Nous avons également expliqué le flux de base de la détection d'anomalies à l'aide de l'Autoencoder. Cet article est devenu subtil en termes de nouveauté technique, mais je pense qu'il y a une demande en termes de détection d'anomalies MNIST par PyTorch (je suis peut-être le seul à le penser). (Des rires) Je n'ai pas abordé l'évaluation quantitative des performances de détection des anomalies (AUROC, etc.) de peur de rendre l'article redondant, mais j'aimerais le résumer dans un proche avenir. En même temps, je voudrais vérifier le cadre de détection d'anomalies par GAN. Récemment, un développement supplémentaire d'Autoencoder, des cadres de détection d'anomalies qui utilisent divers GAN tels que AnoGAN, EfficientGAN et AnoVAEGAN sont apparus, et SOTA a été acquis l'un après l'autre. Vous pouvez vous attendre à plus des tendances futures.

Les références

http://cedro3.com/ai/keras-autoencoder-anomaly/