dbbbbm / f-anogan-pytorch Goto Github PK

Unofficial PyTorch implementation for f-AnoGAN: Fast unsupervised anomaly detection with generative adversarial networks.

Python 100.00%

pytorch anomalydetection anomaly-detection deep-learning

f-anogan-pytorch's Introduction

f-AnoGAN-PyTorch

An unofficial implementation of f-AnoGAN in PyTorch.

Reference

Official TensorFlow implementation: https://github.com/tSchlegl/f-AnoGAN
Paper: f-AnoGAN: Fast unsupervised anomaly detection with generative adversarial networks https://www.sciencedirect.com/science/article/abs/pii/S1361841518302640
WGAN-GP-PyTorch: https://github.com/jalola/improved-wgan-pytorch

Dataset

This implementation performs anomaly detection on CIFAR-10. In the common setting we treat one class of CIFAR-10 as normal class and other 9 classes as anomalies. You can specify which class is considered as normal when running fanogan.py in command line by setting the --class argument.

Usage

Train a GAN

  python fanogan.py --stage 1 --class NORMAL_CLASS

Train an encoder

  python fanogan.py --stage 2 --class NORMAL_CLASS

Evaluation

  python fanogan.py --eval --class NORMAL_CLASS

f-anogan-pytorch's People

Contributors

Stargazers

Watchers

Forkers

edmontdants xiaoyuanguo kiminjo

f-anogan-pytorch's Issues

Encoder Tanh

Hello,

I believe there is an error in the encoder architecture?
The last layer of the encoder uses Tanh, which does not make sense to me since the generator input is torch.randn(64, 128), which can output values below -1 and above 1.
The tanh activation is limiting the encoder output to -1 and 1 though.
This might explain why the images generated in the izif training aren't that good.

Am I missing something?

Why use Adam optimizer for encoder training instead of RMSprop?

The official Tensorflow implementation uses RMSprop for the encoder training, however in this implementation the same adam optimizer used for WGAN training is used for the encoder. Was there a specific reason why?

Thanks!

Mean Squared Error in Evaluation

Hello, first of all thanks for this awesome implementation.

I'm looking at the file fanogan.py in line 247 to 252. Here's the code:

f_x, f_gx = netD.extract_feature(d_input).chunk(2, 0)
rec_diff = ((rec_image.view(bs, -1) - x.view(bs, -1))**2)
rec_score = rec_diff.mean(dim=1) - rec_diff.std(dim=1)
feat_diff = ((f_x - f_gx)**2)
feat_score = feat_diff.mean(dim=1) + feat_diff.std(dim=1)
outlier_score = rec_score + options.alpha * feat_score

This looks like the mean squared error to me, which makes sense since that is used in the paper.
However, I don't really understand why you subtract the standard deviation from the mean error.
Also, the deviation is added to the mean error of extracted features.
I've tested this and i've seen that the tensor rec_score holds negative values, which would not be possible with the mean squared error as it is implemented in for example sklearn.metrics. However, using the standard deviation raises my ROC score from 0.91 to 0.93. Could you give me a hint why the deviation is included at all?