CNN_Autoencoder_Anomaly_Detection.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/danielsoy/ALOCC-CVPR2018/blob/master/CNN_Autoencoder_Anomaly_Detection.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**https://github.com/JudeWells/keras_anomaly_detection**\n",
        "# keras_anomaly_detection\n",
        "CNN based autoencoder combined with kernel density estimation for colour image anomaly detection / novelty detection. \n",
        "Built using Tensforflow 2.0 and Keras.\n",
        "\n",
        "The network was trained using the** fruits 360 dataset **but should work with any colour images.\n",
        "\n",
        "The final model was able to detect 95% to 98% of anomalous images (depending on which class of images were treated as anomalous) with a false positive rate on 'normal' images of 12%. **texto en negrita**"
      ],
      "metadata": {
        "id": "bml7RWn6H7I4"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "biJmOIfAH1GM"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import keras\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Activation, Flatten, Input\n",
        "from keras.layers import Conv2D, MaxPooling2D, UpSampling2D\n",
        "import matplotlib.pyplot as plt\n",
        "from keras import backend as K\n",
        "import numpy as np\n",
        "from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
        "from PIL import Image, ImageChops\n",
        "from sklearn.neighbors import KernelDensity\n",
        "import random"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "collapsed": true,
        "id": "61f6EOyLH1GN"
      },
      "outputs": [],
      "source": [
        "% matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive"
      ],
      "metadata": {
        "id": "CebktpkJKHms"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v2CetcbBKIeu",
        "outputId": "2ab7d08d-f419-4a7a-905e-26e20854f51d"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "img_dir = \"/content/drive/MyDrive/filamentrico\""
      ],
      "metadata": {
        "id": "VvD6ctonMANV"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create generators for training, validation and testing\n",
        "# Generate data from the images in a folder, allows use of datasets that do not fit in main memory all at once\n",
        "# Image resizing is done by the generator so a folder with any sized-images can be used\n",
        "# The named directory must contain one or more subfolders, \n",
        "# path should look like apples_train/apple_class1/img1.jpg...\n",
        "\n",
        "batch_size = 85\n",
        "train_datagen = ImageDataGenerator(rescale=1./255, data_format='channels_last')\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "    '/content/drive/MyDrive/apples_train',\n",
        "    target_size=(96, 96),\n",
        "\n",
        "    batch_size=batch_size,\n",
        "    class_mode='input'\n",
        "    )\n",
        "\n",
        "test_datagen = ImageDataGenerator(rescale=1./255, data_format='channels_last')\n",
        "validation_generator = test_datagen.flow_from_directory(\n",
        "    '/content/drive/MyDrive/apples_test',\n",
        "    target_size=(96, 96),\n",
        "\n",
        "    batch_size=batch_size,\n",
        "    class_mode='input'\n",
        "    )\n",
        "\n",
        "anomaly_generator = test_datagen.flow_from_directory(\n",
        "    '/content/drive/MyDrive/eggplant',\n",
        "    target_size=(96, 96),\n",
        "\n",
        "    batch_size=batch_size,\n",
        "    class_mode='input'\n",
        "    )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O8-Y3G5FTstV",
        "outputId": "1402846d-24a9-438f-e477-c7c907c912ad"
      },
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 6416 images belonging to 13 classes.\n",
            "Found 2138 images belonging to 13 classes.\n",
            "Found 468 images belonging to 3 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {
        "id": "j7lAsnOrH1GO",
        "outputId": "6cb421ed-d3d5-4e72-a460-ef21513614b0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_13\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_67 (Conv2D)          (None, 96, 96, 16)        448       \n",
            "                                                                 \n",
            " max_pooling2d_39 (MaxPoolin  (None, 24, 24, 16)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_68 (Conv2D)          (None, 24, 24, 8)         1160      \n",
            "                                                                 \n",
            " max_pooling2d_40 (MaxPoolin  (None, 6, 6, 8)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_69 (Conv2D)          (None, 6, 6, 3)           219       \n",
            "                                                                 \n",
            " max_pooling2d_41 (MaxPoolin  (None, 3, 3, 3)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_70 (Conv2D)          (None, 3, 3, 3)           84        \n",
            "                                                                 \n",
            " up_sampling2d_21 (UpSamplin  (None, 6, 6, 3)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_71 (Conv2D)          (None, 6, 6, 8)           224       \n",
            "                                                                 \n",
            " up_sampling2d_22 (UpSamplin  (None, 24, 24, 8)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_72 (Conv2D)          (None, 24, 24, 16)        1168      \n",
            "                                                                 \n",
            " up_sampling2d_23 (UpSamplin  (None, 96, 96, 16)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_73 (Conv2D)          (None, 96, 96, 3)         435       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3,738\n",
            "Trainable params: 3,738\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Define the convolutional autoencoder model \n",
        "# input shape must be the same size as the images that will be fed into it by the generators\n",
        "# The output layer must be the same dimensions as the original image\n",
        "model = Sequential()\n",
        "\n",
        "model.add(Conv2D(16, (3, 3), padding='same',activation='relu', input_shape=(96, 96, 3)))\n",
        "model.add(MaxPooling2D(pool_size=(4,4), padding='same')) # using pool_size (4,4) makes the layer 4x smaller in height and width\n",
        "\n",
        "model.add(Conv2D(8,(3, 3),activation='relu',  padding='same'))\n",
        "model.add(MaxPooling2D(pool_size=(4,4), padding='same'))\n",
        "\n",
        "model.add(Conv2D(3,(3, 3),activation='relu',  padding='same'))\n",
        "model.add(MaxPooling2D(pool_size=(2,2), padding='same'))\n",
        "\n",
        "#-------------------------\n",
        "model.add(Conv2D(3,(3, 3),activation='relu',  padding='same'))\n",
        "model.add(UpSampling2D((2, 2)))\n",
        "\n",
        "model.add(Conv2D(8,(3, 3),activation='relu',  padding='same'))\n",
        "model.add(UpSampling2D((4, 4)))\n",
        "\n",
        "model.add(Conv2D(16,(3, 3),activation='relu',  padding='same'))\n",
        "model.add(UpSampling2D((4, 4)))\n",
        "\n",
        "model.add(Conv2D(3,(3, 3), activation='sigmoid', padding='same'))\n",
        "#-------------------------\n",
        "\n",
        "model.summary()\n",
        "\n",
        "# Compile the model\n",
        "model.compile(optimizer='adadelta', loss='mean_squared_error')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4fNSjQmwH1GP",
        "outputId": "f7ff0791-d193-4a5b-fe86-41386abd75b4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:12: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  if sys.path[0] == '':\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "11/11 [==============================] - 5s 428ms/step - loss: 0.1229 - val_loss: 0.1220\n",
            "Epoch 2/100\n",
            "11/11 [==============================] - 4s 400ms/step - loss: 0.1218 - val_loss: 0.1227\n",
            "Epoch 3/100\n",
            "11/11 [==============================] - 4s 388ms/step - loss: 0.1229 - val_loss: 0.1221\n",
            "Epoch 4/100\n",
            "11/11 [==============================] - 4s 404ms/step - loss: 0.1233 - val_loss: 0.1224\n",
            "Epoch 5/100\n",
            "11/11 [==============================] - 4s 389ms/step - loss: 0.1217 - val_loss: 0.1220\n",
            "Epoch 6/100\n",
            "11/11 [==============================] - 4s 408ms/step - loss: 0.1212 - val_loss: 0.1216\n",
            "Epoch 7/100\n",
            "11/11 [==============================] - 4s 400ms/step - loss: 0.1223 - val_loss: 0.1226\n",
            "Epoch 8/100\n",
            "11/11 [==============================] - 5s 432ms/step - loss: 0.1227 - val_loss: 0.1217\n",
            "Epoch 9/100\n",
            "11/11 [==============================] - 5s 473ms/step - loss: 0.1232 - val_loss: 0.1215\n",
            "Epoch 10/100\n",
            "11/11 [==============================] - 4s 403ms/step - loss: 0.1227 - val_loss: 0.1215\n",
            "Epoch 11/100\n",
            "11/11 [==============================] - 4s 396ms/step - loss: 0.1219 - val_loss: 0.1207\n",
            "Epoch 12/100\n",
            "11/11 [==============================] - 4s 417ms/step - loss: 0.1223 - val_loss: 0.1220\n",
            "Epoch 13/100\n",
            "11/11 [==============================] - 4s 414ms/step - loss: 0.1212 - val_loss: 0.1226\n",
            "Epoch 14/100\n",
            "11/11 [==============================] - 4s 403ms/step - loss: 0.1230 - val_loss: 0.1217\n",
            "Epoch 15/100\n",
            "11/11 [==============================] - 4s 403ms/step - loss: 0.1218 - val_loss: 0.1217\n",
            "Epoch 16/100\n",
            "11/11 [==============================] - 4s 397ms/step - loss: 0.1218 - val_loss: 0.1223\n",
            "Epoch 17/100\n",
            "11/11 [==============================] - 4s 400ms/step - loss: 0.1213 - val_loss: 0.1230\n",
            "Epoch 18/100\n",
            "11/11 [==============================] - 4s 390ms/step - loss: 0.1224 - val_loss: 0.1221\n",
            "Epoch 19/100\n",
            "11/11 [==============================] - 5s 437ms/step - loss: 0.1221 - val_loss: 0.1220\n",
            "Epoch 20/100\n",
            "11/11 [==============================] - 5s 455ms/step - loss: 0.1226 - val_loss: 0.1214\n",
            "Epoch 21/100\n",
            "11/11 [==============================] - ETA: 0s - loss: 0.1222"
          ]
        }
      ],
      "source": [
        "# Training the model\n",
        "es = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=30) # Early stopping (stops training when validation doesn't improve for {patience} epochs)\n",
        "model_filepath = 'models/model1.keras'\n",
        "save_best = keras.callbacks.ModelCheckpoint(model_filepath, monitor='val_loss', save_best_only=True, mode='min') # Saves the best version of the model to disk (as measured on the validation data set)\n",
        "model.fit_generator(\n",
        "        train_generator,\n",
        "        steps_per_epoch=1000 // batch_size,\n",
        "        epochs=100,\n",
        "        validation_data=validation_generator,\n",
        "        validation_steps=1000 // batch_size,\n",
        "        shuffle = True,\n",
        "        callbacks=[es, save_best])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {
        "collapsed": true,
        "id": "cKaSlPwRH1GP"
      },
      "outputs": [],
      "source": [
        "# Training continues after improvement stops for the number of epochs equivalent to the 'patience' hyper-parameter\n",
        "# To get back the model that performed best on the validation set we load the checkpointed model from disk:\n",
        "model = keras.models.load_model(model_filepath)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QwrK-QOgH1GP"
      },
      "outputs": [],
      "source": [
        "model_filepath"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {
        "id": "dmkGWC40H1GQ",
        "outputId": "d6f48e7c-95ea-47a3-81a9-2191bd82ef75",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x576 with 8 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Test the model by viewing a sample of original and reconstructed images\n",
        "data_list = []\n",
        "batch_index = 0\n",
        "while batch_index <= train_generator.batch_index:\n",
        "    data = train_generator.next()\n",
        "    data_list.append(data[0])\n",
        "    batch_index = batch_index + 1\n",
        "\n",
        "predicted = model.predict(data_list[0])\n",
        "no_of_samples = 4\n",
        "_, axs = plt.subplots(no_of_samples, 2, figsize=(5, 8))\n",
        "axs = axs.flatten()\n",
        "imgs = []\n",
        "for i in range(no_of_samples):\n",
        "    imgs.append(data_list[i][i])\n",
        "    imgs.append(predicted[i])\n",
        "for img, ax in zip(imgs, axs):\n",
        "    ax.imshow(img)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {
        "id": "AoeLllUNH1GQ",
        "outputId": "f058cdad-511d-4325-9fe6-bc094de2c7e4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:2: UserWarning: `Model.evaluate_generator` is deprecated and will be removed in a future version. Please use `Model.evaluate`, which supports generators.\n",
            "  \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Error on validation set:0.12204378098249435, error on anomaly set:0.02500802092254162\n"
          ]
        }
      ],
      "source": [
        "# We want the difference the difference in error between the validation (normal) images and anomalous images to be as high as possible\n",
        "print(f\"Error on validation set:{model.evaluate_generator(validation_generator)}, error on anomaly set:{model.evaluate_generator(anomaly_generator)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fzXGNRoGH1GQ"
      },
      "source": [
        "# Extracting the encoded image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {
        "id": "3KV0rMFzH1GR",
        "outputId": "dee25ba6-cdd9-497c-d9ed-6de58cc4be5b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_12\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_64 (Conv2D)          (None, 96, 96, 16)        448       \n",
            "                                                                 \n",
            " max_pooling2d_36 (MaxPoolin  (None, 24, 24, 16)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_65 (Conv2D)          (None, 24, 24, 8)         1160      \n",
            "                                                                 \n",
            " max_pooling2d_37 (MaxPoolin  (None, 6, 6, 8)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_66 (Conv2D)          (None, 6, 6, 3)           219       \n",
            "                                                                 \n",
            " max_pooling2d_38 (MaxPoolin  (None, 3, 3, 3)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,827\n",
            "Trainable params: 1,827\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# We build a replica of the first half of the auto-encoder (the encoder only)\n",
        "# This network takes a an image which is 96x96x3 and compresses it down to a 3x3x3 tensor\n",
        "encoder_replica = Sequential()\n",
        "encoder_replica.add(Conv2D(16, (3, 3), padding='same',activation='relu', input_shape=(96, 96, 3), weights=model.layers[0].get_weights()) )\n",
        "encoder_replica.add(MaxPooling2D(pool_size=(4,4), padding='same'))\n",
        "encoder_replica.add(Conv2D(8,(3, 3),activation='relu',  padding='same', weights=model.layers[2].get_weights()))\n",
        "encoder_replica.add(MaxPooling2D(pool_size=(4,4), padding='same'))\n",
        "encoder_replica.add(Conv2D(3,(3, 3),activation='relu',  padding='same', weights=model.layers[4].get_weights()))\n",
        "encoder_replica.add(MaxPooling2D(pool_size=(2,2), padding='same'))\n",
        "encoder_replica.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {
        "collapsed": true,
        "id": "v6OzfTQYH1GS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "32867c83-63d2-4171-9910-e85e08fd97e4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:3: UserWarning: `Model.predict_generator` is deprecated and will be removed in a future version. Please use `Model.predict`, which supports generators.\n",
            "  This is separate from the ipykernel package so we can avoid doing imports until\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:6: UserWarning: `Model.predict_generator` is deprecated and will be removed in a future version. Please use `Model.predict`, which supports generators.\n",
            "  \n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:9: UserWarning: `Model.predict_generator` is deprecated and will be removed in a future version. Please use `Model.predict`, which supports generators.\n",
            "  if __name__ == '__main__':\n"
          ]
        }
      ],
      "source": [
        "# Creating encoded (compressed versions of the training, validation and anomalous images) and getting their density\n",
        "# The SKLearn kernel density function only works with 1D arrays so we need to flatten the tensors created by the encoder\n",
        "encoded_images = encoder_replica.predict_generator(train_generator)\n",
        "encoded_images_flat = [np.reshape(img, (27)) for img in encoded_images]\n",
        "\n",
        "validation_encoded = encoder_replica.predict_generator(validation_generator)\n",
        "val_enc_flat = [np.reshape(img, (27)) for img in validation_encoded]\n",
        "\n",
        "anom_encoded = encoder_replica.predict_generator(anomaly_generator)\n",
        "anom_enc_flat = [np.reshape(img, (27)) for img in anom_encoded]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {
        "id": "KpkDlHvoH1GS",
        "outputId": "63761abf-c138-4c74-f6c7-34c136d42148",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 458
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Kernel Density Estimation of the encoded vectors\n",
        "kde = KernelDensity(kernel='gaussian', bandwidth=0.2).fit(encoded_images_flat)\n",
        "training_density_scores = kde.score_samples(encoded_images_flat) \n",
        "validation_density_scores = kde.score_samples(val_enc_flat)\n",
        "anomaly_density_scores = kde.score_samples(anom_enc_flat)\n",
        "\n",
        "# Plotting the density distributions of the training (normal), validation (normal) and anomalous images\n",
        "# Ideally we want to see high separation between the normal and anomalous classes\n",
        "plt.figure(figsize = (10,7))\n",
        "plt.title('Distribution of Density Scores')\n",
        "plt.hist(training_density_scores, 12, alpha=0.5, label='Training Normal')\n",
        "plt.hist(validation_density_scores, 12, alpha=0.5, label='Validation Normal')\n",
        "plt.hist(anomaly_density_scores, 12, alpha=0.5, label='Anomalies')\n",
        "plt.legend(loc='upper right')\n",
        "plt.xlabel('Density Score')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "collapsed": true,
        "id": "X7VCuWQkH1GT"
      },
      "outputs": [],
      "source": [
        "# Creat a function that will classify whether an unseen image is normal or an anomaly\n",
        "# Low density and high reconstruction error mean that the image is likely to be anomalous\n",
        "def check_anomaly(img_path):\n",
        "    density_threshold = 0 # This threshold was chosen based on looking at the distribution of the density scores of the normal class (validation set)\n",
        "    reconstruction_error_threshold = 0.04 # This threshold was chosen based on looking at the distribution of reconstruction errors of the normal class\n",
        "    img  = Image.open(img_path)\n",
        "    img = np.array(img.resize((96,96), Image.ANTIALIAS))\n",
        "    img = img / 255\n",
        "    encoded_img = encoder_replica.predict([[img]]) # Create a compressed version of the image using the encoder\n",
        "    encoded_img = [np.reshape(img, (27)) for img in encoded_img] # Flatten the compressed image\n",
        "    density = kde.score_samples(encoded_img)[0] # get a density score for the new image\n",
        "#     print(f'density: {density}')\n",
        "    reconstruction = model.predict([[img]])\n",
        "    reconstruction_error = model.evaluate([reconstruction],[[img]], batch_size = 1)\n",
        "#     print(f'reconstruction_error: {reconstruction_error}')\n",
        "    if density < density_threshold or reconstruction_error > reconstruction_error_threshold:\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "id": "m6fpv6WDH1GT",
        "outputId": "f6b244af-e022-470b-cd20-d0d8bf1cbcf6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-93-b2a45404f91b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0monion_files\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0monion_predictions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcheck_anomaly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0monion_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0monion_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ],
      "source": [
        "# Check what proportion of onion images are classified as anomalous\n",
        "onion_files = []\n",
        "for (dirpath, dirnames, filenames) in os.walk('fruta_anomala'):\n",
        "    for x in filenames:\n",
        "        if x.endswith(\".jpg\"):\n",
        "            onion_files.append(os.path.join(dirpath, x))\n",
        "\n",
        "onion_predictions = []\n",
        "for file in onion_files:\n",
        "    onion_predictions.append(check_anomaly(file))\n",
        "print(sum(onion_predictions)/len(onion_predictions))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {
        "id": "k4rfJD3BH1GU",
        "outputId": "186efdd6-65eb-49e1-e6bf-d09b43a1c2c8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 788
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-98-df8fdc285668>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mapples_predictions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mapples_test\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0mapples_predictions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcheck_anomaly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mapples_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mapples_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-91-08fa9dd76d46>\u001b[0m in \u001b[0;36mcheck_anomaly\u001b[0;34m(img_path)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m96\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m96\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mANTIALIAS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m255\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0mencoded_img\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mencoder_replica\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Create a compressed version of the image using the encoder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m     \u001b[0mencoded_img\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m27\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mencoded_img\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# Flatten the compressed image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0mdensity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkde\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mencoded_img\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# get a density score for the new image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m       \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mautograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1127\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint:disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1128\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"ag_error_metadata\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1129\u001b[0;31m               \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mag_error_metadata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1130\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1131\u001b[0m               \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: in user code:\n\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1621, in predict_function  *\n        return step_function(self, iterator)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1611, in step_function  **\n        outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1604, in run_step  **\n        outputs = model.predict_step(data)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1572, in predict_step\n        return self(x, training=False)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 67, in error_handler\n        raise e.with_traceback(filtered_tb) from None\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/input_spec.py\", line 263, in assert_input_compatibility\n        raise ValueError(f'Input {input_index} of layer \"{layer_name}\" is '\n\n    ValueError: Input 0 of layer \"sequential_12\" is incompatible with the layer: expected shape=(None, 96, 96, 3), found shape=(32, 96, 3)\n"
          ]
        }
      ],
      "source": [
        "# Check what proportion of apples are classified as anomalous (we hope that this will be close to zero)\n",
        "apples_test = []\n",
        "for (dirpath, dirnames, filenames) in os.walk('/content/drive/MyDrive/apples_test'):\n",
        "    for x in filenames:\n",
        "        if x.endswith(\".jpg\"):\n",
        "            apples_test.append(os.path.join(dirpath, x))\n",
        "\n",
        "apples_predictions = []\n",
        "for file in apples_test:\n",
        "    apples_predictions.append(check_anomaly(file))\n",
        "print(sum(apples_predictions)/len(apples_predictions))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {
        "id": "jAfGN6E_H1GU",
        "outputId": "f5f81ca0-6052-4a29-9aec-52c93d386c4d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 788
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-99-c03d9a4de45a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0meggplant_predictions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0meggplant_test\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0meggplant_predictions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcheck_anomaly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meggplant_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meggplant_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-91-08fa9dd76d46>\u001b[0m in \u001b[0;36mcheck_anomaly\u001b[0;34m(img_path)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m96\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m96\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mANTIALIAS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m255\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0mencoded_img\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mencoder_replica\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Create a compressed version of the image using the encoder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m     \u001b[0mencoded_img\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m27\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mencoded_img\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# Flatten the compressed image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0mdensity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkde\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mencoded_img\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# get a density score for the new image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m       \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mautograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1127\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint:disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1128\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"ag_error_metadata\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1129\u001b[0;31m               \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mag_error_metadata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1130\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1131\u001b[0m               \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: in user code:\n\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1621, in predict_function  *\n        return step_function(self, iterator)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1611, in step_function  **\n        outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1604, in run_step  **\n        outputs = model.predict_step(data)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1572, in predict_step\n        return self(x, training=False)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 67, in error_handler\n        raise e.with_traceback(filtered_tb) from None\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/input_spec.py\", line 263, in assert_input_compatibility\n        raise ValueError(f'Input {input_index} of layer \"{layer_name}\" is '\n\n    ValueError: Input 0 of layer \"sequential_12\" is incompatible with the layer: expected shape=(None, 96, 96, 3), found shape=(32, 96, 3)\n"
          ]
        }
      ],
      "source": [
        "# Check what proportion of aubergines/eggplants get classed as anomalous.\n",
        "eggplant_test = []\n",
        "for (dirpath, dirnames, filenames) in os.walk('/content/drive/MyDrive/fruta_anomala'):\n",
        "    for x in filenames:\n",
        "        if x.endswith(\".jpg\"):\n",
        "            eggplant_test.append(os.path.join(dirpath, x))\n",
        "\n",
        "eggplant_predictions = []\n",
        "for file in eggplant_test:\n",
        "    eggplant_predictions.append(check_anomaly(file))\n",
        "print(sum(eggplant_predictions)/len(eggplant_predictions))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {
        "id": "Qjy5V3kMH1GU",
        "outputId": "e6a71ee6-6612-4cf9-c86f-58a5d563bf57",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-96-96276602dda2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpeppers_test\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0mpeppers_predictions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcheck_anomaly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpeppers_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpeppers_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ],
      "source": [
        "peppers_test = []\n",
        "for (dirpath, dirnames, filenames) in os.walk('/content/drive/MyDrive/eggplant'):\n",
        "    for x in filenames:\n",
        "        if x.endswith(\".jpg\"):\n",
        "            peppers_test.append(os.path.join(dirpath, x))\n",
        "\n",
        "peppers_predictions = []\n",
        "for file in peppers_test:\n",
        "    peppers_predictions.append(check_anomaly(file))\n",
        "print(sum(peppers_predictions)/len(peppers_predictions))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {
        "id": "APxhftf6H1GV",
        "outputId": "f74916c7-0978-4eb8-df9e-2de1793fab2e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 97
        }
      ],
      "source": [
        "len(peppers_predictions)"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.8"
    },
    "colab": {
      "name": "CNN Autoencoder Anomaly Detection.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}