ImageClassification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Copy of ImageClassification.ipynb",
      "private_outputs": true,
      "provenance": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kmouts/PMS/blob/master/ImageClassification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TBFXQGKYUc4X"
      },
      "source": [
        "##### Copyright - The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "1z4xy2gTUc4a"
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_mOvbRvSXU8"
      },
      "source": [
        "Μετάφραση/Επιμέλεια: Κ.Μούτσελος.  Παν.Πειραιώς"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FE7KNzPPVrVV"
      },
      "source": [
        "# Ταξινόμηση Εικόνας με Συνελικτικά Δίκτυα (TF)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KwQtSOz0VrVX"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/kmouts/PMS/blob/master/ImageClassification.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gN7G9GFmVrVY"
      },
      "source": [
        "Αυτός ο οδηγός δείχνει πώς να ταξινομήσουμε γάτες ή σκύλους από αντίστοιχες εικόνες. Δημιουργεί έναν ταξινομητή εικόνας χρησιμοποιώντας ένα σειριακό  μοντέλο (`tf.keras.Sequential`) και φορτώνει τα δεδομένα χρησιμοποιώντας τη κλάση: `tf.keras.preprocessing.image.ImageDataGenerator`. Θα αποκτήσετε πρακτική εμπειρία για τις ακόλουθες έννοιες:\n",
        "\n",
        "* Δημιουργία ροής εισαγωγής δεδομένων (data pipeline) χρησιμοποιώντας  για εκμάθηση αποθηκευμένα δεδομένα (με τη κλάση: `tf.keras.preprocessing.image.ImageDataGenerator`).\n",
        "* Overfitting - Πώς να το αναγνωρίσετε και να το αποτρέψετε.\n",
        "* Data augmentation και dropout.\n",
        "\n",
        "\n",
        "O οδηγός ακολουθεί μια κλασσική σειρά εργασιών μηχανικής μάθησης:\n",
        "\n",
        "1. Εξέταση και κατανόηση των δεδομένων\n",
        "2. Ροή εισαγωγής δεδομένων\n",
        "3. Κατασκευή μοντέλου\n",
        "4. Εκπαίδευση μοντέλου\n",
        "5. Δοκιμή μοντέλου\n",
        "6. Βελτίωση μοντέλου και επανάληψη της διαδικασίας\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zF9uvbXNVrVY"
      },
      "source": [
        "## Εισαγωγή πακέτων\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VddxeYBEVrVZ"
      },
      "source": [
        "Ας ξεκινήσουμε εισάγοντας τα απαιτούμενα πακέτα. Το πακέτο`os`  χρησιμοποιείται για την ανάγνωση αρχείων και τη δομή του καταλόγου, το `NumPy`  για τη μετατροπή της  python λίστας σε numpy array και για την εκτέλεση πράξεων με πίνακες και το `matplotlib.pyplot` στα γραφήματα και στην εμφάνιση των εικόνων."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jlchl4x2VrVg"
      },
      "source": [
        "Εισαγωγή κλάσεων Tensorflow και Keras."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nmMfiSBcXZST"
      },
      "source": [
        "import tensorflow as tf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L1WtoaOHVrVh"
      },
      "source": [
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZZI6lNkVrVm"
      },
      "source": [
        "## Φόρτωση δεδομένων"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DPHx8-t-VrVo"
      },
      "source": [
        "\n",
        "Ξεκινάμε κατεβάζοντας τα δεδομένα. Εδώ χρησιμοποιούμε μια φιλτραρισμένη έκδοση των δεδομένων <a href=\"https://www.kaggle.com/c/dogs-vs-cats/data\" target=\"_blank\">Dogs vs Cats</a>  από το Kaggle. Κατεβάζουμε τα αρχεία και τα αποθηκεύουμε στον κατάλογο \"/ tmp /\".\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C1nqr-CYY6uw"
      },
      "source": [
        "_URL = 'https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip'\n",
        "\n",
        "path_to_zip = tf.keras.utils.get_file('cats_and_dogs.zip', origin=_URL, extract=True)\n",
        "\n",
        "PATH = os.path.join(os.path.dirname(path_to_zip), 'cats_and_dogs_filtered')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ysLzsNTcxqh"
      },
      "source": [
        "ls -la /root/.keras/datasets/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Giv0wMQzVrVw"
      },
      "source": [
        "Τα δεδομένα έχουν την ακόλουθη δομή:\n",
        "\n",
        "<pre>\n",
        "<b>cats_and_dogs_filtered</b>\n",
        "|__ <b>train</b>\n",
        "    |______ <b>cats</b>: [cat.0.jpg, cat.1.jpg, cat.2.jpg ....]\n",
        "    |______ <b>dogs</b>: [dog.0.jpg, dog.1.jpg, dog.2.jpg ...]\n",
        "|__ <b>validation</b>\n",
        "    |______ <b>cats</b>: [cat.2000.jpg, cat.2001.jpg, cat.2002.jpg ....]\n",
        "    |______ <b>dogs</b>: [dog.2000.jpg, dog.2001.jpg, dog.2002.jpg ...]\n",
        "</pre>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpmywIlsVrVx"
      },
      "source": [
        "Αφού εξαχθούν τα περιεχόμενα, εκχωρούμε μεταβλητές με την κατάλληλη διαδρομή αρχείου για τα σετ εκπαίδευσης και επικύρωσης."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sRucI3QqVrVy"
      },
      "source": [
        "train_dir = os.path.join(PATH, 'train')\n",
        "validation_dir = os.path.join(PATH, 'validation')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Utv3nryxVrV0"
      },
      "source": [
        "train_cats_dir = os.path.join(train_dir, 'cats')  # directory with our training cat pictures\n",
        "train_dogs_dir = os.path.join(train_dir, 'dogs')  # directory with our training dog pictures\n",
        "validation_cats_dir = os.path.join(validation_dir, 'cats')  # directory with our validation cat pictures\n",
        "validation_dogs_dir = os.path.join(validation_dir, 'dogs')  # directory with our validation dog pictures"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZdrHHTy2VrV3"
      },
      "source": [
        "### Κατανόηση Δεδομένων"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LblUYjl-VrV3"
      },
      "source": [
        "Ας δούμε πόσες εικόνες γάτας και σκύλου βρίσκονται στους καταλόγους εκπαίδευσης και επικύρωσης:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vc4u8e9hVrV4"
      },
      "source": [
        "num_cats_tr = len(os.listdir(train_cats_dir))\n",
        "num_dogs_tr = len(os.listdir(train_dogs_dir))\n",
        "\n",
        "num_cats_val = len(os.listdir(validation_cats_dir))\n",
        "num_dogs_val = len(os.listdir(validation_dogs_dir))\n",
        "\n",
        "total_train = num_cats_tr + num_dogs_tr\n",
        "total_val = num_cats_val + num_dogs_val"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g4GGzGt0VrV7"
      },
      "source": [
        "print('total training cat images:', num_cats_tr)\n",
        "print('total training dog images:', num_dogs_tr)\n",
        "\n",
        "print('total validation cat images:', num_cats_val)\n",
        "print('total validation dog images:', num_dogs_val)\n",
        "print(\"--\")\n",
        "print(\"Total training images:\", total_train)\n",
        "print(\"Total validation images:\", total_val)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Lp-0ejxOtP1"
      },
      "source": [
        "Για ευκολία, θέτουμε τις μεταβλητές που θα χρησιμοποιηθούν για την προ-επεξεργασία και την εκπαίδευση του δικτύου:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3NqNselLVrWA"
      },
      "source": [
        "batch_size = 128\n",
        "epochs = 15\n",
        "IMG_HEIGHT = 150\n",
        "IMG_WIDTH = 150"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "INn-cOn1VrWC"
      },
      "source": [
        "## Προετοιμασία δεδομένων"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Jfk6aSAVrWD"
      },
      "source": [
        "Διαμορφώνουμε τις εικόνες σε τανυστές (tensors) κινητής υποδιαστολής (floats) πριν την εισαγωγή τους στο δίκτυο:\n",
        "\n",
        "1. Διάβασμα των εικόνων από τον δίσκο.\n",
        "2. Αποκωδικοποιηση των εικόνων και μετατροπή σε σωστή μορφή RGBD.\n",
        "3. Μετατροπή σε τανυστές κινητής υποδιαστολής.\n",
        "4. Μετατροπή των τανυστών από τιμές μεταξύ 0 and 255 σε τιμές μεταξύ 0 και 1, καθώς στα νευρωνικά δίκτυα είναι καλύτερα να έχουμε μικρές τιμές εισόδου.\n",
        "\n",
        "Όλες αυτές οι εργασίες μπορούν να γίνουν με τη κλάση `ImageDataGenerator` που παρέχεται από την `tf.keras`.\n",
        "Η κλάση μπορεί να διαβάσει εικόνες από το δίσκο και να τις προεπεξεργαστεί σε κατάλληλους τανυστές. Θα δημιουργήσει επίσης γεννήτριες που θα μετατρέπουν αυτές τις εικόνες σε παρτίδες (batches) τανυστών - χρήσιμες κατά την εκπαίδευση του δικτύου."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "syDdF_LWVrWE"
      },
      "source": [
        "train_image_generator = ImageDataGenerator(rescale=1./255) # Generator for our training data\n",
        "validation_image_generator = ImageDataGenerator(rescale=1./255) # Generator for our validation data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RLciCR_FVrWH"
      },
      "source": [
        "Μετά τον καθορισμό των γεννητριών για την  εκπαίδευση και επικύρωση εικόνων, η μέθοδος `flow_from_directory`  φορτώνει τις εικόνες από το δίσκο, κάνει rescaling και αλλάζει το μέγεθος των εικόνων στις απαιτούμενες διαστάσεις."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pw94ajOOVrWI"
      },
      "source": [
        "train_data_gen = train_image_generator.flow_from_directory(batch_size=batch_size,\n",
        "                                                           directory=train_dir,\n",
        "                                                           shuffle=True,\n",
        "                                                           target_size=(IMG_HEIGHT, IMG_WIDTH),\n",
        "                                                           class_mode='binary')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2oUoKUzRVrWM"
      },
      "source": [
        "val_data_gen = validation_image_generator.flow_from_directory(batch_size=batch_size,\n",
        "                                                              directory=validation_dir,\n",
        "                                                              target_size=(IMG_HEIGHT, IMG_WIDTH),\n",
        "                                                              class_mode='binary')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hyexPJ8CVrWP"
      },
      "source": [
        "### Επόπτευση των εικόνων για εκπαίδευση"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "60CnhEL4VrWQ"
      },
      "source": [
        "Βλέπουμε μερικές εικόνες εκπαίδευσης εξάγοντας μια παρτίδα εικόνων από τη γεννήτρια κατάρτισης - που είναι *64* εικόνες σε αυτό το παράδειγμα - και στη συνέχεια σχεδιάζουμε 5 από αυτές με την `matplotlib`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3f0Z7NZgVrWQ"
      },
      "source": [
        "sample_training_images, _ = next(train_data_gen)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "49weMt5YVrWT"
      },
      "source": [
        "Η  συνάρτηση `next` επιστρέφει μια παρτίδα από το σύνολο δεδομένων. Η τιμή που επιστρέφει η  συνάρτηση `next` έχει τη μορφή `(x_train, y_train)`, όπου x_train είναι τα χαρακτηριστικά εκπαίδευσης και y_train, οι ετικέτες της. Αγνοούμε τις ετικέτες για να απεικονίσουμε μόνο τις εικόνες εκπαίδευσης."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JMt2RES_VrWU"
      },
      "source": [
        "# This function will plot images in the form of a grid with 1 row and 5 columns where images are placed in each column.\n",
        "def plotImages(images_arr):\n",
        "    fig, axes = plt.subplots(1, 5, figsize=(20,20))\n",
        "    axes = axes.flatten()\n",
        "    for img, ax in zip( images_arr, axes):\n",
        "        ax.imshow(img)\n",
        "        ax.axis('off')\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d_VVg_gEVrWW"
      },
      "source": [
        "plotImages(sample_training_images[-5:])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5Ej-HLGVrWZ"
      },
      "source": [
        "## Δημιουργία μοντέλου"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wEgW4i18VrWZ"
      },
      "source": [
        "\n",
        "Το μοντέλο αποτελείται από τρία συνελικτικά μπλοκ ακολουθούμενο από ένα max pool επίπεδο σε κάθε ένα από αυτά. Στην κορυφή μπαίνει ένα πλήρως συνδεδεμένο επίπεδο με 512 νευρώνες με ενεργοποίηση relu."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F15-uwLPVrWa"
      },
      "source": [
        "model = Sequential([\n",
        "    Conv2D(16, 3, padding='same', activation='relu', input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),\n",
        "    MaxPooling2D(),\n",
        "    Conv2D(32, 3, padding='same', activation='relu'),\n",
        "    MaxPooling2D(),\n",
        "    Conv2D(64, 3, padding='same', activation='relu'),\n",
        "    MaxPooling2D(),\n",
        "    Flatten(),\n",
        "    Dense(512, activation='relu'),\n",
        "    Dense(1)\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PI5cdkMQVrWc"
      },
      "source": [
        "### Μετάφραση (Compiling) μοντέλου\n",
        "\n",
        "Επιλέγουμε για τη βελτιστοποίηση (optimizer) *ADAM* και *binary cross entropy*. Για να βλέπουμε την ακρίβεια εκπαίδευσης και επικύρωσης σε κάθε εποχή, δίνουμε το  `metrics`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Mg7_TXOVrWd"
      },
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
        "              metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2YmQZ3TAVrWg"
      },
      "source": [
        "### Σύνοψη μοντέλου\n",
        "Βλέπουμε όλα τα επίπεδα του δικτύου χρησιμοποιώντας τη  μέθοδο `summary` του μοντέλου:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vtny8hmBVrWh"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Οπτική αναπαράσταση του μοντέλου με τη χρήση της βιβλιοθήκης [Visualkeras](https://github.com/paulgavrikov/visualkeras) :"
      ],
      "metadata": {
        "id": "FwfHMzB5R2ii"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install visualkeras"
      ],
      "metadata": {
        "id": "MDhJ7OuaRC3V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import visualkeras\n",
        "visualkeras.layered_view(model, legend=True) # without custom font"
      ],
      "metadata": {
        "id": "qZ8GDbZSQkNC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N06iqE8VVrWj"
      },
      "source": [
        "### Εκπαίδευση του μοντέλου"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oub9RtoFVrWk"
      },
      "source": [
        "Χρησιμοποιούμε τη μέθοδο `fit` της κλάσης `Model` για την εκπαίδευση του δικτύου."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KSF2HqhDVrWk"
      },
      "source": [
        "history = model.fit(\n",
        "    train_data_gen,\n",
        "    steps_per_epoch=total_train // batch_size,\n",
        "    epochs=epochs,\n",
        "    validation_data=val_data_gen,\n",
        "    validation_steps=total_val // batch_size\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojJNteAGVrWo"
      },
      "source": [
        "### Εμφάνιση αποτελεσμάτων"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LZPYT-EmVrWo"
      },
      "source": [
        "Στη συνέχεια βλέπουμε τα αποτελέσματα αφού τελειώσει η εκπαίδευση στο δίκτυο"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K6oA77ADVrWp"
      },
      "source": [
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "loss=history.history['loss']\n",
        "val_loss=history.history['val_loss']\n",
        "\n",
        "epochs_range = range(epochs)\n",
        "\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
        "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(epochs_range, loss, label='Training Loss')\n",
        "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDnr50l2VrWu"
      },
      "source": [
        "Όπως μπορείτε να δείτε από τα γραφήματα, η ακρίβεια της εκπαίδευση και η ακρίβεια επικύρωσης αποκλίνουν σε μεγάλο βαθμό και το μοντέλο έχει  ακρίβεια μόνο περίπου **70%**  στα δεδομένα επικύρωσης.\n",
        "\n",
        "Ας δούμε τι πήγε στραβά και ας προσπαθήσουμε να αυξήσουμε τη συνολική απόδοση του μοντέλου."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rLO7yhLlVrWu"
      },
      "source": [
        "## Overfitting (υπερ-εκπαίδευση)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hNyx3Lp4VrWv"
      },
      "source": [
        "Στα παραπάνω γραφήματα, η ακρίβεια  εκπαίδευσης αυξάνεται γραμμικά με την πάροδο του χρόνου, ενώ η ακρίβεια επικύρωσης κολλάει περίπου στο 70% κατά τη διαδικασία εκπαίδευσης. Η διαφορά στην ακρίβεια μεταξύ της προπόνησης και  επικύρωσης είναι φανερή - και αποτελεί σημάδι *overfitting*.\n",
        "\n",
        "Όταν έχουμε μικρό αριθμό δειγμάτων εκπαίδευσης, το μοντέλο μερικές φορές μαθαίνει από θορύβους ή ανεπιθύμητες λεπτομέρειες από τα δείγματα - σε βαθμό που επηρεάζει αρνητικά την απόδοση του μοντέλου σε νέα δείγματα. Αυτό το φαινόμενο είναι γνωστό ως overfitting. Αυτό σημαίνει ότι το μοντέλο θα δυσκολεύεται στη γενίκευση σε ένα νέο σύνολο δεδομένων.\n",
        "\n",
        "Υπάρχουν πολλοί τρόποι για την καταπολέμηση του overfitting στη διαδικασία εκπαίδευσης. Σε αυτόν τον οδηγό, θα χρησιμοποιήσουμε *data augmentation* και *dropout*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOoVpxFwVrWy"
      },
      "source": [
        "## Επαύξηση Δεδομένων - Data augmentation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wn_QLciWVrWy"
      },
      "source": [
        "Γενικά, οverfitting συμβαίνει όταν υπάρχει μικρός αριθμός δειγμάτων εκπαίδευσης. Ένας τρόπος για να διορθώσουμε αυτό το πρόβλημα είναι να αυξήσουμε το σύνολο δεδομένων έτσι ώστε να διαθέτει επαρκή αριθμό δειγμάτων εκπαίδευσης. Η αύξηση δεδομένων ακολουθεί την προσέγγιση της δημιουργίας περισσότερων δεδομένων από τα υπάρχοντα δείγματα εκπαίδευσης, με τυχαίους μετασχηματισμούς που κατασκευάζουν νέες παραπλήσιες εικόνες. Ο στόχος είναι το μοντέλο να μη δει ποτέ την ίδια εικόνα ξανά κατά τη διάρκεια της εκπαίδευσης. Αυτό βοηθά στην έκθεση του μοντέλου σε περισσότερες πτυχές των δεδομένων και οδηγεί σε καλύτερη γενίκευση.\n",
        "\n",
        "Θα το κάνουμε εδώ στη `tf.keras` με χρήση της κλάσης `ImageDataGenerator`. Περνάμε στο σύνολο δεδομένων διαφορετικούς μετασχηματισμούς  που θα εφαρμοστούν κατά τη διάρκεια της εκπαίδευσης."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2uJ1G030VrWz"
      },
      "source": [
        "### Αύξηση και οπτικοποίηση δεδομένων"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hvX7hHlgVrW0"
      },
      "source": [
        "Ξεκινάμε εφαρμόζοντας *τυχαία* οριζόντια αναστροφή στο σύνολο δεδομένων και βλέπουμε πώς φαίνονται κάποιες από τις εικόνες μετά τον μετασχηματισμό."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rlVj6VqaVrW0"
      },
      "source": [
        "### Εφαρμογή οριζόντιας αναστροφής"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xcdvx4TVVrW1"
      },
      "source": [
        "Περνάμε το `horizontal_flip` ως όρισμα στη κλάση `ImageDataGenerator` και θέτουμε `True` για να εφαρμόσει αυτή τη μέθοδο."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bi1_vHyBVrW2"
      },
      "source": [
        "image_gen = ImageDataGenerator(rescale=1./255, horizontal_flip=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zvwqmefgVrW3"
      },
      "source": [
        "train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,\n",
        "                                               directory=train_dir,\n",
        "                                               shuffle=True,\n",
        "                                               target_size=(IMG_HEIGHT, IMG_WIDTH))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zJpRSxJ-VrW7"
      },
      "source": [
        "Για να δούμε πως δουλεύει, ας πάρουμε πέντε φορές ένα δείγμα απο τις εικόνες εκπαίδευσης, ώστε η επαύξηση να εφαρμοστεί πέντε φορές στην ίδια εικόνα."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RrKGd_jjVrW7"
      },
      "source": [
        "augmented_images = [train_data_gen[0][0][0] for i in range(5)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EvBZoQ9xVrW9"
      },
      "source": [
        "# Re-use the same custom plotting function defined and used\n",
        "# above to visualize the training images\n",
        "plotImages(augmented_images)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i7n9xcqCVrXB"
      },
      "source": [
        "### Τυχαία περιστροφή εικόνας"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qXnwkzFuVrXB"
      },
      "source": [
        "Ας δούμε και μια άλλη μέθοδο, την περιστροφή, όπου θα εφαρμόσουμε τυχαία περιστροφή 45 μοιρών στις εικόνες εκπαίδευσης."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1zip35pDVrXB"
      },
      "source": [
        "image_gen = ImageDataGenerator(rescale=1./255, rotation_range=45)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kVoWh4OIVrXD"
      },
      "source": [
        "train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,\n",
        "                                               directory=train_dir,\n",
        "                                               shuffle=True,\n",
        "                                               target_size=(IMG_HEIGHT, IMG_WIDTH))\n",
        "\n",
        "augmented_images = [train_data_gen[0][0][0] for i in range(5)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wmBx8NhrVrXK"
      },
      "source": [
        "plotImages(augmented_images)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FOqGPL76VrXM"
      },
      "source": [
        "### Εφαρμογή μεγέθυνσης (zoom)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NvqXaD8BVrXN"
      },
      "source": [
        "Προσθέτουμε μια τυχαία επαύξηση μεγέθυνσης μέχρι 50%."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tGNKLa_YVrXR"
      },
      "source": [
        "# zoom_range from 0 - 1 where 1 = 100%.\n",
        "image_gen = ImageDataGenerator(rescale=1./255, zoom_range=0.5) #"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VOvTs32FVrXU"
      },
      "source": [
        "train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,\n",
        "                                               directory=train_dir,\n",
        "                                               shuffle=True,\n",
        "                                               target_size=(IMG_HEIGHT, IMG_WIDTH))\n",
        "\n",
        "augmented_images = [train_data_gen[0][0][0] for i in range(5)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-KQWw8IZVrXZ"
      },
      "source": [
        "plotImages(augmented_images)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usS13KCNVrXd"
      },
      "source": [
        "### Όλα μαζί"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OC8fIsalVrXd"
      },
      "source": [
        "Ας εφαρμόσουμε τώρα όλες τις προηγούμενες επαυξήσεις μαζί. Αλλαγή κλίμακας, 45 μοίρες περιστροφή, μετατόπιση πλάτους και ύψους, οριζόντια περιστροφή και μεγέθυνση στις εικόνες εκπαίδευσης"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gnr2xujaVrXe"
      },
      "source": [
        "image_gen_train = ImageDataGenerator(\n",
        "                    rescale=1./255,\n",
        "                    rotation_range=45,\n",
        "                    width_shift_range=.15,\n",
        "                    height_shift_range=.15,\n",
        "                    horizontal_flip=True,\n",
        "                    zoom_range=0.2 # 0.5\n",
        "                    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K0Efxy7EVrXh"
      },
      "source": [
        "train_data_gen = image_gen_train.flow_from_directory(batch_size=batch_size,\n",
        "                                                     directory=train_dir,\n",
        "                                                     shuffle=True,\n",
        "                                                     target_size=(IMG_HEIGHT, IMG_WIDTH),\n",
        "                                                     class_mode='binary')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AW-pV5awVrXl"
      },
      "source": [
        "Ας δούμε πως θα φαίνεται η ίδια εικόνα αν την περάσουμε πέντε φορές, με τις μεθόδους επαύξησης που βαλαμε."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z2m68eMhVrXm"
      },
      "source": [
        "augmented_images = [train_data_gen[0][0][0] for i in range(5)]\n",
        "plotImages(augmented_images)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J8cUd7FXVrXq"
      },
      "source": [
        "### Δημιουργία γενήτριας δεδομένων επικύρωσης"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a99fDBt7VrXr"
      },
      "source": [
        "Γενικά, εφαρμόζουμε επαύξηση δεδομένων μόνο στα δείγματα εκπαίδευσης. Οπότε στα δείγματα επικύρωσης κάνουμε μόνο αλλαγή κλίμακας και τις ενώνουμε σε παρτίδες με την `ImageDataGenerator`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "54x0aNbKVrXr"
      },
      "source": [
        "image_gen_val = ImageDataGenerator(rescale=1./255)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1PCHKzI8VrXv"
      },
      "source": [
        "val_data_gen = image_gen_val.flow_from_directory(batch_size=batch_size,\n",
        "                                                 directory=validation_dir,\n",
        "                                                 target_size=(IMG_HEIGHT, IMG_WIDTH),\n",
        "                                                 class_mode='binary')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yQGhdqHFVrXx"
      },
      "source": [
        "## Παράλειψη - Dropout"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Iq5TAH_VrXx"
      },
      "source": [
        "Μια άλλη τεχνική για τη μείωση του overfitting είναι η εισαγωγή *παράλειψης (dropout)* στο δίκτυο. Είναι μια μορφή *κανονικοποίησης (regularization)* που αναγκάζει τα βάρη στο δίκτυο να λαμβάνουν μόνο μικρές τιμές, γεγονός που καθιστά την κατανομή τιμών βάρους πιο  ομαλή και το δίκτυο μπορεί να μειώσει το overfitting σε μικρά δείγματα.\n",
        "\n",
        "Όταν θέτουμε παράλειψη σε ένα επίπεδο, ένας τυχαίος αριθμός μονάδων εξόδου μηδενίζεται στο τρέχον επίπεδο κατά την εκπαίδευση. Ως την τιμή εισόδου, το Dropout παίρνει έναν δεκαδικό αριθμό, πχ 0.1, 0.2, 0.4, κ.λπ. που σημαίνει την τυχαία κατάργηση 10%, 20% ή 40% των μονάδων εξόδου από το τρέχον επίπεδο.\n",
        "\n",
        "Κατά την εφαρμογή 0.1 παράλειψης σε ένα συγκεκριμένο επίπεδο, μηδενίζεται τυχαία το 10% των μονάδων εξόδου σε κάθε εποχή εκπαίδευσης.\n",
        "\n",
        "Ας δημιουργήσουμε μια αρχιτεκτονική δικτύου με αυτήν τη νέα δυνατότητα παράλειψης και ας την εφαρμόσουμε στα διάφορα συνελικτικά και πλήρως διασυνδεμένα επίπεδα."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DyxxXRmVVrXy"
      },
      "source": [
        "## Δημιουργία νέου δικτύου με το Dropouts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Ba2LjtkVrXy"
      },
      "source": [
        "Εδώ, εφαρμόζουμε την παράλειψη στα πρώτα και τα τελευταία ανώτατα επίπεδα max-pool. Θέτουμε τυχαία το 20% των νευρώνων σε μηδέν κατά τη διάρκεια κάθε εποχής εκπαίδευσης. Αυτό βοηθά στην αποφυγή του overfitting στο σύνολο δεδομένων εκπαίδευσης."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fjio8EsVrXz"
      },
      "source": [
        "model_new = Sequential([\n",
        "    Conv2D(16, 3, padding='same', activation='relu',\n",
        "           input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),\n",
        "    MaxPooling2D(),\n",
        "    Dropout(0.2),\n",
        "    Conv2D(32, 3, padding='same', activation='relu'),\n",
        "    MaxPooling2D(),\n",
        "    Conv2D(64, 3, padding='same', activation='relu'),\n",
        "    MaxPooling2D(),\n",
        "    Dropout(0.2),\n",
        "    Flatten(),\n",
        "    Dense(512, activation='relu'),\n",
        "    Dense(1,activation='sigmoid')\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tpTgIxWAVrX0"
      },
      "source": [
        "### Μετάφραση μοντέλου"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1osvc_iTVrX1"
      },
      "source": [
        "Μετά την εισαγωγή των παραλείψεων στο δίκτυο, ας κάνουμε μετάφραση του μοντέλου και προβολή της περίληψης επιπέδων."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OkIJhS-WVrX1"
      },
      "source": [
        "model_new.compile(optimizer='adam',\n",
        "                  loss=tf.keras.losses.BinaryCrossentropy(from_logits=False),\n",
        "                  metrics=['accuracy'])\n",
        "\n",
        "model_new.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7KiDshEUVrX6"
      },
      "source": [
        "### Εκπαίδευση μοντέλου"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NFj0oVqVVrX6"
      },
      "source": [
        "Αφού εισάγουμε επαύξηση δεδομένων στα δείγματα εκπαίδευσης και προσθέσουμε παραλήψεις στο δίκτυο, ας εκπαιδεύσουμε το νέο δίκτυο:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4zwTGaplg4pY"
      },
      "source": [
        "epochs = 15"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GWxHs_luVrX7"
      },
      "source": [
        "history = model_new.fit(\n",
        "    train_data_gen,\n",
        "    steps_per_epoch=total_train // batch_size,\n",
        "    epochs=epochs,\n",
        "    validation_data=val_data_gen,\n",
        "    validation_steps=total_val // batch_size\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbdyqZdxVrYA"
      },
      "source": [
        "### Εμφάνιση καμπυλών εκπαίδευσης"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OgvF2nt7OtR7"
      },
      "source": [
        "Βλέποντας τις καμπύλες ακρίβειας και σφάλματος στο νέο μοντέλο μετά την προπόνηση, βλέπουμε ότι υπάρχει σημαντικά λιγότερο overfitting από ό,τι πριν. Η ακρίβεια θα αυξηθεί μετά απο προπόνηση του μοντέλου σε περισσότερες εποχές."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7BTeMuNAVrYC",
        "collapsed": true
      },
      "source": [
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs_range = range(epochs)\n",
        "\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
        "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(epochs_range, loss, label='Training Loss')\n",
        "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Για να δούμε πως τα πάει το μοντέλο μας:"
      ],
      "metadata": {
        "id": "3w_r5M6OVrCy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample_val_images, _ = next(val_data_gen)\n",
        "plotImages(sample_val_images[-5:])"
      ],
      "metadata": {
        "id": "qCz4i24bjkmW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_image = sample_val_images[-1]\n",
        "test_image_x = np.expand_dims(sample_val_images[-1], axis=0)\n",
        "predictions = model_new.predict(test_image_x)\n",
        "\n",
        "score = predictions[0][0]\n",
        "print(\n",
        "    \"This image is %.2f percent cat and %.2f percent dog.\"\n",
        "    % (100 * (1 - score), 100 * score)\n",
        ")"
      ],
      "metadata": {
        "id": "xtNxDy28W2O9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predictions[0][0]"
      ],
      "metadata": {
        "id": "2gNv0RMCgODA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "to7bR5nLHCPd"
      },
      "source": [
        "## Συνέχεια εξερεύνησης..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UkUWKw_7HJx5"
      },
      "source": [
        "### Μείωση υπερ-εκπαίδευσης\n",
        "Υπάρχουν και άλλες τεχνικές για μείωση του overfitting.\n",
        "Δοκιμάστε τα εξής\n",
        "\n",
        "*   *Μείωση της πολυπλοκότητας του μοντέλου*. Ποιά είναι η συμπεριφορά του αρχικού μοντέλου αν αφαιρεθεί πχ ένα συνελικτικό επίπεδο;\n",
        "*   *Εφαρμογή L2 regularization*. Ποιά είναι η συμπεριφορά του αρχικού μοντέλου αν προστεθεί η [L2](https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) στα συνελικτικά επίπεδα;\n",
        "*   [*Batch Normalization*](https://www.tensorflow.org/api_docs/python/tf/keras/layers/BatchNormalization). Ποιά είναι η συμπεριφορά του αρχικού μοντέλου μετά την προσθήκη της;\n",
        "*   [Global average pooling](https://codelabs.developers.google.com/codelabs/keras-flowers-convnets/#5). Αντί για χρήση πυκνών επιπέδων στο τέλος του δικτύου, για μείωση της πολυπλοκότητας του μοντέλου\n",
        "\n",
        "Χωριστείτε σε ομάδες και δοκιμάστε αυτές τις μεθόδους. Στο τέλος συγκρίνετε τα αποτελέσματα!\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7bumi770TuM4"
      },
      "source": [
        "### Εμφάνιση επιπέδων ενεργοποίησης (activation or feature maps)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vERLbp6kuFuh"
      },
      "source": [
        "Δημιουργία ενός μοντέλου από ένα τανυστή εισόδου και μια λίστα από τανυστές εξόδου:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V4kzSc9NT49c"
      },
      "source": [
        "from tensorflow.keras import models\n",
        "\n",
        "# Extracts the outputs of the first layer(s)\n",
        "layer_outputs = [layer.output for layer in model_new.layers[:]]\n",
        "\n",
        "# Creates a model that will return these outputs, given the model input\n",
        "activation_model = models.Model(inputs=model_new.input, outputs=layer_outputs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PAOJuv1jufMr"
      },
      "source": [
        "Ας πάρουμε ξανά την εικόνα από validation dataset που διαλέξαμε:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S5oJ3vuiK_ff"
      },
      "source": [
        "plt.imshow(test_image)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4CHloCqDvsSt"
      },
      "source": [
        "Τρέχοντας το μοντέλο για να δούμε τις προγνώσεις:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j1mzcXNXVwdu"
      },
      "source": [
        "activations = activation_model.predict(test_image_x)\n",
        "# Returns a list of  Numpy arrays: one array per layer activation\n",
        "len(activations)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DXoPPKwv3Ew"
      },
      "source": [
        "Ας πάρουμε την ενεργοποίηση του πρώτου επιπέδου:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "daYxGSIdXIEI"
      },
      "source": [
        "first_layer_activation = activations[0]\n",
        "print(first_layer_activation.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVAROYVdwK9B"
      },
      "source": [
        "Τέλος, ας δούμε το 4ο επίπεδο ενεργοποίησης από τα 16 διαθέσιμα:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ROj3jSnXQ3x"
      },
      "source": [
        "plt.matshow(first_layer_activation[0, :, :, 3], cmap='viridis')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-6meZ3dNxGhc"
      },
      "source": [
        "Ο παρακάτω [κώδικας](https://towardsdatascience.com/visualizing-intermediate-activation-in-convolutional-neural-networks-with-keras-260b36d60d0), θα εμφανίσει **όλα** τα επίπεδα ενεργοποίησης για τα οκτώ πρώτα επίπεδα του μοντέλου μας:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c9tBDyDcXn7_"
      },
      "source": [
        "images_per_row = 16\n",
        "\n",
        "layer_names = []\n",
        "for layer in model_new.layers[:]:\n",
        "    layer_names.append(layer.name) # Names of the layers, so you can have them as part of your plot\n",
        "\n",
        "for layer_name, layer_activation in zip(layer_names[:8], activations[:8]): # Displays the feature maps\n",
        "    n_features = layer_activation.shape[-1] # Number of features in the feature map\n",
        "    size = layer_activation.shape[1] #The feature map has shape (1, size, size, n_features).\n",
        "    n_cols = n_features // images_per_row #1 Tiles the activation channels in this matrix\n",
        "    display_grid = np.zeros((size * n_cols, images_per_row * size))\n",
        "\n",
        "    for col in range(n_cols): # Tiles each filter into a big horizontal grid\n",
        "        for row in range(images_per_row):\n",
        "            channel_image = layer_activation[0,\n",
        "                                             :, :,\n",
        "                                             col * images_per_row + row]\n",
        "            channel_image -= channel_image.mean() # Post-processes the feature to make it visually palatable\n",
        "            channel_image /= channel_image.std()\n",
        "            channel_image *= 64\n",
        "            channel_image += 128\n",
        "            channel_image = np.clip(channel_image, 0, 255).astype('uint8')\n",
        "            display_grid[col * size : (col + 1) * size, # Displays the grid\n",
        "                         row * size : (row + 1) * size] = channel_image\n",
        "    scale = 1. / size\n",
        "    plt.figure(figsize=(scale * display_grid.shape[1],\n",
        "                        scale * display_grid.shape[0]))\n",
        "    plt.title(layer_name)\n",
        "    plt.grid(False)\n",
        "    plt.imshow(display_grid, aspect='auto', cmap='viridis')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "### Εξερεύνηση με τον αλγόριθμο [Grad-CAM](https://keras.io/examples/vision/grad_cam/)\n"
      ],
      "metadata": {
        "id": "2waZ-e5kZC9T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow import keras\n",
        "def get_img_array(img_path, size):\n",
        "    # `img` is a PIL image of size 299x299\n",
        "    img = keras.preprocessing.image.load_img(img_path, target_size=size)\n",
        "    # `array` is a float32 Numpy array of shape (299, 299, 3)\n",
        "    array = keras.preprocessing.image.img_to_array(img)\n",
        "    # We add a dimension to transform our array into a \"batch\"\n",
        "    # of size (1, 299, 299, 3)\n",
        "    array = np.expand_dims(array, axis=0)\n",
        "    return array\n",
        "\n",
        "\n",
        "def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):\n",
        "    # First, we create a model that maps the input image to the activations\n",
        "    # of the last conv layer as well as the output predictions\n",
        "    grad_model = tf.keras.models.Model(\n",
        "        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]\n",
        "    )\n",
        "\n",
        "    # Then, we compute the gradient of the top predicted class for our input image\n",
        "    # with respect to the activations of the last conv layer\n",
        "    with tf.GradientTape() as tape:\n",
        "        last_conv_layer_output, preds = grad_model(img_array)\n",
        "        if pred_index is None:\n",
        "            pred_index = tf.argmax(preds[0])\n",
        "        class_channel = preds[:, pred_index]\n",
        "\n",
        "    # This is the gradient of the output neuron (top predicted or chosen)\n",
        "    # with regard to the output feature map of the last conv layer\n",
        "    grads = tape.gradient(class_channel, last_conv_layer_output)\n",
        "\n",
        "    # This is a vector where each entry is the mean intensity of the gradient\n",
        "    # over a specific feature map channel\n",
        "    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))\n",
        "\n",
        "    # We multiply each channel in the feature map array\n",
        "    # by \"how important this channel is\" with regard to the top predicted class\n",
        "    # then sum all the channels to obtain the heatmap class activation\n",
        "    last_conv_layer_output = last_conv_layer_output[0]\n",
        "    heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]\n",
        "    heatmap = tf.squeeze(heatmap)\n",
        "\n",
        "    # For visualization purpose, we will also normalize the heatmap between 0 & 1\n",
        "    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)\n",
        "    return heatmap.numpy()\n"
      ],
      "metadata": {
        "id": "idTpa6jEXmQb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ας το δοκιμάσουμε"
      ],
      "metadata": {
        "id": "0ez5DO_OaE7A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Prepare image\n",
        "# img_array = preprocess_input(get_img_array(img_path, size=(150,150)))\n",
        "\n",
        "# Make model\n",
        "# model = model_builder(weights=\"imagenet\")\n",
        "\n",
        "# Remove last layer's softmax\n",
        "# model.layers[-1].activation = None\n",
        "# model_new.layers[-1].activation = None\n",
        "\n",
        "# Print what the top predicted class is\n",
        "# preds = model.predict(img_array)\n",
        "# print(\"Predicted:\", decode_predictions(preds, top=1)[0])\n",
        "preds = model_new.predict(test_image_x)\n",
        "print(preds)\n",
        "\n",
        "# Generate class activation heatmap\n",
        "# heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name)\n",
        "heatmap = make_gradcam_heatmap(test_image_x, model_new, \"conv2d_4\",0 )\n",
        "\n",
        "# Display heatmap\n",
        "plt.matshow(heatmap)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "collapsed": true,
        "id": "IEw6kDeuaCph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Κατασκευή εικόνας με υπέρθεση:"
      ],
      "metadata": {
        "id": "8IDlPtuKcqJV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Display\n",
        "from IPython.display import Image, display\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib\n",
        "def save_and_display_gradcam(img_path, heatmap, cam_path=\"cam.jpg\", alpha=0.01):\n",
        "    # Load the original image\n",
        "    # img = keras.preprocessing.image.load_img(img_path)\n",
        "    # img = keras.preprocessing.image.img_to_array(img)\n",
        "    img = img_path # kmouts\n",
        "\n",
        "    # Rescale heatmap to a range 0-255\n",
        "    heatmap = np.uint8(255 * heatmap)\n",
        "\n",
        "    # Use jet colormap to colorize heatmap\n",
        "    jet = matplotlib.colormaps[\"jet\"]\n",
        "\n",
        "    # Use RGB values of the colormap\n",
        "    jet_colors = jet(np.arange(256))[:, :3]\n",
        "    jet_heatmap = jet_colors[heatmap]\n",
        "\n",
        "    # Create an image with RGB colorized heatmap\n",
        "    jet_heatmap = keras.preprocessing.image.array_to_img(jet_heatmap)\n",
        "    jet_heatmap = jet_heatmap.resize((img.shape[1], img.shape[0]))\n",
        "    jet_heatmap = keras.preprocessing.image.img_to_array(jet_heatmap)\n",
        "\n",
        "    # Superimpose the heatmap on original image\n",
        "    superimposed_img = jet_heatmap * alpha + img\n",
        "    superimposed_img = keras.preprocessing.image.array_to_img(superimposed_img)\n",
        "\n",
        "    # Save the superimposed image\n",
        "    superimposed_img.save(cam_path)\n",
        "\n",
        "    # Display Grad CAM\n",
        "    display(Image(cam_path))\n",
        "\n",
        "\n",
        "save_and_display_gradcam(test_image, heatmap)\n"
      ],
      "metadata": {
        "id": "rXO6WBoncphf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Εξερεύνηση με δημιουργία εικόνων που μεγιστοποιούν τα  [filter activations](https://keras.io/examples/vision/visualizing_what_convnets_learn/)"
      ],
      "metadata": {
        "id": "TvN0pXa8ZfWM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set up a model that returns the activation values for our target layer\n",
        "layer_name = \"conv2d_2\"\n",
        "layer = model.get_layer(name=layer_name)\n",
        "feature_extractor = keras.Model(inputs=model.inputs, outputs=layer.output)"
      ],
      "metadata": {
        "id": "2ODPSnTkaRv-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_loss(input_image, filter_index):\n",
        "    activation = feature_extractor(input_image)\n",
        "    # We avoid border artifacts by only involving non-border pixels in the loss.\n",
        "    filter_activation = activation[:, 2:-2, 2:-2, filter_index]\n",
        "    return tf.reduce_mean(filter_activation)\n"
      ],
      "metadata": {
        "id": "nnMGrat9alYk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@tf.function\n",
        "def gradient_ascent_step(img, filter_index, learning_rate):\n",
        "    with tf.GradientTape() as tape:\n",
        "        tape.watch(img)\n",
        "        loss = compute_loss(img, filter_index)\n",
        "    # Compute gradients.\n",
        "    grads = tape.gradient(loss, img)\n",
        "    # Normalize gradients.\n",
        "    grads = tf.math.l2_normalize(grads)\n",
        "    img += learning_rate * grads\n",
        "    return loss, img\n"
      ],
      "metadata": {
        "id": "3mCdkn6qaqg-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "img_width = 150\n",
        "img_height = 150\n",
        "def initialize_image():\n",
        "    # We start from a gray image with some random noise\n",
        "    img = tf.random.uniform((1, img_width, img_height, 3))\n",
        "    # ResNet50V2 expects inputs in the range [-1, +1].\n",
        "    # Here we scale our random inputs to [-0.125, +0.125]\n",
        "    return (img - 0.5) * 0.25\n",
        "\n",
        "\n",
        "def visualize_filter(filter_index):\n",
        "    # We run gradient ascent for 20 steps\n",
        "    iterations = 30\n",
        "    learning_rate = 10.0\n",
        "    img = initialize_image()\n",
        "    for iteration in range(iterations):\n",
        "        loss, img = gradient_ascent_step(img, filter_index, learning_rate)\n",
        "\n",
        "    # Decode the resulting input image\n",
        "    img = deprocess_image(img[0].numpy())\n",
        "    return loss, img\n",
        "\n",
        "\n",
        "def deprocess_image(img):\n",
        "    # Normalize array: center on 0., ensure variance is 0.15\n",
        "    img -= img.mean()\n",
        "    img /= img.std() + 1e-5\n",
        "    img *= 0.15\n",
        "\n",
        "    # Center crop\n",
        "    img = img[25:-25, 25:-25, :]\n",
        "\n",
        "    # Clip to [0, 1]\n",
        "    img += 0.5\n",
        "    img = np.clip(img, 0, 1)\n",
        "\n",
        "    # Convert to RGB array\n",
        "    img *= 255\n",
        "    img = np.clip(img, 0, 255).astype(\"uint8\")\n",
        "    return img\n"
      ],
      "metadata": {
        "id": "zK2NFc9Aawle"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import Image, display\n",
        "\n",
        "loss, img = visualize_filter(0)\n",
        "keras.preprocessing.image.save_img(\"0.png\", img)\n"
      ],
      "metadata": {
        "id": "Lfn4-4G1a3WR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "display(Image(\"0.png\"))\n"
      ],
      "metadata": {
        "id": "m-teb9Yja6Av"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "60IMqZQXlbba"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "predictions = model_new.predict(img)\n",
        "\n",
        "score = predictions[0][0]\n",
        "print(\n",
        "    \"This image is %.2f percent cat and %.2f percent dog.\"\n",
        "    % (100 * (1 - score), 100 * score)\n",
        ")"
      ],
      "metadata": {
        "collapsed": true,
        "id": "K51JrYEElb41"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Visualize the first 64 filters in the target layer"
      ],
      "metadata": {
        "id": "3gmGCUUpbjw2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "img_width = 150\n",
        "img_height = 150\n",
        "\n",
        "# Compute image inputs that maximize per-filter activations\n",
        "# for the first 64 filters of our target layer\n",
        "all_imgs = []\n",
        "for filter_index in range(64):\n",
        "    print(\"Processing filter %d\" % (filter_index,))\n",
        "    loss, img = visualize_filter(filter_index)\n",
        "    all_imgs.append(img)\n",
        "\n",
        "# Build a black picture with enough space for\n",
        "# our 8 x 8 filters of size 128 x 128, with a 5px margin in between\n",
        "margin = 5\n",
        "n = 8\n",
        "cropped_width = img_width - 25 * 2\n",
        "cropped_height = img_height - 25 * 2\n",
        "width = n * cropped_width + (n - 1) * margin\n",
        "height = n * cropped_height + (n - 1) * margin\n",
        "stitched_filters = np.zeros((width, height, 3))\n",
        "\n",
        "# Fill the picture with our saved filters\n",
        "for i in range(n):\n",
        "    for j in range(n):\n",
        "        img = all_imgs[i * n + j]\n",
        "        stitched_filters[\n",
        "            (cropped_width + margin) * i : (cropped_width + margin) * i + cropped_width,\n",
        "            (cropped_height + margin) * j : (cropped_height + margin) * j\n",
        "            + cropped_height,\n",
        "            :,\n",
        "        ] = img\n",
        "keras.preprocessing.image.save_img(\"stiched_filters.png\", stitched_filters)\n",
        "\n",
        "from IPython.display import Image, display\n",
        "\n",
        "display(Image(\"stiched_filters.png\"))\n"
      ],
      "metadata": {
        "id": "5C5dmHe-bpKc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finding an input that maximizes a specific class"
      ],
      "metadata": {
        "id": "hLPw7vFigDOh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "layer = model.get_layer(name=\"conv2d_2\")\n",
        "feature_extractor = keras.Model(inputs=model.inputs, outputs=layer.output)\n",
        "\n",
        "def compute_loss(input_image,filter_index):\n",
        "    activation = feature_extractor(input_image)\n",
        "    # We avoid border artifacts by only involving non-border pixels in the loss.\n",
        "    filter_activation = activation[:, 2:-2, 2:-2, filter_index]\n",
        "    return tf.reduce_mean(filter_activation)\n",
        "\n",
        "\n",
        "iterations = 30\n",
        "learning_rate = 10.0\n",
        "img = initialize_image()\n",
        "for iteration in range(iterations):\n",
        "    loss, img = gradient_ascent_step(img, -1, learning_rate)\n",
        "    print(loss.numpy())\n",
        "\n",
        "# Decode the resulting input image\n",
        "img2 = deprocess_image(img[0].numpy())\n",
        "\n",
        "keras.preprocessing.image.save_img(\"1.png\", img2)\n",
        "display(Image(\"1.png\",width=500, height=500))\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "PpshEAdTgD9E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(np.squeeze(img))"
      ],
      "metadata": {
        "id": "XUKqHjtctSYX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "predictions = model_new.predict(img)\n",
        "\n",
        "score = predictions[0][0]\n",
        "print(\n",
        "    \"This image is %.2f percent cat and %.2f percent dog.\"\n",
        "    % (100 * (1 - score), 100 * score)\n",
        ")"
      ],
      "metadata": {
        "id": "lW-peU0NrpXJ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}